coc-springboot 0.0.1
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/.editorconfig +10 -0
- package/.gitattributes +1 -0
- package/.gitmodules +3 -0
- package/.ignore +1 -0
- package/LICENSE +674 -0
- package/README.md +76 -0
- package/build.sh +72 -0
- package/esbuild.mjs +24 -0
- package/lib/index.js +3857 -0
- package/package.json +1063 -0
- package/sts4/eclipse-distribution/.mvn/wrapper/maven-wrapper.jar +0 -0
- package/sts4/eclipse-extensions/org.springframework.ide.eclipse.docker.client/docker-client-wrapper/.mvn/wrapper/maven-wrapper.jar +0 -0
- package/sts4/eclipse-language-servers/.mvn/wrapper/maven-wrapper.jar +0 -0
- package/sts4/headless-services/.mvn/wrapper/maven-wrapper.jar +0 -0
- package/sts4/headless-services/commons/commons-maven/src/test/resources/empty-boot-project-with-classpath-file/.mvn/wrapper/maven-wrapper.jar +0 -0
- package/sts4/headless-services/commons/commons-maven/src/test/resources/gs-rest-service-cors-boot-1.4.1-with-classpath-file/.mvn/wrapper/maven-wrapper.jar +0 -0
- package/sts4/headless-services/commons/commons-rewrite/src/test/resources/test-projects/test-maven-project-parser/.mvn/wrapper/maven-wrapper.jar +0 -0
package/lib/index.js
ADDED
|
@@ -0,0 +1,3857 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
var __create = Object.create;
|
|
3
|
+
var __defProp = Object.defineProperty;
|
|
4
|
+
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
5
|
+
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
6
|
+
var __getProtoOf = Object.getPrototypeOf;
|
|
7
|
+
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
8
|
+
var __commonJS = (cb, mod) => function __require() {
|
|
9
|
+
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
|
|
10
|
+
};
|
|
11
|
+
var __export = (target, all) => {
|
|
12
|
+
for (var name in all)
|
|
13
|
+
__defProp(target, name, { get: all[name], enumerable: true });
|
|
14
|
+
};
|
|
15
|
+
var __copyProps = (to, from, except, desc) => {
|
|
16
|
+
if (from && typeof from === "object" || typeof from === "function") {
|
|
17
|
+
for (let key of __getOwnPropNames(from))
|
|
18
|
+
if (!__hasOwnProp.call(to, key) && key !== except)
|
|
19
|
+
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
|
20
|
+
}
|
|
21
|
+
return to;
|
|
22
|
+
};
|
|
23
|
+
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
|
|
24
|
+
// If the importer is in node compatibility mode or this is not an ESM
|
|
25
|
+
// file that has been converted to a CommonJS file using a Babel-
|
|
26
|
+
// compatible transform (i.e. "__esModule" has not been set), then set
|
|
27
|
+
// "default" to the CommonJS "module.exports" for node compatibility.
|
|
28
|
+
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
|
|
29
|
+
mod
|
|
30
|
+
));
|
|
31
|
+
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
|
32
|
+
|
|
33
|
+
// node_modules/@pivotal-tools/jvm-launch-utils/lib/jvm-util.js
|
|
34
|
+
var require_jvm_util = __commonJS({
|
|
35
|
+
"node_modules/@pivotal-tools/jvm-launch-utils/lib/jvm-util.js"(exports2) {
|
|
36
|
+
"use strict";
|
|
37
|
+
Object.defineProperty(exports2, "__esModule", { value: true });
|
|
38
|
+
exports2.findJdk = exports2.findJvm = void 0;
|
|
39
|
+
var FS2 = require("fs");
|
|
40
|
+
var Path2 = require("path");
|
|
41
|
+
var ChildProcess = require("child_process");
|
|
42
|
+
function findJvm2(javaHome, log) {
|
|
43
|
+
if (!log) {
|
|
44
|
+
log = console.log;
|
|
45
|
+
}
|
|
46
|
+
try {
|
|
47
|
+
let javaExe = findJavaExe(javaHome, log);
|
|
48
|
+
if (javaExe) {
|
|
49
|
+
return getJavaInfo(javaExe).then((javaProps) => new JVMImpl(javaProps.get("java.home"), javaExe, getMajorVersion(javaProps)));
|
|
50
|
+
}
|
|
51
|
+
return Promise.resolve(null);
|
|
52
|
+
} catch (e) {
|
|
53
|
+
return Promise.reject(e);
|
|
54
|
+
}
|
|
55
|
+
}
|
|
56
|
+
exports2.findJvm = findJvm2;
|
|
57
|
+
function findJdk2(javaHome, log) {
|
|
58
|
+
if (!log) {
|
|
59
|
+
log = console.log;
|
|
60
|
+
}
|
|
61
|
+
return findJvm2(javaHome, log).then((jvm) => {
|
|
62
|
+
if (!jvm) {
|
|
63
|
+
return null;
|
|
64
|
+
}
|
|
65
|
+
if (!jvm.isJdk()) {
|
|
66
|
+
log(`found JVM at location "${jvm.getJavaHome()}" is not a JDK`);
|
|
67
|
+
let javaExe = jvm.getJavaExecutable();
|
|
68
|
+
let jhome = jvm.getJavaHome();
|
|
69
|
+
let basename3 = Path2.basename(jhome);
|
|
70
|
+
let altBasename = basename3.replace("jre", "jdk");
|
|
71
|
+
if (altBasename !== basename3) {
|
|
72
|
+
let altHome = Path2.join(Path2.dirname(jhome), altBasename);
|
|
73
|
+
log(`Trying to find JDK corresping to currently found JRE. Checking for JDK at ${altHome}`);
|
|
74
|
+
if (FS2.existsSync(altHome)) {
|
|
75
|
+
let altExe = Path2.resolve(altHome, "bin", correctBinname("java"));
|
|
76
|
+
log("altExe = " + altExe);
|
|
77
|
+
return new JVMImpl(altHome, altExe, jvm.getMajorVersion());
|
|
78
|
+
}
|
|
79
|
+
}
|
|
80
|
+
}
|
|
81
|
+
return jvm;
|
|
82
|
+
});
|
|
83
|
+
}
|
|
84
|
+
exports2.findJdk = findJdk2;
|
|
85
|
+
function findJavaExe(javaHome, log) {
|
|
86
|
+
if (!log) {
|
|
87
|
+
log = console.log;
|
|
88
|
+
}
|
|
89
|
+
if (!javaHome) {
|
|
90
|
+
log("No user specified java-home setting. Looking for JAVA_HOME env variable...");
|
|
91
|
+
javaHome = process.env["JAVA_HOME"];
|
|
92
|
+
}
|
|
93
|
+
if (javaHome) {
|
|
94
|
+
javaHome = FS2.realpathSync(javaHome);
|
|
95
|
+
} else {
|
|
96
|
+
log("JAVA_HOME environment variable not set");
|
|
97
|
+
}
|
|
98
|
+
let binName = correctBinname("java");
|
|
99
|
+
if (javaHome) {
|
|
100
|
+
let javaExe = Path2.resolve(javaHome, "bin", binName);
|
|
101
|
+
if (FS2.existsSync(javaExe)) {
|
|
102
|
+
return javaExe;
|
|
103
|
+
}
|
|
104
|
+
log(`JAVA_HOME env variable points to location that does NOT exist: ${javaHome}`);
|
|
105
|
+
}
|
|
106
|
+
log("Looking for the path to JVM inside PATH env variable");
|
|
107
|
+
for (let searchPath of process.env["PATH"].split(Path2.delimiter)) {
|
|
108
|
+
let javaExe = Path2.resolve(searchPath, binName);
|
|
109
|
+
if (FS2.existsSync(javaExe)) {
|
|
110
|
+
return FS2.realpathSync(javaExe);
|
|
111
|
+
}
|
|
112
|
+
}
|
|
113
|
+
log("No valid JVM found on the system!!!");
|
|
114
|
+
return null;
|
|
115
|
+
}
|
|
116
|
+
var JVMImpl = class {
|
|
117
|
+
constructor(javaHome, javaExe, version) {
|
|
118
|
+
this.javaHome = javaHome;
|
|
119
|
+
this.javaExe = javaExe;
|
|
120
|
+
this.version = version;
|
|
121
|
+
}
|
|
122
|
+
getJavaHome() {
|
|
123
|
+
return this.javaHome;
|
|
124
|
+
}
|
|
125
|
+
getMajorVersion() {
|
|
126
|
+
return this.version;
|
|
127
|
+
}
|
|
128
|
+
getJavaExecutable() {
|
|
129
|
+
return this.javaExe;
|
|
130
|
+
}
|
|
131
|
+
isJdk() {
|
|
132
|
+
const javaExecutable = this.getJavaExecutable();
|
|
133
|
+
const str = ChildProcess.execFileSync(javaExecutable, ["--list-modules"], { windowsHide: true, encoding: "utf8" });
|
|
134
|
+
return str.search(/^jdk.management@.*$/m) >= 0;
|
|
135
|
+
}
|
|
136
|
+
jarLaunch(jar, vmargs, execFileOptions) {
|
|
137
|
+
let args = [];
|
|
138
|
+
if (vmargs) {
|
|
139
|
+
args.push(...vmargs);
|
|
140
|
+
}
|
|
141
|
+
args.push("-jar", jar);
|
|
142
|
+
return ChildProcess.execFile(this.getJavaExecutable(), args, execFileOptions);
|
|
143
|
+
}
|
|
144
|
+
mainClassLaunch(mainClass, classpath, jvmArgs, execFileOptions) {
|
|
145
|
+
const args = [];
|
|
146
|
+
args.push("-cp");
|
|
147
|
+
let classpathStr = classpath.join(Path2.delimiter);
|
|
148
|
+
args.push(classpathStr);
|
|
149
|
+
args.push(...jvmArgs);
|
|
150
|
+
args.push(mainClass);
|
|
151
|
+
return ChildProcess.execFile(this.getJavaExecutable(), args, execFileOptions);
|
|
152
|
+
}
|
|
153
|
+
};
|
|
154
|
+
function getJavaInfo(javaExe) {
|
|
155
|
+
return new Promise((resolve2, reject) => {
|
|
156
|
+
ChildProcess.execFile(javaExe, ["-XshowSettings:properties"], {}, (error, stdout, stderr) => {
|
|
157
|
+
let lines = stderr.split(/\r?\n/);
|
|
158
|
+
let propNames = ["java.version", "java.home"];
|
|
159
|
+
let props = /* @__PURE__ */ new Map();
|
|
160
|
+
for (var l of lines) {
|
|
161
|
+
for (var p of propNames) {
|
|
162
|
+
let offset = l.indexOf(p);
|
|
163
|
+
if (offset >= 0) {
|
|
164
|
+
let assign = " " + p + " = ";
|
|
165
|
+
offset = l.indexOf(assign);
|
|
166
|
+
if (offset >= 0) {
|
|
167
|
+
offset = offset + assign.length;
|
|
168
|
+
let value = l.substring(offset);
|
|
169
|
+
props.set(p, value);
|
|
170
|
+
if (props.size >= propNames.length) {
|
|
171
|
+
return resolve2(props);
|
|
172
|
+
}
|
|
173
|
+
}
|
|
174
|
+
}
|
|
175
|
+
}
|
|
176
|
+
}
|
|
177
|
+
return reject("Unexpected output from `java -XshowSettings:properties`. Didn't find all expected properties: " + propNames);
|
|
178
|
+
});
|
|
179
|
+
});
|
|
180
|
+
}
|
|
181
|
+
function getMajorVersion(javaProperties) {
|
|
182
|
+
let versionString = javaProperties.get("java.version");
|
|
183
|
+
let pieces = versionString.split(".");
|
|
184
|
+
let major = parseInt(pieces[0]);
|
|
185
|
+
return major == 1 ? parseInt(pieces[1]) : major;
|
|
186
|
+
}
|
|
187
|
+
function correctBinname(binname) {
|
|
188
|
+
if (process.platform === "win32")
|
|
189
|
+
return binname + ".exe";
|
|
190
|
+
else
|
|
191
|
+
return binname;
|
|
192
|
+
}
|
|
193
|
+
}
|
|
194
|
+
});
|
|
195
|
+
|
|
196
|
+
// node_modules/@pivotal-tools/jvm-launch-utils/lib/index.js
|
|
197
|
+
var require_lib = __commonJS({
|
|
198
|
+
"node_modules/@pivotal-tools/jvm-launch-utils/lib/index.js"(exports2) {
|
|
199
|
+
"use strict";
|
|
200
|
+
Object.defineProperty(exports2, "__esModule", { value: true });
|
|
201
|
+
exports2.findJvm = exports2.findJdk = void 0;
|
|
202
|
+
var jvm_util_1 = require_jvm_util();
|
|
203
|
+
Object.defineProperty(exports2, "findJdk", { enumerable: true, get: function() {
|
|
204
|
+
return jvm_util_1.findJdk;
|
|
205
|
+
} });
|
|
206
|
+
Object.defineProperty(exports2, "findJvm", { enumerable: true, get: function() {
|
|
207
|
+
return jvm_util_1.findJvm;
|
|
208
|
+
} });
|
|
209
|
+
}
|
|
210
|
+
});
|
|
211
|
+
|
|
212
|
+
// node_modules/async/dist/async.js
|
|
213
|
+
var require_async = __commonJS({
|
|
214
|
+
"node_modules/async/dist/async.js"(exports2, module2) {
|
|
215
|
+
(function(global2, factory) {
|
|
216
|
+
typeof exports2 === "object" && typeof module2 !== "undefined" ? factory(exports2) : typeof define === "function" && define.amd ? define(["exports"], factory) : factory(global2.async = global2.async || {});
|
|
217
|
+
})(exports2, function(exports3) {
|
|
218
|
+
"use strict";
|
|
219
|
+
function slice(arrayLike, start) {
|
|
220
|
+
start = start | 0;
|
|
221
|
+
var newLen = Math.max(arrayLike.length - start, 0);
|
|
222
|
+
var newArr = Array(newLen);
|
|
223
|
+
for (var idx = 0; idx < newLen; idx++) {
|
|
224
|
+
newArr[idx] = arrayLike[start + idx];
|
|
225
|
+
}
|
|
226
|
+
return newArr;
|
|
227
|
+
}
|
|
228
|
+
var apply = function(fn) {
|
|
229
|
+
var args = slice(arguments, 1);
|
|
230
|
+
return function() {
|
|
231
|
+
var callArgs = slice(arguments);
|
|
232
|
+
return fn.apply(null, args.concat(callArgs));
|
|
233
|
+
};
|
|
234
|
+
};
|
|
235
|
+
var initialParams = function(fn) {
|
|
236
|
+
return function() {
|
|
237
|
+
var args = slice(arguments);
|
|
238
|
+
var callback = args.pop();
|
|
239
|
+
fn.call(this, args, callback);
|
|
240
|
+
};
|
|
241
|
+
};
|
|
242
|
+
function isObject(value) {
|
|
243
|
+
var type = typeof value;
|
|
244
|
+
return value != null && (type == "object" || type == "function");
|
|
245
|
+
}
|
|
246
|
+
var hasSetImmediate = typeof setImmediate === "function" && setImmediate;
|
|
247
|
+
var hasNextTick = typeof process === "object" && typeof process.nextTick === "function";
|
|
248
|
+
function fallback(fn) {
|
|
249
|
+
setTimeout(fn, 0);
|
|
250
|
+
}
|
|
251
|
+
function wrap(defer) {
|
|
252
|
+
return function(fn) {
|
|
253
|
+
var args = slice(arguments, 1);
|
|
254
|
+
defer(function() {
|
|
255
|
+
fn.apply(null, args);
|
|
256
|
+
});
|
|
257
|
+
};
|
|
258
|
+
}
|
|
259
|
+
var _defer;
|
|
260
|
+
if (hasSetImmediate) {
|
|
261
|
+
_defer = setImmediate;
|
|
262
|
+
} else if (hasNextTick) {
|
|
263
|
+
_defer = process.nextTick;
|
|
264
|
+
} else {
|
|
265
|
+
_defer = fallback;
|
|
266
|
+
}
|
|
267
|
+
var setImmediate$1 = wrap(_defer);
|
|
268
|
+
function asyncify(func) {
|
|
269
|
+
return initialParams(function(args, callback) {
|
|
270
|
+
var result;
|
|
271
|
+
try {
|
|
272
|
+
result = func.apply(this, args);
|
|
273
|
+
} catch (e) {
|
|
274
|
+
return callback(e);
|
|
275
|
+
}
|
|
276
|
+
if (isObject(result) && typeof result.then === "function") {
|
|
277
|
+
result.then(function(value) {
|
|
278
|
+
invokeCallback(callback, null, value);
|
|
279
|
+
}, function(err) {
|
|
280
|
+
invokeCallback(callback, err.message ? err : new Error(err));
|
|
281
|
+
});
|
|
282
|
+
} else {
|
|
283
|
+
callback(null, result);
|
|
284
|
+
}
|
|
285
|
+
});
|
|
286
|
+
}
|
|
287
|
+
function invokeCallback(callback, error, value) {
|
|
288
|
+
try {
|
|
289
|
+
callback(error, value);
|
|
290
|
+
} catch (e) {
|
|
291
|
+
setImmediate$1(rethrow, e);
|
|
292
|
+
}
|
|
293
|
+
}
|
|
294
|
+
function rethrow(error) {
|
|
295
|
+
throw error;
|
|
296
|
+
}
|
|
297
|
+
var supportsSymbol = typeof Symbol === "function";
|
|
298
|
+
function isAsync(fn) {
|
|
299
|
+
return supportsSymbol && fn[Symbol.toStringTag] === "AsyncFunction";
|
|
300
|
+
}
|
|
301
|
+
function wrapAsync(asyncFn) {
|
|
302
|
+
return isAsync(asyncFn) ? asyncify(asyncFn) : asyncFn;
|
|
303
|
+
}
|
|
304
|
+
function applyEach$1(eachfn) {
|
|
305
|
+
return function(fns) {
|
|
306
|
+
var args = slice(arguments, 1);
|
|
307
|
+
var go = initialParams(function(args2, callback) {
|
|
308
|
+
var that = this;
|
|
309
|
+
return eachfn(fns, function(fn, cb) {
|
|
310
|
+
wrapAsync(fn).apply(that, args2.concat(cb));
|
|
311
|
+
}, callback);
|
|
312
|
+
});
|
|
313
|
+
if (args.length) {
|
|
314
|
+
return go.apply(this, args);
|
|
315
|
+
} else {
|
|
316
|
+
return go;
|
|
317
|
+
}
|
|
318
|
+
};
|
|
319
|
+
}
|
|
320
|
+
var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
|
|
321
|
+
var freeSelf = typeof self == "object" && self && self.Object === Object && self;
|
|
322
|
+
var root = freeGlobal || freeSelf || Function("return this")();
|
|
323
|
+
var Symbol$1 = root.Symbol;
|
|
324
|
+
var objectProto = Object.prototype;
|
|
325
|
+
var hasOwnProperty = objectProto.hasOwnProperty;
|
|
326
|
+
var nativeObjectToString = objectProto.toString;
|
|
327
|
+
var symToStringTag$1 = Symbol$1 ? Symbol$1.toStringTag : void 0;
|
|
328
|
+
function getRawTag(value) {
|
|
329
|
+
var isOwn = hasOwnProperty.call(value, symToStringTag$1), tag = value[symToStringTag$1];
|
|
330
|
+
try {
|
|
331
|
+
value[symToStringTag$1] = void 0;
|
|
332
|
+
var unmasked = true;
|
|
333
|
+
} catch (e) {
|
|
334
|
+
}
|
|
335
|
+
var result = nativeObjectToString.call(value);
|
|
336
|
+
if (unmasked) {
|
|
337
|
+
if (isOwn) {
|
|
338
|
+
value[symToStringTag$1] = tag;
|
|
339
|
+
} else {
|
|
340
|
+
delete value[symToStringTag$1];
|
|
341
|
+
}
|
|
342
|
+
}
|
|
343
|
+
return result;
|
|
344
|
+
}
|
|
345
|
+
var objectProto$1 = Object.prototype;
|
|
346
|
+
var nativeObjectToString$1 = objectProto$1.toString;
|
|
347
|
+
function objectToString(value) {
|
|
348
|
+
return nativeObjectToString$1.call(value);
|
|
349
|
+
}
|
|
350
|
+
var nullTag = "[object Null]";
|
|
351
|
+
var undefinedTag = "[object Undefined]";
|
|
352
|
+
var symToStringTag = Symbol$1 ? Symbol$1.toStringTag : void 0;
|
|
353
|
+
function baseGetTag(value) {
|
|
354
|
+
if (value == null) {
|
|
355
|
+
return value === void 0 ? undefinedTag : nullTag;
|
|
356
|
+
}
|
|
357
|
+
return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
|
|
358
|
+
}
|
|
359
|
+
var asyncTag = "[object AsyncFunction]";
|
|
360
|
+
var funcTag = "[object Function]";
|
|
361
|
+
var genTag = "[object GeneratorFunction]";
|
|
362
|
+
var proxyTag = "[object Proxy]";
|
|
363
|
+
function isFunction(value) {
|
|
364
|
+
if (!isObject(value)) {
|
|
365
|
+
return false;
|
|
366
|
+
}
|
|
367
|
+
var tag = baseGetTag(value);
|
|
368
|
+
return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
|
|
369
|
+
}
|
|
370
|
+
var MAX_SAFE_INTEGER = 9007199254740991;
|
|
371
|
+
function isLength(value) {
|
|
372
|
+
return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
|
|
373
|
+
}
|
|
374
|
+
function isArrayLike(value) {
|
|
375
|
+
return value != null && isLength(value.length) && !isFunction(value);
|
|
376
|
+
}
|
|
377
|
+
var breakLoop = {};
|
|
378
|
+
function noop() {
|
|
379
|
+
}
|
|
380
|
+
function once(fn) {
|
|
381
|
+
return function() {
|
|
382
|
+
if (fn === null)
|
|
383
|
+
return;
|
|
384
|
+
var callFn = fn;
|
|
385
|
+
fn = null;
|
|
386
|
+
callFn.apply(this, arguments);
|
|
387
|
+
};
|
|
388
|
+
}
|
|
389
|
+
var iteratorSymbol = typeof Symbol === "function" && Symbol.iterator;
|
|
390
|
+
var getIterator = function(coll) {
|
|
391
|
+
return iteratorSymbol && coll[iteratorSymbol] && coll[iteratorSymbol]();
|
|
392
|
+
};
|
|
393
|
+
function baseTimes(n, iteratee) {
|
|
394
|
+
var index2 = -1, result = Array(n);
|
|
395
|
+
while (++index2 < n) {
|
|
396
|
+
result[index2] = iteratee(index2);
|
|
397
|
+
}
|
|
398
|
+
return result;
|
|
399
|
+
}
|
|
400
|
+
function isObjectLike(value) {
|
|
401
|
+
return value != null && typeof value == "object";
|
|
402
|
+
}
|
|
403
|
+
var argsTag = "[object Arguments]";
|
|
404
|
+
function baseIsArguments(value) {
|
|
405
|
+
return isObjectLike(value) && baseGetTag(value) == argsTag;
|
|
406
|
+
}
|
|
407
|
+
var objectProto$3 = Object.prototype;
|
|
408
|
+
var hasOwnProperty$2 = objectProto$3.hasOwnProperty;
|
|
409
|
+
var propertyIsEnumerable = objectProto$3.propertyIsEnumerable;
|
|
410
|
+
var isArguments = baseIsArguments(/* @__PURE__ */ function() {
|
|
411
|
+
return arguments;
|
|
412
|
+
}()) ? baseIsArguments : function(value) {
|
|
413
|
+
return isObjectLike(value) && hasOwnProperty$2.call(value, "callee") && !propertyIsEnumerable.call(value, "callee");
|
|
414
|
+
};
|
|
415
|
+
var isArray = Array.isArray;
|
|
416
|
+
function stubFalse() {
|
|
417
|
+
return false;
|
|
418
|
+
}
|
|
419
|
+
var freeExports = typeof exports3 == "object" && exports3 && !exports3.nodeType && exports3;
|
|
420
|
+
var freeModule = freeExports && typeof module2 == "object" && module2 && !module2.nodeType && module2;
|
|
421
|
+
var moduleExports = freeModule && freeModule.exports === freeExports;
|
|
422
|
+
var Buffer2 = moduleExports ? root.Buffer : void 0;
|
|
423
|
+
var nativeIsBuffer = Buffer2 ? Buffer2.isBuffer : void 0;
|
|
424
|
+
var isBuffer = nativeIsBuffer || stubFalse;
|
|
425
|
+
var MAX_SAFE_INTEGER$1 = 9007199254740991;
|
|
426
|
+
var reIsUint = /^(?:0|[1-9]\d*)$/;
|
|
427
|
+
function isIndex(value, length) {
|
|
428
|
+
var type = typeof value;
|
|
429
|
+
length = length == null ? MAX_SAFE_INTEGER$1 : length;
|
|
430
|
+
return !!length && (type == "number" || type != "symbol" && reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
|
|
431
|
+
}
|
|
432
|
+
var argsTag$1 = "[object Arguments]";
|
|
433
|
+
var arrayTag = "[object Array]";
|
|
434
|
+
var boolTag = "[object Boolean]";
|
|
435
|
+
var dateTag = "[object Date]";
|
|
436
|
+
var errorTag = "[object Error]";
|
|
437
|
+
var funcTag$1 = "[object Function]";
|
|
438
|
+
var mapTag = "[object Map]";
|
|
439
|
+
var numberTag = "[object Number]";
|
|
440
|
+
var objectTag = "[object Object]";
|
|
441
|
+
var regexpTag = "[object RegExp]";
|
|
442
|
+
var setTag = "[object Set]";
|
|
443
|
+
var stringTag = "[object String]";
|
|
444
|
+
var weakMapTag = "[object WeakMap]";
|
|
445
|
+
var arrayBufferTag = "[object ArrayBuffer]";
|
|
446
|
+
var dataViewTag = "[object DataView]";
|
|
447
|
+
var float32Tag = "[object Float32Array]";
|
|
448
|
+
var float64Tag = "[object Float64Array]";
|
|
449
|
+
var int8Tag = "[object Int8Array]";
|
|
450
|
+
var int16Tag = "[object Int16Array]";
|
|
451
|
+
var int32Tag = "[object Int32Array]";
|
|
452
|
+
var uint8Tag = "[object Uint8Array]";
|
|
453
|
+
var uint8ClampedTag = "[object Uint8ClampedArray]";
|
|
454
|
+
var uint16Tag = "[object Uint16Array]";
|
|
455
|
+
var uint32Tag = "[object Uint32Array]";
|
|
456
|
+
var typedArrayTags = {};
|
|
457
|
+
typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;
|
|
458
|
+
typedArrayTags[argsTag$1] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag$1] = typedArrayTags[mapTag] = typedArrayTags[numberTag] = typedArrayTags[objectTag] = typedArrayTags[regexpTag] = typedArrayTags[setTag] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;
|
|
459
|
+
function baseIsTypedArray(value) {
|
|
460
|
+
return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
|
|
461
|
+
}
|
|
462
|
+
function baseUnary(func) {
|
|
463
|
+
return function(value) {
|
|
464
|
+
return func(value);
|
|
465
|
+
};
|
|
466
|
+
}
|
|
467
|
+
var freeExports$1 = typeof exports3 == "object" && exports3 && !exports3.nodeType && exports3;
|
|
468
|
+
var freeModule$1 = freeExports$1 && typeof module2 == "object" && module2 && !module2.nodeType && module2;
|
|
469
|
+
var moduleExports$1 = freeModule$1 && freeModule$1.exports === freeExports$1;
|
|
470
|
+
var freeProcess = moduleExports$1 && freeGlobal.process;
|
|
471
|
+
var nodeUtil = function() {
|
|
472
|
+
try {
|
|
473
|
+
var types = freeModule$1 && freeModule$1.require && freeModule$1.require("util").types;
|
|
474
|
+
if (types) {
|
|
475
|
+
return types;
|
|
476
|
+
}
|
|
477
|
+
return freeProcess && freeProcess.binding && freeProcess.binding("util");
|
|
478
|
+
} catch (e) {
|
|
479
|
+
}
|
|
480
|
+
}();
|
|
481
|
+
var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
|
|
482
|
+
var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
|
|
483
|
+
var objectProto$2 = Object.prototype;
|
|
484
|
+
var hasOwnProperty$1 = objectProto$2.hasOwnProperty;
|
|
485
|
+
function arrayLikeKeys(value, inherited) {
|
|
486
|
+
var isArr = isArray(value), isArg = !isArr && isArguments(value), isBuff = !isArr && !isArg && isBuffer(value), isType = !isArr && !isArg && !isBuff && isTypedArray(value), skipIndexes = isArr || isArg || isBuff || isType, result = skipIndexes ? baseTimes(value.length, String) : [], length = result.length;
|
|
487
|
+
for (var key in value) {
|
|
488
|
+
if ((inherited || hasOwnProperty$1.call(value, key)) && !(skipIndexes && // Safari 9 has enumerable `arguments.length` in strict mode.
|
|
489
|
+
(key == "length" || // Node.js 0.10 has enumerable non-index properties on buffers.
|
|
490
|
+
isBuff && (key == "offset" || key == "parent") || // PhantomJS 2 has enumerable non-index properties on typed arrays.
|
|
491
|
+
isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || // Skip index properties.
|
|
492
|
+
isIndex(key, length)))) {
|
|
493
|
+
result.push(key);
|
|
494
|
+
}
|
|
495
|
+
}
|
|
496
|
+
return result;
|
|
497
|
+
}
|
|
498
|
+
var objectProto$5 = Object.prototype;
|
|
499
|
+
function isPrototype(value) {
|
|
500
|
+
var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto$5;
|
|
501
|
+
return value === proto;
|
|
502
|
+
}
|
|
503
|
+
function overArg(func, transform2) {
|
|
504
|
+
return function(arg) {
|
|
505
|
+
return func(transform2(arg));
|
|
506
|
+
};
|
|
507
|
+
}
|
|
508
|
+
var nativeKeys = overArg(Object.keys, Object);
|
|
509
|
+
var objectProto$4 = Object.prototype;
|
|
510
|
+
var hasOwnProperty$3 = objectProto$4.hasOwnProperty;
|
|
511
|
+
function baseKeys(object) {
|
|
512
|
+
if (!isPrototype(object)) {
|
|
513
|
+
return nativeKeys(object);
|
|
514
|
+
}
|
|
515
|
+
var result = [];
|
|
516
|
+
for (var key in Object(object)) {
|
|
517
|
+
if (hasOwnProperty$3.call(object, key) && key != "constructor") {
|
|
518
|
+
result.push(key);
|
|
519
|
+
}
|
|
520
|
+
}
|
|
521
|
+
return result;
|
|
522
|
+
}
|
|
523
|
+
function keys(object) {
|
|
524
|
+
return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
|
|
525
|
+
}
|
|
526
|
+
function createArrayIterator(coll) {
|
|
527
|
+
var i = -1;
|
|
528
|
+
var len = coll.length;
|
|
529
|
+
return function next() {
|
|
530
|
+
return ++i < len ? { value: coll[i], key: i } : null;
|
|
531
|
+
};
|
|
532
|
+
}
|
|
533
|
+
function createES2015Iterator(iterator2) {
|
|
534
|
+
var i = -1;
|
|
535
|
+
return function next() {
|
|
536
|
+
var item = iterator2.next();
|
|
537
|
+
if (item.done)
|
|
538
|
+
return null;
|
|
539
|
+
i++;
|
|
540
|
+
return { value: item.value, key: i };
|
|
541
|
+
};
|
|
542
|
+
}
|
|
543
|
+
function createObjectIterator(obj) {
|
|
544
|
+
var okeys = keys(obj);
|
|
545
|
+
var i = -1;
|
|
546
|
+
var len = okeys.length;
|
|
547
|
+
return function next() {
|
|
548
|
+
var key = okeys[++i];
|
|
549
|
+
if (key === "__proto__") {
|
|
550
|
+
return next();
|
|
551
|
+
}
|
|
552
|
+
return i < len ? { value: obj[key], key } : null;
|
|
553
|
+
};
|
|
554
|
+
}
|
|
555
|
+
function iterator(coll) {
|
|
556
|
+
if (isArrayLike(coll)) {
|
|
557
|
+
return createArrayIterator(coll);
|
|
558
|
+
}
|
|
559
|
+
var iterator2 = getIterator(coll);
|
|
560
|
+
return iterator2 ? createES2015Iterator(iterator2) : createObjectIterator(coll);
|
|
561
|
+
}
|
|
562
|
+
function onlyOnce(fn) {
|
|
563
|
+
return function() {
|
|
564
|
+
if (fn === null)
|
|
565
|
+
throw new Error("Callback was already called.");
|
|
566
|
+
var callFn = fn;
|
|
567
|
+
fn = null;
|
|
568
|
+
callFn.apply(this, arguments);
|
|
569
|
+
};
|
|
570
|
+
}
|
|
571
|
+
function _eachOfLimit(limit) {
|
|
572
|
+
return function(obj, iteratee, callback) {
|
|
573
|
+
callback = once(callback || noop);
|
|
574
|
+
if (limit <= 0 || !obj) {
|
|
575
|
+
return callback(null);
|
|
576
|
+
}
|
|
577
|
+
var nextElem = iterator(obj);
|
|
578
|
+
var done = false;
|
|
579
|
+
var running = 0;
|
|
580
|
+
var looping = false;
|
|
581
|
+
function iterateeCallback(err, value) {
|
|
582
|
+
running -= 1;
|
|
583
|
+
if (err) {
|
|
584
|
+
done = true;
|
|
585
|
+
callback(err);
|
|
586
|
+
} else if (value === breakLoop || done && running <= 0) {
|
|
587
|
+
done = true;
|
|
588
|
+
return callback(null);
|
|
589
|
+
} else if (!looping) {
|
|
590
|
+
replenish();
|
|
591
|
+
}
|
|
592
|
+
}
|
|
593
|
+
function replenish() {
|
|
594
|
+
looping = true;
|
|
595
|
+
while (running < limit && !done) {
|
|
596
|
+
var elem = nextElem();
|
|
597
|
+
if (elem === null) {
|
|
598
|
+
done = true;
|
|
599
|
+
if (running <= 0) {
|
|
600
|
+
callback(null);
|
|
601
|
+
}
|
|
602
|
+
return;
|
|
603
|
+
}
|
|
604
|
+
running += 1;
|
|
605
|
+
iteratee(elem.value, elem.key, onlyOnce(iterateeCallback));
|
|
606
|
+
}
|
|
607
|
+
looping = false;
|
|
608
|
+
}
|
|
609
|
+
replenish();
|
|
610
|
+
};
|
|
611
|
+
}
|
|
612
|
+
function eachOfLimit(coll, limit, iteratee, callback) {
|
|
613
|
+
_eachOfLimit(limit)(coll, wrapAsync(iteratee), callback);
|
|
614
|
+
}
|
|
615
|
+
function doLimit(fn, limit) {
|
|
616
|
+
return function(iterable, iteratee, callback) {
|
|
617
|
+
return fn(iterable, limit, iteratee, callback);
|
|
618
|
+
};
|
|
619
|
+
}
|
|
620
|
+
function eachOfArrayLike(coll, iteratee, callback) {
|
|
621
|
+
callback = once(callback || noop);
|
|
622
|
+
var index2 = 0, completed = 0, length = coll.length;
|
|
623
|
+
if (length === 0) {
|
|
624
|
+
callback(null);
|
|
625
|
+
}
|
|
626
|
+
function iteratorCallback(err, value) {
|
|
627
|
+
if (err) {
|
|
628
|
+
callback(err);
|
|
629
|
+
} else if (++completed === length || value === breakLoop) {
|
|
630
|
+
callback(null);
|
|
631
|
+
}
|
|
632
|
+
}
|
|
633
|
+
for (; index2 < length; index2++) {
|
|
634
|
+
iteratee(coll[index2], index2, onlyOnce(iteratorCallback));
|
|
635
|
+
}
|
|
636
|
+
}
|
|
637
|
+
var eachOfGeneric = doLimit(eachOfLimit, Infinity);
|
|
638
|
+
var eachOf = function(coll, iteratee, callback) {
|
|
639
|
+
var eachOfImplementation = isArrayLike(coll) ? eachOfArrayLike : eachOfGeneric;
|
|
640
|
+
eachOfImplementation(coll, wrapAsync(iteratee), callback);
|
|
641
|
+
};
|
|
642
|
+
function doParallel(fn) {
|
|
643
|
+
return function(obj, iteratee, callback) {
|
|
644
|
+
return fn(eachOf, obj, wrapAsync(iteratee), callback);
|
|
645
|
+
};
|
|
646
|
+
}
|
|
647
|
+
function _asyncMap(eachfn, arr, iteratee, callback) {
|
|
648
|
+
callback = callback || noop;
|
|
649
|
+
arr = arr || [];
|
|
650
|
+
var results = [];
|
|
651
|
+
var counter = 0;
|
|
652
|
+
var _iteratee = wrapAsync(iteratee);
|
|
653
|
+
eachfn(arr, function(value, _, callback2) {
|
|
654
|
+
var index2 = counter++;
|
|
655
|
+
_iteratee(value, function(err, v) {
|
|
656
|
+
results[index2] = v;
|
|
657
|
+
callback2(err);
|
|
658
|
+
});
|
|
659
|
+
}, function(err) {
|
|
660
|
+
callback(err, results);
|
|
661
|
+
});
|
|
662
|
+
}
|
|
663
|
+
var map = doParallel(_asyncMap);
|
|
664
|
+
var applyEach = applyEach$1(map);
|
|
665
|
+
function doParallelLimit(fn) {
|
|
666
|
+
return function(obj, limit, iteratee, callback) {
|
|
667
|
+
return fn(_eachOfLimit(limit), obj, wrapAsync(iteratee), callback);
|
|
668
|
+
};
|
|
669
|
+
}
|
|
670
|
+
var mapLimit = doParallelLimit(_asyncMap);
|
|
671
|
+
var mapSeries = doLimit(mapLimit, 1);
|
|
672
|
+
var applyEachSeries = applyEach$1(mapSeries);
|
|
673
|
+
function arrayEach(array, iteratee) {
|
|
674
|
+
var index2 = -1, length = array == null ? 0 : array.length;
|
|
675
|
+
while (++index2 < length) {
|
|
676
|
+
if (iteratee(array[index2], index2, array) === false) {
|
|
677
|
+
break;
|
|
678
|
+
}
|
|
679
|
+
}
|
|
680
|
+
return array;
|
|
681
|
+
}
|
|
682
|
+
function createBaseFor(fromRight) {
|
|
683
|
+
return function(object, iteratee, keysFunc) {
|
|
684
|
+
var index2 = -1, iterable = Object(object), props = keysFunc(object), length = props.length;
|
|
685
|
+
while (length--) {
|
|
686
|
+
var key = props[fromRight ? length : ++index2];
|
|
687
|
+
if (iteratee(iterable[key], key, iterable) === false) {
|
|
688
|
+
break;
|
|
689
|
+
}
|
|
690
|
+
}
|
|
691
|
+
return object;
|
|
692
|
+
};
|
|
693
|
+
}
|
|
694
|
+
var baseFor = createBaseFor();
|
|
695
|
+
function baseForOwn(object, iteratee) {
|
|
696
|
+
return object && baseFor(object, iteratee, keys);
|
|
697
|
+
}
|
|
698
|
+
function baseFindIndex(array, predicate, fromIndex, fromRight) {
|
|
699
|
+
var length = array.length, index2 = fromIndex + (fromRight ? 1 : -1);
|
|
700
|
+
while (fromRight ? index2-- : ++index2 < length) {
|
|
701
|
+
if (predicate(array[index2], index2, array)) {
|
|
702
|
+
return index2;
|
|
703
|
+
}
|
|
704
|
+
}
|
|
705
|
+
return -1;
|
|
706
|
+
}
|
|
707
|
+
function baseIsNaN(value) {
|
|
708
|
+
return value !== value;
|
|
709
|
+
}
|
|
710
|
+
function strictIndexOf(array, value, fromIndex) {
|
|
711
|
+
var index2 = fromIndex - 1, length = array.length;
|
|
712
|
+
while (++index2 < length) {
|
|
713
|
+
if (array[index2] === value) {
|
|
714
|
+
return index2;
|
|
715
|
+
}
|
|
716
|
+
}
|
|
717
|
+
return -1;
|
|
718
|
+
}
|
|
719
|
+
function baseIndexOf(array, value, fromIndex) {
|
|
720
|
+
return value === value ? strictIndexOf(array, value, fromIndex) : baseFindIndex(array, baseIsNaN, fromIndex);
|
|
721
|
+
}
|
|
722
|
+
var auto = function(tasks, concurrency, callback) {
|
|
723
|
+
if (typeof concurrency === "function") {
|
|
724
|
+
callback = concurrency;
|
|
725
|
+
concurrency = null;
|
|
726
|
+
}
|
|
727
|
+
callback = once(callback || noop);
|
|
728
|
+
var keys$$1 = keys(tasks);
|
|
729
|
+
var numTasks = keys$$1.length;
|
|
730
|
+
if (!numTasks) {
|
|
731
|
+
return callback(null);
|
|
732
|
+
}
|
|
733
|
+
if (!concurrency) {
|
|
734
|
+
concurrency = numTasks;
|
|
735
|
+
}
|
|
736
|
+
var results = {};
|
|
737
|
+
var runningTasks = 0;
|
|
738
|
+
var hasError = false;
|
|
739
|
+
var listeners = /* @__PURE__ */ Object.create(null);
|
|
740
|
+
var readyTasks = [];
|
|
741
|
+
var readyToCheck = [];
|
|
742
|
+
var uncheckedDependencies = {};
|
|
743
|
+
baseForOwn(tasks, function(task, key) {
|
|
744
|
+
if (!isArray(task)) {
|
|
745
|
+
enqueueTask(key, [task]);
|
|
746
|
+
readyToCheck.push(key);
|
|
747
|
+
return;
|
|
748
|
+
}
|
|
749
|
+
var dependencies = task.slice(0, task.length - 1);
|
|
750
|
+
var remainingDependencies = dependencies.length;
|
|
751
|
+
if (remainingDependencies === 0) {
|
|
752
|
+
enqueueTask(key, task);
|
|
753
|
+
readyToCheck.push(key);
|
|
754
|
+
return;
|
|
755
|
+
}
|
|
756
|
+
uncheckedDependencies[key] = remainingDependencies;
|
|
757
|
+
arrayEach(dependencies, function(dependencyName) {
|
|
758
|
+
if (!tasks[dependencyName]) {
|
|
759
|
+
throw new Error("async.auto task `" + key + "` has a non-existent dependency `" + dependencyName + "` in " + dependencies.join(", "));
|
|
760
|
+
}
|
|
761
|
+
addListener(dependencyName, function() {
|
|
762
|
+
remainingDependencies--;
|
|
763
|
+
if (remainingDependencies === 0) {
|
|
764
|
+
enqueueTask(key, task);
|
|
765
|
+
}
|
|
766
|
+
});
|
|
767
|
+
});
|
|
768
|
+
});
|
|
769
|
+
checkForDeadlocks();
|
|
770
|
+
processQueue();
|
|
771
|
+
function enqueueTask(key, task) {
|
|
772
|
+
readyTasks.push(function() {
|
|
773
|
+
runTask(key, task);
|
|
774
|
+
});
|
|
775
|
+
}
|
|
776
|
+
function processQueue() {
|
|
777
|
+
if (readyTasks.length === 0 && runningTasks === 0) {
|
|
778
|
+
return callback(null, results);
|
|
779
|
+
}
|
|
780
|
+
while (readyTasks.length && runningTasks < concurrency) {
|
|
781
|
+
var run = readyTasks.shift();
|
|
782
|
+
run();
|
|
783
|
+
}
|
|
784
|
+
}
|
|
785
|
+
function addListener(taskName, fn) {
|
|
786
|
+
var taskListeners = listeners[taskName];
|
|
787
|
+
if (!taskListeners) {
|
|
788
|
+
taskListeners = listeners[taskName] = [];
|
|
789
|
+
}
|
|
790
|
+
taskListeners.push(fn);
|
|
791
|
+
}
|
|
792
|
+
function taskComplete(taskName) {
|
|
793
|
+
var taskListeners = listeners[taskName] || [];
|
|
794
|
+
arrayEach(taskListeners, function(fn) {
|
|
795
|
+
fn();
|
|
796
|
+
});
|
|
797
|
+
processQueue();
|
|
798
|
+
}
|
|
799
|
+
function runTask(key, task) {
|
|
800
|
+
if (hasError)
|
|
801
|
+
return;
|
|
802
|
+
var taskCallback = onlyOnce(function(err, result) {
|
|
803
|
+
runningTasks--;
|
|
804
|
+
if (arguments.length > 2) {
|
|
805
|
+
result = slice(arguments, 1);
|
|
806
|
+
}
|
|
807
|
+
if (err) {
|
|
808
|
+
var safeResults = {};
|
|
809
|
+
baseForOwn(results, function(val, rkey) {
|
|
810
|
+
safeResults[rkey] = val;
|
|
811
|
+
});
|
|
812
|
+
safeResults[key] = result;
|
|
813
|
+
hasError = true;
|
|
814
|
+
listeners = /* @__PURE__ */ Object.create(null);
|
|
815
|
+
callback(err, safeResults);
|
|
816
|
+
} else {
|
|
817
|
+
results[key] = result;
|
|
818
|
+
taskComplete(key);
|
|
819
|
+
}
|
|
820
|
+
});
|
|
821
|
+
runningTasks++;
|
|
822
|
+
var taskFn = wrapAsync(task[task.length - 1]);
|
|
823
|
+
if (task.length > 1) {
|
|
824
|
+
taskFn(results, taskCallback);
|
|
825
|
+
} else {
|
|
826
|
+
taskFn(taskCallback);
|
|
827
|
+
}
|
|
828
|
+
}
|
|
829
|
+
function checkForDeadlocks() {
|
|
830
|
+
var currentTask;
|
|
831
|
+
var counter = 0;
|
|
832
|
+
while (readyToCheck.length) {
|
|
833
|
+
currentTask = readyToCheck.pop();
|
|
834
|
+
counter++;
|
|
835
|
+
arrayEach(getDependents(currentTask), function(dependent) {
|
|
836
|
+
if (--uncheckedDependencies[dependent] === 0) {
|
|
837
|
+
readyToCheck.push(dependent);
|
|
838
|
+
}
|
|
839
|
+
});
|
|
840
|
+
}
|
|
841
|
+
if (counter !== numTasks) {
|
|
842
|
+
throw new Error(
|
|
843
|
+
"async.auto cannot execute tasks due to a recursive dependency"
|
|
844
|
+
);
|
|
845
|
+
}
|
|
846
|
+
}
|
|
847
|
+
function getDependents(taskName) {
|
|
848
|
+
var result = [];
|
|
849
|
+
baseForOwn(tasks, function(task, key) {
|
|
850
|
+
if (isArray(task) && baseIndexOf(task, taskName, 0) >= 0) {
|
|
851
|
+
result.push(key);
|
|
852
|
+
}
|
|
853
|
+
});
|
|
854
|
+
return result;
|
|
855
|
+
}
|
|
856
|
+
};
|
|
857
|
+
function arrayMap(array, iteratee) {
|
|
858
|
+
var index2 = -1, length = array == null ? 0 : array.length, result = Array(length);
|
|
859
|
+
while (++index2 < length) {
|
|
860
|
+
result[index2] = iteratee(array[index2], index2, array);
|
|
861
|
+
}
|
|
862
|
+
return result;
|
|
863
|
+
}
|
|
864
|
+
var symbolTag = "[object Symbol]";
|
|
865
|
+
function isSymbol(value) {
|
|
866
|
+
return typeof value == "symbol" || isObjectLike(value) && baseGetTag(value) == symbolTag;
|
|
867
|
+
}
|
|
868
|
+
var INFINITY = 1 / 0;
|
|
869
|
+
var symbolProto = Symbol$1 ? Symbol$1.prototype : void 0;
|
|
870
|
+
var symbolToString = symbolProto ? symbolProto.toString : void 0;
|
|
871
|
+
function baseToString(value) {
|
|
872
|
+
if (typeof value == "string") {
|
|
873
|
+
return value;
|
|
874
|
+
}
|
|
875
|
+
if (isArray(value)) {
|
|
876
|
+
return arrayMap(value, baseToString) + "";
|
|
877
|
+
}
|
|
878
|
+
if (isSymbol(value)) {
|
|
879
|
+
return symbolToString ? symbolToString.call(value) : "";
|
|
880
|
+
}
|
|
881
|
+
var result = value + "";
|
|
882
|
+
return result == "0" && 1 / value == -INFINITY ? "-0" : result;
|
|
883
|
+
}
|
|
884
|
+
function baseSlice(array, start, end) {
|
|
885
|
+
var index2 = -1, length = array.length;
|
|
886
|
+
if (start < 0) {
|
|
887
|
+
start = -start > length ? 0 : length + start;
|
|
888
|
+
}
|
|
889
|
+
end = end > length ? length : end;
|
|
890
|
+
if (end < 0) {
|
|
891
|
+
end += length;
|
|
892
|
+
}
|
|
893
|
+
length = start > end ? 0 : end - start >>> 0;
|
|
894
|
+
start >>>= 0;
|
|
895
|
+
var result = Array(length);
|
|
896
|
+
while (++index2 < length) {
|
|
897
|
+
result[index2] = array[index2 + start];
|
|
898
|
+
}
|
|
899
|
+
return result;
|
|
900
|
+
}
|
|
901
|
+
function castSlice(array, start, end) {
|
|
902
|
+
var length = array.length;
|
|
903
|
+
end = end === void 0 ? length : end;
|
|
904
|
+
return !start && end >= length ? array : baseSlice(array, start, end);
|
|
905
|
+
}
|
|
906
|
+
function charsEndIndex(strSymbols, chrSymbols) {
|
|
907
|
+
var index2 = strSymbols.length;
|
|
908
|
+
while (index2-- && baseIndexOf(chrSymbols, strSymbols[index2], 0) > -1) {
|
|
909
|
+
}
|
|
910
|
+
return index2;
|
|
911
|
+
}
|
|
912
|
+
function charsStartIndex(strSymbols, chrSymbols) {
|
|
913
|
+
var index2 = -1, length = strSymbols.length;
|
|
914
|
+
while (++index2 < length && baseIndexOf(chrSymbols, strSymbols[index2], 0) > -1) {
|
|
915
|
+
}
|
|
916
|
+
return index2;
|
|
917
|
+
}
|
|
918
|
+
function asciiToArray(string) {
|
|
919
|
+
return string.split("");
|
|
920
|
+
}
|
|
921
|
+
var rsAstralRange = "\\ud800-\\udfff";
|
|
922
|
+
var rsComboMarksRange = "\\u0300-\\u036f";
|
|
923
|
+
var reComboHalfMarksRange = "\\ufe20-\\ufe2f";
|
|
924
|
+
var rsComboSymbolsRange = "\\u20d0-\\u20ff";
|
|
925
|
+
var rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange;
|
|
926
|
+
var rsVarRange = "\\ufe0e\\ufe0f";
|
|
927
|
+
var rsZWJ = "\\u200d";
|
|
928
|
+
var reHasUnicode = RegExp("[" + rsZWJ + rsAstralRange + rsComboRange + rsVarRange + "]");
|
|
929
|
+
function hasUnicode(string) {
|
|
930
|
+
return reHasUnicode.test(string);
|
|
931
|
+
}
|
|
932
|
+
var rsAstralRange$1 = "\\ud800-\\udfff";
|
|
933
|
+
var rsComboMarksRange$1 = "\\u0300-\\u036f";
|
|
934
|
+
var reComboHalfMarksRange$1 = "\\ufe20-\\ufe2f";
|
|
935
|
+
var rsComboSymbolsRange$1 = "\\u20d0-\\u20ff";
|
|
936
|
+
var rsComboRange$1 = rsComboMarksRange$1 + reComboHalfMarksRange$1 + rsComboSymbolsRange$1;
|
|
937
|
+
var rsVarRange$1 = "\\ufe0e\\ufe0f";
|
|
938
|
+
var rsAstral = "[" + rsAstralRange$1 + "]";
|
|
939
|
+
var rsCombo = "[" + rsComboRange$1 + "]";
|
|
940
|
+
var rsFitz = "\\ud83c[\\udffb-\\udfff]";
|
|
941
|
+
var rsModifier = "(?:" + rsCombo + "|" + rsFitz + ")";
|
|
942
|
+
var rsNonAstral = "[^" + rsAstralRange$1 + "]";
|
|
943
|
+
var rsRegional = "(?:\\ud83c[\\udde6-\\uddff]){2}";
|
|
944
|
+
var rsSurrPair = "[\\ud800-\\udbff][\\udc00-\\udfff]";
|
|
945
|
+
var rsZWJ$1 = "\\u200d";
|
|
946
|
+
var reOptMod = rsModifier + "?";
|
|
947
|
+
var rsOptVar = "[" + rsVarRange$1 + "]?";
|
|
948
|
+
var rsOptJoin = "(?:" + rsZWJ$1 + "(?:" + [rsNonAstral, rsRegional, rsSurrPair].join("|") + ")" + rsOptVar + reOptMod + ")*";
|
|
949
|
+
var rsSeq = rsOptVar + reOptMod + rsOptJoin;
|
|
950
|
+
var rsSymbol = "(?:" + [rsNonAstral + rsCombo + "?", rsCombo, rsRegional, rsSurrPair, rsAstral].join("|") + ")";
|
|
951
|
+
var reUnicode = RegExp(rsFitz + "(?=" + rsFitz + ")|" + rsSymbol + rsSeq, "g");
|
|
952
|
+
function unicodeToArray(string) {
|
|
953
|
+
return string.match(reUnicode) || [];
|
|
954
|
+
}
|
|
955
|
+
function stringToArray(string) {
|
|
956
|
+
return hasUnicode(string) ? unicodeToArray(string) : asciiToArray(string);
|
|
957
|
+
}
|
|
958
|
+
function toString(value) {
|
|
959
|
+
return value == null ? "" : baseToString(value);
|
|
960
|
+
}
|
|
961
|
+
var reTrim = /^\s+|\s+$/g;
|
|
962
|
+
function trim(string, chars, guard) {
|
|
963
|
+
string = toString(string);
|
|
964
|
+
if (string && (guard || chars === void 0)) {
|
|
965
|
+
return string.replace(reTrim, "");
|
|
966
|
+
}
|
|
967
|
+
if (!string || !(chars = baseToString(chars))) {
|
|
968
|
+
return string;
|
|
969
|
+
}
|
|
970
|
+
var strSymbols = stringToArray(string), chrSymbols = stringToArray(chars), start = charsStartIndex(strSymbols, chrSymbols), end = charsEndIndex(strSymbols, chrSymbols) + 1;
|
|
971
|
+
return castSlice(strSymbols, start, end).join("");
|
|
972
|
+
}
|
|
973
|
+
var FN_ARGS = /^(?:async\s+)?(function)?\s*[^\(]*\(\s*([^\)]*)\)/m;
|
|
974
|
+
var FN_ARG_SPLIT = /,/;
|
|
975
|
+
var FN_ARG = /(=.+)?(\s*)$/;
|
|
976
|
+
var STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/mg;
|
|
977
|
+
function parseParams(func) {
|
|
978
|
+
func = func.toString().replace(STRIP_COMMENTS, "");
|
|
979
|
+
func = func.match(FN_ARGS)[2].replace(" ", "");
|
|
980
|
+
func = func ? func.split(FN_ARG_SPLIT) : [];
|
|
981
|
+
func = func.map(function(arg) {
|
|
982
|
+
return trim(arg.replace(FN_ARG, ""));
|
|
983
|
+
});
|
|
984
|
+
return func;
|
|
985
|
+
}
|
|
986
|
+
function autoInject(tasks, callback) {
|
|
987
|
+
var newTasks = {};
|
|
988
|
+
baseForOwn(tasks, function(taskFn, key) {
|
|
989
|
+
var params;
|
|
990
|
+
var fnIsAsync = isAsync(taskFn);
|
|
991
|
+
var hasNoDeps = !fnIsAsync && taskFn.length === 1 || fnIsAsync && taskFn.length === 0;
|
|
992
|
+
if (isArray(taskFn)) {
|
|
993
|
+
params = taskFn.slice(0, -1);
|
|
994
|
+
taskFn = taskFn[taskFn.length - 1];
|
|
995
|
+
newTasks[key] = params.concat(params.length > 0 ? newTask : taskFn);
|
|
996
|
+
} else if (hasNoDeps) {
|
|
997
|
+
newTasks[key] = taskFn;
|
|
998
|
+
} else {
|
|
999
|
+
params = parseParams(taskFn);
|
|
1000
|
+
if (taskFn.length === 0 && !fnIsAsync && params.length === 0) {
|
|
1001
|
+
throw new Error("autoInject task functions require explicit parameters.");
|
|
1002
|
+
}
|
|
1003
|
+
if (!fnIsAsync)
|
|
1004
|
+
params.pop();
|
|
1005
|
+
newTasks[key] = params.concat(newTask);
|
|
1006
|
+
}
|
|
1007
|
+
function newTask(results, taskCb) {
|
|
1008
|
+
var newArgs = arrayMap(params, function(name) {
|
|
1009
|
+
return results[name];
|
|
1010
|
+
});
|
|
1011
|
+
newArgs.push(taskCb);
|
|
1012
|
+
wrapAsync(taskFn).apply(null, newArgs);
|
|
1013
|
+
}
|
|
1014
|
+
});
|
|
1015
|
+
auto(newTasks, callback);
|
|
1016
|
+
}
|
|
1017
|
+
function DLL() {
|
|
1018
|
+
this.head = this.tail = null;
|
|
1019
|
+
this.length = 0;
|
|
1020
|
+
}
|
|
1021
|
+
function setInitial(dll, node) {
|
|
1022
|
+
dll.length = 1;
|
|
1023
|
+
dll.head = dll.tail = node;
|
|
1024
|
+
}
|
|
1025
|
+
DLL.prototype.removeLink = function(node) {
|
|
1026
|
+
if (node.prev)
|
|
1027
|
+
node.prev.next = node.next;
|
|
1028
|
+
else
|
|
1029
|
+
this.head = node.next;
|
|
1030
|
+
if (node.next)
|
|
1031
|
+
node.next.prev = node.prev;
|
|
1032
|
+
else
|
|
1033
|
+
this.tail = node.prev;
|
|
1034
|
+
node.prev = node.next = null;
|
|
1035
|
+
this.length -= 1;
|
|
1036
|
+
return node;
|
|
1037
|
+
};
|
|
1038
|
+
DLL.prototype.empty = function() {
|
|
1039
|
+
while (this.head)
|
|
1040
|
+
this.shift();
|
|
1041
|
+
return this;
|
|
1042
|
+
};
|
|
1043
|
+
DLL.prototype.insertAfter = function(node, newNode) {
|
|
1044
|
+
newNode.prev = node;
|
|
1045
|
+
newNode.next = node.next;
|
|
1046
|
+
if (node.next)
|
|
1047
|
+
node.next.prev = newNode;
|
|
1048
|
+
else
|
|
1049
|
+
this.tail = newNode;
|
|
1050
|
+
node.next = newNode;
|
|
1051
|
+
this.length += 1;
|
|
1052
|
+
};
|
|
1053
|
+
DLL.prototype.insertBefore = function(node, newNode) {
|
|
1054
|
+
newNode.prev = node.prev;
|
|
1055
|
+
newNode.next = node;
|
|
1056
|
+
if (node.prev)
|
|
1057
|
+
node.prev.next = newNode;
|
|
1058
|
+
else
|
|
1059
|
+
this.head = newNode;
|
|
1060
|
+
node.prev = newNode;
|
|
1061
|
+
this.length += 1;
|
|
1062
|
+
};
|
|
1063
|
+
DLL.prototype.unshift = function(node) {
|
|
1064
|
+
if (this.head)
|
|
1065
|
+
this.insertBefore(this.head, node);
|
|
1066
|
+
else
|
|
1067
|
+
setInitial(this, node);
|
|
1068
|
+
};
|
|
1069
|
+
DLL.prototype.push = function(node) {
|
|
1070
|
+
if (this.tail)
|
|
1071
|
+
this.insertAfter(this.tail, node);
|
|
1072
|
+
else
|
|
1073
|
+
setInitial(this, node);
|
|
1074
|
+
};
|
|
1075
|
+
DLL.prototype.shift = function() {
|
|
1076
|
+
return this.head && this.removeLink(this.head);
|
|
1077
|
+
};
|
|
1078
|
+
DLL.prototype.pop = function() {
|
|
1079
|
+
return this.tail && this.removeLink(this.tail);
|
|
1080
|
+
};
|
|
1081
|
+
DLL.prototype.toArray = function() {
|
|
1082
|
+
var arr = Array(this.length);
|
|
1083
|
+
var curr = this.head;
|
|
1084
|
+
for (var idx = 0; idx < this.length; idx++) {
|
|
1085
|
+
arr[idx] = curr.data;
|
|
1086
|
+
curr = curr.next;
|
|
1087
|
+
}
|
|
1088
|
+
return arr;
|
|
1089
|
+
};
|
|
1090
|
+
DLL.prototype.remove = function(testFn) {
|
|
1091
|
+
var curr = this.head;
|
|
1092
|
+
while (!!curr) {
|
|
1093
|
+
var next = curr.next;
|
|
1094
|
+
if (testFn(curr)) {
|
|
1095
|
+
this.removeLink(curr);
|
|
1096
|
+
}
|
|
1097
|
+
curr = next;
|
|
1098
|
+
}
|
|
1099
|
+
return this;
|
|
1100
|
+
};
|
|
1101
|
+
function queue(worker, concurrency, payload) {
|
|
1102
|
+
if (concurrency == null) {
|
|
1103
|
+
concurrency = 1;
|
|
1104
|
+
} else if (concurrency === 0) {
|
|
1105
|
+
throw new Error("Concurrency must not be zero");
|
|
1106
|
+
}
|
|
1107
|
+
var _worker = wrapAsync(worker);
|
|
1108
|
+
var numRunning = 0;
|
|
1109
|
+
var workersList = [];
|
|
1110
|
+
var processingScheduled = false;
|
|
1111
|
+
function _insert(data, insertAtFront, callback) {
|
|
1112
|
+
if (callback != null && typeof callback !== "function") {
|
|
1113
|
+
throw new Error("task callback must be a function");
|
|
1114
|
+
}
|
|
1115
|
+
q.started = true;
|
|
1116
|
+
if (!isArray(data)) {
|
|
1117
|
+
data = [data];
|
|
1118
|
+
}
|
|
1119
|
+
if (data.length === 0 && q.idle()) {
|
|
1120
|
+
return setImmediate$1(function() {
|
|
1121
|
+
q.drain();
|
|
1122
|
+
});
|
|
1123
|
+
}
|
|
1124
|
+
for (var i = 0, l = data.length; i < l; i++) {
|
|
1125
|
+
var item = {
|
|
1126
|
+
data: data[i],
|
|
1127
|
+
callback: callback || noop
|
|
1128
|
+
};
|
|
1129
|
+
if (insertAtFront) {
|
|
1130
|
+
q._tasks.unshift(item);
|
|
1131
|
+
} else {
|
|
1132
|
+
q._tasks.push(item);
|
|
1133
|
+
}
|
|
1134
|
+
}
|
|
1135
|
+
if (!processingScheduled) {
|
|
1136
|
+
processingScheduled = true;
|
|
1137
|
+
setImmediate$1(function() {
|
|
1138
|
+
processingScheduled = false;
|
|
1139
|
+
q.process();
|
|
1140
|
+
});
|
|
1141
|
+
}
|
|
1142
|
+
}
|
|
1143
|
+
function _next(tasks) {
|
|
1144
|
+
return function(err) {
|
|
1145
|
+
numRunning -= 1;
|
|
1146
|
+
for (var i = 0, l = tasks.length; i < l; i++) {
|
|
1147
|
+
var task = tasks[i];
|
|
1148
|
+
var index2 = baseIndexOf(workersList, task, 0);
|
|
1149
|
+
if (index2 === 0) {
|
|
1150
|
+
workersList.shift();
|
|
1151
|
+
} else if (index2 > 0) {
|
|
1152
|
+
workersList.splice(index2, 1);
|
|
1153
|
+
}
|
|
1154
|
+
task.callback.apply(task, arguments);
|
|
1155
|
+
if (err != null) {
|
|
1156
|
+
q.error(err, task.data);
|
|
1157
|
+
}
|
|
1158
|
+
}
|
|
1159
|
+
if (numRunning <= q.concurrency - q.buffer) {
|
|
1160
|
+
q.unsaturated();
|
|
1161
|
+
}
|
|
1162
|
+
if (q.idle()) {
|
|
1163
|
+
q.drain();
|
|
1164
|
+
}
|
|
1165
|
+
q.process();
|
|
1166
|
+
};
|
|
1167
|
+
}
|
|
1168
|
+
var isProcessing = false;
|
|
1169
|
+
var q = {
|
|
1170
|
+
_tasks: new DLL(),
|
|
1171
|
+
concurrency,
|
|
1172
|
+
payload,
|
|
1173
|
+
saturated: noop,
|
|
1174
|
+
unsaturated: noop,
|
|
1175
|
+
buffer: concurrency / 4,
|
|
1176
|
+
empty: noop,
|
|
1177
|
+
drain: noop,
|
|
1178
|
+
error: noop,
|
|
1179
|
+
started: false,
|
|
1180
|
+
paused: false,
|
|
1181
|
+
push: function(data, callback) {
|
|
1182
|
+
_insert(data, false, callback);
|
|
1183
|
+
},
|
|
1184
|
+
kill: function() {
|
|
1185
|
+
q.drain = noop;
|
|
1186
|
+
q._tasks.empty();
|
|
1187
|
+
},
|
|
1188
|
+
unshift: function(data, callback) {
|
|
1189
|
+
_insert(data, true, callback);
|
|
1190
|
+
},
|
|
1191
|
+
remove: function(testFn) {
|
|
1192
|
+
q._tasks.remove(testFn);
|
|
1193
|
+
},
|
|
1194
|
+
process: function() {
|
|
1195
|
+
if (isProcessing) {
|
|
1196
|
+
return;
|
|
1197
|
+
}
|
|
1198
|
+
isProcessing = true;
|
|
1199
|
+
while (!q.paused && numRunning < q.concurrency && q._tasks.length) {
|
|
1200
|
+
var tasks = [], data = [];
|
|
1201
|
+
var l = q._tasks.length;
|
|
1202
|
+
if (q.payload)
|
|
1203
|
+
l = Math.min(l, q.payload);
|
|
1204
|
+
for (var i = 0; i < l; i++) {
|
|
1205
|
+
var node = q._tasks.shift();
|
|
1206
|
+
tasks.push(node);
|
|
1207
|
+
workersList.push(node);
|
|
1208
|
+
data.push(node.data);
|
|
1209
|
+
}
|
|
1210
|
+
numRunning += 1;
|
|
1211
|
+
if (q._tasks.length === 0) {
|
|
1212
|
+
q.empty();
|
|
1213
|
+
}
|
|
1214
|
+
if (numRunning === q.concurrency) {
|
|
1215
|
+
q.saturated();
|
|
1216
|
+
}
|
|
1217
|
+
var cb = onlyOnce(_next(tasks));
|
|
1218
|
+
_worker(data, cb);
|
|
1219
|
+
}
|
|
1220
|
+
isProcessing = false;
|
|
1221
|
+
},
|
|
1222
|
+
length: function() {
|
|
1223
|
+
return q._tasks.length;
|
|
1224
|
+
},
|
|
1225
|
+
running: function() {
|
|
1226
|
+
return numRunning;
|
|
1227
|
+
},
|
|
1228
|
+
workersList: function() {
|
|
1229
|
+
return workersList;
|
|
1230
|
+
},
|
|
1231
|
+
idle: function() {
|
|
1232
|
+
return q._tasks.length + numRunning === 0;
|
|
1233
|
+
},
|
|
1234
|
+
pause: function() {
|
|
1235
|
+
q.paused = true;
|
|
1236
|
+
},
|
|
1237
|
+
resume: function() {
|
|
1238
|
+
if (q.paused === false) {
|
|
1239
|
+
return;
|
|
1240
|
+
}
|
|
1241
|
+
q.paused = false;
|
|
1242
|
+
setImmediate$1(q.process);
|
|
1243
|
+
}
|
|
1244
|
+
};
|
|
1245
|
+
return q;
|
|
1246
|
+
}
|
|
1247
|
+
function cargo(worker, payload) {
|
|
1248
|
+
return queue(worker, 1, payload);
|
|
1249
|
+
}
|
|
1250
|
+
var eachOfSeries = doLimit(eachOfLimit, 1);
|
|
1251
|
+
function reduce(coll, memo, iteratee, callback) {
|
|
1252
|
+
callback = once(callback || noop);
|
|
1253
|
+
var _iteratee = wrapAsync(iteratee);
|
|
1254
|
+
eachOfSeries(coll, function(x, i, callback2) {
|
|
1255
|
+
_iteratee(memo, x, function(err, v) {
|
|
1256
|
+
memo = v;
|
|
1257
|
+
callback2(err);
|
|
1258
|
+
});
|
|
1259
|
+
}, function(err) {
|
|
1260
|
+
callback(err, memo);
|
|
1261
|
+
});
|
|
1262
|
+
}
|
|
1263
|
+
function seq() {
|
|
1264
|
+
var _functions = arrayMap(arguments, wrapAsync);
|
|
1265
|
+
return function() {
|
|
1266
|
+
var args = slice(arguments);
|
|
1267
|
+
var that = this;
|
|
1268
|
+
var cb = args[args.length - 1];
|
|
1269
|
+
if (typeof cb == "function") {
|
|
1270
|
+
args.pop();
|
|
1271
|
+
} else {
|
|
1272
|
+
cb = noop;
|
|
1273
|
+
}
|
|
1274
|
+
reduce(
|
|
1275
|
+
_functions,
|
|
1276
|
+
args,
|
|
1277
|
+
function(newargs, fn, cb2) {
|
|
1278
|
+
fn.apply(that, newargs.concat(function(err) {
|
|
1279
|
+
var nextargs = slice(arguments, 1);
|
|
1280
|
+
cb2(err, nextargs);
|
|
1281
|
+
}));
|
|
1282
|
+
},
|
|
1283
|
+
function(err, results) {
|
|
1284
|
+
cb.apply(that, [err].concat(results));
|
|
1285
|
+
}
|
|
1286
|
+
);
|
|
1287
|
+
};
|
|
1288
|
+
}
|
|
1289
|
+
var compose = function() {
|
|
1290
|
+
return seq.apply(null, slice(arguments).reverse());
|
|
1291
|
+
};
|
|
1292
|
+
var _concat = Array.prototype.concat;
|
|
1293
|
+
var concatLimit = function(coll, limit, iteratee, callback) {
|
|
1294
|
+
callback = callback || noop;
|
|
1295
|
+
var _iteratee = wrapAsync(iteratee);
|
|
1296
|
+
mapLimit(coll, limit, function(val, callback2) {
|
|
1297
|
+
_iteratee(val, function(err) {
|
|
1298
|
+
if (err)
|
|
1299
|
+
return callback2(err);
|
|
1300
|
+
return callback2(null, slice(arguments, 1));
|
|
1301
|
+
});
|
|
1302
|
+
}, function(err, mapResults) {
|
|
1303
|
+
var result = [];
|
|
1304
|
+
for (var i = 0; i < mapResults.length; i++) {
|
|
1305
|
+
if (mapResults[i]) {
|
|
1306
|
+
result = _concat.apply(result, mapResults[i]);
|
|
1307
|
+
}
|
|
1308
|
+
}
|
|
1309
|
+
return callback(err, result);
|
|
1310
|
+
});
|
|
1311
|
+
};
|
|
1312
|
+
var concat = doLimit(concatLimit, Infinity);
|
|
1313
|
+
var concatSeries = doLimit(concatLimit, 1);
|
|
1314
|
+
var constant = function() {
|
|
1315
|
+
var values = slice(arguments);
|
|
1316
|
+
var args = [null].concat(values);
|
|
1317
|
+
return function() {
|
|
1318
|
+
var callback = arguments[arguments.length - 1];
|
|
1319
|
+
return callback.apply(this, args);
|
|
1320
|
+
};
|
|
1321
|
+
};
|
|
1322
|
+
function identity(value) {
|
|
1323
|
+
return value;
|
|
1324
|
+
}
|
|
1325
|
+
function _createTester(check, getResult) {
|
|
1326
|
+
return function(eachfn, arr, iteratee, cb) {
|
|
1327
|
+
cb = cb || noop;
|
|
1328
|
+
var testPassed = false;
|
|
1329
|
+
var testResult;
|
|
1330
|
+
eachfn(arr, function(value, _, callback) {
|
|
1331
|
+
iteratee(value, function(err, result) {
|
|
1332
|
+
if (err) {
|
|
1333
|
+
callback(err);
|
|
1334
|
+
} else if (check(result) && !testResult) {
|
|
1335
|
+
testPassed = true;
|
|
1336
|
+
testResult = getResult(true, value);
|
|
1337
|
+
callback(null, breakLoop);
|
|
1338
|
+
} else {
|
|
1339
|
+
callback();
|
|
1340
|
+
}
|
|
1341
|
+
});
|
|
1342
|
+
}, function(err) {
|
|
1343
|
+
if (err) {
|
|
1344
|
+
cb(err);
|
|
1345
|
+
} else {
|
|
1346
|
+
cb(null, testPassed ? testResult : getResult(false));
|
|
1347
|
+
}
|
|
1348
|
+
});
|
|
1349
|
+
};
|
|
1350
|
+
}
|
|
1351
|
+
function _findGetResult(v, x) {
|
|
1352
|
+
return x;
|
|
1353
|
+
}
|
|
1354
|
+
var detect = doParallel(_createTester(identity, _findGetResult));
|
|
1355
|
+
var detectLimit = doParallelLimit(_createTester(identity, _findGetResult));
|
|
1356
|
+
var detectSeries = doLimit(detectLimit, 1);
|
|
1357
|
+
function consoleFunc(name) {
|
|
1358
|
+
return function(fn) {
|
|
1359
|
+
var args = slice(arguments, 1);
|
|
1360
|
+
args.push(function(err) {
|
|
1361
|
+
var args2 = slice(arguments, 1);
|
|
1362
|
+
if (typeof console === "object") {
|
|
1363
|
+
if (err) {
|
|
1364
|
+
if (console.error) {
|
|
1365
|
+
console.error(err);
|
|
1366
|
+
}
|
|
1367
|
+
} else if (console[name]) {
|
|
1368
|
+
arrayEach(args2, function(x) {
|
|
1369
|
+
console[name](x);
|
|
1370
|
+
});
|
|
1371
|
+
}
|
|
1372
|
+
}
|
|
1373
|
+
});
|
|
1374
|
+
wrapAsync(fn).apply(null, args);
|
|
1375
|
+
};
|
|
1376
|
+
}
|
|
1377
|
+
var dir = consoleFunc("dir");
|
|
1378
|
+
function doDuring(fn, test, callback) {
|
|
1379
|
+
callback = onlyOnce(callback || noop);
|
|
1380
|
+
var _fn = wrapAsync(fn);
|
|
1381
|
+
var _test = wrapAsync(test);
|
|
1382
|
+
function next(err) {
|
|
1383
|
+
if (err)
|
|
1384
|
+
return callback(err);
|
|
1385
|
+
var args = slice(arguments, 1);
|
|
1386
|
+
args.push(check);
|
|
1387
|
+
_test.apply(this, args);
|
|
1388
|
+
}
|
|
1389
|
+
function check(err, truth) {
|
|
1390
|
+
if (err)
|
|
1391
|
+
return callback(err);
|
|
1392
|
+
if (!truth)
|
|
1393
|
+
return callback(null);
|
|
1394
|
+
_fn(next);
|
|
1395
|
+
}
|
|
1396
|
+
check(null, true);
|
|
1397
|
+
}
|
|
1398
|
+
function doWhilst(iteratee, test, callback) {
|
|
1399
|
+
callback = onlyOnce(callback || noop);
|
|
1400
|
+
var _iteratee = wrapAsync(iteratee);
|
|
1401
|
+
var next = function(err) {
|
|
1402
|
+
if (err)
|
|
1403
|
+
return callback(err);
|
|
1404
|
+
var args = slice(arguments, 1);
|
|
1405
|
+
if (test.apply(this, args))
|
|
1406
|
+
return _iteratee(next);
|
|
1407
|
+
callback.apply(null, [null].concat(args));
|
|
1408
|
+
};
|
|
1409
|
+
_iteratee(next);
|
|
1410
|
+
}
|
|
1411
|
+
function doUntil(iteratee, test, callback) {
|
|
1412
|
+
doWhilst(iteratee, function() {
|
|
1413
|
+
return !test.apply(this, arguments);
|
|
1414
|
+
}, callback);
|
|
1415
|
+
}
|
|
1416
|
+
function during(test, fn, callback) {
|
|
1417
|
+
callback = onlyOnce(callback || noop);
|
|
1418
|
+
var _fn = wrapAsync(fn);
|
|
1419
|
+
var _test = wrapAsync(test);
|
|
1420
|
+
function next(err) {
|
|
1421
|
+
if (err)
|
|
1422
|
+
return callback(err);
|
|
1423
|
+
_test(check);
|
|
1424
|
+
}
|
|
1425
|
+
function check(err, truth) {
|
|
1426
|
+
if (err)
|
|
1427
|
+
return callback(err);
|
|
1428
|
+
if (!truth)
|
|
1429
|
+
return callback(null);
|
|
1430
|
+
_fn(next);
|
|
1431
|
+
}
|
|
1432
|
+
_test(check);
|
|
1433
|
+
}
|
|
1434
|
+
function _withoutIndex(iteratee) {
|
|
1435
|
+
return function(value, index2, callback) {
|
|
1436
|
+
return iteratee(value, callback);
|
|
1437
|
+
};
|
|
1438
|
+
}
|
|
1439
|
+
function eachLimit(coll, iteratee, callback) {
|
|
1440
|
+
eachOf(coll, _withoutIndex(wrapAsync(iteratee)), callback);
|
|
1441
|
+
}
|
|
1442
|
+
function eachLimit$1(coll, limit, iteratee, callback) {
|
|
1443
|
+
_eachOfLimit(limit)(coll, _withoutIndex(wrapAsync(iteratee)), callback);
|
|
1444
|
+
}
|
|
1445
|
+
var eachSeries = doLimit(eachLimit$1, 1);
|
|
1446
|
+
function ensureAsync(fn) {
|
|
1447
|
+
if (isAsync(fn))
|
|
1448
|
+
return fn;
|
|
1449
|
+
return initialParams(function(args, callback) {
|
|
1450
|
+
var sync = true;
|
|
1451
|
+
args.push(function() {
|
|
1452
|
+
var innerArgs = arguments;
|
|
1453
|
+
if (sync) {
|
|
1454
|
+
setImmediate$1(function() {
|
|
1455
|
+
callback.apply(null, innerArgs);
|
|
1456
|
+
});
|
|
1457
|
+
} else {
|
|
1458
|
+
callback.apply(null, innerArgs);
|
|
1459
|
+
}
|
|
1460
|
+
});
|
|
1461
|
+
fn.apply(this, args);
|
|
1462
|
+
sync = false;
|
|
1463
|
+
});
|
|
1464
|
+
}
|
|
1465
|
+
function notId(v) {
|
|
1466
|
+
return !v;
|
|
1467
|
+
}
|
|
1468
|
+
var every = doParallel(_createTester(notId, notId));
|
|
1469
|
+
var everyLimit = doParallelLimit(_createTester(notId, notId));
|
|
1470
|
+
var everySeries = doLimit(everyLimit, 1);
|
|
1471
|
+
function baseProperty(key) {
|
|
1472
|
+
return function(object) {
|
|
1473
|
+
return object == null ? void 0 : object[key];
|
|
1474
|
+
};
|
|
1475
|
+
}
|
|
1476
|
+
function filterArray(eachfn, arr, iteratee, callback) {
|
|
1477
|
+
var truthValues = new Array(arr.length);
|
|
1478
|
+
eachfn(arr, function(x, index2, callback2) {
|
|
1479
|
+
iteratee(x, function(err, v) {
|
|
1480
|
+
truthValues[index2] = !!v;
|
|
1481
|
+
callback2(err);
|
|
1482
|
+
});
|
|
1483
|
+
}, function(err) {
|
|
1484
|
+
if (err)
|
|
1485
|
+
return callback(err);
|
|
1486
|
+
var results = [];
|
|
1487
|
+
for (var i = 0; i < arr.length; i++) {
|
|
1488
|
+
if (truthValues[i])
|
|
1489
|
+
results.push(arr[i]);
|
|
1490
|
+
}
|
|
1491
|
+
callback(null, results);
|
|
1492
|
+
});
|
|
1493
|
+
}
|
|
1494
|
+
function filterGeneric(eachfn, coll, iteratee, callback) {
|
|
1495
|
+
var results = [];
|
|
1496
|
+
eachfn(coll, function(x, index2, callback2) {
|
|
1497
|
+
iteratee(x, function(err, v) {
|
|
1498
|
+
if (err) {
|
|
1499
|
+
callback2(err);
|
|
1500
|
+
} else {
|
|
1501
|
+
if (v) {
|
|
1502
|
+
results.push({ index: index2, value: x });
|
|
1503
|
+
}
|
|
1504
|
+
callback2();
|
|
1505
|
+
}
|
|
1506
|
+
});
|
|
1507
|
+
}, function(err) {
|
|
1508
|
+
if (err) {
|
|
1509
|
+
callback(err);
|
|
1510
|
+
} else {
|
|
1511
|
+
callback(null, arrayMap(results.sort(function(a, b) {
|
|
1512
|
+
return a.index - b.index;
|
|
1513
|
+
}), baseProperty("value")));
|
|
1514
|
+
}
|
|
1515
|
+
});
|
|
1516
|
+
}
|
|
1517
|
+
function _filter(eachfn, coll, iteratee, callback) {
|
|
1518
|
+
var filter2 = isArrayLike(coll) ? filterArray : filterGeneric;
|
|
1519
|
+
filter2(eachfn, coll, wrapAsync(iteratee), callback || noop);
|
|
1520
|
+
}
|
|
1521
|
+
var filter = doParallel(_filter);
|
|
1522
|
+
var filterLimit = doParallelLimit(_filter);
|
|
1523
|
+
var filterSeries = doLimit(filterLimit, 1);
|
|
1524
|
+
function forever(fn, errback) {
|
|
1525
|
+
var done = onlyOnce(errback || noop);
|
|
1526
|
+
var task = wrapAsync(ensureAsync(fn));
|
|
1527
|
+
function next(err) {
|
|
1528
|
+
if (err)
|
|
1529
|
+
return done(err);
|
|
1530
|
+
task(next);
|
|
1531
|
+
}
|
|
1532
|
+
next();
|
|
1533
|
+
}
|
|
1534
|
+
var groupByLimit = function(coll, limit, iteratee, callback) {
|
|
1535
|
+
callback = callback || noop;
|
|
1536
|
+
var _iteratee = wrapAsync(iteratee);
|
|
1537
|
+
mapLimit(coll, limit, function(val, callback2) {
|
|
1538
|
+
_iteratee(val, function(err, key) {
|
|
1539
|
+
if (err)
|
|
1540
|
+
return callback2(err);
|
|
1541
|
+
return callback2(null, { key, val });
|
|
1542
|
+
});
|
|
1543
|
+
}, function(err, mapResults) {
|
|
1544
|
+
var result = {};
|
|
1545
|
+
var hasOwnProperty2 = Object.prototype.hasOwnProperty;
|
|
1546
|
+
for (var i = 0; i < mapResults.length; i++) {
|
|
1547
|
+
if (mapResults[i]) {
|
|
1548
|
+
var key = mapResults[i].key;
|
|
1549
|
+
var val = mapResults[i].val;
|
|
1550
|
+
if (hasOwnProperty2.call(result, key)) {
|
|
1551
|
+
result[key].push(val);
|
|
1552
|
+
} else {
|
|
1553
|
+
result[key] = [val];
|
|
1554
|
+
}
|
|
1555
|
+
}
|
|
1556
|
+
}
|
|
1557
|
+
return callback(err, result);
|
|
1558
|
+
});
|
|
1559
|
+
};
|
|
1560
|
+
var groupBy = doLimit(groupByLimit, Infinity);
|
|
1561
|
+
var groupBySeries = doLimit(groupByLimit, 1);
|
|
1562
|
+
var log = consoleFunc("log");
|
|
1563
|
+
function mapValuesLimit(obj, limit, iteratee, callback) {
|
|
1564
|
+
callback = once(callback || noop);
|
|
1565
|
+
var newObj = {};
|
|
1566
|
+
var _iteratee = wrapAsync(iteratee);
|
|
1567
|
+
eachOfLimit(obj, limit, function(val, key, next) {
|
|
1568
|
+
_iteratee(val, key, function(err, result) {
|
|
1569
|
+
if (err)
|
|
1570
|
+
return next(err);
|
|
1571
|
+
newObj[key] = result;
|
|
1572
|
+
next();
|
|
1573
|
+
});
|
|
1574
|
+
}, function(err) {
|
|
1575
|
+
callback(err, newObj);
|
|
1576
|
+
});
|
|
1577
|
+
}
|
|
1578
|
+
var mapValues = doLimit(mapValuesLimit, Infinity);
|
|
1579
|
+
var mapValuesSeries = doLimit(mapValuesLimit, 1);
|
|
1580
|
+
function has(obj, key) {
|
|
1581
|
+
return key in obj;
|
|
1582
|
+
}
|
|
1583
|
+
function memoize(fn, hasher) {
|
|
1584
|
+
var memo = /* @__PURE__ */ Object.create(null);
|
|
1585
|
+
var queues = /* @__PURE__ */ Object.create(null);
|
|
1586
|
+
hasher = hasher || identity;
|
|
1587
|
+
var _fn = wrapAsync(fn);
|
|
1588
|
+
var memoized = initialParams(function memoized2(args, callback) {
|
|
1589
|
+
var key = hasher.apply(null, args);
|
|
1590
|
+
if (has(memo, key)) {
|
|
1591
|
+
setImmediate$1(function() {
|
|
1592
|
+
callback.apply(null, memo[key]);
|
|
1593
|
+
});
|
|
1594
|
+
} else if (has(queues, key)) {
|
|
1595
|
+
queues[key].push(callback);
|
|
1596
|
+
} else {
|
|
1597
|
+
queues[key] = [callback];
|
|
1598
|
+
_fn.apply(null, args.concat(function() {
|
|
1599
|
+
var args2 = slice(arguments);
|
|
1600
|
+
memo[key] = args2;
|
|
1601
|
+
var q = queues[key];
|
|
1602
|
+
delete queues[key];
|
|
1603
|
+
for (var i = 0, l = q.length; i < l; i++) {
|
|
1604
|
+
q[i].apply(null, args2);
|
|
1605
|
+
}
|
|
1606
|
+
}));
|
|
1607
|
+
}
|
|
1608
|
+
});
|
|
1609
|
+
memoized.memo = memo;
|
|
1610
|
+
memoized.unmemoized = fn;
|
|
1611
|
+
return memoized;
|
|
1612
|
+
}
|
|
1613
|
+
var _defer$1;
|
|
1614
|
+
if (hasNextTick) {
|
|
1615
|
+
_defer$1 = process.nextTick;
|
|
1616
|
+
} else if (hasSetImmediate) {
|
|
1617
|
+
_defer$1 = setImmediate;
|
|
1618
|
+
} else {
|
|
1619
|
+
_defer$1 = fallback;
|
|
1620
|
+
}
|
|
1621
|
+
var nextTick = wrap(_defer$1);
|
|
1622
|
+
function _parallel(eachfn, tasks, callback) {
|
|
1623
|
+
callback = callback || noop;
|
|
1624
|
+
var results = isArrayLike(tasks) ? [] : {};
|
|
1625
|
+
eachfn(tasks, function(task, key, callback2) {
|
|
1626
|
+
wrapAsync(task)(function(err, result) {
|
|
1627
|
+
if (arguments.length > 2) {
|
|
1628
|
+
result = slice(arguments, 1);
|
|
1629
|
+
}
|
|
1630
|
+
results[key] = result;
|
|
1631
|
+
callback2(err);
|
|
1632
|
+
});
|
|
1633
|
+
}, function(err) {
|
|
1634
|
+
callback(err, results);
|
|
1635
|
+
});
|
|
1636
|
+
}
|
|
1637
|
+
function parallelLimit(tasks, callback) {
|
|
1638
|
+
_parallel(eachOf, tasks, callback);
|
|
1639
|
+
}
|
|
1640
|
+
function parallelLimit$1(tasks, limit, callback) {
|
|
1641
|
+
_parallel(_eachOfLimit(limit), tasks, callback);
|
|
1642
|
+
}
|
|
1643
|
+
var queue$1 = function(worker, concurrency) {
|
|
1644
|
+
var _worker = wrapAsync(worker);
|
|
1645
|
+
return queue(function(items, cb) {
|
|
1646
|
+
_worker(items[0], cb);
|
|
1647
|
+
}, concurrency, 1);
|
|
1648
|
+
};
|
|
1649
|
+
var priorityQueue = function(worker, concurrency) {
|
|
1650
|
+
var q = queue$1(worker, concurrency);
|
|
1651
|
+
q.push = function(data, priority, callback) {
|
|
1652
|
+
if (callback == null)
|
|
1653
|
+
callback = noop;
|
|
1654
|
+
if (typeof callback !== "function") {
|
|
1655
|
+
throw new Error("task callback must be a function");
|
|
1656
|
+
}
|
|
1657
|
+
q.started = true;
|
|
1658
|
+
if (!isArray(data)) {
|
|
1659
|
+
data = [data];
|
|
1660
|
+
}
|
|
1661
|
+
if (data.length === 0) {
|
|
1662
|
+
return setImmediate$1(function() {
|
|
1663
|
+
q.drain();
|
|
1664
|
+
});
|
|
1665
|
+
}
|
|
1666
|
+
priority = priority || 0;
|
|
1667
|
+
var nextNode = q._tasks.head;
|
|
1668
|
+
while (nextNode && priority >= nextNode.priority) {
|
|
1669
|
+
nextNode = nextNode.next;
|
|
1670
|
+
}
|
|
1671
|
+
for (var i = 0, l = data.length; i < l; i++) {
|
|
1672
|
+
var item = {
|
|
1673
|
+
data: data[i],
|
|
1674
|
+
priority,
|
|
1675
|
+
callback
|
|
1676
|
+
};
|
|
1677
|
+
if (nextNode) {
|
|
1678
|
+
q._tasks.insertBefore(nextNode, item);
|
|
1679
|
+
} else {
|
|
1680
|
+
q._tasks.push(item);
|
|
1681
|
+
}
|
|
1682
|
+
}
|
|
1683
|
+
setImmediate$1(q.process);
|
|
1684
|
+
};
|
|
1685
|
+
delete q.unshift;
|
|
1686
|
+
return q;
|
|
1687
|
+
};
|
|
1688
|
+
function race(tasks, callback) {
|
|
1689
|
+
callback = once(callback || noop);
|
|
1690
|
+
if (!isArray(tasks))
|
|
1691
|
+
return callback(new TypeError("First argument to race must be an array of functions"));
|
|
1692
|
+
if (!tasks.length)
|
|
1693
|
+
return callback();
|
|
1694
|
+
for (var i = 0, l = tasks.length; i < l; i++) {
|
|
1695
|
+
wrapAsync(tasks[i])(callback);
|
|
1696
|
+
}
|
|
1697
|
+
}
|
|
1698
|
+
function reduceRight(array, memo, iteratee, callback) {
|
|
1699
|
+
var reversed = slice(array).reverse();
|
|
1700
|
+
reduce(reversed, memo, iteratee, callback);
|
|
1701
|
+
}
|
|
1702
|
+
function reflect(fn) {
|
|
1703
|
+
var _fn = wrapAsync(fn);
|
|
1704
|
+
return initialParams(function reflectOn(args, reflectCallback) {
|
|
1705
|
+
args.push(function callback(error, cbArg) {
|
|
1706
|
+
if (error) {
|
|
1707
|
+
reflectCallback(null, { error });
|
|
1708
|
+
} else {
|
|
1709
|
+
var value;
|
|
1710
|
+
if (arguments.length <= 2) {
|
|
1711
|
+
value = cbArg;
|
|
1712
|
+
} else {
|
|
1713
|
+
value = slice(arguments, 1);
|
|
1714
|
+
}
|
|
1715
|
+
reflectCallback(null, { value });
|
|
1716
|
+
}
|
|
1717
|
+
});
|
|
1718
|
+
return _fn.apply(this, args);
|
|
1719
|
+
});
|
|
1720
|
+
}
|
|
1721
|
+
function reflectAll(tasks) {
|
|
1722
|
+
var results;
|
|
1723
|
+
if (isArray(tasks)) {
|
|
1724
|
+
results = arrayMap(tasks, reflect);
|
|
1725
|
+
} else {
|
|
1726
|
+
results = {};
|
|
1727
|
+
baseForOwn(tasks, function(task, key) {
|
|
1728
|
+
results[key] = reflect.call(this, task);
|
|
1729
|
+
});
|
|
1730
|
+
}
|
|
1731
|
+
return results;
|
|
1732
|
+
}
|
|
1733
|
+
function reject$1(eachfn, arr, iteratee, callback) {
|
|
1734
|
+
_filter(eachfn, arr, function(value, cb) {
|
|
1735
|
+
iteratee(value, function(err, v) {
|
|
1736
|
+
cb(err, !v);
|
|
1737
|
+
});
|
|
1738
|
+
}, callback);
|
|
1739
|
+
}
|
|
1740
|
+
var reject = doParallel(reject$1);
|
|
1741
|
+
var rejectLimit = doParallelLimit(reject$1);
|
|
1742
|
+
var rejectSeries = doLimit(rejectLimit, 1);
|
|
1743
|
+
function constant$1(value) {
|
|
1744
|
+
return function() {
|
|
1745
|
+
return value;
|
|
1746
|
+
};
|
|
1747
|
+
}
|
|
1748
|
+
function retry(opts, task, callback) {
|
|
1749
|
+
var DEFAULT_TIMES = 5;
|
|
1750
|
+
var DEFAULT_INTERVAL = 0;
|
|
1751
|
+
var options = {
|
|
1752
|
+
times: DEFAULT_TIMES,
|
|
1753
|
+
intervalFunc: constant$1(DEFAULT_INTERVAL)
|
|
1754
|
+
};
|
|
1755
|
+
function parseTimes(acc, t) {
|
|
1756
|
+
if (typeof t === "object") {
|
|
1757
|
+
acc.times = +t.times || DEFAULT_TIMES;
|
|
1758
|
+
acc.intervalFunc = typeof t.interval === "function" ? t.interval : constant$1(+t.interval || DEFAULT_INTERVAL);
|
|
1759
|
+
acc.errorFilter = t.errorFilter;
|
|
1760
|
+
} else if (typeof t === "number" || typeof t === "string") {
|
|
1761
|
+
acc.times = +t || DEFAULT_TIMES;
|
|
1762
|
+
} else {
|
|
1763
|
+
throw new Error("Invalid arguments for async.retry");
|
|
1764
|
+
}
|
|
1765
|
+
}
|
|
1766
|
+
if (arguments.length < 3 && typeof opts === "function") {
|
|
1767
|
+
callback = task || noop;
|
|
1768
|
+
task = opts;
|
|
1769
|
+
} else {
|
|
1770
|
+
parseTimes(options, opts);
|
|
1771
|
+
callback = callback || noop;
|
|
1772
|
+
}
|
|
1773
|
+
if (typeof task !== "function") {
|
|
1774
|
+
throw new Error("Invalid arguments for async.retry");
|
|
1775
|
+
}
|
|
1776
|
+
var _task = wrapAsync(task);
|
|
1777
|
+
var attempt = 1;
|
|
1778
|
+
function retryAttempt() {
|
|
1779
|
+
_task(function(err) {
|
|
1780
|
+
if (err && attempt++ < options.times && (typeof options.errorFilter != "function" || options.errorFilter(err))) {
|
|
1781
|
+
setTimeout(retryAttempt, options.intervalFunc(attempt));
|
|
1782
|
+
} else {
|
|
1783
|
+
callback.apply(null, arguments);
|
|
1784
|
+
}
|
|
1785
|
+
});
|
|
1786
|
+
}
|
|
1787
|
+
retryAttempt();
|
|
1788
|
+
}
|
|
1789
|
+
var retryable = function(opts, task) {
|
|
1790
|
+
if (!task) {
|
|
1791
|
+
task = opts;
|
|
1792
|
+
opts = null;
|
|
1793
|
+
}
|
|
1794
|
+
var _task = wrapAsync(task);
|
|
1795
|
+
return initialParams(function(args, callback) {
|
|
1796
|
+
function taskFn(cb) {
|
|
1797
|
+
_task.apply(null, args.concat(cb));
|
|
1798
|
+
}
|
|
1799
|
+
if (opts)
|
|
1800
|
+
retry(opts, taskFn, callback);
|
|
1801
|
+
else
|
|
1802
|
+
retry(taskFn, callback);
|
|
1803
|
+
});
|
|
1804
|
+
};
|
|
1805
|
+
function series(tasks, callback) {
|
|
1806
|
+
_parallel(eachOfSeries, tasks, callback);
|
|
1807
|
+
}
|
|
1808
|
+
var some = doParallel(_createTester(Boolean, identity));
|
|
1809
|
+
var someLimit = doParallelLimit(_createTester(Boolean, identity));
|
|
1810
|
+
var someSeries = doLimit(someLimit, 1);
|
|
1811
|
+
function sortBy(coll, iteratee, callback) {
|
|
1812
|
+
var _iteratee = wrapAsync(iteratee);
|
|
1813
|
+
map(coll, function(x, callback2) {
|
|
1814
|
+
_iteratee(x, function(err, criteria) {
|
|
1815
|
+
if (err)
|
|
1816
|
+
return callback2(err);
|
|
1817
|
+
callback2(null, { value: x, criteria });
|
|
1818
|
+
});
|
|
1819
|
+
}, function(err, results) {
|
|
1820
|
+
if (err)
|
|
1821
|
+
return callback(err);
|
|
1822
|
+
callback(null, arrayMap(results.sort(comparator), baseProperty("value")));
|
|
1823
|
+
});
|
|
1824
|
+
function comparator(left, right) {
|
|
1825
|
+
var a = left.criteria, b = right.criteria;
|
|
1826
|
+
return a < b ? -1 : a > b ? 1 : 0;
|
|
1827
|
+
}
|
|
1828
|
+
}
|
|
1829
|
+
function timeout(asyncFn, milliseconds, info) {
|
|
1830
|
+
var fn = wrapAsync(asyncFn);
|
|
1831
|
+
return initialParams(function(args, callback) {
|
|
1832
|
+
var timedOut = false;
|
|
1833
|
+
var timer;
|
|
1834
|
+
function timeoutCallback() {
|
|
1835
|
+
var name = asyncFn.name || "anonymous";
|
|
1836
|
+
var error = new Error('Callback function "' + name + '" timed out.');
|
|
1837
|
+
error.code = "ETIMEDOUT";
|
|
1838
|
+
if (info) {
|
|
1839
|
+
error.info = info;
|
|
1840
|
+
}
|
|
1841
|
+
timedOut = true;
|
|
1842
|
+
callback(error);
|
|
1843
|
+
}
|
|
1844
|
+
args.push(function() {
|
|
1845
|
+
if (!timedOut) {
|
|
1846
|
+
callback.apply(null, arguments);
|
|
1847
|
+
clearTimeout(timer);
|
|
1848
|
+
}
|
|
1849
|
+
});
|
|
1850
|
+
timer = setTimeout(timeoutCallback, milliseconds);
|
|
1851
|
+
fn.apply(null, args);
|
|
1852
|
+
});
|
|
1853
|
+
}
|
|
1854
|
+
var nativeCeil = Math.ceil;
|
|
1855
|
+
var nativeMax = Math.max;
|
|
1856
|
+
function baseRange(start, end, step, fromRight) {
|
|
1857
|
+
var index2 = -1, length = nativeMax(nativeCeil((end - start) / (step || 1)), 0), result = Array(length);
|
|
1858
|
+
while (length--) {
|
|
1859
|
+
result[fromRight ? length : ++index2] = start;
|
|
1860
|
+
start += step;
|
|
1861
|
+
}
|
|
1862
|
+
return result;
|
|
1863
|
+
}
|
|
1864
|
+
function timeLimit(count, limit, iteratee, callback) {
|
|
1865
|
+
var _iteratee = wrapAsync(iteratee);
|
|
1866
|
+
mapLimit(baseRange(0, count, 1), limit, _iteratee, callback);
|
|
1867
|
+
}
|
|
1868
|
+
var times = doLimit(timeLimit, Infinity);
|
|
1869
|
+
var timesSeries = doLimit(timeLimit, 1);
|
|
1870
|
+
function transform(coll, accumulator, iteratee, callback) {
|
|
1871
|
+
if (arguments.length <= 3) {
|
|
1872
|
+
callback = iteratee;
|
|
1873
|
+
iteratee = accumulator;
|
|
1874
|
+
accumulator = isArray(coll) ? [] : {};
|
|
1875
|
+
}
|
|
1876
|
+
callback = once(callback || noop);
|
|
1877
|
+
var _iteratee = wrapAsync(iteratee);
|
|
1878
|
+
eachOf(coll, function(v, k, cb) {
|
|
1879
|
+
_iteratee(accumulator, v, k, cb);
|
|
1880
|
+
}, function(err) {
|
|
1881
|
+
callback(err, accumulator);
|
|
1882
|
+
});
|
|
1883
|
+
}
|
|
1884
|
+
function tryEach(tasks, callback) {
|
|
1885
|
+
var error = null;
|
|
1886
|
+
var result;
|
|
1887
|
+
callback = callback || noop;
|
|
1888
|
+
eachSeries(tasks, function(task, callback2) {
|
|
1889
|
+
wrapAsync(task)(function(err, res) {
|
|
1890
|
+
if (arguments.length > 2) {
|
|
1891
|
+
result = slice(arguments, 1);
|
|
1892
|
+
} else {
|
|
1893
|
+
result = res;
|
|
1894
|
+
}
|
|
1895
|
+
error = err;
|
|
1896
|
+
callback2(!err);
|
|
1897
|
+
});
|
|
1898
|
+
}, function() {
|
|
1899
|
+
callback(error, result);
|
|
1900
|
+
});
|
|
1901
|
+
}
|
|
1902
|
+
function unmemoize(fn) {
|
|
1903
|
+
return function() {
|
|
1904
|
+
return (fn.unmemoized || fn).apply(null, arguments);
|
|
1905
|
+
};
|
|
1906
|
+
}
|
|
1907
|
+
function whilst(test, iteratee, callback) {
|
|
1908
|
+
callback = onlyOnce(callback || noop);
|
|
1909
|
+
var _iteratee = wrapAsync(iteratee);
|
|
1910
|
+
if (!test())
|
|
1911
|
+
return callback(null);
|
|
1912
|
+
var next = function(err) {
|
|
1913
|
+
if (err)
|
|
1914
|
+
return callback(err);
|
|
1915
|
+
if (test())
|
|
1916
|
+
return _iteratee(next);
|
|
1917
|
+
var args = slice(arguments, 1);
|
|
1918
|
+
callback.apply(null, [null].concat(args));
|
|
1919
|
+
};
|
|
1920
|
+
_iteratee(next);
|
|
1921
|
+
}
|
|
1922
|
+
function until(test, iteratee, callback) {
|
|
1923
|
+
whilst(function() {
|
|
1924
|
+
return !test.apply(this, arguments);
|
|
1925
|
+
}, iteratee, callback);
|
|
1926
|
+
}
|
|
1927
|
+
var waterfall = function(tasks, callback) {
|
|
1928
|
+
callback = once(callback || noop);
|
|
1929
|
+
if (!isArray(tasks))
|
|
1930
|
+
return callback(new Error("First argument to waterfall must be an array of functions"));
|
|
1931
|
+
if (!tasks.length)
|
|
1932
|
+
return callback();
|
|
1933
|
+
var taskIndex = 0;
|
|
1934
|
+
function nextTask(args) {
|
|
1935
|
+
var task = wrapAsync(tasks[taskIndex++]);
|
|
1936
|
+
args.push(onlyOnce(next));
|
|
1937
|
+
task.apply(null, args);
|
|
1938
|
+
}
|
|
1939
|
+
function next(err) {
|
|
1940
|
+
if (err || taskIndex === tasks.length) {
|
|
1941
|
+
return callback.apply(null, arguments);
|
|
1942
|
+
}
|
|
1943
|
+
nextTask(slice(arguments, 1));
|
|
1944
|
+
}
|
|
1945
|
+
nextTask([]);
|
|
1946
|
+
};
|
|
1947
|
+
var index = {
|
|
1948
|
+
apply,
|
|
1949
|
+
applyEach,
|
|
1950
|
+
applyEachSeries,
|
|
1951
|
+
asyncify,
|
|
1952
|
+
auto,
|
|
1953
|
+
autoInject,
|
|
1954
|
+
cargo,
|
|
1955
|
+
compose,
|
|
1956
|
+
concat,
|
|
1957
|
+
concatLimit,
|
|
1958
|
+
concatSeries,
|
|
1959
|
+
constant,
|
|
1960
|
+
detect,
|
|
1961
|
+
detectLimit,
|
|
1962
|
+
detectSeries,
|
|
1963
|
+
dir,
|
|
1964
|
+
doDuring,
|
|
1965
|
+
doUntil,
|
|
1966
|
+
doWhilst,
|
|
1967
|
+
during,
|
|
1968
|
+
each: eachLimit,
|
|
1969
|
+
eachLimit: eachLimit$1,
|
|
1970
|
+
eachOf,
|
|
1971
|
+
eachOfLimit,
|
|
1972
|
+
eachOfSeries,
|
|
1973
|
+
eachSeries,
|
|
1974
|
+
ensureAsync,
|
|
1975
|
+
every,
|
|
1976
|
+
everyLimit,
|
|
1977
|
+
everySeries,
|
|
1978
|
+
filter,
|
|
1979
|
+
filterLimit,
|
|
1980
|
+
filterSeries,
|
|
1981
|
+
forever,
|
|
1982
|
+
groupBy,
|
|
1983
|
+
groupByLimit,
|
|
1984
|
+
groupBySeries,
|
|
1985
|
+
log,
|
|
1986
|
+
map,
|
|
1987
|
+
mapLimit,
|
|
1988
|
+
mapSeries,
|
|
1989
|
+
mapValues,
|
|
1990
|
+
mapValuesLimit,
|
|
1991
|
+
mapValuesSeries,
|
|
1992
|
+
memoize,
|
|
1993
|
+
nextTick,
|
|
1994
|
+
parallel: parallelLimit,
|
|
1995
|
+
parallelLimit: parallelLimit$1,
|
|
1996
|
+
priorityQueue,
|
|
1997
|
+
queue: queue$1,
|
|
1998
|
+
race,
|
|
1999
|
+
reduce,
|
|
2000
|
+
reduceRight,
|
|
2001
|
+
reflect,
|
|
2002
|
+
reflectAll,
|
|
2003
|
+
reject,
|
|
2004
|
+
rejectLimit,
|
|
2005
|
+
rejectSeries,
|
|
2006
|
+
retry,
|
|
2007
|
+
retryable,
|
|
2008
|
+
seq,
|
|
2009
|
+
series,
|
|
2010
|
+
setImmediate: setImmediate$1,
|
|
2011
|
+
some,
|
|
2012
|
+
someLimit,
|
|
2013
|
+
someSeries,
|
|
2014
|
+
sortBy,
|
|
2015
|
+
timeout,
|
|
2016
|
+
times,
|
|
2017
|
+
timesLimit: timeLimit,
|
|
2018
|
+
timesSeries,
|
|
2019
|
+
transform,
|
|
2020
|
+
tryEach,
|
|
2021
|
+
unmemoize,
|
|
2022
|
+
until,
|
|
2023
|
+
waterfall,
|
|
2024
|
+
whilst,
|
|
2025
|
+
// aliases
|
|
2026
|
+
all: every,
|
|
2027
|
+
allLimit: everyLimit,
|
|
2028
|
+
allSeries: everySeries,
|
|
2029
|
+
any: some,
|
|
2030
|
+
anyLimit: someLimit,
|
|
2031
|
+
anySeries: someSeries,
|
|
2032
|
+
find: detect,
|
|
2033
|
+
findLimit: detectLimit,
|
|
2034
|
+
findSeries: detectSeries,
|
|
2035
|
+
forEach: eachLimit,
|
|
2036
|
+
forEachSeries: eachSeries,
|
|
2037
|
+
forEachLimit: eachLimit$1,
|
|
2038
|
+
forEachOf: eachOf,
|
|
2039
|
+
forEachOfSeries: eachOfSeries,
|
|
2040
|
+
forEachOfLimit: eachOfLimit,
|
|
2041
|
+
inject: reduce,
|
|
2042
|
+
foldl: reduce,
|
|
2043
|
+
foldr: reduceRight,
|
|
2044
|
+
select: filter,
|
|
2045
|
+
selectLimit: filterLimit,
|
|
2046
|
+
selectSeries: filterSeries,
|
|
2047
|
+
wrapSync: asyncify
|
|
2048
|
+
};
|
|
2049
|
+
exports3["default"] = index;
|
|
2050
|
+
exports3.apply = apply;
|
|
2051
|
+
exports3.applyEach = applyEach;
|
|
2052
|
+
exports3.applyEachSeries = applyEachSeries;
|
|
2053
|
+
exports3.asyncify = asyncify;
|
|
2054
|
+
exports3.auto = auto;
|
|
2055
|
+
exports3.autoInject = autoInject;
|
|
2056
|
+
exports3.cargo = cargo;
|
|
2057
|
+
exports3.compose = compose;
|
|
2058
|
+
exports3.concat = concat;
|
|
2059
|
+
exports3.concatLimit = concatLimit;
|
|
2060
|
+
exports3.concatSeries = concatSeries;
|
|
2061
|
+
exports3.constant = constant;
|
|
2062
|
+
exports3.detect = detect;
|
|
2063
|
+
exports3.detectLimit = detectLimit;
|
|
2064
|
+
exports3.detectSeries = detectSeries;
|
|
2065
|
+
exports3.dir = dir;
|
|
2066
|
+
exports3.doDuring = doDuring;
|
|
2067
|
+
exports3.doUntil = doUntil;
|
|
2068
|
+
exports3.doWhilst = doWhilst;
|
|
2069
|
+
exports3.during = during;
|
|
2070
|
+
exports3.each = eachLimit;
|
|
2071
|
+
exports3.eachLimit = eachLimit$1;
|
|
2072
|
+
exports3.eachOf = eachOf;
|
|
2073
|
+
exports3.eachOfLimit = eachOfLimit;
|
|
2074
|
+
exports3.eachOfSeries = eachOfSeries;
|
|
2075
|
+
exports3.eachSeries = eachSeries;
|
|
2076
|
+
exports3.ensureAsync = ensureAsync;
|
|
2077
|
+
exports3.every = every;
|
|
2078
|
+
exports3.everyLimit = everyLimit;
|
|
2079
|
+
exports3.everySeries = everySeries;
|
|
2080
|
+
exports3.filter = filter;
|
|
2081
|
+
exports3.filterLimit = filterLimit;
|
|
2082
|
+
exports3.filterSeries = filterSeries;
|
|
2083
|
+
exports3.forever = forever;
|
|
2084
|
+
exports3.groupBy = groupBy;
|
|
2085
|
+
exports3.groupByLimit = groupByLimit;
|
|
2086
|
+
exports3.groupBySeries = groupBySeries;
|
|
2087
|
+
exports3.log = log;
|
|
2088
|
+
exports3.map = map;
|
|
2089
|
+
exports3.mapLimit = mapLimit;
|
|
2090
|
+
exports3.mapSeries = mapSeries;
|
|
2091
|
+
exports3.mapValues = mapValues;
|
|
2092
|
+
exports3.mapValuesLimit = mapValuesLimit;
|
|
2093
|
+
exports3.mapValuesSeries = mapValuesSeries;
|
|
2094
|
+
exports3.memoize = memoize;
|
|
2095
|
+
exports3.nextTick = nextTick;
|
|
2096
|
+
exports3.parallel = parallelLimit;
|
|
2097
|
+
exports3.parallelLimit = parallelLimit$1;
|
|
2098
|
+
exports3.priorityQueue = priorityQueue;
|
|
2099
|
+
exports3.queue = queue$1;
|
|
2100
|
+
exports3.race = race;
|
|
2101
|
+
exports3.reduce = reduce;
|
|
2102
|
+
exports3.reduceRight = reduceRight;
|
|
2103
|
+
exports3.reflect = reflect;
|
|
2104
|
+
exports3.reflectAll = reflectAll;
|
|
2105
|
+
exports3.reject = reject;
|
|
2106
|
+
exports3.rejectLimit = rejectLimit;
|
|
2107
|
+
exports3.rejectSeries = rejectSeries;
|
|
2108
|
+
exports3.retry = retry;
|
|
2109
|
+
exports3.retryable = retryable;
|
|
2110
|
+
exports3.seq = seq;
|
|
2111
|
+
exports3.series = series;
|
|
2112
|
+
exports3.setImmediate = setImmediate$1;
|
|
2113
|
+
exports3.some = some;
|
|
2114
|
+
exports3.someLimit = someLimit;
|
|
2115
|
+
exports3.someSeries = someSeries;
|
|
2116
|
+
exports3.sortBy = sortBy;
|
|
2117
|
+
exports3.timeout = timeout;
|
|
2118
|
+
exports3.times = times;
|
|
2119
|
+
exports3.timesLimit = timeLimit;
|
|
2120
|
+
exports3.timesSeries = timesSeries;
|
|
2121
|
+
exports3.transform = transform;
|
|
2122
|
+
exports3.tryEach = tryEach;
|
|
2123
|
+
exports3.unmemoize = unmemoize;
|
|
2124
|
+
exports3.until = until;
|
|
2125
|
+
exports3.waterfall = waterfall;
|
|
2126
|
+
exports3.whilst = whilst;
|
|
2127
|
+
exports3.all = every;
|
|
2128
|
+
exports3.allLimit = everyLimit;
|
|
2129
|
+
exports3.allSeries = everySeries;
|
|
2130
|
+
exports3.any = some;
|
|
2131
|
+
exports3.anyLimit = someLimit;
|
|
2132
|
+
exports3.anySeries = someSeries;
|
|
2133
|
+
exports3.find = detect;
|
|
2134
|
+
exports3.findLimit = detectLimit;
|
|
2135
|
+
exports3.findSeries = detectSeries;
|
|
2136
|
+
exports3.forEach = eachLimit;
|
|
2137
|
+
exports3.forEachSeries = eachSeries;
|
|
2138
|
+
exports3.forEachLimit = eachLimit$1;
|
|
2139
|
+
exports3.forEachOf = eachOf;
|
|
2140
|
+
exports3.forEachOfSeries = eachOfSeries;
|
|
2141
|
+
exports3.forEachOfLimit = eachOfLimit;
|
|
2142
|
+
exports3.inject = reduce;
|
|
2143
|
+
exports3.foldl = reduce;
|
|
2144
|
+
exports3.foldr = reduceRight;
|
|
2145
|
+
exports3.select = filter;
|
|
2146
|
+
exports3.selectLimit = filterLimit;
|
|
2147
|
+
exports3.selectSeries = filterSeries;
|
|
2148
|
+
exports3.wrapSync = asyncify;
|
|
2149
|
+
Object.defineProperty(exports3, "__esModule", { value: true });
|
|
2150
|
+
});
|
|
2151
|
+
}
|
|
2152
|
+
});
|
|
2153
|
+
|
|
2154
|
+
// node_modules/ms/index.js
|
|
2155
|
+
var require_ms = __commonJS({
|
|
2156
|
+
"node_modules/ms/index.js"(exports2, module2) {
|
|
2157
|
+
var s = 1e3;
|
|
2158
|
+
var m = s * 60;
|
|
2159
|
+
var h = m * 60;
|
|
2160
|
+
var d = h * 24;
|
|
2161
|
+
var w = d * 7;
|
|
2162
|
+
var y = d * 365.25;
|
|
2163
|
+
module2.exports = function(val, options) {
|
|
2164
|
+
options = options || {};
|
|
2165
|
+
var type = typeof val;
|
|
2166
|
+
if (type === "string" && val.length > 0) {
|
|
2167
|
+
return parse(val);
|
|
2168
|
+
} else if (type === "number" && isFinite(val)) {
|
|
2169
|
+
return options.long ? fmtLong(val) : fmtShort(val);
|
|
2170
|
+
}
|
|
2171
|
+
throw new Error(
|
|
2172
|
+
"val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
|
|
2173
|
+
);
|
|
2174
|
+
};
|
|
2175
|
+
function parse(str) {
|
|
2176
|
+
str = String(str);
|
|
2177
|
+
if (str.length > 100) {
|
|
2178
|
+
return;
|
|
2179
|
+
}
|
|
2180
|
+
var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
|
|
2181
|
+
str
|
|
2182
|
+
);
|
|
2183
|
+
if (!match) {
|
|
2184
|
+
return;
|
|
2185
|
+
}
|
|
2186
|
+
var n = parseFloat(match[1]);
|
|
2187
|
+
var type = (match[2] || "ms").toLowerCase();
|
|
2188
|
+
switch (type) {
|
|
2189
|
+
case "years":
|
|
2190
|
+
case "year":
|
|
2191
|
+
case "yrs":
|
|
2192
|
+
case "yr":
|
|
2193
|
+
case "y":
|
|
2194
|
+
return n * y;
|
|
2195
|
+
case "weeks":
|
|
2196
|
+
case "week":
|
|
2197
|
+
case "w":
|
|
2198
|
+
return n * w;
|
|
2199
|
+
case "days":
|
|
2200
|
+
case "day":
|
|
2201
|
+
case "d":
|
|
2202
|
+
return n * d;
|
|
2203
|
+
case "hours":
|
|
2204
|
+
case "hour":
|
|
2205
|
+
case "hrs":
|
|
2206
|
+
case "hr":
|
|
2207
|
+
case "h":
|
|
2208
|
+
return n * h;
|
|
2209
|
+
case "minutes":
|
|
2210
|
+
case "minute":
|
|
2211
|
+
case "mins":
|
|
2212
|
+
case "min":
|
|
2213
|
+
case "m":
|
|
2214
|
+
return n * m;
|
|
2215
|
+
case "seconds":
|
|
2216
|
+
case "second":
|
|
2217
|
+
case "secs":
|
|
2218
|
+
case "sec":
|
|
2219
|
+
case "s":
|
|
2220
|
+
return n * s;
|
|
2221
|
+
case "milliseconds":
|
|
2222
|
+
case "millisecond":
|
|
2223
|
+
case "msecs":
|
|
2224
|
+
case "msec":
|
|
2225
|
+
case "ms":
|
|
2226
|
+
return n;
|
|
2227
|
+
default:
|
|
2228
|
+
return void 0;
|
|
2229
|
+
}
|
|
2230
|
+
}
|
|
2231
|
+
function fmtShort(ms) {
|
|
2232
|
+
var msAbs = Math.abs(ms);
|
|
2233
|
+
if (msAbs >= d) {
|
|
2234
|
+
return Math.round(ms / d) + "d";
|
|
2235
|
+
}
|
|
2236
|
+
if (msAbs >= h) {
|
|
2237
|
+
return Math.round(ms / h) + "h";
|
|
2238
|
+
}
|
|
2239
|
+
if (msAbs >= m) {
|
|
2240
|
+
return Math.round(ms / m) + "m";
|
|
2241
|
+
}
|
|
2242
|
+
if (msAbs >= s) {
|
|
2243
|
+
return Math.round(ms / s) + "s";
|
|
2244
|
+
}
|
|
2245
|
+
return ms + "ms";
|
|
2246
|
+
}
|
|
2247
|
+
function fmtLong(ms) {
|
|
2248
|
+
var msAbs = Math.abs(ms);
|
|
2249
|
+
if (msAbs >= d) {
|
|
2250
|
+
return plural(ms, msAbs, d, "day");
|
|
2251
|
+
}
|
|
2252
|
+
if (msAbs >= h) {
|
|
2253
|
+
return plural(ms, msAbs, h, "hour");
|
|
2254
|
+
}
|
|
2255
|
+
if (msAbs >= m) {
|
|
2256
|
+
return plural(ms, msAbs, m, "minute");
|
|
2257
|
+
}
|
|
2258
|
+
if (msAbs >= s) {
|
|
2259
|
+
return plural(ms, msAbs, s, "second");
|
|
2260
|
+
}
|
|
2261
|
+
return ms + " ms";
|
|
2262
|
+
}
|
|
2263
|
+
function plural(ms, msAbs, n, name) {
|
|
2264
|
+
var isPlural = msAbs >= n * 1.5;
|
|
2265
|
+
return Math.round(ms / n) + " " + name + (isPlural ? "s" : "");
|
|
2266
|
+
}
|
|
2267
|
+
}
|
|
2268
|
+
});
|
|
2269
|
+
|
|
2270
|
+
// node_modules/debug/src/common.js
|
|
2271
|
+
var require_common = __commonJS({
|
|
2272
|
+
"node_modules/debug/src/common.js"(exports2, module2) {
|
|
2273
|
+
"use strict";
|
|
2274
|
+
function setup(env) {
|
|
2275
|
+
createDebug.debug = createDebug;
|
|
2276
|
+
createDebug.default = createDebug;
|
|
2277
|
+
createDebug.coerce = coerce;
|
|
2278
|
+
createDebug.disable = disable;
|
|
2279
|
+
createDebug.enable = enable;
|
|
2280
|
+
createDebug.enabled = enabled;
|
|
2281
|
+
createDebug.humanize = require_ms();
|
|
2282
|
+
Object.keys(env).forEach(function(key) {
|
|
2283
|
+
createDebug[key] = env[key];
|
|
2284
|
+
});
|
|
2285
|
+
createDebug.instances = [];
|
|
2286
|
+
createDebug.names = [];
|
|
2287
|
+
createDebug.skips = [];
|
|
2288
|
+
createDebug.formatters = {};
|
|
2289
|
+
function selectColor(namespace) {
|
|
2290
|
+
var hash = 0;
|
|
2291
|
+
for (var i = 0; i < namespace.length; i++) {
|
|
2292
|
+
hash = (hash << 5) - hash + namespace.charCodeAt(i);
|
|
2293
|
+
hash |= 0;
|
|
2294
|
+
}
|
|
2295
|
+
return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
|
|
2296
|
+
}
|
|
2297
|
+
createDebug.selectColor = selectColor;
|
|
2298
|
+
function createDebug(namespace) {
|
|
2299
|
+
var prevTime;
|
|
2300
|
+
function debug() {
|
|
2301
|
+
if (!debug.enabled) {
|
|
2302
|
+
return;
|
|
2303
|
+
}
|
|
2304
|
+
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
|
|
2305
|
+
args[_key] = arguments[_key];
|
|
2306
|
+
}
|
|
2307
|
+
var self2 = debug;
|
|
2308
|
+
var curr = Number(/* @__PURE__ */ new Date());
|
|
2309
|
+
var ms = curr - (prevTime || curr);
|
|
2310
|
+
self2.diff = ms;
|
|
2311
|
+
self2.prev = prevTime;
|
|
2312
|
+
self2.curr = curr;
|
|
2313
|
+
prevTime = curr;
|
|
2314
|
+
args[0] = createDebug.coerce(args[0]);
|
|
2315
|
+
if (typeof args[0] !== "string") {
|
|
2316
|
+
args.unshift("%O");
|
|
2317
|
+
}
|
|
2318
|
+
var index = 0;
|
|
2319
|
+
args[0] = args[0].replace(/%([a-zA-Z%])/g, function(match, format) {
|
|
2320
|
+
if (match === "%%") {
|
|
2321
|
+
return match;
|
|
2322
|
+
}
|
|
2323
|
+
index++;
|
|
2324
|
+
var formatter = createDebug.formatters[format];
|
|
2325
|
+
if (typeof formatter === "function") {
|
|
2326
|
+
var val = args[index];
|
|
2327
|
+
match = formatter.call(self2, val);
|
|
2328
|
+
args.splice(index, 1);
|
|
2329
|
+
index--;
|
|
2330
|
+
}
|
|
2331
|
+
return match;
|
|
2332
|
+
});
|
|
2333
|
+
createDebug.formatArgs.call(self2, args);
|
|
2334
|
+
var logFn = self2.log || createDebug.log;
|
|
2335
|
+
logFn.apply(self2, args);
|
|
2336
|
+
}
|
|
2337
|
+
debug.namespace = namespace;
|
|
2338
|
+
debug.enabled = createDebug.enabled(namespace);
|
|
2339
|
+
debug.useColors = createDebug.useColors();
|
|
2340
|
+
debug.color = selectColor(namespace);
|
|
2341
|
+
debug.destroy = destroy;
|
|
2342
|
+
debug.extend = extend;
|
|
2343
|
+
if (typeof createDebug.init === "function") {
|
|
2344
|
+
createDebug.init(debug);
|
|
2345
|
+
}
|
|
2346
|
+
createDebug.instances.push(debug);
|
|
2347
|
+
return debug;
|
|
2348
|
+
}
|
|
2349
|
+
function destroy() {
|
|
2350
|
+
var index = createDebug.instances.indexOf(this);
|
|
2351
|
+
if (index !== -1) {
|
|
2352
|
+
createDebug.instances.splice(index, 1);
|
|
2353
|
+
return true;
|
|
2354
|
+
}
|
|
2355
|
+
return false;
|
|
2356
|
+
}
|
|
2357
|
+
function extend(namespace, delimiter2) {
|
|
2358
|
+
return createDebug(this.namespace + (typeof delimiter2 === "undefined" ? ":" : delimiter2) + namespace);
|
|
2359
|
+
}
|
|
2360
|
+
function enable(namespaces) {
|
|
2361
|
+
createDebug.save(namespaces);
|
|
2362
|
+
createDebug.names = [];
|
|
2363
|
+
createDebug.skips = [];
|
|
2364
|
+
var i;
|
|
2365
|
+
var split = (typeof namespaces === "string" ? namespaces : "").split(/[\s,]+/);
|
|
2366
|
+
var len = split.length;
|
|
2367
|
+
for (i = 0; i < len; i++) {
|
|
2368
|
+
if (!split[i]) {
|
|
2369
|
+
continue;
|
|
2370
|
+
}
|
|
2371
|
+
namespaces = split[i].replace(/\*/g, ".*?");
|
|
2372
|
+
if (namespaces[0] === "-") {
|
|
2373
|
+
createDebug.skips.push(new RegExp("^" + namespaces.substr(1) + "$"));
|
|
2374
|
+
} else {
|
|
2375
|
+
createDebug.names.push(new RegExp("^" + namespaces + "$"));
|
|
2376
|
+
}
|
|
2377
|
+
}
|
|
2378
|
+
for (i = 0; i < createDebug.instances.length; i++) {
|
|
2379
|
+
var instance = createDebug.instances[i];
|
|
2380
|
+
instance.enabled = createDebug.enabled(instance.namespace);
|
|
2381
|
+
}
|
|
2382
|
+
}
|
|
2383
|
+
function disable() {
|
|
2384
|
+
createDebug.enable("");
|
|
2385
|
+
}
|
|
2386
|
+
function enabled(name) {
|
|
2387
|
+
if (name[name.length - 1] === "*") {
|
|
2388
|
+
return true;
|
|
2389
|
+
}
|
|
2390
|
+
var i;
|
|
2391
|
+
var len;
|
|
2392
|
+
for (i = 0, len = createDebug.skips.length; i < len; i++) {
|
|
2393
|
+
if (createDebug.skips[i].test(name)) {
|
|
2394
|
+
return false;
|
|
2395
|
+
}
|
|
2396
|
+
}
|
|
2397
|
+
for (i = 0, len = createDebug.names.length; i < len; i++) {
|
|
2398
|
+
if (createDebug.names[i].test(name)) {
|
|
2399
|
+
return true;
|
|
2400
|
+
}
|
|
2401
|
+
}
|
|
2402
|
+
return false;
|
|
2403
|
+
}
|
|
2404
|
+
function coerce(val) {
|
|
2405
|
+
if (val instanceof Error) {
|
|
2406
|
+
return val.stack || val.message;
|
|
2407
|
+
}
|
|
2408
|
+
return val;
|
|
2409
|
+
}
|
|
2410
|
+
createDebug.enable(createDebug.load());
|
|
2411
|
+
return createDebug;
|
|
2412
|
+
}
|
|
2413
|
+
module2.exports = setup;
|
|
2414
|
+
}
|
|
2415
|
+
});
|
|
2416
|
+
|
|
2417
|
+
// node_modules/debug/src/browser.js
|
|
2418
|
+
var require_browser = __commonJS({
|
|
2419
|
+
"node_modules/debug/src/browser.js"(exports2, module2) {
|
|
2420
|
+
"use strict";
|
|
2421
|
+
function _typeof(obj) {
|
|
2422
|
+
if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
|
|
2423
|
+
_typeof = function _typeof2(obj2) {
|
|
2424
|
+
return typeof obj2;
|
|
2425
|
+
};
|
|
2426
|
+
} else {
|
|
2427
|
+
_typeof = function _typeof2(obj2) {
|
|
2428
|
+
return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
|
|
2429
|
+
};
|
|
2430
|
+
}
|
|
2431
|
+
return _typeof(obj);
|
|
2432
|
+
}
|
|
2433
|
+
exports2.log = log;
|
|
2434
|
+
exports2.formatArgs = formatArgs;
|
|
2435
|
+
exports2.save = save;
|
|
2436
|
+
exports2.load = load;
|
|
2437
|
+
exports2.useColors = useColors;
|
|
2438
|
+
exports2.storage = localstorage();
|
|
2439
|
+
exports2.colors = ["#0000CC", "#0000FF", "#0033CC", "#0033FF", "#0066CC", "#0066FF", "#0099CC", "#0099FF", "#00CC00", "#00CC33", "#00CC66", "#00CC99", "#00CCCC", "#00CCFF", "#3300CC", "#3300FF", "#3333CC", "#3333FF", "#3366CC", "#3366FF", "#3399CC", "#3399FF", "#33CC00", "#33CC33", "#33CC66", "#33CC99", "#33CCCC", "#33CCFF", "#6600CC", "#6600FF", "#6633CC", "#6633FF", "#66CC00", "#66CC33", "#9900CC", "#9900FF", "#9933CC", "#9933FF", "#99CC00", "#99CC33", "#CC0000", "#CC0033", "#CC0066", "#CC0099", "#CC00CC", "#CC00FF", "#CC3300", "#CC3333", "#CC3366", "#CC3399", "#CC33CC", "#CC33FF", "#CC6600", "#CC6633", "#CC9900", "#CC9933", "#CCCC00", "#CCCC33", "#FF0000", "#FF0033", "#FF0066", "#FF0099", "#FF00CC", "#FF00FF", "#FF3300", "#FF3333", "#FF3366", "#FF3399", "#FF33CC", "#FF33FF", "#FF6600", "#FF6633", "#FF9900", "#FF9933", "#FFCC00", "#FFCC33"];
|
|
2440
|
+
function useColors() {
|
|
2441
|
+
if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) {
|
|
2442
|
+
return true;
|
|
2443
|
+
}
|
|
2444
|
+
if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
|
|
2445
|
+
return false;
|
|
2446
|
+
}
|
|
2447
|
+
return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // Is firebug? http://stackoverflow.com/a/398120/376773
|
|
2448
|
+
typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || // Is firefox >= v31?
|
|
2449
|
+
// https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
|
|
2450
|
+
typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker
|
|
2451
|
+
typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
|
|
2452
|
+
}
|
|
2453
|
+
function formatArgs(args) {
|
|
2454
|
+
args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module2.exports.humanize(this.diff);
|
|
2455
|
+
if (!this.useColors) {
|
|
2456
|
+
return;
|
|
2457
|
+
}
|
|
2458
|
+
var c = "color: " + this.color;
|
|
2459
|
+
args.splice(1, 0, c, "color: inherit");
|
|
2460
|
+
var index = 0;
|
|
2461
|
+
var lastC = 0;
|
|
2462
|
+
args[0].replace(/%[a-zA-Z%]/g, function(match) {
|
|
2463
|
+
if (match === "%%") {
|
|
2464
|
+
return;
|
|
2465
|
+
}
|
|
2466
|
+
index++;
|
|
2467
|
+
if (match === "%c") {
|
|
2468
|
+
lastC = index;
|
|
2469
|
+
}
|
|
2470
|
+
});
|
|
2471
|
+
args.splice(lastC, 0, c);
|
|
2472
|
+
}
|
|
2473
|
+
function log() {
|
|
2474
|
+
var _console;
|
|
2475
|
+
return (typeof console === "undefined" ? "undefined" : _typeof(console)) === "object" && console.log && (_console = console).log.apply(_console, arguments);
|
|
2476
|
+
}
|
|
2477
|
+
function save(namespaces) {
|
|
2478
|
+
try {
|
|
2479
|
+
if (namespaces) {
|
|
2480
|
+
exports2.storage.setItem("debug", namespaces);
|
|
2481
|
+
} else {
|
|
2482
|
+
exports2.storage.removeItem("debug");
|
|
2483
|
+
}
|
|
2484
|
+
} catch (error) {
|
|
2485
|
+
}
|
|
2486
|
+
}
|
|
2487
|
+
function load() {
|
|
2488
|
+
var r;
|
|
2489
|
+
try {
|
|
2490
|
+
r = exports2.storage.getItem("debug");
|
|
2491
|
+
} catch (error) {
|
|
2492
|
+
}
|
|
2493
|
+
if (!r && typeof process !== "undefined" && "env" in process) {
|
|
2494
|
+
r = process.env.DEBUG;
|
|
2495
|
+
}
|
|
2496
|
+
return r;
|
|
2497
|
+
}
|
|
2498
|
+
function localstorage() {
|
|
2499
|
+
try {
|
|
2500
|
+
return localStorage;
|
|
2501
|
+
} catch (error) {
|
|
2502
|
+
}
|
|
2503
|
+
}
|
|
2504
|
+
module2.exports = require_common()(exports2);
|
|
2505
|
+
var formatters = module2.exports.formatters;
|
|
2506
|
+
formatters.j = function(v) {
|
|
2507
|
+
try {
|
|
2508
|
+
return JSON.stringify(v);
|
|
2509
|
+
} catch (error) {
|
|
2510
|
+
return "[UnexpectedJSONParseError]: " + error.message;
|
|
2511
|
+
}
|
|
2512
|
+
};
|
|
2513
|
+
}
|
|
2514
|
+
});
|
|
2515
|
+
|
|
2516
|
+
// node_modules/debug/src/node.js
|
|
2517
|
+
var require_node = __commonJS({
|
|
2518
|
+
"node_modules/debug/src/node.js"(exports2, module2) {
|
|
2519
|
+
"use strict";
|
|
2520
|
+
var tty = require("tty");
|
|
2521
|
+
var util = require("util");
|
|
2522
|
+
exports2.init = init;
|
|
2523
|
+
exports2.log = log;
|
|
2524
|
+
exports2.formatArgs = formatArgs;
|
|
2525
|
+
exports2.save = save;
|
|
2526
|
+
exports2.load = load;
|
|
2527
|
+
exports2.useColors = useColors;
|
|
2528
|
+
exports2.colors = [6, 2, 3, 4, 5, 1];
|
|
2529
|
+
try {
|
|
2530
|
+
supportsColor = require("supports-color");
|
|
2531
|
+
if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
|
|
2532
|
+
exports2.colors = [20, 21, 26, 27, 32, 33, 38, 39, 40, 41, 42, 43, 44, 45, 56, 57, 62, 63, 68, 69, 74, 75, 76, 77, 78, 79, 80, 81, 92, 93, 98, 99, 112, 113, 128, 129, 134, 135, 148, 149, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 178, 179, 184, 185, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 214, 215, 220, 221];
|
|
2533
|
+
}
|
|
2534
|
+
} catch (error) {
|
|
2535
|
+
}
|
|
2536
|
+
var supportsColor;
|
|
2537
|
+
exports2.inspectOpts = Object.keys(process.env).filter(function(key) {
|
|
2538
|
+
return /^debug_/i.test(key);
|
|
2539
|
+
}).reduce(function(obj, key) {
|
|
2540
|
+
var prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, function(_, k) {
|
|
2541
|
+
return k.toUpperCase();
|
|
2542
|
+
});
|
|
2543
|
+
var val = process.env[key];
|
|
2544
|
+
if (/^(yes|on|true|enabled)$/i.test(val)) {
|
|
2545
|
+
val = true;
|
|
2546
|
+
} else if (/^(no|off|false|disabled)$/i.test(val)) {
|
|
2547
|
+
val = false;
|
|
2548
|
+
} else if (val === "null") {
|
|
2549
|
+
val = null;
|
|
2550
|
+
} else {
|
|
2551
|
+
val = Number(val);
|
|
2552
|
+
}
|
|
2553
|
+
obj[prop] = val;
|
|
2554
|
+
return obj;
|
|
2555
|
+
}, {});
|
|
2556
|
+
function useColors() {
|
|
2557
|
+
return "colors" in exports2.inspectOpts ? Boolean(exports2.inspectOpts.colors) : tty.isatty(process.stderr.fd);
|
|
2558
|
+
}
|
|
2559
|
+
function formatArgs(args) {
|
|
2560
|
+
var name = this.namespace, useColors2 = this.useColors;
|
|
2561
|
+
if (useColors2) {
|
|
2562
|
+
var c = this.color;
|
|
2563
|
+
var colorCode = "\x1B[3" + (c < 8 ? c : "8;5;" + c);
|
|
2564
|
+
var prefix = " ".concat(colorCode, ";1m").concat(name, " \x1B[0m");
|
|
2565
|
+
args[0] = prefix + args[0].split("\n").join("\n" + prefix);
|
|
2566
|
+
args.push(colorCode + "m+" + module2.exports.humanize(this.diff) + "\x1B[0m");
|
|
2567
|
+
} else {
|
|
2568
|
+
args[0] = getDate() + name + " " + args[0];
|
|
2569
|
+
}
|
|
2570
|
+
}
|
|
2571
|
+
function getDate() {
|
|
2572
|
+
if (exports2.inspectOpts.hideDate) {
|
|
2573
|
+
return "";
|
|
2574
|
+
}
|
|
2575
|
+
return (/* @__PURE__ */ new Date()).toISOString() + " ";
|
|
2576
|
+
}
|
|
2577
|
+
function log() {
|
|
2578
|
+
return process.stderr.write(util.format.apply(util, arguments) + "\n");
|
|
2579
|
+
}
|
|
2580
|
+
function save(namespaces) {
|
|
2581
|
+
if (namespaces) {
|
|
2582
|
+
process.env.DEBUG = namespaces;
|
|
2583
|
+
} else {
|
|
2584
|
+
delete process.env.DEBUG;
|
|
2585
|
+
}
|
|
2586
|
+
}
|
|
2587
|
+
function load() {
|
|
2588
|
+
return process.env.DEBUG;
|
|
2589
|
+
}
|
|
2590
|
+
function init(debug) {
|
|
2591
|
+
debug.inspectOpts = {};
|
|
2592
|
+
var keys = Object.keys(exports2.inspectOpts);
|
|
2593
|
+
for (var i = 0; i < keys.length; i++) {
|
|
2594
|
+
debug.inspectOpts[keys[i]] = exports2.inspectOpts[keys[i]];
|
|
2595
|
+
}
|
|
2596
|
+
}
|
|
2597
|
+
module2.exports = require_common()(exports2);
|
|
2598
|
+
var formatters = module2.exports.formatters;
|
|
2599
|
+
formatters.o = function(v) {
|
|
2600
|
+
this.inspectOpts.colors = this.useColors;
|
|
2601
|
+
return util.inspect(v, this.inspectOpts).split("\n").map(function(str) {
|
|
2602
|
+
return str.trim();
|
|
2603
|
+
}).join(" ");
|
|
2604
|
+
};
|
|
2605
|
+
formatters.O = function(v) {
|
|
2606
|
+
this.inspectOpts.colors = this.useColors;
|
|
2607
|
+
return util.inspect(v, this.inspectOpts);
|
|
2608
|
+
};
|
|
2609
|
+
}
|
|
2610
|
+
});
|
|
2611
|
+
|
|
2612
|
+
// node_modules/debug/src/index.js
|
|
2613
|
+
var require_src = __commonJS({
|
|
2614
|
+
"node_modules/debug/src/index.js"(exports2, module2) {
|
|
2615
|
+
"use strict";
|
|
2616
|
+
if (typeof process === "undefined" || process.type === "renderer" || process.browser === true || process.__nwjs) {
|
|
2617
|
+
module2.exports = require_browser();
|
|
2618
|
+
} else {
|
|
2619
|
+
module2.exports = require_node();
|
|
2620
|
+
}
|
|
2621
|
+
}
|
|
2622
|
+
});
|
|
2623
|
+
|
|
2624
|
+
// node_modules/mkdirp/index.js
|
|
2625
|
+
var require_mkdirp = __commonJS({
|
|
2626
|
+
"node_modules/mkdirp/index.js"(exports2, module2) {
|
|
2627
|
+
var path3 = require("path");
|
|
2628
|
+
var fs = require("fs");
|
|
2629
|
+
var _0777 = parseInt("0777", 8);
|
|
2630
|
+
module2.exports = mkdirP.mkdirp = mkdirP.mkdirP = mkdirP;
|
|
2631
|
+
function mkdirP(p, opts, f, made) {
|
|
2632
|
+
if (typeof opts === "function") {
|
|
2633
|
+
f = opts;
|
|
2634
|
+
opts = {};
|
|
2635
|
+
} else if (!opts || typeof opts !== "object") {
|
|
2636
|
+
opts = { mode: opts };
|
|
2637
|
+
}
|
|
2638
|
+
var mode = opts.mode;
|
|
2639
|
+
var xfs = opts.fs || fs;
|
|
2640
|
+
if (mode === void 0) {
|
|
2641
|
+
mode = _0777;
|
|
2642
|
+
}
|
|
2643
|
+
if (!made)
|
|
2644
|
+
made = null;
|
|
2645
|
+
var cb = f || /* istanbul ignore next */
|
|
2646
|
+
function() {
|
|
2647
|
+
};
|
|
2648
|
+
p = path3.resolve(p);
|
|
2649
|
+
xfs.mkdir(p, mode, function(er) {
|
|
2650
|
+
if (!er) {
|
|
2651
|
+
made = made || p;
|
|
2652
|
+
return cb(null, made);
|
|
2653
|
+
}
|
|
2654
|
+
switch (er.code) {
|
|
2655
|
+
case "ENOENT":
|
|
2656
|
+
if (path3.dirname(p) === p)
|
|
2657
|
+
return cb(er);
|
|
2658
|
+
mkdirP(path3.dirname(p), opts, function(er2, made2) {
|
|
2659
|
+
if (er2)
|
|
2660
|
+
cb(er2, made2);
|
|
2661
|
+
else
|
|
2662
|
+
mkdirP(p, opts, cb, made2);
|
|
2663
|
+
});
|
|
2664
|
+
break;
|
|
2665
|
+
default:
|
|
2666
|
+
xfs.stat(p, function(er2, stat) {
|
|
2667
|
+
if (er2 || !stat.isDirectory())
|
|
2668
|
+
cb(er, made);
|
|
2669
|
+
else
|
|
2670
|
+
cb(null, made);
|
|
2671
|
+
});
|
|
2672
|
+
break;
|
|
2673
|
+
}
|
|
2674
|
+
});
|
|
2675
|
+
}
|
|
2676
|
+
mkdirP.sync = function sync(p, opts, made) {
|
|
2677
|
+
if (!opts || typeof opts !== "object") {
|
|
2678
|
+
opts = { mode: opts };
|
|
2679
|
+
}
|
|
2680
|
+
var mode = opts.mode;
|
|
2681
|
+
var xfs = opts.fs || fs;
|
|
2682
|
+
if (mode === void 0) {
|
|
2683
|
+
mode = _0777;
|
|
2684
|
+
}
|
|
2685
|
+
if (!made)
|
|
2686
|
+
made = null;
|
|
2687
|
+
p = path3.resolve(p);
|
|
2688
|
+
try {
|
|
2689
|
+
xfs.mkdirSync(p, mode);
|
|
2690
|
+
made = made || p;
|
|
2691
|
+
} catch (err0) {
|
|
2692
|
+
switch (err0.code) {
|
|
2693
|
+
case "ENOENT":
|
|
2694
|
+
made = sync(path3.dirname(p), opts, made);
|
|
2695
|
+
sync(p, opts, made);
|
|
2696
|
+
break;
|
|
2697
|
+
default:
|
|
2698
|
+
var stat;
|
|
2699
|
+
try {
|
|
2700
|
+
stat = xfs.statSync(p);
|
|
2701
|
+
} catch (err1) {
|
|
2702
|
+
throw err0;
|
|
2703
|
+
}
|
|
2704
|
+
if (!stat.isDirectory())
|
|
2705
|
+
throw err0;
|
|
2706
|
+
break;
|
|
2707
|
+
}
|
|
2708
|
+
}
|
|
2709
|
+
return made;
|
|
2710
|
+
};
|
|
2711
|
+
}
|
|
2712
|
+
});
|
|
2713
|
+
|
|
2714
|
+
// node_modules/portfinder/lib/portfinder.js
|
|
2715
|
+
var require_portfinder = __commonJS({
|
|
2716
|
+
"node_modules/portfinder/lib/portfinder.js"(exports2) {
|
|
2717
|
+
"use strict";
|
|
2718
|
+
var fs = require("fs");
|
|
2719
|
+
var os = require("os");
|
|
2720
|
+
var net = require("net");
|
|
2721
|
+
var path3 = require("path");
|
|
2722
|
+
var _async = require_async();
|
|
2723
|
+
var debug = require_src();
|
|
2724
|
+
var mkdirp = require_mkdirp().mkdirp;
|
|
2725
|
+
var debugTestPort = debug("portfinder:testPort");
|
|
2726
|
+
var debugGetPort = debug("portfinder:getPort");
|
|
2727
|
+
var debugDefaultHosts = debug("portfinder:defaultHosts");
|
|
2728
|
+
var internals = {};
|
|
2729
|
+
internals.testPort = function(options, callback) {
|
|
2730
|
+
if (!callback) {
|
|
2731
|
+
callback = options;
|
|
2732
|
+
options = {};
|
|
2733
|
+
}
|
|
2734
|
+
options.server = options.server || net.createServer(function() {
|
|
2735
|
+
});
|
|
2736
|
+
debugTestPort("entered testPort(): trying", options.host, "port", options.port);
|
|
2737
|
+
function onListen() {
|
|
2738
|
+
debugTestPort("done w/ testPort(): OK", options.host, "port", options.port);
|
|
2739
|
+
options.server.removeListener("error", onError);
|
|
2740
|
+
options.server.close();
|
|
2741
|
+
callback(null, options.port);
|
|
2742
|
+
}
|
|
2743
|
+
function onError(err) {
|
|
2744
|
+
debugTestPort("done w/ testPort(): failed", options.host, "w/ port", options.port, "with error", err.code);
|
|
2745
|
+
options.server.removeListener("listening", onListen);
|
|
2746
|
+
if (!(err.code == "EADDRINUSE" || err.code == "EACCES")) {
|
|
2747
|
+
return callback(err);
|
|
2748
|
+
}
|
|
2749
|
+
var nextPort = exports2.nextPort(options.port);
|
|
2750
|
+
if (nextPort > exports2.highestPort) {
|
|
2751
|
+
return callback(new Error("No open ports available"));
|
|
2752
|
+
}
|
|
2753
|
+
internals.testPort({
|
|
2754
|
+
port: nextPort,
|
|
2755
|
+
host: options.host,
|
|
2756
|
+
server: options.server
|
|
2757
|
+
}, callback);
|
|
2758
|
+
}
|
|
2759
|
+
options.server.once("error", onError);
|
|
2760
|
+
options.server.once("listening", onListen);
|
|
2761
|
+
if (options.host) {
|
|
2762
|
+
options.server.listen(options.port, options.host);
|
|
2763
|
+
} else {
|
|
2764
|
+
options.server.listen(options.port);
|
|
2765
|
+
}
|
|
2766
|
+
};
|
|
2767
|
+
exports2.basePort = 8e3;
|
|
2768
|
+
exports2.setBasePort = function(port) {
|
|
2769
|
+
exports2.basePort = port;
|
|
2770
|
+
};
|
|
2771
|
+
exports2.highestPort = 65535;
|
|
2772
|
+
exports2.setHighestPort = function(port) {
|
|
2773
|
+
exports2.highestPort = port;
|
|
2774
|
+
};
|
|
2775
|
+
exports2.basePath = "/tmp/portfinder";
|
|
2776
|
+
exports2.getPort = function(options, callback) {
|
|
2777
|
+
if (!callback) {
|
|
2778
|
+
callback = options;
|
|
2779
|
+
options = {};
|
|
2780
|
+
}
|
|
2781
|
+
options.port = Number(options.port) || Number(exports2.basePort);
|
|
2782
|
+
options.host = options.host || null;
|
|
2783
|
+
options.stopPort = Number(options.stopPort) || Number(exports2.highestPort);
|
|
2784
|
+
if (!options.startPort) {
|
|
2785
|
+
options.startPort = Number(options.port);
|
|
2786
|
+
if (options.startPort < 0) {
|
|
2787
|
+
throw Error("Provided options.startPort(" + options.startPort + ") is less than 0, which are cannot be bound.");
|
|
2788
|
+
}
|
|
2789
|
+
if (options.stopPort < options.startPort) {
|
|
2790
|
+
throw Error("Provided options.stopPort(" + options.stopPort + "is less than options.startPort (" + options.startPort + ")");
|
|
2791
|
+
}
|
|
2792
|
+
}
|
|
2793
|
+
if (options.host) {
|
|
2794
|
+
if (exports2._defaultHosts.indexOf(options.host) !== -1) {
|
|
2795
|
+
exports2._defaultHosts.push(options.host);
|
|
2796
|
+
}
|
|
2797
|
+
}
|
|
2798
|
+
var openPorts = [], currentHost;
|
|
2799
|
+
return _async.eachSeries(exports2._defaultHosts, function(host, next) {
|
|
2800
|
+
debugGetPort("in eachSeries() iteration callback: host is", host);
|
|
2801
|
+
return internals.testPort({ host, port: options.port }, function(err, port) {
|
|
2802
|
+
if (err) {
|
|
2803
|
+
debugGetPort("in eachSeries() iteration callback testPort() callback", "with an err:", err.code);
|
|
2804
|
+
currentHost = host;
|
|
2805
|
+
return next(err);
|
|
2806
|
+
} else {
|
|
2807
|
+
debugGetPort(
|
|
2808
|
+
"in eachSeries() iteration callback testPort() callback",
|
|
2809
|
+
"with a success for port",
|
|
2810
|
+
port
|
|
2811
|
+
);
|
|
2812
|
+
openPorts.push(port);
|
|
2813
|
+
return next();
|
|
2814
|
+
}
|
|
2815
|
+
});
|
|
2816
|
+
}, function(err) {
|
|
2817
|
+
if (err) {
|
|
2818
|
+
debugGetPort("in eachSeries() result callback: err is", err);
|
|
2819
|
+
if (err.code === "EADDRNOTAVAIL" || err.code === "EINVAL") {
|
|
2820
|
+
if (options.host === currentHost) {
|
|
2821
|
+
var msg = "Provided host " + options.host + " could NOT be bound. Please provide a different host address or hostname";
|
|
2822
|
+
return callback(Error(msg));
|
|
2823
|
+
} else {
|
|
2824
|
+
var idx = exports2._defaultHosts.indexOf(currentHost);
|
|
2825
|
+
exports2._defaultHosts.splice(idx, 1);
|
|
2826
|
+
return exports2.getPort(options, callback);
|
|
2827
|
+
}
|
|
2828
|
+
} else {
|
|
2829
|
+
return callback(err);
|
|
2830
|
+
}
|
|
2831
|
+
}
|
|
2832
|
+
openPorts.sort(function(a, b) {
|
|
2833
|
+
return a - b;
|
|
2834
|
+
});
|
|
2835
|
+
debugGetPort("in eachSeries() result callback: openPorts is", openPorts);
|
|
2836
|
+
if (openPorts[0] === openPorts[openPorts.length - 1]) {
|
|
2837
|
+
if (openPorts[0] <= options.stopPort) {
|
|
2838
|
+
return callback(null, openPorts[0]);
|
|
2839
|
+
} else {
|
|
2840
|
+
var msg = "No open ports found in between " + options.startPort + " and " + options.stopPort;
|
|
2841
|
+
return callback(Error(msg));
|
|
2842
|
+
}
|
|
2843
|
+
} else {
|
|
2844
|
+
return exports2.getPort({ port: openPorts.pop(), host: options.host, startPort: options.startPort, stopPort: options.stopPort }, callback);
|
|
2845
|
+
}
|
|
2846
|
+
});
|
|
2847
|
+
};
|
|
2848
|
+
exports2.getPortPromise = function(options) {
|
|
2849
|
+
if (typeof Promise !== "function") {
|
|
2850
|
+
throw Error("Native promise support is not available in this version of node.Please install a polyfill and assign Promise to global.Promise before calling this method");
|
|
2851
|
+
}
|
|
2852
|
+
if (!options) {
|
|
2853
|
+
options = {};
|
|
2854
|
+
}
|
|
2855
|
+
return new Promise(function(resolve2, reject) {
|
|
2856
|
+
exports2.getPort(options, function(err, port) {
|
|
2857
|
+
if (err) {
|
|
2858
|
+
return reject(err);
|
|
2859
|
+
}
|
|
2860
|
+
resolve2(port);
|
|
2861
|
+
});
|
|
2862
|
+
});
|
|
2863
|
+
};
|
|
2864
|
+
exports2.getPorts = function(count, options, callback) {
|
|
2865
|
+
if (!callback) {
|
|
2866
|
+
callback = options;
|
|
2867
|
+
options = {};
|
|
2868
|
+
}
|
|
2869
|
+
var lastPort = null;
|
|
2870
|
+
_async.timesSeries(count, function(index, asyncCallback) {
|
|
2871
|
+
if (lastPort) {
|
|
2872
|
+
options.port = exports2.nextPort(lastPort);
|
|
2873
|
+
}
|
|
2874
|
+
exports2.getPort(options, function(err, port) {
|
|
2875
|
+
if (err) {
|
|
2876
|
+
asyncCallback(err);
|
|
2877
|
+
} else {
|
|
2878
|
+
lastPort = port;
|
|
2879
|
+
asyncCallback(null, port);
|
|
2880
|
+
}
|
|
2881
|
+
});
|
|
2882
|
+
}, callback);
|
|
2883
|
+
};
|
|
2884
|
+
exports2.getSocket = function(options, callback) {
|
|
2885
|
+
if (!callback) {
|
|
2886
|
+
callback = options;
|
|
2887
|
+
options = {};
|
|
2888
|
+
}
|
|
2889
|
+
options.mod = options.mod || parseInt(755, 8);
|
|
2890
|
+
options.path = options.path || exports2.basePath + ".sock";
|
|
2891
|
+
function testSocket() {
|
|
2892
|
+
fs.stat(options.path, function(err) {
|
|
2893
|
+
if (err) {
|
|
2894
|
+
if (err.code == "ENOENT") {
|
|
2895
|
+
callback(null, options.path);
|
|
2896
|
+
} else {
|
|
2897
|
+
callback(err);
|
|
2898
|
+
}
|
|
2899
|
+
} else {
|
|
2900
|
+
options.path = exports2.nextSocket(options.path);
|
|
2901
|
+
exports2.getSocket(options, callback);
|
|
2902
|
+
}
|
|
2903
|
+
});
|
|
2904
|
+
}
|
|
2905
|
+
function createAndTestSocket(dir) {
|
|
2906
|
+
mkdirp(dir, options.mod, function(err) {
|
|
2907
|
+
if (err) {
|
|
2908
|
+
return callback(err);
|
|
2909
|
+
}
|
|
2910
|
+
options.exists = true;
|
|
2911
|
+
testSocket();
|
|
2912
|
+
});
|
|
2913
|
+
}
|
|
2914
|
+
function checkAndTestSocket() {
|
|
2915
|
+
var dir = path3.dirname(options.path);
|
|
2916
|
+
fs.stat(dir, function(err, stats) {
|
|
2917
|
+
if (err || !stats.isDirectory()) {
|
|
2918
|
+
return createAndTestSocket(dir);
|
|
2919
|
+
}
|
|
2920
|
+
options.exists = true;
|
|
2921
|
+
testSocket();
|
|
2922
|
+
});
|
|
2923
|
+
}
|
|
2924
|
+
return options.exists ? testSocket() : checkAndTestSocket();
|
|
2925
|
+
};
|
|
2926
|
+
exports2.nextPort = function(port) {
|
|
2927
|
+
return port + 1;
|
|
2928
|
+
};
|
|
2929
|
+
exports2.nextSocket = function(socketPath) {
|
|
2930
|
+
var dir = path3.dirname(socketPath), name = path3.basename(socketPath, ".sock"), match = name.match(/^([a-zA-z]+)(\d*)$/i), index = parseInt(match[2]), base = match[1];
|
|
2931
|
+
if (isNaN(index)) {
|
|
2932
|
+
index = 0;
|
|
2933
|
+
}
|
|
2934
|
+
index += 1;
|
|
2935
|
+
return path3.join(dir, base + index + ".sock");
|
|
2936
|
+
};
|
|
2937
|
+
exports2._defaultHosts = function() {
|
|
2938
|
+
var interfaces = {};
|
|
2939
|
+
try {
|
|
2940
|
+
interfaces = os.networkInterfaces();
|
|
2941
|
+
} catch (e) {
|
|
2942
|
+
if (e.syscall === "uv_interface_addresses") {
|
|
2943
|
+
} else {
|
|
2944
|
+
throw e;
|
|
2945
|
+
}
|
|
2946
|
+
}
|
|
2947
|
+
var interfaceNames = Object.keys(interfaces), hiddenButImportantHost = "0.0.0.0", results = [hiddenButImportantHost];
|
|
2948
|
+
for (var i = 0; i < interfaceNames.length; i++) {
|
|
2949
|
+
var _interface = interfaces[interfaceNames[i]];
|
|
2950
|
+
for (var j = 0; j < _interface.length; j++) {
|
|
2951
|
+
var curr = _interface[j];
|
|
2952
|
+
results.push(curr.address);
|
|
2953
|
+
}
|
|
2954
|
+
}
|
|
2955
|
+
results.push(null);
|
|
2956
|
+
debugDefaultHosts("exports._defaultHosts is: %o", results);
|
|
2957
|
+
return results;
|
|
2958
|
+
}();
|
|
2959
|
+
}
|
|
2960
|
+
});
|
|
2961
|
+
|
|
2962
|
+
// src/index.ts
|
|
2963
|
+
var src_exports = {};
|
|
2964
|
+
__export(src_exports, {
|
|
2965
|
+
activate: () => activate3
|
|
2966
|
+
});
|
|
2967
|
+
module.exports = __toCommonJS(src_exports);
|
|
2968
|
+
var import_coc6 = require("coc.nvim");
|
|
2969
|
+
|
|
2970
|
+
// src/utils/launch-util.ts
|
|
2971
|
+
var coc3 = __toESM(require("coc.nvim"));
|
|
2972
|
+
var Path = __toESM(require("path"));
|
|
2973
|
+
var FS = __toESM(require("fs"));
|
|
2974
|
+
var Net = __toESM(require("net"));
|
|
2975
|
+
var import_coc = require("coc.nvim");
|
|
2976
|
+
|
|
2977
|
+
// src/utils/classpath.ts
|
|
2978
|
+
var coc = __toESM(require("coc.nvim"));
|
|
2979
|
+
var JDT_SERVER_STANDARD_MODE = "Standard";
|
|
2980
|
+
var CMD_STS_ENABLE_CLASSPATH_LISTENER = "sts.vscode-spring-boot.enableClasspathListening";
|
|
2981
|
+
function getJavaExtension() {
|
|
2982
|
+
const java = coc.extensions.getExtensionById("coc-java");
|
|
2983
|
+
if (!java || java == null || java === void 0) {
|
|
2984
|
+
return coc.extensions.getExtensionById("coc-java-dev");
|
|
2985
|
+
}
|
|
2986
|
+
return java;
|
|
2987
|
+
}
|
|
2988
|
+
function registerClasspathService(client) {
|
|
2989
|
+
const javaExt = getJavaExtension();
|
|
2990
|
+
const javaApi = javaExt?.exports;
|
|
2991
|
+
let addRequest = new coc.RequestType("sts/addClasspathListener");
|
|
2992
|
+
client.onRequest(addRequest, async (params) => {
|
|
2993
|
+
if (javaApi?.serverMode === "LightWeight") {
|
|
2994
|
+
throw new Error("Classpath listener not supported while Java Language Server is in LightWeight mode");
|
|
2995
|
+
}
|
|
2996
|
+
return await coc.commands.executeCommand("java.execute.workspaceCommand", "sts.java.addClasspathListener", params.callbackCommandId);
|
|
2997
|
+
});
|
|
2998
|
+
let removeRequest = new coc.RequestType("sts/removeClasspathListener");
|
|
2999
|
+
client.onRequest(removeRequest, async (params) => {
|
|
3000
|
+
return await coc.commands.executeCommand("java.execute.workspaceCommand", "sts.java.removeClasspathListener", params.callbackCommandId);
|
|
3001
|
+
});
|
|
3002
|
+
if (javaApi) {
|
|
3003
|
+
coc.commands.executeCommand(CMD_STS_ENABLE_CLASSPATH_LISTENER, javaApi.serverMode === JDT_SERVER_STANDARD_MODE);
|
|
3004
|
+
javaApi.onDidServerModeChange(() => coc.commands.executeCommand(CMD_STS_ENABLE_CLASSPATH_LISTENER, javaApi.serverMode === JDT_SERVER_STANDARD_MODE));
|
|
3005
|
+
}
|
|
3006
|
+
}
|
|
3007
|
+
|
|
3008
|
+
// src/utils/logging.ts
|
|
3009
|
+
var coc2 = __toESM(require("coc.nvim"));
|
|
3010
|
+
var springBootOutput;
|
|
3011
|
+
function initLogOutput(context) {
|
|
3012
|
+
springBootOutput = coc2.window.createOutputChannel("SpringBoot");
|
|
3013
|
+
context.subscriptions.push(springBootOutput);
|
|
3014
|
+
return springBootOutput;
|
|
3015
|
+
}
|
|
3016
|
+
function logToSpringBootOutput(message) {
|
|
3017
|
+
if (springBootOutput) {
|
|
3018
|
+
springBootOutput.appendLine(message);
|
|
3019
|
+
}
|
|
3020
|
+
}
|
|
3021
|
+
|
|
3022
|
+
// src/utils/launch-util.ts
|
|
3023
|
+
var import_jvm_launch_utils = __toESM(require_lib());
|
|
3024
|
+
var import_process = require("process");
|
|
3025
|
+
var PortFinder = require_portfinder();
|
|
3026
|
+
var LOG_RESOLVE_VM_ARG_PREFIX = "-Xlog:jni+resolve=";
|
|
3027
|
+
var DEBUG_ARG = "-agentlib:jdwp=transport=dt_socket,server=y,address=8000,suspend=y";
|
|
3028
|
+
PortFinder.basePort = 45556;
|
|
3029
|
+
function getUserDefinedJvmHeap(wsOpts, dflt) {
|
|
3030
|
+
if (!wsOpts) {
|
|
3031
|
+
return dflt;
|
|
3032
|
+
}
|
|
3033
|
+
const javaOptions = wsOpts.get("java");
|
|
3034
|
+
return javaOptions?.heap || dflt;
|
|
3035
|
+
}
|
|
3036
|
+
function isCheckingJVM(wsOpts) {
|
|
3037
|
+
if (!wsOpts) {
|
|
3038
|
+
return true;
|
|
3039
|
+
}
|
|
3040
|
+
return wsOpts.get("checkJVM");
|
|
3041
|
+
}
|
|
3042
|
+
function getUserDefinedJvmArgs(wsOpts) {
|
|
3043
|
+
const dflt = [];
|
|
3044
|
+
if (!wsOpts) {
|
|
3045
|
+
return dflt;
|
|
3046
|
+
}
|
|
3047
|
+
let javaOptions = wsOpts.get("java");
|
|
3048
|
+
return javaOptions?.vmargs ? [...javaOptions.vmargs] : dflt;
|
|
3049
|
+
}
|
|
3050
|
+
function getUserDefinedLsDirectory(options, context) {
|
|
3051
|
+
let location = options.workspaceOptions.get("directory");
|
|
3052
|
+
location = !location || !FS.existsSync(location) ? context.extensionPath : location;
|
|
3053
|
+
if (location) {
|
|
3054
|
+
location = coc3.workspace.expand(location);
|
|
3055
|
+
if (!FS.existsSync(location)) {
|
|
3056
|
+
logToSpringBootOutput(
|
|
3057
|
+
`Spring boot can not start, invalid or non existent path was detected ${location}`
|
|
3058
|
+
);
|
|
3059
|
+
coc3.window.showErrorMessage(`Spring boot not found, check springboot output`);
|
|
3060
|
+
(0, import_process.abort)();
|
|
3061
|
+
}
|
|
3062
|
+
} else {
|
|
3063
|
+
coc3.window.showErrorMessage(`Spring boot binaries directory could not be resolved at all`);
|
|
3064
|
+
(0, import_process.abort)();
|
|
3065
|
+
}
|
|
3066
|
+
return location;
|
|
3067
|
+
}
|
|
3068
|
+
function getSpringUserDefinedJavaHome(wsOpts, log) {
|
|
3069
|
+
let javaHome = void 0;
|
|
3070
|
+
if (wsOpts) {
|
|
3071
|
+
let javaOptions = wsOpts.get("java");
|
|
3072
|
+
javaHome = javaOptions?.home;
|
|
3073
|
+
}
|
|
3074
|
+
if (!javaHome) {
|
|
3075
|
+
log.appendLine('"spring-boot.ls.java.home" setting not specified or empty value');
|
|
3076
|
+
javaHome = void 0;
|
|
3077
|
+
} else if (!FS.existsSync(javaHome)) {
|
|
3078
|
+
log.appendLine('"spring-boot.ls.java.home" points to folder that does NOT exist: ' + javaHome);
|
|
3079
|
+
javaHome = void 0;
|
|
3080
|
+
} else {
|
|
3081
|
+
log.appendLine('Trying to use "spring-boot.ls.java.home" value: ' + javaHome);
|
|
3082
|
+
}
|
|
3083
|
+
return javaHome;
|
|
3084
|
+
}
|
|
3085
|
+
function getJdtUserDefinedJavaHome(log) {
|
|
3086
|
+
let javaHome = coc3.workspace.getConfiguration("java")?.get("home");
|
|
3087
|
+
if (!javaHome) {
|
|
3088
|
+
log.appendLine('"java.home" setting not specified or empty value');
|
|
3089
|
+
javaHome = void 0;
|
|
3090
|
+
} else if (!FS.existsSync(javaHome)) {
|
|
3091
|
+
log.appendLine('"java.home" points to folder that does NOT exist: ' + javaHome);
|
|
3092
|
+
javaHome = void 0;
|
|
3093
|
+
} else {
|
|
3094
|
+
log.appendLine('Trying to use "java.home" value: ' + javaHome);
|
|
3095
|
+
}
|
|
3096
|
+
return javaHome;
|
|
3097
|
+
}
|
|
3098
|
+
function findJdtEmbeddedJRE() {
|
|
3099
|
+
const javaExtension = getJavaExtension();
|
|
3100
|
+
if (javaExtension) {
|
|
3101
|
+
const jreHome = Path.resolve(javaExtension.extensionPath, "jre");
|
|
3102
|
+
if (FS.existsSync(jreHome) && FS.statSync(jreHome).isDirectory()) {
|
|
3103
|
+
const candidates = FS.readdirSync(jreHome);
|
|
3104
|
+
for (const candidate of candidates) {
|
|
3105
|
+
if (FS.existsSync(Path.join(jreHome, candidate, "bin"))) {
|
|
3106
|
+
return Path.join(jreHome, candidate);
|
|
3107
|
+
}
|
|
3108
|
+
}
|
|
3109
|
+
}
|
|
3110
|
+
}
|
|
3111
|
+
return void 0;
|
|
3112
|
+
}
|
|
3113
|
+
async function activate(options, context) {
|
|
3114
|
+
let location = getUserDefinedLsDirectory(options, context);
|
|
3115
|
+
if (options.CONNECT_TO_LS) {
|
|
3116
|
+
await coc3.window.showInformationMessage("Connecting to spring boot language server");
|
|
3117
|
+
return await connectToLS(location, options);
|
|
3118
|
+
} else {
|
|
3119
|
+
const clientOptions = options.clientOptions;
|
|
3120
|
+
clientOptions.outputChannel = initLogOutput(context);
|
|
3121
|
+
let finder = options.preferJdk ? import_jvm_launch_utils.findJdk : import_jvm_launch_utils.findJvm;
|
|
3122
|
+
let home = getSpringUserDefinedJavaHome(options.workspaceOptions, clientOptions?.outputChannel) || findJdtEmbeddedJRE() || getJdtUserDefinedJavaHome(clientOptions?.outputChannel);
|
|
3123
|
+
home = home?.length == 0 ? void 0 : home;
|
|
3124
|
+
let jvm;
|
|
3125
|
+
try {
|
|
3126
|
+
jvm = await finder(home, (msg) => clientOptions?.outputChannel?.appendLine(msg));
|
|
3127
|
+
} catch (error) {
|
|
3128
|
+
coc3.window.showErrorMessage("Error while trying to find jvm: " + error);
|
|
3129
|
+
await Promise.reject(error);
|
|
3130
|
+
}
|
|
3131
|
+
if (!jvm) {
|
|
3132
|
+
coc3.window.showErrorMessage("Couldn't locate java in $JAVA_HOME or $PATH");
|
|
3133
|
+
return Promise.reject(new Error());
|
|
3134
|
+
}
|
|
3135
|
+
let javaExecutablePath = jvm.getJavaExecutable();
|
|
3136
|
+
clientOptions?.outputChannel?.appendLine("Found java executable: " + javaExecutablePath);
|
|
3137
|
+
clientOptions?.outputChannel?.appendLine("isJavaEightOrHigher => true");
|
|
3138
|
+
if (process.env["SPRING_LS_USE_SOCKET"]) {
|
|
3139
|
+
return setupLanguageClient(location, createServerOptionsForPortComm(location, options, context, jvm), options);
|
|
3140
|
+
} else {
|
|
3141
|
+
return setupLanguageClient(location, createServerOptions(location, options, context, jvm), options);
|
|
3142
|
+
}
|
|
3143
|
+
}
|
|
3144
|
+
}
|
|
3145
|
+
function createServerOptions(location, options, context, jvm, port) {
|
|
3146
|
+
const executable = /* @__PURE__ */ Object.create(null);
|
|
3147
|
+
const execOptions = /* @__PURE__ */ Object.create(null);
|
|
3148
|
+
execOptions.env = Object.assign(process.env);
|
|
3149
|
+
executable.options = execOptions;
|
|
3150
|
+
executable.command = jvm.getJavaExecutable();
|
|
3151
|
+
const vmArgs = prepareJvmArgs(location, options, context, jvm, port);
|
|
3152
|
+
addCpAndLauncherToJvmArgs(location, vmArgs, options, context);
|
|
3153
|
+
executable.args = vmArgs;
|
|
3154
|
+
return executable;
|
|
3155
|
+
}
|
|
3156
|
+
function createServerOptionsForPortComm(location, options, context, jvm) {
|
|
3157
|
+
return () => new Promise((resolve2) => {
|
|
3158
|
+
PortFinder.getPort((_, port) => {
|
|
3159
|
+
Net.createServer((socket) => {
|
|
3160
|
+
options.clientOptions?.outputChannel?.appendLine("Child process connected on port " + port);
|
|
3161
|
+
resolve2({
|
|
3162
|
+
reader: socket,
|
|
3163
|
+
writer: socket
|
|
3164
|
+
});
|
|
3165
|
+
}).listen(port, () => {
|
|
3166
|
+
let processLaunchoptions = {
|
|
3167
|
+
cwd: coc3.workspace.root
|
|
3168
|
+
};
|
|
3169
|
+
const args = prepareJvmArgs(location, options, context, jvm, port);
|
|
3170
|
+
if (options.explodedLsJarData) {
|
|
3171
|
+
const explodedLsJarData = options.explodedLsJarData;
|
|
3172
|
+
const lsRoot = Path.resolve(location, explodedLsJarData.lsLocation);
|
|
3173
|
+
const classpath = [];
|
|
3174
|
+
classpath.push(Path.resolve(lsRoot, "BOOT-INF/classes"));
|
|
3175
|
+
classpath.push(`${Path.resolve(lsRoot, "BOOT-INF/lib")}${Path.sep}*`);
|
|
3176
|
+
jvm.mainClassLaunch(explodedLsJarData.mainClass, classpath, args, processLaunchoptions);
|
|
3177
|
+
} else {
|
|
3178
|
+
const launcher = findServerJar(Path.resolve(location, "language-server"));
|
|
3179
|
+
jvm.jarLaunch(launcher, args, processLaunchoptions);
|
|
3180
|
+
}
|
|
3181
|
+
});
|
|
3182
|
+
});
|
|
3183
|
+
});
|
|
3184
|
+
}
|
|
3185
|
+
function prepareJvmArgs(location, options, context, jvm, port) {
|
|
3186
|
+
const DEBUG = options.DEBUG;
|
|
3187
|
+
const jvmHeap = getUserDefinedJvmHeap(options.workspaceOptions, options.jvmHeap);
|
|
3188
|
+
const jvmArgs = getUserDefinedJvmArgs(options.workspaceOptions);
|
|
3189
|
+
if (Array.isArray(options.vmArgs)) {
|
|
3190
|
+
jvmArgs.push(...options.vmArgs);
|
|
3191
|
+
}
|
|
3192
|
+
let logfile = options.workspaceOptions.get("logfile") || "/dev/null";
|
|
3193
|
+
options.clientOptions?.outputChannel?.appendLine("Redirecting server logs to " + logfile);
|
|
3194
|
+
const args = [
|
|
3195
|
+
"-Dsts.lsp.client=vscode",
|
|
3196
|
+
"-Dsts.log.file=" + logfile,
|
|
3197
|
+
"-XX:TieredStopAtLevel=1"
|
|
3198
|
+
];
|
|
3199
|
+
if (port && port > 0) {
|
|
3200
|
+
args.push("-Dspring.lsp.client-port=" + port);
|
|
3201
|
+
args.push("-Dserver.port=" + port);
|
|
3202
|
+
}
|
|
3203
|
+
if (isCheckingJVM(options.workspaceOptions) && options.checkjvm) {
|
|
3204
|
+
options.checkjvm(context, jvm);
|
|
3205
|
+
}
|
|
3206
|
+
if (jvmHeap && !hasHeapArg(jvmArgs)) {
|
|
3207
|
+
args.unshift("-Xmx" + jvmHeap);
|
|
3208
|
+
}
|
|
3209
|
+
if (jvmArgs) {
|
|
3210
|
+
args.unshift(...jvmArgs);
|
|
3211
|
+
}
|
|
3212
|
+
if (DEBUG) {
|
|
3213
|
+
args.unshift(DEBUG_ARG);
|
|
3214
|
+
}
|
|
3215
|
+
if (!hasVmArg(LOG_RESOLVE_VM_ARG_PREFIX, args)) {
|
|
3216
|
+
args.push(`${LOG_RESOLVE_VM_ARG_PREFIX}off`);
|
|
3217
|
+
}
|
|
3218
|
+
if (options.explodedLsJarData) {
|
|
3219
|
+
const explodedLsJarData = options.explodedLsJarData;
|
|
3220
|
+
const lsRoot = Path.resolve(location, explodedLsJarData.lsLocation);
|
|
3221
|
+
if (explodedLsJarData.configFileName) {
|
|
3222
|
+
args.push(`-Dspring.config.location=file:${Path.resolve(lsRoot, `BOOT-INF/classes/${explodedLsJarData.configFileName}`)}`);
|
|
3223
|
+
}
|
|
3224
|
+
}
|
|
3225
|
+
return args;
|
|
3226
|
+
}
|
|
3227
|
+
function addCpAndLauncherToJvmArgs(location, args, options, context) {
|
|
3228
|
+
if (options.explodedLsJarData) {
|
|
3229
|
+
const explodedLsJarData = options.explodedLsJarData;
|
|
3230
|
+
const lsRoot = Path.resolve(location, explodedLsJarData.lsLocation);
|
|
3231
|
+
const classpath = [];
|
|
3232
|
+
classpath.push(Path.resolve(lsRoot, "BOOT-INF/classes"));
|
|
3233
|
+
classpath.push(`${Path.resolve(lsRoot, "BOOT-INF/lib")}${Path.sep}*`);
|
|
3234
|
+
args.unshift(classpath.join(Path.delimiter));
|
|
3235
|
+
args.unshift("-cp");
|
|
3236
|
+
args.push(explodedLsJarData.mainClass);
|
|
3237
|
+
} else {
|
|
3238
|
+
args.push("-jar");
|
|
3239
|
+
const launcher = findServerJar(Path.resolve(location, "language-server"));
|
|
3240
|
+
args.push(launcher);
|
|
3241
|
+
}
|
|
3242
|
+
}
|
|
3243
|
+
function hasHeapArg(vmargs) {
|
|
3244
|
+
return hasVmArg("-Xmx", vmargs);
|
|
3245
|
+
}
|
|
3246
|
+
function hasVmArg(argPrefix, vmargs) {
|
|
3247
|
+
if (vmargs) {
|
|
3248
|
+
return vmargs.some((a) => a.startsWith(argPrefix));
|
|
3249
|
+
}
|
|
3250
|
+
return false;
|
|
3251
|
+
}
|
|
3252
|
+
function findServerJar(jarsDir) {
|
|
3253
|
+
let serverJars = FS.readdirSync(jarsDir).filter(
|
|
3254
|
+
(jar) => jar.indexOf("language-server") >= 0 && jar.endsWith(".jar")
|
|
3255
|
+
);
|
|
3256
|
+
if (serverJars.length == 0) {
|
|
3257
|
+
throw new Error("Server jar not found in " + jarsDir);
|
|
3258
|
+
}
|
|
3259
|
+
if (serverJars.length > 1) {
|
|
3260
|
+
throw new Error("Multiple server jars found in " + jarsDir);
|
|
3261
|
+
}
|
|
3262
|
+
return Path.resolve(jarsDir, serverJars[0]);
|
|
3263
|
+
}
|
|
3264
|
+
function connectToLS(location, options) {
|
|
3265
|
+
let connectionInfo = {
|
|
3266
|
+
port: 5007
|
|
3267
|
+
};
|
|
3268
|
+
let serverOptions = () => {
|
|
3269
|
+
let socket = Net.connect(connectionInfo);
|
|
3270
|
+
let result = {
|
|
3271
|
+
writer: socket,
|
|
3272
|
+
reader: socket
|
|
3273
|
+
};
|
|
3274
|
+
return Promise.resolve(result);
|
|
3275
|
+
};
|
|
3276
|
+
console.log(`Connecting to spring boot language server on port ${connectionInfo.port}`);
|
|
3277
|
+
return setupLanguageClient(location, serverOptions, options);
|
|
3278
|
+
}
|
|
3279
|
+
function setupLanguageClient(location, createServer2, options) {
|
|
3280
|
+
let client = new import_coc.LanguageClient(options.extensionId, options.extensionId, createServer2, options.clientOptions);
|
|
3281
|
+
logToSpringBootOutput(`Registered spring boot language server resources for ${location}`);
|
|
3282
|
+
if (options.TRACE) {
|
|
3283
|
+
client.trace = coc3.Trace.Verbose;
|
|
3284
|
+
}
|
|
3285
|
+
let moveCursorRequest = new coc3.RequestType("sts/moveCursor");
|
|
3286
|
+
client.onRequest(moveCursorRequest, (params) => {
|
|
3287
|
+
for (let editor of coc3.window.visibleTextEditors) {
|
|
3288
|
+
if (editor.document.uri.toString() == params.uri) {
|
|
3289
|
+
}
|
|
3290
|
+
}
|
|
3291
|
+
return { applied: true };
|
|
3292
|
+
});
|
|
3293
|
+
return Promise.resolve(client);
|
|
3294
|
+
}
|
|
3295
|
+
|
|
3296
|
+
// src/utils/index.ts
|
|
3297
|
+
var import_jvm_launch_utils2 = __toESM(require_lib());
|
|
3298
|
+
|
|
3299
|
+
// src/utils/java-data.ts
|
|
3300
|
+
var import_coc2 = require("coc.nvim");
|
|
3301
|
+
function registerJavaDataService(client) {
|
|
3302
|
+
const javaTypeRequest = new import_coc2.RequestType("sts/javaType");
|
|
3303
|
+
client.onRequest(
|
|
3304
|
+
javaTypeRequest,
|
|
3305
|
+
async (params) => await import_coc2.commands.executeCommand("java.execute.workspaceCommand", "sts.java.type", params)
|
|
3306
|
+
);
|
|
3307
|
+
const javadocHoverLinkRequest = new import_coc2.RequestType("sts/javadocHoverLink");
|
|
3308
|
+
client.onRequest(
|
|
3309
|
+
javadocHoverLinkRequest,
|
|
3310
|
+
async (params) => await import_coc2.commands.executeCommand("java.execute.workspaceCommand", "sts.java.javadocHoverLink", params)
|
|
3311
|
+
);
|
|
3312
|
+
const javaLocationRequest = new import_coc2.RequestType("sts/javaLocation");
|
|
3313
|
+
client.onRequest(
|
|
3314
|
+
javaLocationRequest,
|
|
3315
|
+
async (params) => await import_coc2.commands.executeCommand("java.execute.workspaceCommand", "sts.java.location", params)
|
|
3316
|
+
);
|
|
3317
|
+
const javadocRequest = new import_coc2.RequestType("sts/javadoc");
|
|
3318
|
+
client.onRequest(
|
|
3319
|
+
javadocRequest,
|
|
3320
|
+
async (params) => await import_coc2.commands.executeCommand("java.execute.workspaceCommand", "sts.java.javadoc", params)
|
|
3321
|
+
);
|
|
3322
|
+
const javaSearchTypes = new import_coc2.RequestType("sts/javaSearchTypes");
|
|
3323
|
+
client.onRequest(
|
|
3324
|
+
javaSearchTypes,
|
|
3325
|
+
async (params) => await import_coc2.commands.executeCommand("java.execute.workspaceCommand", "sts.java.search.types", params)
|
|
3326
|
+
);
|
|
3327
|
+
const javaSearchPackages = new import_coc2.RequestType("sts/javaSearchPackages");
|
|
3328
|
+
client.onRequest(
|
|
3329
|
+
javaSearchPackages,
|
|
3330
|
+
async (params) => await import_coc2.commands.executeCommand("java.execute.workspaceCommand", "sts.java.search.packages", params)
|
|
3331
|
+
);
|
|
3332
|
+
const javaSubTypes = new import_coc2.RequestType("sts/javaSubTypes");
|
|
3333
|
+
client.onRequest(
|
|
3334
|
+
javaSubTypes,
|
|
3335
|
+
async (params) => await import_coc2.commands.executeCommand("java.execute.workspaceCommand", "sts.java.hierarchy.subtypes", params)
|
|
3336
|
+
);
|
|
3337
|
+
const javaSuperTypes = new import_coc2.RequestType("sts/javaSuperTypes");
|
|
3338
|
+
client.onRequest(
|
|
3339
|
+
javaSuperTypes,
|
|
3340
|
+
async (params) => await import_coc2.commands.executeCommand("java.execute.workspaceCommand", "sts.java.hierarchy.supertypes", params)
|
|
3341
|
+
);
|
|
3342
|
+
const javaCodeCompletion = new import_coc2.RequestType("sts/javaCodeComplete");
|
|
3343
|
+
client.onRequest(
|
|
3344
|
+
javaCodeCompletion,
|
|
3345
|
+
async (params) => await import_coc2.commands.executeCommand("java.execute.workspaceCommand", "sts.java.code.completions", params)
|
|
3346
|
+
);
|
|
3347
|
+
const projectGav = new import_coc2.RequestType("sts/project/gav");
|
|
3348
|
+
client.onRequest(
|
|
3349
|
+
projectGav,
|
|
3350
|
+
async (params) => await import_coc2.commands.executeCommand("java.execute.workspaceCommand", "sts.project.gav", params)
|
|
3351
|
+
);
|
|
3352
|
+
}
|
|
3353
|
+
|
|
3354
|
+
// src/rewrite.ts
|
|
3355
|
+
var coc4 = __toESM(require("coc.nvim"));
|
|
3356
|
+
var path = __toESM(require("path"));
|
|
3357
|
+
var BOOT_UPGRADE = "BOOT_UPGRADE";
|
|
3358
|
+
var OTHER_REFACTORINGS = "NON_BOOT_UPGRADE";
|
|
3359
|
+
var quickPick;
|
|
3360
|
+
var RECIPE_PICK_ACTIONS = [
|
|
3361
|
+
{
|
|
3362
|
+
id: "root",
|
|
3363
|
+
label: "Initial",
|
|
3364
|
+
description: "Navigate to the base list of receipes",
|
|
3365
|
+
selected: false,
|
|
3366
|
+
action: "root",
|
|
3367
|
+
children: void 0
|
|
3368
|
+
},
|
|
3369
|
+
{
|
|
3370
|
+
id: "parent",
|
|
3371
|
+
label: "Parent",
|
|
3372
|
+
description: "Navigate to the parent of this receipe",
|
|
3373
|
+
selected: false,
|
|
3374
|
+
action: "parent",
|
|
3375
|
+
children: void 0
|
|
3376
|
+
}
|
|
3377
|
+
];
|
|
3378
|
+
function getWorkspaceFolderName(file) {
|
|
3379
|
+
if (file) {
|
|
3380
|
+
const wf = coc4.workspace.getWorkspaceFolder(file);
|
|
3381
|
+
if (wf) {
|
|
3382
|
+
return wf.name;
|
|
3383
|
+
}
|
|
3384
|
+
}
|
|
3385
|
+
return "";
|
|
3386
|
+
}
|
|
3387
|
+
function getRelativePathToWorkspaceFolder(file) {
|
|
3388
|
+
if (file) {
|
|
3389
|
+
const wf = coc4.workspace.getWorkspaceFolder(file);
|
|
3390
|
+
if (wf) {
|
|
3391
|
+
return path.relative(wf.uri, file.fsPath);
|
|
3392
|
+
}
|
|
3393
|
+
}
|
|
3394
|
+
return "";
|
|
3395
|
+
}
|
|
3396
|
+
async function getTargetPomXml() {
|
|
3397
|
+
if (coc4.window.activeTextEditor) {
|
|
3398
|
+
const activeUri = coc4.window.activeTextEditor.document.uri;
|
|
3399
|
+
if ("pom.xml" === path.basename(activeUri).toLowerCase()) {
|
|
3400
|
+
return coc4.Uri.parse(activeUri);
|
|
3401
|
+
}
|
|
3402
|
+
}
|
|
3403
|
+
const candidates = await coc4.workspace.findFiles("**/pom.xml");
|
|
3404
|
+
if (candidates.length > 0) {
|
|
3405
|
+
if (candidates.length === 1) {
|
|
3406
|
+
return candidates[0];
|
|
3407
|
+
} else {
|
|
3408
|
+
return await coc4.window.showQuickPick(
|
|
3409
|
+
candidates.map((c) => ({ value: c, label: getRelativePathToWorkspaceFolder(c), description: getWorkspaceFolderName(c) })),
|
|
3410
|
+
{ placeholder: "Select the target project." }
|
|
3411
|
+
).then((res) => res && res.value);
|
|
3412
|
+
}
|
|
3413
|
+
}
|
|
3414
|
+
return void 0;
|
|
3415
|
+
}
|
|
3416
|
+
async function showRefactorings(uri, filter) {
|
|
3417
|
+
if (!uri) {
|
|
3418
|
+
uri = await getTargetPomXml();
|
|
3419
|
+
}
|
|
3420
|
+
const choices = await showCurrentPathQuickPick(coc4.commands.executeCommand(
|
|
3421
|
+
"sts/rewrite/list",
|
|
3422
|
+
filter
|
|
3423
|
+
).then((cmds) => cmds.map((d) => convertToQuickPickItem(d, false))), []);
|
|
3424
|
+
const recipeDescriptors = choices.filter((i) => i.selected).map(convertToRecipeSelectionDescriptor);
|
|
3425
|
+
if (recipeDescriptors.length) {
|
|
3426
|
+
coc4.commands.executeCommand("sts/rewrite/execute", uri.toString(true), recipeDescriptors, true);
|
|
3427
|
+
} else {
|
|
3428
|
+
coc4.window.showErrorMessage("No recipes were selected from the list");
|
|
3429
|
+
}
|
|
3430
|
+
}
|
|
3431
|
+
function convertToRecipeSelectionDescriptor(i) {
|
|
3432
|
+
return {
|
|
3433
|
+
id: i.id,
|
|
3434
|
+
selected: i.selected,
|
|
3435
|
+
subselection: i.children ? i.children.map(convertToRecipeSelectionDescriptor) : void 0
|
|
3436
|
+
};
|
|
3437
|
+
}
|
|
3438
|
+
function convertToQuickPickItem(i, selected) {
|
|
3439
|
+
return {
|
|
3440
|
+
id: i.name,
|
|
3441
|
+
label: i.displayName,
|
|
3442
|
+
description: i.description,
|
|
3443
|
+
selected: !!selected,
|
|
3444
|
+
children: void 0,
|
|
3445
|
+
recipeDescriptor: i
|
|
3446
|
+
};
|
|
3447
|
+
}
|
|
3448
|
+
async function showCurrentPathQuickPick(itemsPromise, itemsPath) {
|
|
3449
|
+
if (!quickPick) {
|
|
3450
|
+
quickPick = await coc4.window.createQuickPick();
|
|
3451
|
+
const columns = await coc4.nvim.eval("&columns");
|
|
3452
|
+
quickPick.width = Math.ceil(columns * 0.7);
|
|
3453
|
+
quickPick.matchOnDescription = true;
|
|
3454
|
+
quickPick.canSelectMany = true;
|
|
3455
|
+
}
|
|
3456
|
+
quickPick.title = "Loading Recipes";
|
|
3457
|
+
quickPick.value = "";
|
|
3458
|
+
quickPick.items = [];
|
|
3459
|
+
quickPick.loading = true;
|
|
3460
|
+
quickPick.show();
|
|
3461
|
+
return itemsPromise.then((items) => {
|
|
3462
|
+
return new Promise((resolve2, reject) => {
|
|
3463
|
+
let currentItems = items;
|
|
3464
|
+
let parent;
|
|
3465
|
+
itemsPath.forEach((p) => {
|
|
3466
|
+
parent = currentItems.find((i) => i === p);
|
|
3467
|
+
if (parent?.children) {
|
|
3468
|
+
currentItems = parent?.children;
|
|
3469
|
+
}
|
|
3470
|
+
});
|
|
3471
|
+
if (itemsPath.length > 0) {
|
|
3472
|
+
currentItems = [...RECIPE_PICK_ACTIONS, ...currentItems];
|
|
3473
|
+
} else {
|
|
3474
|
+
currentItems = [...currentItems];
|
|
3475
|
+
}
|
|
3476
|
+
setTimeout(() => {
|
|
3477
|
+
quickPick.title = "Select Recipes";
|
|
3478
|
+
quickPick.items = currentItems;
|
|
3479
|
+
quickPick.loading = false;
|
|
3480
|
+
}, 175);
|
|
3481
|
+
quickPick.onDidChangeSelection((selected) => {
|
|
3482
|
+
if (selected.filter((i) => i.action === "root" || i.action === "parent").length > 0) {
|
|
3483
|
+
return;
|
|
3484
|
+
}
|
|
3485
|
+
currentItems.forEach((i) => {
|
|
3486
|
+
const isSelectedItem = selected.includes(i);
|
|
3487
|
+
if (!i.action && i.selected !== isSelectedItem) {
|
|
3488
|
+
selectItemRecursively(i, isSelectedItem);
|
|
3489
|
+
}
|
|
3490
|
+
});
|
|
3491
|
+
updateParentSelection(itemsPath.slice());
|
|
3492
|
+
});
|
|
3493
|
+
quickPick.onDidFinish((selectedItems) => {
|
|
3494
|
+
const index = quickPick.currIndex;
|
|
3495
|
+
quickPick = null;
|
|
3496
|
+
if (selectedItems && selectedItems.length > 0) {
|
|
3497
|
+
resolve2(selectedItems);
|
|
3498
|
+
coc4.window.showInformationMessage(`Applying ${selectedItems.length} items from the list of recipes `);
|
|
3499
|
+
} else {
|
|
3500
|
+
if (index >= 0 && index < currentItems.length) {
|
|
3501
|
+
const item = currentItems[index];
|
|
3502
|
+
if (item.action === "root") {
|
|
3503
|
+
showCurrentPathQuickPick(Promise.resolve(items), []).then(resolve2, reject);
|
|
3504
|
+
} else if (item.action === "parent") {
|
|
3505
|
+
itemsPath.pop();
|
|
3506
|
+
showCurrentPathQuickPick(Promise.resolve(items), itemsPath).then(resolve2, reject);
|
|
3507
|
+
} else {
|
|
3508
|
+
itemsPath.push(item);
|
|
3509
|
+
const next = navigateToSubRecipes(item, itemsPath).then(() => items);
|
|
3510
|
+
showCurrentPathQuickPick(next, itemsPath).then(resolve2, reject);
|
|
3511
|
+
}
|
|
3512
|
+
} else {
|
|
3513
|
+
coc4.window.showErrorMessage("Invalid quick list pick index or item from user selection");
|
|
3514
|
+
}
|
|
3515
|
+
}
|
|
3516
|
+
});
|
|
3517
|
+
});
|
|
3518
|
+
});
|
|
3519
|
+
}
|
|
3520
|
+
async function navigateToSubRecipes(item, itemsPath) {
|
|
3521
|
+
if (!item.children) {
|
|
3522
|
+
const indexPath = [];
|
|
3523
|
+
for (let i = 1; i < itemsPath.length; i++) {
|
|
3524
|
+
const parent = itemsPath[i - 1];
|
|
3525
|
+
const children = parent?.children;
|
|
3526
|
+
if (children) {
|
|
3527
|
+
indexPath.push(children.indexOf(itemsPath[i]));
|
|
3528
|
+
}
|
|
3529
|
+
}
|
|
3530
|
+
const recipeDescriptors = await coc4.commands.executeCommand("sts/rewrite/sublist", itemsPath[0].id, indexPath);
|
|
3531
|
+
item.children = recipeDescriptors.map((d) => convertToQuickPickItem(d, item.selected));
|
|
3532
|
+
}
|
|
3533
|
+
}
|
|
3534
|
+
function updateParentSelection(hierarchy) {
|
|
3535
|
+
if (hierarchy.length) {
|
|
3536
|
+
const parent = hierarchy.pop();
|
|
3537
|
+
const isSelected = !!parent?.children?.find((i) => i.selected);
|
|
3538
|
+
if (parent && parent.selected !== isSelected) {
|
|
3539
|
+
parent.selected = isSelected;
|
|
3540
|
+
updateParentSelection(hierarchy);
|
|
3541
|
+
}
|
|
3542
|
+
}
|
|
3543
|
+
}
|
|
3544
|
+
function selectItemRecursively(i, isSelectedItem) {
|
|
3545
|
+
i.selected = isSelectedItem;
|
|
3546
|
+
if (i.children) {
|
|
3547
|
+
i.children.forEach((c) => selectItemRecursively(c, isSelectedItem));
|
|
3548
|
+
}
|
|
3549
|
+
}
|
|
3550
|
+
function activate2(client, options, context) {
|
|
3551
|
+
context.subscriptions.push(
|
|
3552
|
+
coc4.commands.registerCommand("springboot.rewrite.list.upgrades", (param) => {
|
|
3553
|
+
if (client.started) {
|
|
3554
|
+
return showRefactorings(param, BOOT_UPGRADE);
|
|
3555
|
+
} else {
|
|
3556
|
+
coc4.window.showErrorMessage("No Spring Boot project found. Action is only available for Spring Boot Projects");
|
|
3557
|
+
}
|
|
3558
|
+
}),
|
|
3559
|
+
coc4.commands.registerCommand("springboot.rewrite.list.refactors", (param) => {
|
|
3560
|
+
if (client.started) {
|
|
3561
|
+
return showRefactorings(param, OTHER_REFACTORINGS);
|
|
3562
|
+
} else {
|
|
3563
|
+
coc4.window.showErrorMessage("No Spring Boot project found. Action is only available for Spring Boot Projects");
|
|
3564
|
+
}
|
|
3565
|
+
}),
|
|
3566
|
+
coc4.commands.registerCommand("springboot.rewrite.reload", () => {
|
|
3567
|
+
if (client.started) {
|
|
3568
|
+
return coc4.commands.executeCommand("sts/rewrite/reload");
|
|
3569
|
+
} else {
|
|
3570
|
+
coc4.window.showErrorMessage("No Spring Boot project found. Action is only available for Spring Boot Projects");
|
|
3571
|
+
}
|
|
3572
|
+
})
|
|
3573
|
+
);
|
|
3574
|
+
}
|
|
3575
|
+
|
|
3576
|
+
// src/apiManager.ts
|
|
3577
|
+
var import_coc4 = require("coc.nvim");
|
|
3578
|
+
|
|
3579
|
+
// src/notification.ts
|
|
3580
|
+
var import_coc3 = require("coc.nvim");
|
|
3581
|
+
var LiveProcessConnectedNotification;
|
|
3582
|
+
((LiveProcessConnectedNotification2) => {
|
|
3583
|
+
LiveProcessConnectedNotification2.type = new import_coc3.NotificationType("sts/liveprocess/connected");
|
|
3584
|
+
})(LiveProcessConnectedNotification || (LiveProcessConnectedNotification = {}));
|
|
3585
|
+
var LiveProcessDisconnectedNotification;
|
|
3586
|
+
((LiveProcessDisconnectedNotification2) => {
|
|
3587
|
+
LiveProcessDisconnectedNotification2.type = new import_coc3.NotificationType("sts/liveprocess/disconnected");
|
|
3588
|
+
})(LiveProcessDisconnectedNotification || (LiveProcessDisconnectedNotification = {}));
|
|
3589
|
+
var LiveProcessUpdatedNotification;
|
|
3590
|
+
((LiveProcessUpdatedNotification2) => {
|
|
3591
|
+
LiveProcessUpdatedNotification2.type = new import_coc3.NotificationType("sts/liveprocess/updated");
|
|
3592
|
+
})(LiveProcessUpdatedNotification || (LiveProcessUpdatedNotification = {}));
|
|
3593
|
+
var LiveProcessGcPausesMetricsUpdatedNotification;
|
|
3594
|
+
((LiveProcessGcPausesMetricsUpdatedNotification2) => {
|
|
3595
|
+
LiveProcessGcPausesMetricsUpdatedNotification2.type = new import_coc3.NotificationType("sts/liveprocess/gcpauses/metrics/updated");
|
|
3596
|
+
})(LiveProcessGcPausesMetricsUpdatedNotification || (LiveProcessGcPausesMetricsUpdatedNotification = {}));
|
|
3597
|
+
var LiveProcessMemoryMetricsUpdatedNotification;
|
|
3598
|
+
((LiveProcessMemoryMetricsUpdatedNotification2) => {
|
|
3599
|
+
LiveProcessMemoryMetricsUpdatedNotification2.type = new import_coc3.NotificationType("sts/liveprocess/memory/metrics/updated");
|
|
3600
|
+
})(LiveProcessMemoryMetricsUpdatedNotification || (LiveProcessMemoryMetricsUpdatedNotification = {}));
|
|
3601
|
+
var SpringIndexUpdatedNotification;
|
|
3602
|
+
((SpringIndexUpdatedNotification2) => {
|
|
3603
|
+
SpringIndexUpdatedNotification2.type = new import_coc3.NotificationType("spring/index/updated");
|
|
3604
|
+
})(SpringIndexUpdatedNotification || (SpringIndexUpdatedNotification = {}));
|
|
3605
|
+
var LiveProcessLogLevelUpdatedNotification;
|
|
3606
|
+
((LiveProcessLogLevelUpdatedNotification2) => {
|
|
3607
|
+
LiveProcessLogLevelUpdatedNotification2.type = new import_coc3.NotificationType("sts/liveprocess/loglevel/updated");
|
|
3608
|
+
})(LiveProcessLogLevelUpdatedNotification || (LiveProcessLogLevelUpdatedNotification = {}));
|
|
3609
|
+
|
|
3610
|
+
// src/apiManager.ts
|
|
3611
|
+
var ApiManager = class {
|
|
3612
|
+
api;
|
|
3613
|
+
onDidLiveProcessConnectEmitter = new import_coc4.Emitter();
|
|
3614
|
+
onDidLiveProcessDisconnectEmitter = new import_coc4.Emitter();
|
|
3615
|
+
onDidLiveProcessUpdateEmitter = new import_coc4.Emitter();
|
|
3616
|
+
onDidLiveProcessGcPausesMetricsUpdateEmitter = new import_coc4.Emitter();
|
|
3617
|
+
onDidLiveProcessMemoryMetricsUpdateEmitter = new import_coc4.Emitter();
|
|
3618
|
+
onSpringIndexUpdateEmitter = new import_coc4.Emitter();
|
|
3619
|
+
constructor(client) {
|
|
3620
|
+
const onDidLiveProcessConnect = this.onDidLiveProcessConnectEmitter.event;
|
|
3621
|
+
const onDidLiveProcessDisconnect = this.onDidLiveProcessDisconnectEmitter.event;
|
|
3622
|
+
const onDidLiveProcessUpdate = this.onDidLiveProcessUpdateEmitter.event;
|
|
3623
|
+
const onDidLiveProcessGcPausesMetricsUpdate = this.onDidLiveProcessGcPausesMetricsUpdateEmitter.event;
|
|
3624
|
+
const onDidLiveProcessMemoryMetricsUpdate = this.onDidLiveProcessMemoryMetricsUpdateEmitter.event;
|
|
3625
|
+
const onSpringIndexUpdated = this.onSpringIndexUpdateEmitter.event;
|
|
3626
|
+
const COMMAND_LIVEDATA_GET = "sts/livedata/get";
|
|
3627
|
+
const getLiveProcessData = async (query) => {
|
|
3628
|
+
return await import_coc4.commands.executeCommand(COMMAND_LIVEDATA_GET, query);
|
|
3629
|
+
};
|
|
3630
|
+
const COMMAND_LIVEDATA_REFRESH = "sts/livedata/refresh";
|
|
3631
|
+
const refreshLiveProcessData = async (query) => {
|
|
3632
|
+
return await import_coc4.commands.executeCommand(COMMAND_LIVEDATA_REFRESH, query);
|
|
3633
|
+
};
|
|
3634
|
+
const COMMAND_LIVEDATA_LIST_CONNECTED = "sts/livedata/listConnected";
|
|
3635
|
+
const listConnectedProcesses = async () => {
|
|
3636
|
+
return await import_coc4.commands.executeCommand(COMMAND_LIVEDATA_LIST_CONNECTED);
|
|
3637
|
+
};
|
|
3638
|
+
const COMMAND_LIVEDATA_GET_METRICS = "sts/livedata/get/metrics";
|
|
3639
|
+
const getLiveProcessMetricsData = async (query) => {
|
|
3640
|
+
return await import_coc4.commands.executeCommand(COMMAND_LIVEDATA_GET_METRICS, query);
|
|
3641
|
+
};
|
|
3642
|
+
const COMMAND_LIVEDATA_REFRESH_METRICS = "sts/livedata/refresh/metrics";
|
|
3643
|
+
const refreshLiveProcessMetricsData = async (query) => {
|
|
3644
|
+
return await import_coc4.commands.executeCommand(COMMAND_LIVEDATA_REFRESH_METRICS, query);
|
|
3645
|
+
};
|
|
3646
|
+
client.onNotification(LiveProcessConnectedNotification.type, (process2) => this.onDidLiveProcessConnectEmitter.fire(process2));
|
|
3647
|
+
client.onNotification(LiveProcessDisconnectedNotification.type, (process2) => this.onDidLiveProcessDisconnectEmitter.fire(process2));
|
|
3648
|
+
client.onNotification(LiveProcessUpdatedNotification.type, (process2) => this.onDidLiveProcessUpdateEmitter.fire(process2));
|
|
3649
|
+
client.onNotification(LiveProcessGcPausesMetricsUpdatedNotification.type, (process2) => this.onDidLiveProcessGcPausesMetricsUpdateEmitter.fire(process2));
|
|
3650
|
+
client.onNotification(LiveProcessMemoryMetricsUpdatedNotification.type, (process2) => this.onDidLiveProcessMemoryMetricsUpdateEmitter.fire(process2));
|
|
3651
|
+
client.onNotification(SpringIndexUpdatedNotification.type, () => this.onSpringIndexUpdateEmitter.fire());
|
|
3652
|
+
const beansRequestType = new import_coc4.RequestType("spring/index/beans");
|
|
3653
|
+
const beans = (params) => {
|
|
3654
|
+
return client.sendRequest(beansRequestType, params);
|
|
3655
|
+
};
|
|
3656
|
+
const getSpringIndex = () => ({
|
|
3657
|
+
onSpringIndexUpdated,
|
|
3658
|
+
beans
|
|
3659
|
+
});
|
|
3660
|
+
this.api = {
|
|
3661
|
+
client,
|
|
3662
|
+
onDidLiveProcessConnect,
|
|
3663
|
+
onDidLiveProcessDisconnect,
|
|
3664
|
+
onDidLiveProcessUpdate,
|
|
3665
|
+
onDidLiveProcessMemoryMetricsUpdate,
|
|
3666
|
+
onDidLiveProcessGcPausesMetricsUpdate,
|
|
3667
|
+
getLiveProcessData,
|
|
3668
|
+
refreshLiveProcessData,
|
|
3669
|
+
getLiveProcessMetricsData,
|
|
3670
|
+
refreshLiveProcessMetricsData,
|
|
3671
|
+
listConnectedProcesses,
|
|
3672
|
+
getSpringIndex
|
|
3673
|
+
};
|
|
3674
|
+
}
|
|
3675
|
+
};
|
|
3676
|
+
|
|
3677
|
+
// src/convert-props-yaml.ts
|
|
3678
|
+
var path2 = __toESM(require("path"));
|
|
3679
|
+
var import_fs = require("fs");
|
|
3680
|
+
var import_coc5 = require("coc.nvim");
|
|
3681
|
+
function startPropertiesConversionSupport(extension) {
|
|
3682
|
+
extension.subscriptions.push(
|
|
3683
|
+
import_coc5.commands.registerCommand("springboot.props-to-yaml", async (uri) => {
|
|
3684
|
+
if (!uri && import_coc5.window.activeTextEditor) {
|
|
3685
|
+
const activeUri = import_coc5.window.activeTextEditor.document.uri;
|
|
3686
|
+
if (".properties" === path2.extname(activeUri)) {
|
|
3687
|
+
uri = activeUri;
|
|
3688
|
+
}
|
|
3689
|
+
}
|
|
3690
|
+
if (!uri) {
|
|
3691
|
+
throw new Error("No '.properties' file selected");
|
|
3692
|
+
}
|
|
3693
|
+
return await import_coc5.commands.executeCommand("sts/boot/props-to-yaml", uri.toString(), import_coc5.Uri.file(getTargetFile(uri.path, "yml")).toString(), shouldReplace());
|
|
3694
|
+
}),
|
|
3695
|
+
import_coc5.commands.registerCommand("springboot.yaml-to-props", async (uri) => {
|
|
3696
|
+
if (!uri && import_coc5.window.activeTextEditor) {
|
|
3697
|
+
const activeUri = import_coc5.window.activeTextEditor.document.uri;
|
|
3698
|
+
const ext = path2.extname(activeUri);
|
|
3699
|
+
if (".yml" === ext || ".yaml" === ext) {
|
|
3700
|
+
uri = activeUri;
|
|
3701
|
+
}
|
|
3702
|
+
}
|
|
3703
|
+
if (!uri) {
|
|
3704
|
+
throw new Error("No '.yaml' file selected");
|
|
3705
|
+
}
|
|
3706
|
+
return await import_coc5.commands.executeCommand("sts/boot/yaml-to-props", uri.toString(), import_coc5.Uri.file(getTargetFile(uri.path, "properties")).toString(), shouldReplace());
|
|
3707
|
+
})
|
|
3708
|
+
);
|
|
3709
|
+
}
|
|
3710
|
+
function getTargetFile(sourcePath, ext) {
|
|
3711
|
+
const dir = path2.dirname(sourcePath);
|
|
3712
|
+
const fileName = path2.basename(sourcePath);
|
|
3713
|
+
const filenameNoExt = path2.basename(sourcePath).substring(0, fileName.length - path2.extname(fileName).length);
|
|
3714
|
+
let targetPath = path2.join(dir, `${filenameNoExt}.${ext}`);
|
|
3715
|
+
for (let i = 1; i < Number.MAX_SAFE_INTEGER && (0, import_fs.existsSync)(targetPath); i++) {
|
|
3716
|
+
targetPath = path2.join(dir, `${filenameNoExt}-${i}.${ext}`);
|
|
3717
|
+
}
|
|
3718
|
+
return targetPath;
|
|
3719
|
+
}
|
|
3720
|
+
function shouldReplace() {
|
|
3721
|
+
return import_coc5.workspace.getConfiguration("spring.tools.properties").get("replace-converted-file");
|
|
3722
|
+
}
|
|
3723
|
+
|
|
3724
|
+
// src/index.ts
|
|
3725
|
+
var PROPERTIES_LANGUAGE_ID = "spring-boot-properties";
|
|
3726
|
+
var YAML_LANGUAGE_ID = "spring-boot-properties-yaml";
|
|
3727
|
+
var JAVA_LANGUAGE_ID = "java";
|
|
3728
|
+
var XML_LANGUAGE_ID = "xml";
|
|
3729
|
+
var FACTORIES_LANGUAGE_ID = "spring-factories";
|
|
3730
|
+
var JPA_QUERY_PROPERTIES_LANGUAGE_ID = "jpa-query-properties";
|
|
3731
|
+
var STOP_ASKING = "Stop Asking";
|
|
3732
|
+
function activate3(context) {
|
|
3733
|
+
let options = {
|
|
3734
|
+
// explodedLsJarData: {
|
|
3735
|
+
// lsLocation: 'language-server',
|
|
3736
|
+
// configFileName: 'application.properties',
|
|
3737
|
+
// mainClass: 'org.springframework.ide.vscode.boot.app.BootLanguageServerBootApp',
|
|
3738
|
+
// },
|
|
3739
|
+
extensionId: "springboot",
|
|
3740
|
+
CONNECT_TO_LS: false,
|
|
3741
|
+
jvmHeap: "1024m",
|
|
3742
|
+
preferJdk: true,
|
|
3743
|
+
DEBUG: false,
|
|
3744
|
+
vmArgs: [],
|
|
3745
|
+
checkjvm: (_, jvm) => {
|
|
3746
|
+
let version = jvm.getMajorVersion();
|
|
3747
|
+
if (version < 17) {
|
|
3748
|
+
throw Error(`Spring Tools Language Server requires Java 17 or higher to be launched. Current Java version is ${version}`);
|
|
3749
|
+
}
|
|
3750
|
+
if (!jvm.isJdk()) {
|
|
3751
|
+
import_coc6.window.showWarningMessage(
|
|
3752
|
+
"JAVA_HOME or PATH environment variable seems to point to a JRE. A JDK is required, hence Boot Hints are unavailable.",
|
|
3753
|
+
STOP_ASKING
|
|
3754
|
+
).then((selection) => {
|
|
3755
|
+
if (selection === STOP_ASKING) {
|
|
3756
|
+
options.workspaceOptions.update("checkJVM", false);
|
|
3757
|
+
}
|
|
3758
|
+
});
|
|
3759
|
+
}
|
|
3760
|
+
},
|
|
3761
|
+
workspaceOptions: import_coc6.workspace.getConfiguration("spring-boot.ls"),
|
|
3762
|
+
clientOptions: {
|
|
3763
|
+
markdown: {
|
|
3764
|
+
isTrusted: true
|
|
3765
|
+
},
|
|
3766
|
+
disabledFeatures: [
|
|
3767
|
+
// TODO: coc does not handle multiple symbol providing clients
|
|
3768
|
+
"documentHighlight",
|
|
3769
|
+
"documentSymbol"
|
|
3770
|
+
],
|
|
3771
|
+
documentSelector: [
|
|
3772
|
+
{
|
|
3773
|
+
language: PROPERTIES_LANGUAGE_ID,
|
|
3774
|
+
scheme: "file"
|
|
3775
|
+
},
|
|
3776
|
+
{
|
|
3777
|
+
language: YAML_LANGUAGE_ID,
|
|
3778
|
+
scheme: "file"
|
|
3779
|
+
},
|
|
3780
|
+
{
|
|
3781
|
+
language: FACTORIES_LANGUAGE_ID,
|
|
3782
|
+
scheme: "file"
|
|
3783
|
+
},
|
|
3784
|
+
{
|
|
3785
|
+
language: JPA_QUERY_PROPERTIES_LANGUAGE_ID,
|
|
3786
|
+
scheme: "file"
|
|
3787
|
+
},
|
|
3788
|
+
{
|
|
3789
|
+
language: XML_LANGUAGE_ID,
|
|
3790
|
+
scheme: "file"
|
|
3791
|
+
},
|
|
3792
|
+
{
|
|
3793
|
+
language: JAVA_LANGUAGE_ID,
|
|
3794
|
+
scheme: "file"
|
|
3795
|
+
},
|
|
3796
|
+
{
|
|
3797
|
+
language: JAVA_LANGUAGE_ID,
|
|
3798
|
+
scheme: "jdt"
|
|
3799
|
+
}
|
|
3800
|
+
],
|
|
3801
|
+
synchronize: {
|
|
3802
|
+
configurationSection: ["boot-java", "spring-boot", "http"]
|
|
3803
|
+
},
|
|
3804
|
+
initializationOptions: () => ({
|
|
3805
|
+
workspaceFolders: import_coc6.workspace.workspaceFolders ? import_coc6.workspace.workspaceFolders.map((f) => f.uri.toString()) : null,
|
|
3806
|
+
// Do not enable JDT classpath listeners at the startup - classpath service would enable it later if needed based on the Java extension mode
|
|
3807
|
+
// Classpath service registration requires commands to be registered and Boot LS needs to register classpath
|
|
3808
|
+
// listeners when client has callbacks for STS4 extension java related messages registered via JDT classpath and Data Service registration
|
|
3809
|
+
enableJdtClasspath: false
|
|
3810
|
+
})
|
|
3811
|
+
}
|
|
3812
|
+
};
|
|
3813
|
+
return activate(options, context).then((client) => {
|
|
3814
|
+
import_coc6.commands.registerCommand("vscode-spring-boot.ls.start", () => client.start().then(() => {
|
|
3815
|
+
console.log(`Starting spring-boot server`);
|
|
3816
|
+
import_coc6.services.registerLanguageClient(client);
|
|
3817
|
+
registerClasspathService(client);
|
|
3818
|
+
registerJavaDataService(client);
|
|
3819
|
+
}));
|
|
3820
|
+
import_coc6.commands.registerCommand("vscode-spring-boot.ls.stop", () => client.stop());
|
|
3821
|
+
activate2(client, options, context);
|
|
3822
|
+
startPropertiesConversionSupport(context);
|
|
3823
|
+
registerMiscCommands(context);
|
|
3824
|
+
return new ApiManager(client).api;
|
|
3825
|
+
});
|
|
3826
|
+
}
|
|
3827
|
+
function registerMiscCommands(context) {
|
|
3828
|
+
context.subscriptions.push(
|
|
3829
|
+
import_coc6.commands.registerCommand("springboot.spring.modulith.metadata.refresh", async () => {
|
|
3830
|
+
const modulithProjects = await import_coc6.commands.executeCommand("sts/modulith/projects");
|
|
3831
|
+
const projectNames = Object.keys(modulithProjects);
|
|
3832
|
+
if (projectNames.length === 0) {
|
|
3833
|
+
import_coc6.window.showErrorMessage("No Spring Modulith projects found");
|
|
3834
|
+
} else {
|
|
3835
|
+
const projectName = projectNames.length === 1 ? projectNames[0] : await import_coc6.window.showQuickPick(
|
|
3836
|
+
projectNames,
|
|
3837
|
+
{ placeholder: "Select the target project." }
|
|
3838
|
+
);
|
|
3839
|
+
import_coc6.commands.executeCommand("sts/modulith/metadata/refresh", modulithProjects[projectName]);
|
|
3840
|
+
}
|
|
3841
|
+
}),
|
|
3842
|
+
import_coc6.commands.registerCommand("springboot.open.url", async (openUrl) => {
|
|
3843
|
+
import_coc6.window.showInformationMessage(`Opening ${openUrl} with browser`);
|
|
3844
|
+
return import_coc6.workspace.nvim.call("coc#ui#open_url", [openUrl], true);
|
|
3845
|
+
}),
|
|
3846
|
+
import_coc6.commands.registerCommand("springboot.properties.reload", async () => {
|
|
3847
|
+
const relaodOutput = await import_coc6.commands.executeCommand("sts/common-properties/reload");
|
|
3848
|
+
if (relaodOutput) {
|
|
3849
|
+
import_coc6.window.showInformationMessage("Reloading common properties metadata");
|
|
3850
|
+
}
|
|
3851
|
+
})
|
|
3852
|
+
);
|
|
3853
|
+
}
|
|
3854
|
+
// Annotate the CommonJS export names for ESM import in node:
|
|
3855
|
+
0 && (module.exports = {
|
|
3856
|
+
activate
|
|
3857
|
+
});
|