eventmodeler 0.6.2 → 0.6.4
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/README.md +221 -91
- package/dist/index.js +2095 -74
- package/package.json +9 -4
package/dist/index.js
CHANGED
|
@@ -1,4 +1,1818 @@
|
|
|
1
1
|
#!/usr/bin/env node
|
|
2
|
+
var __create = Object.create;
|
|
3
|
+
var __getProtoOf = Object.getPrototypeOf;
|
|
4
|
+
var __defProp = Object.defineProperty;
|
|
5
|
+
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
6
|
+
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
7
|
+
function __accessProp(key) {
|
|
8
|
+
return this[key];
|
|
9
|
+
}
|
|
10
|
+
var __toESMCache_node;
|
|
11
|
+
var __toESMCache_esm;
|
|
12
|
+
var __toESM = (mod, isNodeMode, target) => {
|
|
13
|
+
var canCache = mod != null && typeof mod === "object";
|
|
14
|
+
if (canCache) {
|
|
15
|
+
var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
|
|
16
|
+
var cached = cache.get(mod);
|
|
17
|
+
if (cached)
|
|
18
|
+
return cached;
|
|
19
|
+
}
|
|
20
|
+
target = mod != null ? __create(__getProtoOf(mod)) : {};
|
|
21
|
+
const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
|
|
22
|
+
for (let key of __getOwnPropNames(mod))
|
|
23
|
+
if (!__hasOwnProp.call(to, key))
|
|
24
|
+
__defProp(to, key, {
|
|
25
|
+
get: __accessProp.bind(mod, key),
|
|
26
|
+
enumerable: true
|
|
27
|
+
});
|
|
28
|
+
if (canCache)
|
|
29
|
+
cache.set(mod, to);
|
|
30
|
+
return to;
|
|
31
|
+
};
|
|
32
|
+
var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
|
|
33
|
+
|
|
34
|
+
// ../node_modules/.bun/semver@7.7.4/node_modules/semver/internal/constants.js
|
|
35
|
+
var require_constants = __commonJS((exports, module) => {
|
|
36
|
+
var SEMVER_SPEC_VERSION = "2.0.0";
|
|
37
|
+
var MAX_LENGTH = 256;
|
|
38
|
+
var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991;
|
|
39
|
+
var MAX_SAFE_COMPONENT_LENGTH = 16;
|
|
40
|
+
var MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6;
|
|
41
|
+
var RELEASE_TYPES = [
|
|
42
|
+
"major",
|
|
43
|
+
"premajor",
|
|
44
|
+
"minor",
|
|
45
|
+
"preminor",
|
|
46
|
+
"patch",
|
|
47
|
+
"prepatch",
|
|
48
|
+
"prerelease"
|
|
49
|
+
];
|
|
50
|
+
module.exports = {
|
|
51
|
+
MAX_LENGTH,
|
|
52
|
+
MAX_SAFE_COMPONENT_LENGTH,
|
|
53
|
+
MAX_SAFE_BUILD_LENGTH,
|
|
54
|
+
MAX_SAFE_INTEGER,
|
|
55
|
+
RELEASE_TYPES,
|
|
56
|
+
SEMVER_SPEC_VERSION,
|
|
57
|
+
FLAG_INCLUDE_PRERELEASE: 1,
|
|
58
|
+
FLAG_LOOSE: 2
|
|
59
|
+
};
|
|
60
|
+
});
|
|
61
|
+
|
|
62
|
+
// ../node_modules/.bun/semver@7.7.4/node_modules/semver/internal/debug.js
|
|
63
|
+
var require_debug = __commonJS((exports, module) => {
|
|
64
|
+
var debug = typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => {};
|
|
65
|
+
module.exports = debug;
|
|
66
|
+
});
|
|
67
|
+
|
|
68
|
+
// ../node_modules/.bun/semver@7.7.4/node_modules/semver/internal/re.js
|
|
69
|
+
var require_re = __commonJS((exports, module) => {
|
|
70
|
+
var {
|
|
71
|
+
MAX_SAFE_COMPONENT_LENGTH,
|
|
72
|
+
MAX_SAFE_BUILD_LENGTH,
|
|
73
|
+
MAX_LENGTH
|
|
74
|
+
} = require_constants();
|
|
75
|
+
var debug = require_debug();
|
|
76
|
+
exports = module.exports = {};
|
|
77
|
+
var re = exports.re = [];
|
|
78
|
+
var safeRe = exports.safeRe = [];
|
|
79
|
+
var src = exports.src = [];
|
|
80
|
+
var safeSrc = exports.safeSrc = [];
|
|
81
|
+
var t = exports.t = {};
|
|
82
|
+
var R = 0;
|
|
83
|
+
var LETTERDASHNUMBER = "[a-zA-Z0-9-]";
|
|
84
|
+
var safeRegexReplacements = [
|
|
85
|
+
["\\s", 1],
|
|
86
|
+
["\\d", MAX_LENGTH],
|
|
87
|
+
[LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH]
|
|
88
|
+
];
|
|
89
|
+
var makeSafeRegex = (value) => {
|
|
90
|
+
for (const [token, max] of safeRegexReplacements) {
|
|
91
|
+
value = value.split(`${token}*`).join(`${token}{0,${max}}`).split(`${token}+`).join(`${token}{1,${max}}`);
|
|
92
|
+
}
|
|
93
|
+
return value;
|
|
94
|
+
};
|
|
95
|
+
var createToken = (name, value, isGlobal) => {
|
|
96
|
+
const safe = makeSafeRegex(value);
|
|
97
|
+
const index = R++;
|
|
98
|
+
debug(name, index, value);
|
|
99
|
+
t[name] = index;
|
|
100
|
+
src[index] = value;
|
|
101
|
+
safeSrc[index] = safe;
|
|
102
|
+
re[index] = new RegExp(value, isGlobal ? "g" : undefined);
|
|
103
|
+
safeRe[index] = new RegExp(safe, isGlobal ? "g" : undefined);
|
|
104
|
+
};
|
|
105
|
+
createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*");
|
|
106
|
+
createToken("NUMERICIDENTIFIERLOOSE", "\\d+");
|
|
107
|
+
createToken("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
|
|
108
|
+
createToken("MAINVERSION", `(${src[t.NUMERICIDENTIFIER]})\\.` + `(${src[t.NUMERICIDENTIFIER]})\\.` + `(${src[t.NUMERICIDENTIFIER]})`);
|
|
109
|
+
createToken("MAINVERSIONLOOSE", `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` + `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` + `(${src[t.NUMERICIDENTIFIERLOOSE]})`);
|
|
110
|
+
createToken("PRERELEASEIDENTIFIER", `(?:${src[t.NONNUMERICIDENTIFIER]}|${src[t.NUMERICIDENTIFIER]})`);
|
|
111
|
+
createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t.NONNUMERICIDENTIFIER]}|${src[t.NUMERICIDENTIFIERLOOSE]})`);
|
|
112
|
+
createToken("PRERELEASE", `(?:-(${src[t.PRERELEASEIDENTIFIER]}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`);
|
|
113
|
+
createToken("PRERELEASELOOSE", `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`);
|
|
114
|
+
createToken("BUILDIDENTIFIER", `${LETTERDASHNUMBER}+`);
|
|
115
|
+
createToken("BUILD", `(?:\\+(${src[t.BUILDIDENTIFIER]}(?:\\.${src[t.BUILDIDENTIFIER]})*))`);
|
|
116
|
+
createToken("FULLPLAIN", `v?${src[t.MAINVERSION]}${src[t.PRERELEASE]}?${src[t.BUILD]}?`);
|
|
117
|
+
createToken("FULL", `^${src[t.FULLPLAIN]}$`);
|
|
118
|
+
createToken("LOOSEPLAIN", `[v=\\s]*${src[t.MAINVERSIONLOOSE]}${src[t.PRERELEASELOOSE]}?${src[t.BUILD]}?`);
|
|
119
|
+
createToken("LOOSE", `^${src[t.LOOSEPLAIN]}$`);
|
|
120
|
+
createToken("GTLT", "((?:<|>)?=?)");
|
|
121
|
+
createToken("XRANGEIDENTIFIERLOOSE", `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
|
|
122
|
+
createToken("XRANGEIDENTIFIER", `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`);
|
|
123
|
+
createToken("XRANGEPLAIN", `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})` + `(?:\\.(${src[t.XRANGEIDENTIFIER]})` + `(?:\\.(${src[t.XRANGEIDENTIFIER]})` + `(?:${src[t.PRERELEASE]})?${src[t.BUILD]}?` + `)?)?`);
|
|
124
|
+
createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})` + `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` + `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` + `(?:${src[t.PRERELEASELOOSE]})?${src[t.BUILD]}?` + `)?)?`);
|
|
125
|
+
createToken("XRANGE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`);
|
|
126
|
+
createToken("XRANGELOOSE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`);
|
|
127
|
+
createToken("COERCEPLAIN", `${"(^|[^\\d])" + "(\\d{1,"}${MAX_SAFE_COMPONENT_LENGTH}})` + `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` + `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`);
|
|
128
|
+
createToken("COERCE", `${src[t.COERCEPLAIN]}(?:$|[^\\d])`);
|
|
129
|
+
createToken("COERCEFULL", src[t.COERCEPLAIN] + `(?:${src[t.PRERELEASE]})?` + `(?:${src[t.BUILD]})?` + `(?:$|[^\\d])`);
|
|
130
|
+
createToken("COERCERTL", src[t.COERCE], true);
|
|
131
|
+
createToken("COERCERTLFULL", src[t.COERCEFULL], true);
|
|
132
|
+
createToken("LONETILDE", "(?:~>?)");
|
|
133
|
+
createToken("TILDETRIM", `(\\s*)${src[t.LONETILDE]}\\s+`, true);
|
|
134
|
+
exports.tildeTrimReplace = "$1~";
|
|
135
|
+
createToken("TILDE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`);
|
|
136
|
+
createToken("TILDELOOSE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`);
|
|
137
|
+
createToken("LONECARET", "(?:\\^)");
|
|
138
|
+
createToken("CARETTRIM", `(\\s*)${src[t.LONECARET]}\\s+`, true);
|
|
139
|
+
exports.caretTrimReplace = "$1^";
|
|
140
|
+
createToken("CARET", `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`);
|
|
141
|
+
createToken("CARETLOOSE", `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`);
|
|
142
|
+
createToken("COMPARATORLOOSE", `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`);
|
|
143
|
+
createToken("COMPARATOR", `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`);
|
|
144
|
+
createToken("COMPARATORTRIM", `(\\s*)${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true);
|
|
145
|
+
exports.comparatorTrimReplace = "$1$2$3";
|
|
146
|
+
createToken("HYPHENRANGE", `^\\s*(${src[t.XRANGEPLAIN]})` + `\\s+-\\s+` + `(${src[t.XRANGEPLAIN]})` + `\\s*$`);
|
|
147
|
+
createToken("HYPHENRANGELOOSE", `^\\s*(${src[t.XRANGEPLAINLOOSE]})` + `\\s+-\\s+` + `(${src[t.XRANGEPLAINLOOSE]})` + `\\s*$`);
|
|
148
|
+
createToken("STAR", "(<|>)?=?\\s*\\*");
|
|
149
|
+
createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
|
|
150
|
+
createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
|
|
151
|
+
});
|
|
152
|
+
|
|
153
|
+
// ../node_modules/.bun/semver@7.7.4/node_modules/semver/internal/parse-options.js
|
|
154
|
+
var require_parse_options = __commonJS((exports, module) => {
|
|
155
|
+
var looseOption = Object.freeze({ loose: true });
|
|
156
|
+
var emptyOpts = Object.freeze({});
|
|
157
|
+
var parseOptions = (options) => {
|
|
158
|
+
if (!options) {
|
|
159
|
+
return emptyOpts;
|
|
160
|
+
}
|
|
161
|
+
if (typeof options !== "object") {
|
|
162
|
+
return looseOption;
|
|
163
|
+
}
|
|
164
|
+
return options;
|
|
165
|
+
};
|
|
166
|
+
module.exports = parseOptions;
|
|
167
|
+
});
|
|
168
|
+
|
|
169
|
+
// ../node_modules/.bun/semver@7.7.4/node_modules/semver/internal/identifiers.js
|
|
170
|
+
var require_identifiers = __commonJS((exports, module) => {
|
|
171
|
+
var numeric = /^[0-9]+$/;
|
|
172
|
+
var compareIdentifiers = (a, b) => {
|
|
173
|
+
if (typeof a === "number" && typeof b === "number") {
|
|
174
|
+
return a === b ? 0 : a < b ? -1 : 1;
|
|
175
|
+
}
|
|
176
|
+
const anum = numeric.test(a);
|
|
177
|
+
const bnum = numeric.test(b);
|
|
178
|
+
if (anum && bnum) {
|
|
179
|
+
a = +a;
|
|
180
|
+
b = +b;
|
|
181
|
+
}
|
|
182
|
+
return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
|
|
183
|
+
};
|
|
184
|
+
var rcompareIdentifiers = (a, b) => compareIdentifiers(b, a);
|
|
185
|
+
module.exports = {
|
|
186
|
+
compareIdentifiers,
|
|
187
|
+
rcompareIdentifiers
|
|
188
|
+
};
|
|
189
|
+
});
|
|
190
|
+
|
|
191
|
+
// ../node_modules/.bun/semver@7.7.4/node_modules/semver/classes/semver.js
|
|
192
|
+
var require_semver = __commonJS((exports, module) => {
|
|
193
|
+
var debug = require_debug();
|
|
194
|
+
var { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants();
|
|
195
|
+
var { safeRe: re, t } = require_re();
|
|
196
|
+
var parseOptions = require_parse_options();
|
|
197
|
+
var { compareIdentifiers } = require_identifiers();
|
|
198
|
+
|
|
199
|
+
class SemVer {
|
|
200
|
+
constructor(version, options) {
|
|
201
|
+
options = parseOptions(options);
|
|
202
|
+
if (version instanceof SemVer) {
|
|
203
|
+
if (version.loose === !!options.loose && version.includePrerelease === !!options.includePrerelease) {
|
|
204
|
+
return version;
|
|
205
|
+
} else {
|
|
206
|
+
version = version.version;
|
|
207
|
+
}
|
|
208
|
+
} else if (typeof version !== "string") {
|
|
209
|
+
throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version}".`);
|
|
210
|
+
}
|
|
211
|
+
if (version.length > MAX_LENGTH) {
|
|
212
|
+
throw new TypeError(`version is longer than ${MAX_LENGTH} characters`);
|
|
213
|
+
}
|
|
214
|
+
debug("SemVer", version, options);
|
|
215
|
+
this.options = options;
|
|
216
|
+
this.loose = !!options.loose;
|
|
217
|
+
this.includePrerelease = !!options.includePrerelease;
|
|
218
|
+
const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]);
|
|
219
|
+
if (!m) {
|
|
220
|
+
throw new TypeError(`Invalid Version: ${version}`);
|
|
221
|
+
}
|
|
222
|
+
this.raw = version;
|
|
223
|
+
this.major = +m[1];
|
|
224
|
+
this.minor = +m[2];
|
|
225
|
+
this.patch = +m[3];
|
|
226
|
+
if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
|
|
227
|
+
throw new TypeError("Invalid major version");
|
|
228
|
+
}
|
|
229
|
+
if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
|
|
230
|
+
throw new TypeError("Invalid minor version");
|
|
231
|
+
}
|
|
232
|
+
if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
|
|
233
|
+
throw new TypeError("Invalid patch version");
|
|
234
|
+
}
|
|
235
|
+
if (!m[4]) {
|
|
236
|
+
this.prerelease = [];
|
|
237
|
+
} else {
|
|
238
|
+
this.prerelease = m[4].split(".").map((id) => {
|
|
239
|
+
if (/^[0-9]+$/.test(id)) {
|
|
240
|
+
const num = +id;
|
|
241
|
+
if (num >= 0 && num < MAX_SAFE_INTEGER) {
|
|
242
|
+
return num;
|
|
243
|
+
}
|
|
244
|
+
}
|
|
245
|
+
return id;
|
|
246
|
+
});
|
|
247
|
+
}
|
|
248
|
+
this.build = m[5] ? m[5].split(".") : [];
|
|
249
|
+
this.format();
|
|
250
|
+
}
|
|
251
|
+
format() {
|
|
252
|
+
this.version = `${this.major}.${this.minor}.${this.patch}`;
|
|
253
|
+
if (this.prerelease.length) {
|
|
254
|
+
this.version += `-${this.prerelease.join(".")}`;
|
|
255
|
+
}
|
|
256
|
+
return this.version;
|
|
257
|
+
}
|
|
258
|
+
toString() {
|
|
259
|
+
return this.version;
|
|
260
|
+
}
|
|
261
|
+
compare(other) {
|
|
262
|
+
debug("SemVer.compare", this.version, this.options, other);
|
|
263
|
+
if (!(other instanceof SemVer)) {
|
|
264
|
+
if (typeof other === "string" && other === this.version) {
|
|
265
|
+
return 0;
|
|
266
|
+
}
|
|
267
|
+
other = new SemVer(other, this.options);
|
|
268
|
+
}
|
|
269
|
+
if (other.version === this.version) {
|
|
270
|
+
return 0;
|
|
271
|
+
}
|
|
272
|
+
return this.compareMain(other) || this.comparePre(other);
|
|
273
|
+
}
|
|
274
|
+
compareMain(other) {
|
|
275
|
+
if (!(other instanceof SemVer)) {
|
|
276
|
+
other = new SemVer(other, this.options);
|
|
277
|
+
}
|
|
278
|
+
if (this.major < other.major) {
|
|
279
|
+
return -1;
|
|
280
|
+
}
|
|
281
|
+
if (this.major > other.major) {
|
|
282
|
+
return 1;
|
|
283
|
+
}
|
|
284
|
+
if (this.minor < other.minor) {
|
|
285
|
+
return -1;
|
|
286
|
+
}
|
|
287
|
+
if (this.minor > other.minor) {
|
|
288
|
+
return 1;
|
|
289
|
+
}
|
|
290
|
+
if (this.patch < other.patch) {
|
|
291
|
+
return -1;
|
|
292
|
+
}
|
|
293
|
+
if (this.patch > other.patch) {
|
|
294
|
+
return 1;
|
|
295
|
+
}
|
|
296
|
+
return 0;
|
|
297
|
+
}
|
|
298
|
+
comparePre(other) {
|
|
299
|
+
if (!(other instanceof SemVer)) {
|
|
300
|
+
other = new SemVer(other, this.options);
|
|
301
|
+
}
|
|
302
|
+
if (this.prerelease.length && !other.prerelease.length) {
|
|
303
|
+
return -1;
|
|
304
|
+
} else if (!this.prerelease.length && other.prerelease.length) {
|
|
305
|
+
return 1;
|
|
306
|
+
} else if (!this.prerelease.length && !other.prerelease.length) {
|
|
307
|
+
return 0;
|
|
308
|
+
}
|
|
309
|
+
let i = 0;
|
|
310
|
+
do {
|
|
311
|
+
const a = this.prerelease[i];
|
|
312
|
+
const b = other.prerelease[i];
|
|
313
|
+
debug("prerelease compare", i, a, b);
|
|
314
|
+
if (a === undefined && b === undefined) {
|
|
315
|
+
return 0;
|
|
316
|
+
} else if (b === undefined) {
|
|
317
|
+
return 1;
|
|
318
|
+
} else if (a === undefined) {
|
|
319
|
+
return -1;
|
|
320
|
+
} else if (a === b) {
|
|
321
|
+
continue;
|
|
322
|
+
} else {
|
|
323
|
+
return compareIdentifiers(a, b);
|
|
324
|
+
}
|
|
325
|
+
} while (++i);
|
|
326
|
+
}
|
|
327
|
+
compareBuild(other) {
|
|
328
|
+
if (!(other instanceof SemVer)) {
|
|
329
|
+
other = new SemVer(other, this.options);
|
|
330
|
+
}
|
|
331
|
+
let i = 0;
|
|
332
|
+
do {
|
|
333
|
+
const a = this.build[i];
|
|
334
|
+
const b = other.build[i];
|
|
335
|
+
debug("build compare", i, a, b);
|
|
336
|
+
if (a === undefined && b === undefined) {
|
|
337
|
+
return 0;
|
|
338
|
+
} else if (b === undefined) {
|
|
339
|
+
return 1;
|
|
340
|
+
} else if (a === undefined) {
|
|
341
|
+
return -1;
|
|
342
|
+
} else if (a === b) {
|
|
343
|
+
continue;
|
|
344
|
+
} else {
|
|
345
|
+
return compareIdentifiers(a, b);
|
|
346
|
+
}
|
|
347
|
+
} while (++i);
|
|
348
|
+
}
|
|
349
|
+
inc(release, identifier, identifierBase) {
|
|
350
|
+
if (release.startsWith("pre")) {
|
|
351
|
+
if (!identifier && identifierBase === false) {
|
|
352
|
+
throw new Error("invalid increment argument: identifier is empty");
|
|
353
|
+
}
|
|
354
|
+
if (identifier) {
|
|
355
|
+
const match = `-${identifier}`.match(this.options.loose ? re[t.PRERELEASELOOSE] : re[t.PRERELEASE]);
|
|
356
|
+
if (!match || match[1] !== identifier) {
|
|
357
|
+
throw new Error(`invalid identifier: ${identifier}`);
|
|
358
|
+
}
|
|
359
|
+
}
|
|
360
|
+
}
|
|
361
|
+
switch (release) {
|
|
362
|
+
case "premajor":
|
|
363
|
+
this.prerelease.length = 0;
|
|
364
|
+
this.patch = 0;
|
|
365
|
+
this.minor = 0;
|
|
366
|
+
this.major++;
|
|
367
|
+
this.inc("pre", identifier, identifierBase);
|
|
368
|
+
break;
|
|
369
|
+
case "preminor":
|
|
370
|
+
this.prerelease.length = 0;
|
|
371
|
+
this.patch = 0;
|
|
372
|
+
this.minor++;
|
|
373
|
+
this.inc("pre", identifier, identifierBase);
|
|
374
|
+
break;
|
|
375
|
+
case "prepatch":
|
|
376
|
+
this.prerelease.length = 0;
|
|
377
|
+
this.inc("patch", identifier, identifierBase);
|
|
378
|
+
this.inc("pre", identifier, identifierBase);
|
|
379
|
+
break;
|
|
380
|
+
case "prerelease":
|
|
381
|
+
if (this.prerelease.length === 0) {
|
|
382
|
+
this.inc("patch", identifier, identifierBase);
|
|
383
|
+
}
|
|
384
|
+
this.inc("pre", identifier, identifierBase);
|
|
385
|
+
break;
|
|
386
|
+
case "release":
|
|
387
|
+
if (this.prerelease.length === 0) {
|
|
388
|
+
throw new Error(`version ${this.raw} is not a prerelease`);
|
|
389
|
+
}
|
|
390
|
+
this.prerelease.length = 0;
|
|
391
|
+
break;
|
|
392
|
+
case "major":
|
|
393
|
+
if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) {
|
|
394
|
+
this.major++;
|
|
395
|
+
}
|
|
396
|
+
this.minor = 0;
|
|
397
|
+
this.patch = 0;
|
|
398
|
+
this.prerelease = [];
|
|
399
|
+
break;
|
|
400
|
+
case "minor":
|
|
401
|
+
if (this.patch !== 0 || this.prerelease.length === 0) {
|
|
402
|
+
this.minor++;
|
|
403
|
+
}
|
|
404
|
+
this.patch = 0;
|
|
405
|
+
this.prerelease = [];
|
|
406
|
+
break;
|
|
407
|
+
case "patch":
|
|
408
|
+
if (this.prerelease.length === 0) {
|
|
409
|
+
this.patch++;
|
|
410
|
+
}
|
|
411
|
+
this.prerelease = [];
|
|
412
|
+
break;
|
|
413
|
+
case "pre": {
|
|
414
|
+
const base = Number(identifierBase) ? 1 : 0;
|
|
415
|
+
if (this.prerelease.length === 0) {
|
|
416
|
+
this.prerelease = [base];
|
|
417
|
+
} else {
|
|
418
|
+
let i = this.prerelease.length;
|
|
419
|
+
while (--i >= 0) {
|
|
420
|
+
if (typeof this.prerelease[i] === "number") {
|
|
421
|
+
this.prerelease[i]++;
|
|
422
|
+
i = -2;
|
|
423
|
+
}
|
|
424
|
+
}
|
|
425
|
+
if (i === -1) {
|
|
426
|
+
if (identifier === this.prerelease.join(".") && identifierBase === false) {
|
|
427
|
+
throw new Error("invalid increment argument: identifier already exists");
|
|
428
|
+
}
|
|
429
|
+
this.prerelease.push(base);
|
|
430
|
+
}
|
|
431
|
+
}
|
|
432
|
+
if (identifier) {
|
|
433
|
+
let prerelease = [identifier, base];
|
|
434
|
+
if (identifierBase === false) {
|
|
435
|
+
prerelease = [identifier];
|
|
436
|
+
}
|
|
437
|
+
if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
|
|
438
|
+
if (isNaN(this.prerelease[1])) {
|
|
439
|
+
this.prerelease = prerelease;
|
|
440
|
+
}
|
|
441
|
+
} else {
|
|
442
|
+
this.prerelease = prerelease;
|
|
443
|
+
}
|
|
444
|
+
}
|
|
445
|
+
break;
|
|
446
|
+
}
|
|
447
|
+
default:
|
|
448
|
+
throw new Error(`invalid increment argument: ${release}`);
|
|
449
|
+
}
|
|
450
|
+
this.raw = this.format();
|
|
451
|
+
if (this.build.length) {
|
|
452
|
+
this.raw += `+${this.build.join(".")}`;
|
|
453
|
+
}
|
|
454
|
+
return this;
|
|
455
|
+
}
|
|
456
|
+
}
|
|
457
|
+
module.exports = SemVer;
|
|
458
|
+
});
|
|
459
|
+
|
|
460
|
+
// ../node_modules/.bun/semver@7.7.4/node_modules/semver/functions/parse.js
|
|
461
|
+
var require_parse = __commonJS((exports, module) => {
|
|
462
|
+
var SemVer = require_semver();
|
|
463
|
+
var parse2 = (version, options, throwErrors = false) => {
|
|
464
|
+
if (version instanceof SemVer) {
|
|
465
|
+
return version;
|
|
466
|
+
}
|
|
467
|
+
try {
|
|
468
|
+
return new SemVer(version, options);
|
|
469
|
+
} catch (er) {
|
|
470
|
+
if (!throwErrors) {
|
|
471
|
+
return null;
|
|
472
|
+
}
|
|
473
|
+
throw er;
|
|
474
|
+
}
|
|
475
|
+
};
|
|
476
|
+
module.exports = parse2;
|
|
477
|
+
});
|
|
478
|
+
|
|
479
|
+
// ../node_modules/.bun/semver@7.7.4/node_modules/semver/functions/valid.js
|
|
480
|
+
var require_valid = __commonJS((exports, module) => {
|
|
481
|
+
var parse2 = require_parse();
|
|
482
|
+
var valid = (version, options) => {
|
|
483
|
+
const v = parse2(version, options);
|
|
484
|
+
return v ? v.version : null;
|
|
485
|
+
};
|
|
486
|
+
module.exports = valid;
|
|
487
|
+
});
|
|
488
|
+
|
|
489
|
+
// ../node_modules/.bun/semver@7.7.4/node_modules/semver/functions/clean.js
|
|
490
|
+
var require_clean = __commonJS((exports, module) => {
|
|
491
|
+
var parse2 = require_parse();
|
|
492
|
+
var clean = (version, options) => {
|
|
493
|
+
const s = parse2(version.trim().replace(/^[=v]+/, ""), options);
|
|
494
|
+
return s ? s.version : null;
|
|
495
|
+
};
|
|
496
|
+
module.exports = clean;
|
|
497
|
+
});
|
|
498
|
+
|
|
499
|
+
// ../node_modules/.bun/semver@7.7.4/node_modules/semver/functions/inc.js
|
|
500
|
+
var require_inc = __commonJS((exports, module) => {
|
|
501
|
+
var SemVer = require_semver();
|
|
502
|
+
var inc = (version, release, options, identifier, identifierBase) => {
|
|
503
|
+
if (typeof options === "string") {
|
|
504
|
+
identifierBase = identifier;
|
|
505
|
+
identifier = options;
|
|
506
|
+
options = undefined;
|
|
507
|
+
}
|
|
508
|
+
try {
|
|
509
|
+
return new SemVer(version instanceof SemVer ? version.version : version, options).inc(release, identifier, identifierBase).version;
|
|
510
|
+
} catch (er) {
|
|
511
|
+
return null;
|
|
512
|
+
}
|
|
513
|
+
};
|
|
514
|
+
module.exports = inc;
|
|
515
|
+
});
|
|
516
|
+
|
|
517
|
+
// ../node_modules/.bun/semver@7.7.4/node_modules/semver/functions/diff.js
|
|
518
|
+
var require_diff = __commonJS((exports, module) => {
|
|
519
|
+
var parse2 = require_parse();
|
|
520
|
+
var diff = (version1, version2) => {
|
|
521
|
+
const v1 = parse2(version1, null, true);
|
|
522
|
+
const v2 = parse2(version2, null, true);
|
|
523
|
+
const comparison = v1.compare(v2);
|
|
524
|
+
if (comparison === 0) {
|
|
525
|
+
return null;
|
|
526
|
+
}
|
|
527
|
+
const v1Higher = comparison > 0;
|
|
528
|
+
const highVersion = v1Higher ? v1 : v2;
|
|
529
|
+
const lowVersion = v1Higher ? v2 : v1;
|
|
530
|
+
const highHasPre = !!highVersion.prerelease.length;
|
|
531
|
+
const lowHasPre = !!lowVersion.prerelease.length;
|
|
532
|
+
if (lowHasPre && !highHasPre) {
|
|
533
|
+
if (!lowVersion.patch && !lowVersion.minor) {
|
|
534
|
+
return "major";
|
|
535
|
+
}
|
|
536
|
+
if (lowVersion.compareMain(highVersion) === 0) {
|
|
537
|
+
if (lowVersion.minor && !lowVersion.patch) {
|
|
538
|
+
return "minor";
|
|
539
|
+
}
|
|
540
|
+
return "patch";
|
|
541
|
+
}
|
|
542
|
+
}
|
|
543
|
+
const prefix = highHasPre ? "pre" : "";
|
|
544
|
+
if (v1.major !== v2.major) {
|
|
545
|
+
return prefix + "major";
|
|
546
|
+
}
|
|
547
|
+
if (v1.minor !== v2.minor) {
|
|
548
|
+
return prefix + "minor";
|
|
549
|
+
}
|
|
550
|
+
if (v1.patch !== v2.patch) {
|
|
551
|
+
return prefix + "patch";
|
|
552
|
+
}
|
|
553
|
+
return "prerelease";
|
|
554
|
+
};
|
|
555
|
+
module.exports = diff;
|
|
556
|
+
});
|
|
557
|
+
|
|
558
|
+
// ../node_modules/.bun/semver@7.7.4/node_modules/semver/functions/major.js
|
|
559
|
+
var require_major = __commonJS((exports, module) => {
|
|
560
|
+
var SemVer = require_semver();
|
|
561
|
+
var major = (a, loose) => new SemVer(a, loose).major;
|
|
562
|
+
module.exports = major;
|
|
563
|
+
});
|
|
564
|
+
|
|
565
|
+
// ../node_modules/.bun/semver@7.7.4/node_modules/semver/functions/minor.js
|
|
566
|
+
var require_minor = __commonJS((exports, module) => {
|
|
567
|
+
var SemVer = require_semver();
|
|
568
|
+
var minor = (a, loose) => new SemVer(a, loose).minor;
|
|
569
|
+
module.exports = minor;
|
|
570
|
+
});
|
|
571
|
+
|
|
572
|
+
// ../node_modules/.bun/semver@7.7.4/node_modules/semver/functions/patch.js
|
|
573
|
+
var require_patch = __commonJS((exports, module) => {
|
|
574
|
+
var SemVer = require_semver();
|
|
575
|
+
var patch = (a, loose) => new SemVer(a, loose).patch;
|
|
576
|
+
module.exports = patch;
|
|
577
|
+
});
|
|
578
|
+
|
|
579
|
+
// ../node_modules/.bun/semver@7.7.4/node_modules/semver/functions/prerelease.js
|
|
580
|
+
var require_prerelease = __commonJS((exports, module) => {
|
|
581
|
+
var parse2 = require_parse();
|
|
582
|
+
var prerelease = (version, options) => {
|
|
583
|
+
const parsed = parse2(version, options);
|
|
584
|
+
return parsed && parsed.prerelease.length ? parsed.prerelease : null;
|
|
585
|
+
};
|
|
586
|
+
module.exports = prerelease;
|
|
587
|
+
});
|
|
588
|
+
|
|
589
|
+
// ../node_modules/.bun/semver@7.7.4/node_modules/semver/functions/compare.js
|
|
590
|
+
var require_compare = __commonJS((exports, module) => {
|
|
591
|
+
var SemVer = require_semver();
|
|
592
|
+
var compare = (a, b, loose) => new SemVer(a, loose).compare(new SemVer(b, loose));
|
|
593
|
+
module.exports = compare;
|
|
594
|
+
});
|
|
595
|
+
|
|
596
|
+
// ../node_modules/.bun/semver@7.7.4/node_modules/semver/functions/rcompare.js
|
|
597
|
+
var require_rcompare = __commonJS((exports, module) => {
|
|
598
|
+
var compare = require_compare();
|
|
599
|
+
var rcompare = (a, b, loose) => compare(b, a, loose);
|
|
600
|
+
module.exports = rcompare;
|
|
601
|
+
});
|
|
602
|
+
|
|
603
|
+
// ../node_modules/.bun/semver@7.7.4/node_modules/semver/functions/compare-loose.js
|
|
604
|
+
var require_compare_loose = __commonJS((exports, module) => {
|
|
605
|
+
var compare = require_compare();
|
|
606
|
+
var compareLoose = (a, b) => compare(a, b, true);
|
|
607
|
+
module.exports = compareLoose;
|
|
608
|
+
});
|
|
609
|
+
|
|
610
|
+
// ../node_modules/.bun/semver@7.7.4/node_modules/semver/functions/compare-build.js
|
|
611
|
+
var require_compare_build = __commonJS((exports, module) => {
|
|
612
|
+
var SemVer = require_semver();
|
|
613
|
+
var compareBuild = (a, b, loose) => {
|
|
614
|
+
const versionA = new SemVer(a, loose);
|
|
615
|
+
const versionB = new SemVer(b, loose);
|
|
616
|
+
return versionA.compare(versionB) || versionA.compareBuild(versionB);
|
|
617
|
+
};
|
|
618
|
+
module.exports = compareBuild;
|
|
619
|
+
});
|
|
620
|
+
|
|
621
|
+
// ../node_modules/.bun/semver@7.7.4/node_modules/semver/functions/sort.js
|
|
622
|
+
var require_sort = __commonJS((exports, module) => {
|
|
623
|
+
var compareBuild = require_compare_build();
|
|
624
|
+
var sort = (list, loose) => list.sort((a, b) => compareBuild(a, b, loose));
|
|
625
|
+
module.exports = sort;
|
|
626
|
+
});
|
|
627
|
+
|
|
628
|
+
// ../node_modules/.bun/semver@7.7.4/node_modules/semver/functions/rsort.js
|
|
629
|
+
var require_rsort = __commonJS((exports, module) => {
|
|
630
|
+
var compareBuild = require_compare_build();
|
|
631
|
+
var rsort = (list, loose) => list.sort((a, b) => compareBuild(b, a, loose));
|
|
632
|
+
module.exports = rsort;
|
|
633
|
+
});
|
|
634
|
+
|
|
635
|
+
// ../node_modules/.bun/semver@7.7.4/node_modules/semver/functions/gt.js
|
|
636
|
+
var require_gt = __commonJS((exports, module) => {
|
|
637
|
+
var compare = require_compare();
|
|
638
|
+
var gt = (a, b, loose) => compare(a, b, loose) > 0;
|
|
639
|
+
module.exports = gt;
|
|
640
|
+
});
|
|
641
|
+
|
|
642
|
+
// ../node_modules/.bun/semver@7.7.4/node_modules/semver/functions/lt.js
|
|
643
|
+
var require_lt = __commonJS((exports, module) => {
|
|
644
|
+
var compare = require_compare();
|
|
645
|
+
var lt = (a, b, loose) => compare(a, b, loose) < 0;
|
|
646
|
+
module.exports = lt;
|
|
647
|
+
});
|
|
648
|
+
|
|
649
|
+
// ../node_modules/.bun/semver@7.7.4/node_modules/semver/functions/eq.js
|
|
650
|
+
var require_eq = __commonJS((exports, module) => {
|
|
651
|
+
var compare = require_compare();
|
|
652
|
+
var eq = (a, b, loose) => compare(a, b, loose) === 0;
|
|
653
|
+
module.exports = eq;
|
|
654
|
+
});
|
|
655
|
+
|
|
656
|
+
// ../node_modules/.bun/semver@7.7.4/node_modules/semver/functions/neq.js
|
|
657
|
+
var require_neq = __commonJS((exports, module) => {
|
|
658
|
+
var compare = require_compare();
|
|
659
|
+
var neq = (a, b, loose) => compare(a, b, loose) !== 0;
|
|
660
|
+
module.exports = neq;
|
|
661
|
+
});
|
|
662
|
+
|
|
663
|
+
// ../node_modules/.bun/semver@7.7.4/node_modules/semver/functions/gte.js
|
|
664
|
+
var require_gte = __commonJS((exports, module) => {
|
|
665
|
+
var compare = require_compare();
|
|
666
|
+
var gte = (a, b, loose) => compare(a, b, loose) >= 0;
|
|
667
|
+
module.exports = gte;
|
|
668
|
+
});
|
|
669
|
+
|
|
670
|
+
// ../node_modules/.bun/semver@7.7.4/node_modules/semver/functions/lte.js
|
|
671
|
+
var require_lte = __commonJS((exports, module) => {
|
|
672
|
+
var compare = require_compare();
|
|
673
|
+
var lte = (a, b, loose) => compare(a, b, loose) <= 0;
|
|
674
|
+
module.exports = lte;
|
|
675
|
+
});
|
|
676
|
+
|
|
677
|
+
// ../node_modules/.bun/semver@7.7.4/node_modules/semver/functions/cmp.js
|
|
678
|
+
var require_cmp = __commonJS((exports, module) => {
|
|
679
|
+
var eq = require_eq();
|
|
680
|
+
var neq = require_neq();
|
|
681
|
+
var gt = require_gt();
|
|
682
|
+
var gte = require_gte();
|
|
683
|
+
var lt = require_lt();
|
|
684
|
+
var lte = require_lte();
|
|
685
|
+
var cmp = (a, op, b, loose) => {
|
|
686
|
+
switch (op) {
|
|
687
|
+
case "===":
|
|
688
|
+
if (typeof a === "object") {
|
|
689
|
+
a = a.version;
|
|
690
|
+
}
|
|
691
|
+
if (typeof b === "object") {
|
|
692
|
+
b = b.version;
|
|
693
|
+
}
|
|
694
|
+
return a === b;
|
|
695
|
+
case "!==":
|
|
696
|
+
if (typeof a === "object") {
|
|
697
|
+
a = a.version;
|
|
698
|
+
}
|
|
699
|
+
if (typeof b === "object") {
|
|
700
|
+
b = b.version;
|
|
701
|
+
}
|
|
702
|
+
return a !== b;
|
|
703
|
+
case "":
|
|
704
|
+
case "=":
|
|
705
|
+
case "==":
|
|
706
|
+
return eq(a, b, loose);
|
|
707
|
+
case "!=":
|
|
708
|
+
return neq(a, b, loose);
|
|
709
|
+
case ">":
|
|
710
|
+
return gt(a, b, loose);
|
|
711
|
+
case ">=":
|
|
712
|
+
return gte(a, b, loose);
|
|
713
|
+
case "<":
|
|
714
|
+
return lt(a, b, loose);
|
|
715
|
+
case "<=":
|
|
716
|
+
return lte(a, b, loose);
|
|
717
|
+
default:
|
|
718
|
+
throw new TypeError(`Invalid operator: ${op}`);
|
|
719
|
+
}
|
|
720
|
+
};
|
|
721
|
+
module.exports = cmp;
|
|
722
|
+
});
|
|
723
|
+
|
|
724
|
+
// ../node_modules/.bun/semver@7.7.4/node_modules/semver/functions/coerce.js
|
|
725
|
+
var require_coerce = __commonJS((exports, module) => {
|
|
726
|
+
var SemVer = require_semver();
|
|
727
|
+
var parse2 = require_parse();
|
|
728
|
+
var { safeRe: re, t } = require_re();
|
|
729
|
+
var coerce = (version, options) => {
|
|
730
|
+
if (version instanceof SemVer) {
|
|
731
|
+
return version;
|
|
732
|
+
}
|
|
733
|
+
if (typeof version === "number") {
|
|
734
|
+
version = String(version);
|
|
735
|
+
}
|
|
736
|
+
if (typeof version !== "string") {
|
|
737
|
+
return null;
|
|
738
|
+
}
|
|
739
|
+
options = options || {};
|
|
740
|
+
let match = null;
|
|
741
|
+
if (!options.rtl) {
|
|
742
|
+
match = version.match(options.includePrerelease ? re[t.COERCEFULL] : re[t.COERCE]);
|
|
743
|
+
} else {
|
|
744
|
+
const coerceRtlRegex = options.includePrerelease ? re[t.COERCERTLFULL] : re[t.COERCERTL];
|
|
745
|
+
let next;
|
|
746
|
+
while ((next = coerceRtlRegex.exec(version)) && (!match || match.index + match[0].length !== version.length)) {
|
|
747
|
+
if (!match || next.index + next[0].length !== match.index + match[0].length) {
|
|
748
|
+
match = next;
|
|
749
|
+
}
|
|
750
|
+
coerceRtlRegex.lastIndex = next.index + next[1].length + next[2].length;
|
|
751
|
+
}
|
|
752
|
+
coerceRtlRegex.lastIndex = -1;
|
|
753
|
+
}
|
|
754
|
+
if (match === null) {
|
|
755
|
+
return null;
|
|
756
|
+
}
|
|
757
|
+
const major = match[2];
|
|
758
|
+
const minor = match[3] || "0";
|
|
759
|
+
const patch = match[4] || "0";
|
|
760
|
+
const prerelease = options.includePrerelease && match[5] ? `-${match[5]}` : "";
|
|
761
|
+
const build = options.includePrerelease && match[6] ? `+${match[6]}` : "";
|
|
762
|
+
return parse2(`${major}.${minor}.${patch}${prerelease}${build}`, options);
|
|
763
|
+
};
|
|
764
|
+
module.exports = coerce;
|
|
765
|
+
});
|
|
766
|
+
|
|
767
|
+
// ../node_modules/.bun/semver@7.7.4/node_modules/semver/internal/lrucache.js
|
|
768
|
+
var require_lrucache = __commonJS((exports, module) => {
|
|
769
|
+
class LRUCache {
|
|
770
|
+
constructor() {
|
|
771
|
+
this.max = 1000;
|
|
772
|
+
this.map = new Map;
|
|
773
|
+
}
|
|
774
|
+
get(key) {
|
|
775
|
+
const value = this.map.get(key);
|
|
776
|
+
if (value === undefined) {
|
|
777
|
+
return;
|
|
778
|
+
} else {
|
|
779
|
+
this.map.delete(key);
|
|
780
|
+
this.map.set(key, value);
|
|
781
|
+
return value;
|
|
782
|
+
}
|
|
783
|
+
}
|
|
784
|
+
delete(key) {
|
|
785
|
+
return this.map.delete(key);
|
|
786
|
+
}
|
|
787
|
+
set(key, value) {
|
|
788
|
+
const deleted = this.delete(key);
|
|
789
|
+
if (!deleted && value !== undefined) {
|
|
790
|
+
if (this.map.size >= this.max) {
|
|
791
|
+
const firstKey = this.map.keys().next().value;
|
|
792
|
+
this.delete(firstKey);
|
|
793
|
+
}
|
|
794
|
+
this.map.set(key, value);
|
|
795
|
+
}
|
|
796
|
+
return this;
|
|
797
|
+
}
|
|
798
|
+
}
|
|
799
|
+
module.exports = LRUCache;
|
|
800
|
+
});
|
|
801
|
+
|
|
802
|
+
// ../node_modules/.bun/semver@7.7.4/node_modules/semver/classes/range.js
|
|
803
|
+
var require_range = __commonJS((exports, module) => {
|
|
804
|
+
var SPACE_CHARACTERS = /\s+/g;
|
|
805
|
+
|
|
806
|
+
class Range {
|
|
807
|
+
constructor(range, options) {
|
|
808
|
+
options = parseOptions(options);
|
|
809
|
+
if (range instanceof Range) {
|
|
810
|
+
if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) {
|
|
811
|
+
return range;
|
|
812
|
+
} else {
|
|
813
|
+
return new Range(range.raw, options);
|
|
814
|
+
}
|
|
815
|
+
}
|
|
816
|
+
if (range instanceof Comparator) {
|
|
817
|
+
this.raw = range.value;
|
|
818
|
+
this.set = [[range]];
|
|
819
|
+
this.formatted = undefined;
|
|
820
|
+
return this;
|
|
821
|
+
}
|
|
822
|
+
this.options = options;
|
|
823
|
+
this.loose = !!options.loose;
|
|
824
|
+
this.includePrerelease = !!options.includePrerelease;
|
|
825
|
+
this.raw = range.trim().replace(SPACE_CHARACTERS, " ");
|
|
826
|
+
this.set = this.raw.split("||").map((r) => this.parseRange(r.trim())).filter((c) => c.length);
|
|
827
|
+
if (!this.set.length) {
|
|
828
|
+
throw new TypeError(`Invalid SemVer Range: ${this.raw}`);
|
|
829
|
+
}
|
|
830
|
+
if (this.set.length > 1) {
|
|
831
|
+
const first = this.set[0];
|
|
832
|
+
this.set = this.set.filter((c) => !isNullSet(c[0]));
|
|
833
|
+
if (this.set.length === 0) {
|
|
834
|
+
this.set = [first];
|
|
835
|
+
} else if (this.set.length > 1) {
|
|
836
|
+
for (const c of this.set) {
|
|
837
|
+
if (c.length === 1 && isAny(c[0])) {
|
|
838
|
+
this.set = [c];
|
|
839
|
+
break;
|
|
840
|
+
}
|
|
841
|
+
}
|
|
842
|
+
}
|
|
843
|
+
}
|
|
844
|
+
this.formatted = undefined;
|
|
845
|
+
}
|
|
846
|
+
get range() {
|
|
847
|
+
if (this.formatted === undefined) {
|
|
848
|
+
this.formatted = "";
|
|
849
|
+
for (let i = 0;i < this.set.length; i++) {
|
|
850
|
+
if (i > 0) {
|
|
851
|
+
this.formatted += "||";
|
|
852
|
+
}
|
|
853
|
+
const comps = this.set[i];
|
|
854
|
+
for (let k = 0;k < comps.length; k++) {
|
|
855
|
+
if (k > 0) {
|
|
856
|
+
this.formatted += " ";
|
|
857
|
+
}
|
|
858
|
+
this.formatted += comps[k].toString().trim();
|
|
859
|
+
}
|
|
860
|
+
}
|
|
861
|
+
}
|
|
862
|
+
return this.formatted;
|
|
863
|
+
}
|
|
864
|
+
format() {
|
|
865
|
+
return this.range;
|
|
866
|
+
}
|
|
867
|
+
toString() {
|
|
868
|
+
return this.range;
|
|
869
|
+
}
|
|
870
|
+
parseRange(range) {
|
|
871
|
+
const memoOpts = (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE);
|
|
872
|
+
const memoKey = memoOpts + ":" + range;
|
|
873
|
+
const cached = cache.get(memoKey);
|
|
874
|
+
if (cached) {
|
|
875
|
+
return cached;
|
|
876
|
+
}
|
|
877
|
+
const loose = this.options.loose;
|
|
878
|
+
const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE];
|
|
879
|
+
range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
|
|
880
|
+
debug("hyphen replace", range);
|
|
881
|
+
range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);
|
|
882
|
+
debug("comparator trim", range);
|
|
883
|
+
range = range.replace(re[t.TILDETRIM], tildeTrimReplace);
|
|
884
|
+
debug("tilde trim", range);
|
|
885
|
+
range = range.replace(re[t.CARETTRIM], caretTrimReplace);
|
|
886
|
+
debug("caret trim", range);
|
|
887
|
+
let rangeList = range.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options));
|
|
888
|
+
if (loose) {
|
|
889
|
+
rangeList = rangeList.filter((comp) => {
|
|
890
|
+
debug("loose invalid filter", comp, this.options);
|
|
891
|
+
return !!comp.match(re[t.COMPARATORLOOSE]);
|
|
892
|
+
});
|
|
893
|
+
}
|
|
894
|
+
debug("range list", rangeList);
|
|
895
|
+
const rangeMap = new Map;
|
|
896
|
+
const comparators = rangeList.map((comp) => new Comparator(comp, this.options));
|
|
897
|
+
for (const comp of comparators) {
|
|
898
|
+
if (isNullSet(comp)) {
|
|
899
|
+
return [comp];
|
|
900
|
+
}
|
|
901
|
+
rangeMap.set(comp.value, comp);
|
|
902
|
+
}
|
|
903
|
+
if (rangeMap.size > 1 && rangeMap.has("")) {
|
|
904
|
+
rangeMap.delete("");
|
|
905
|
+
}
|
|
906
|
+
const result = [...rangeMap.values()];
|
|
907
|
+
cache.set(memoKey, result);
|
|
908
|
+
return result;
|
|
909
|
+
}
|
|
910
|
+
intersects(range, options) {
|
|
911
|
+
if (!(range instanceof Range)) {
|
|
912
|
+
throw new TypeError("a Range is required");
|
|
913
|
+
}
|
|
914
|
+
return this.set.some((thisComparators) => {
|
|
915
|
+
return isSatisfiable(thisComparators, options) && range.set.some((rangeComparators) => {
|
|
916
|
+
return isSatisfiable(rangeComparators, options) && thisComparators.every((thisComparator) => {
|
|
917
|
+
return rangeComparators.every((rangeComparator) => {
|
|
918
|
+
return thisComparator.intersects(rangeComparator, options);
|
|
919
|
+
});
|
|
920
|
+
});
|
|
921
|
+
});
|
|
922
|
+
});
|
|
923
|
+
}
|
|
924
|
+
test(version) {
|
|
925
|
+
if (!version) {
|
|
926
|
+
return false;
|
|
927
|
+
}
|
|
928
|
+
if (typeof version === "string") {
|
|
929
|
+
try {
|
|
930
|
+
version = new SemVer(version, this.options);
|
|
931
|
+
} catch (er) {
|
|
932
|
+
return false;
|
|
933
|
+
}
|
|
934
|
+
}
|
|
935
|
+
for (let i = 0;i < this.set.length; i++) {
|
|
936
|
+
if (testSet(this.set[i], version, this.options)) {
|
|
937
|
+
return true;
|
|
938
|
+
}
|
|
939
|
+
}
|
|
940
|
+
return false;
|
|
941
|
+
}
|
|
942
|
+
}
|
|
943
|
+
module.exports = Range;
|
|
944
|
+
var LRU = require_lrucache();
|
|
945
|
+
var cache = new LRU;
|
|
946
|
+
var parseOptions = require_parse_options();
|
|
947
|
+
var Comparator = require_comparator();
|
|
948
|
+
var debug = require_debug();
|
|
949
|
+
var SemVer = require_semver();
|
|
950
|
+
var {
|
|
951
|
+
safeRe: re,
|
|
952
|
+
t,
|
|
953
|
+
comparatorTrimReplace,
|
|
954
|
+
tildeTrimReplace,
|
|
955
|
+
caretTrimReplace
|
|
956
|
+
} = require_re();
|
|
957
|
+
var { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require_constants();
|
|
958
|
+
var isNullSet = (c) => c.value === "<0.0.0-0";
|
|
959
|
+
var isAny = (c) => c.value === "";
|
|
960
|
+
var isSatisfiable = (comparators, options) => {
|
|
961
|
+
let result = true;
|
|
962
|
+
const remainingComparators = comparators.slice();
|
|
963
|
+
let testComparator = remainingComparators.pop();
|
|
964
|
+
while (result && remainingComparators.length) {
|
|
965
|
+
result = remainingComparators.every((otherComparator) => {
|
|
966
|
+
return testComparator.intersects(otherComparator, options);
|
|
967
|
+
});
|
|
968
|
+
testComparator = remainingComparators.pop();
|
|
969
|
+
}
|
|
970
|
+
return result;
|
|
971
|
+
};
|
|
972
|
+
var parseComparator = (comp, options) => {
|
|
973
|
+
comp = comp.replace(re[t.BUILD], "");
|
|
974
|
+
debug("comp", comp, options);
|
|
975
|
+
comp = replaceCarets(comp, options);
|
|
976
|
+
debug("caret", comp);
|
|
977
|
+
comp = replaceTildes(comp, options);
|
|
978
|
+
debug("tildes", comp);
|
|
979
|
+
comp = replaceXRanges(comp, options);
|
|
980
|
+
debug("xrange", comp);
|
|
981
|
+
comp = replaceStars(comp, options);
|
|
982
|
+
debug("stars", comp);
|
|
983
|
+
return comp;
|
|
984
|
+
};
|
|
985
|
+
var isX = (id) => !id || id.toLowerCase() === "x" || id === "*";
|
|
986
|
+
var replaceTildes = (comp, options) => {
|
|
987
|
+
return comp.trim().split(/\s+/).map((c) => replaceTilde(c, options)).join(" ");
|
|
988
|
+
};
|
|
989
|
+
var replaceTilde = (comp, options) => {
|
|
990
|
+
const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE];
|
|
991
|
+
return comp.replace(r, (_, M, m, p, pr) => {
|
|
992
|
+
debug("tilde", comp, _, M, m, p, pr);
|
|
993
|
+
let ret;
|
|
994
|
+
if (isX(M)) {
|
|
995
|
+
ret = "";
|
|
996
|
+
} else if (isX(m)) {
|
|
997
|
+
ret = `>=${M}.0.0 <${+M + 1}.0.0-0`;
|
|
998
|
+
} else if (isX(p)) {
|
|
999
|
+
ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`;
|
|
1000
|
+
} else if (pr) {
|
|
1001
|
+
debug("replaceTilde pr", pr);
|
|
1002
|
+
ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
|
|
1003
|
+
} else {
|
|
1004
|
+
ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`;
|
|
1005
|
+
}
|
|
1006
|
+
debug("tilde return", ret);
|
|
1007
|
+
return ret;
|
|
1008
|
+
});
|
|
1009
|
+
};
|
|
1010
|
+
var replaceCarets = (comp, options) => {
|
|
1011
|
+
return comp.trim().split(/\s+/).map((c) => replaceCaret(c, options)).join(" ");
|
|
1012
|
+
};
|
|
1013
|
+
var replaceCaret = (comp, options) => {
|
|
1014
|
+
debug("caret", comp, options);
|
|
1015
|
+
const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET];
|
|
1016
|
+
const z2 = options.includePrerelease ? "-0" : "";
|
|
1017
|
+
return comp.replace(r, (_, M, m, p, pr) => {
|
|
1018
|
+
debug("caret", comp, _, M, m, p, pr);
|
|
1019
|
+
let ret;
|
|
1020
|
+
if (isX(M)) {
|
|
1021
|
+
ret = "";
|
|
1022
|
+
} else if (isX(m)) {
|
|
1023
|
+
ret = `>=${M}.0.0${z2} <${+M + 1}.0.0-0`;
|
|
1024
|
+
} else if (isX(p)) {
|
|
1025
|
+
if (M === "0") {
|
|
1026
|
+
ret = `>=${M}.${m}.0${z2} <${M}.${+m + 1}.0-0`;
|
|
1027
|
+
} else {
|
|
1028
|
+
ret = `>=${M}.${m}.0${z2} <${+M + 1}.0.0-0`;
|
|
1029
|
+
}
|
|
1030
|
+
} else if (pr) {
|
|
1031
|
+
debug("replaceCaret pr", pr);
|
|
1032
|
+
if (M === "0") {
|
|
1033
|
+
if (m === "0") {
|
|
1034
|
+
ret = `>=${M}.${m}.${p}-${pr} <${M}.${m}.${+p + 1}-0`;
|
|
1035
|
+
} else {
|
|
1036
|
+
ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
|
|
1037
|
+
}
|
|
1038
|
+
} else {
|
|
1039
|
+
ret = `>=${M}.${m}.${p}-${pr} <${+M + 1}.0.0-0`;
|
|
1040
|
+
}
|
|
1041
|
+
} else {
|
|
1042
|
+
debug("no pr");
|
|
1043
|
+
if (M === "0") {
|
|
1044
|
+
if (m === "0") {
|
|
1045
|
+
ret = `>=${M}.${m}.${p}${z2} <${M}.${m}.${+p + 1}-0`;
|
|
1046
|
+
} else {
|
|
1047
|
+
ret = `>=${M}.${m}.${p}${z2} <${M}.${+m + 1}.0-0`;
|
|
1048
|
+
}
|
|
1049
|
+
} else {
|
|
1050
|
+
ret = `>=${M}.${m}.${p} <${+M + 1}.0.0-0`;
|
|
1051
|
+
}
|
|
1052
|
+
}
|
|
1053
|
+
debug("caret return", ret);
|
|
1054
|
+
return ret;
|
|
1055
|
+
});
|
|
1056
|
+
};
|
|
1057
|
+
var replaceXRanges = (comp, options) => {
|
|
1058
|
+
debug("replaceXRanges", comp, options);
|
|
1059
|
+
return comp.split(/\s+/).map((c) => replaceXRange(c, options)).join(" ");
|
|
1060
|
+
};
|
|
1061
|
+
var replaceXRange = (comp, options) => {
|
|
1062
|
+
comp = comp.trim();
|
|
1063
|
+
const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE];
|
|
1064
|
+
return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
|
|
1065
|
+
debug("xRange", comp, ret, gtlt, M, m, p, pr);
|
|
1066
|
+
const xM = isX(M);
|
|
1067
|
+
const xm = xM || isX(m);
|
|
1068
|
+
const xp = xm || isX(p);
|
|
1069
|
+
const anyX = xp;
|
|
1070
|
+
if (gtlt === "=" && anyX) {
|
|
1071
|
+
gtlt = "";
|
|
1072
|
+
}
|
|
1073
|
+
pr = options.includePrerelease ? "-0" : "";
|
|
1074
|
+
if (xM) {
|
|
1075
|
+
if (gtlt === ">" || gtlt === "<") {
|
|
1076
|
+
ret = "<0.0.0-0";
|
|
1077
|
+
} else {
|
|
1078
|
+
ret = "*";
|
|
1079
|
+
}
|
|
1080
|
+
} else if (gtlt && anyX) {
|
|
1081
|
+
if (xm) {
|
|
1082
|
+
m = 0;
|
|
1083
|
+
}
|
|
1084
|
+
p = 0;
|
|
1085
|
+
if (gtlt === ">") {
|
|
1086
|
+
gtlt = ">=";
|
|
1087
|
+
if (xm) {
|
|
1088
|
+
M = +M + 1;
|
|
1089
|
+
m = 0;
|
|
1090
|
+
p = 0;
|
|
1091
|
+
} else {
|
|
1092
|
+
m = +m + 1;
|
|
1093
|
+
p = 0;
|
|
1094
|
+
}
|
|
1095
|
+
} else if (gtlt === "<=") {
|
|
1096
|
+
gtlt = "<";
|
|
1097
|
+
if (xm) {
|
|
1098
|
+
M = +M + 1;
|
|
1099
|
+
} else {
|
|
1100
|
+
m = +m + 1;
|
|
1101
|
+
}
|
|
1102
|
+
}
|
|
1103
|
+
if (gtlt === "<") {
|
|
1104
|
+
pr = "-0";
|
|
1105
|
+
}
|
|
1106
|
+
ret = `${gtlt + M}.${m}.${p}${pr}`;
|
|
1107
|
+
} else if (xm) {
|
|
1108
|
+
ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`;
|
|
1109
|
+
} else if (xp) {
|
|
1110
|
+
ret = `>=${M}.${m}.0${pr} <${M}.${+m + 1}.0-0`;
|
|
1111
|
+
}
|
|
1112
|
+
debug("xRange return", ret);
|
|
1113
|
+
return ret;
|
|
1114
|
+
});
|
|
1115
|
+
};
|
|
1116
|
+
var replaceStars = (comp, options) => {
|
|
1117
|
+
debug("replaceStars", comp, options);
|
|
1118
|
+
return comp.trim().replace(re[t.STAR], "");
|
|
1119
|
+
};
|
|
1120
|
+
var replaceGTE0 = (comp, options) => {
|
|
1121
|
+
debug("replaceGTE0", comp, options);
|
|
1122
|
+
return comp.trim().replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], "");
|
|
1123
|
+
};
|
|
1124
|
+
var hyphenReplace = (incPr) => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr) => {
|
|
1125
|
+
if (isX(fM)) {
|
|
1126
|
+
from = "";
|
|
1127
|
+
} else if (isX(fm)) {
|
|
1128
|
+
from = `>=${fM}.0.0${incPr ? "-0" : ""}`;
|
|
1129
|
+
} else if (isX(fp)) {
|
|
1130
|
+
from = `>=${fM}.${fm}.0${incPr ? "-0" : ""}`;
|
|
1131
|
+
} else if (fpr) {
|
|
1132
|
+
from = `>=${from}`;
|
|
1133
|
+
} else {
|
|
1134
|
+
from = `>=${from}${incPr ? "-0" : ""}`;
|
|
1135
|
+
}
|
|
1136
|
+
if (isX(tM)) {
|
|
1137
|
+
to = "";
|
|
1138
|
+
} else if (isX(tm)) {
|
|
1139
|
+
to = `<${+tM + 1}.0.0-0`;
|
|
1140
|
+
} else if (isX(tp)) {
|
|
1141
|
+
to = `<${tM}.${+tm + 1}.0-0`;
|
|
1142
|
+
} else if (tpr) {
|
|
1143
|
+
to = `<=${tM}.${tm}.${tp}-${tpr}`;
|
|
1144
|
+
} else if (incPr) {
|
|
1145
|
+
to = `<${tM}.${tm}.${+tp + 1}-0`;
|
|
1146
|
+
} else {
|
|
1147
|
+
to = `<=${to}`;
|
|
1148
|
+
}
|
|
1149
|
+
return `${from} ${to}`.trim();
|
|
1150
|
+
};
|
|
1151
|
+
var testSet = (set, version, options) => {
|
|
1152
|
+
for (let i = 0;i < set.length; i++) {
|
|
1153
|
+
if (!set[i].test(version)) {
|
|
1154
|
+
return false;
|
|
1155
|
+
}
|
|
1156
|
+
}
|
|
1157
|
+
if (version.prerelease.length && !options.includePrerelease) {
|
|
1158
|
+
for (let i = 0;i < set.length; i++) {
|
|
1159
|
+
debug(set[i].semver);
|
|
1160
|
+
if (set[i].semver === Comparator.ANY) {
|
|
1161
|
+
continue;
|
|
1162
|
+
}
|
|
1163
|
+
if (set[i].semver.prerelease.length > 0) {
|
|
1164
|
+
const allowed = set[i].semver;
|
|
1165
|
+
if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) {
|
|
1166
|
+
return true;
|
|
1167
|
+
}
|
|
1168
|
+
}
|
|
1169
|
+
}
|
|
1170
|
+
return false;
|
|
1171
|
+
}
|
|
1172
|
+
return true;
|
|
1173
|
+
};
|
|
1174
|
+
});
|
|
1175
|
+
|
|
1176
|
+
// ../node_modules/.bun/semver@7.7.4/node_modules/semver/classes/comparator.js
|
|
1177
|
+
var require_comparator = __commonJS((exports, module) => {
|
|
1178
|
+
var ANY = Symbol("SemVer ANY");
|
|
1179
|
+
|
|
1180
|
+
class Comparator {
|
|
1181
|
+
static get ANY() {
|
|
1182
|
+
return ANY;
|
|
1183
|
+
}
|
|
1184
|
+
constructor(comp, options) {
|
|
1185
|
+
options = parseOptions(options);
|
|
1186
|
+
if (comp instanceof Comparator) {
|
|
1187
|
+
if (comp.loose === !!options.loose) {
|
|
1188
|
+
return comp;
|
|
1189
|
+
} else {
|
|
1190
|
+
comp = comp.value;
|
|
1191
|
+
}
|
|
1192
|
+
}
|
|
1193
|
+
comp = comp.trim().split(/\s+/).join(" ");
|
|
1194
|
+
debug("comparator", comp, options);
|
|
1195
|
+
this.options = options;
|
|
1196
|
+
this.loose = !!options.loose;
|
|
1197
|
+
this.parse(comp);
|
|
1198
|
+
if (this.semver === ANY) {
|
|
1199
|
+
this.value = "";
|
|
1200
|
+
} else {
|
|
1201
|
+
this.value = this.operator + this.semver.version;
|
|
1202
|
+
}
|
|
1203
|
+
debug("comp", this);
|
|
1204
|
+
}
|
|
1205
|
+
parse(comp) {
|
|
1206
|
+
const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR];
|
|
1207
|
+
const m = comp.match(r);
|
|
1208
|
+
if (!m) {
|
|
1209
|
+
throw new TypeError(`Invalid comparator: ${comp}`);
|
|
1210
|
+
}
|
|
1211
|
+
this.operator = m[1] !== undefined ? m[1] : "";
|
|
1212
|
+
if (this.operator === "=") {
|
|
1213
|
+
this.operator = "";
|
|
1214
|
+
}
|
|
1215
|
+
if (!m[2]) {
|
|
1216
|
+
this.semver = ANY;
|
|
1217
|
+
} else {
|
|
1218
|
+
this.semver = new SemVer(m[2], this.options.loose);
|
|
1219
|
+
}
|
|
1220
|
+
}
|
|
1221
|
+
toString() {
|
|
1222
|
+
return this.value;
|
|
1223
|
+
}
|
|
1224
|
+
test(version) {
|
|
1225
|
+
debug("Comparator.test", version, this.options.loose);
|
|
1226
|
+
if (this.semver === ANY || version === ANY) {
|
|
1227
|
+
return true;
|
|
1228
|
+
}
|
|
1229
|
+
if (typeof version === "string") {
|
|
1230
|
+
try {
|
|
1231
|
+
version = new SemVer(version, this.options);
|
|
1232
|
+
} catch (er) {
|
|
1233
|
+
return false;
|
|
1234
|
+
}
|
|
1235
|
+
}
|
|
1236
|
+
return cmp(version, this.operator, this.semver, this.options);
|
|
1237
|
+
}
|
|
1238
|
+
intersects(comp, options) {
|
|
1239
|
+
if (!(comp instanceof Comparator)) {
|
|
1240
|
+
throw new TypeError("a Comparator is required");
|
|
1241
|
+
}
|
|
1242
|
+
if (this.operator === "") {
|
|
1243
|
+
if (this.value === "") {
|
|
1244
|
+
return true;
|
|
1245
|
+
}
|
|
1246
|
+
return new Range(comp.value, options).test(this.value);
|
|
1247
|
+
} else if (comp.operator === "") {
|
|
1248
|
+
if (comp.value === "") {
|
|
1249
|
+
return true;
|
|
1250
|
+
}
|
|
1251
|
+
return new Range(this.value, options).test(comp.semver);
|
|
1252
|
+
}
|
|
1253
|
+
options = parseOptions(options);
|
|
1254
|
+
if (options.includePrerelease && (this.value === "<0.0.0-0" || comp.value === "<0.0.0-0")) {
|
|
1255
|
+
return false;
|
|
1256
|
+
}
|
|
1257
|
+
if (!options.includePrerelease && (this.value.startsWith("<0.0.0") || comp.value.startsWith("<0.0.0"))) {
|
|
1258
|
+
return false;
|
|
1259
|
+
}
|
|
1260
|
+
if (this.operator.startsWith(">") && comp.operator.startsWith(">")) {
|
|
1261
|
+
return true;
|
|
1262
|
+
}
|
|
1263
|
+
if (this.operator.startsWith("<") && comp.operator.startsWith("<")) {
|
|
1264
|
+
return true;
|
|
1265
|
+
}
|
|
1266
|
+
if (this.semver.version === comp.semver.version && this.operator.includes("=") && comp.operator.includes("=")) {
|
|
1267
|
+
return true;
|
|
1268
|
+
}
|
|
1269
|
+
if (cmp(this.semver, "<", comp.semver, options) && this.operator.startsWith(">") && comp.operator.startsWith("<")) {
|
|
1270
|
+
return true;
|
|
1271
|
+
}
|
|
1272
|
+
if (cmp(this.semver, ">", comp.semver, options) && this.operator.startsWith("<") && comp.operator.startsWith(">")) {
|
|
1273
|
+
return true;
|
|
1274
|
+
}
|
|
1275
|
+
return false;
|
|
1276
|
+
}
|
|
1277
|
+
}
|
|
1278
|
+
module.exports = Comparator;
|
|
1279
|
+
var parseOptions = require_parse_options();
|
|
1280
|
+
var { safeRe: re, t } = require_re();
|
|
1281
|
+
var cmp = require_cmp();
|
|
1282
|
+
var debug = require_debug();
|
|
1283
|
+
var SemVer = require_semver();
|
|
1284
|
+
var Range = require_range();
|
|
1285
|
+
});
|
|
1286
|
+
|
|
1287
|
+
// ../node_modules/.bun/semver@7.7.4/node_modules/semver/functions/satisfies.js
|
|
1288
|
+
var require_satisfies = __commonJS((exports, module) => {
|
|
1289
|
+
var Range = require_range();
|
|
1290
|
+
var satisfies = (version, range, options) => {
|
|
1291
|
+
try {
|
|
1292
|
+
range = new Range(range, options);
|
|
1293
|
+
} catch (er) {
|
|
1294
|
+
return false;
|
|
1295
|
+
}
|
|
1296
|
+
return range.test(version);
|
|
1297
|
+
};
|
|
1298
|
+
module.exports = satisfies;
|
|
1299
|
+
});
|
|
1300
|
+
|
|
1301
|
+
// ../node_modules/.bun/semver@7.7.4/node_modules/semver/ranges/to-comparators.js
|
|
1302
|
+
var require_to_comparators = __commonJS((exports, module) => {
|
|
1303
|
+
var Range = require_range();
|
|
1304
|
+
var toComparators = (range, options) => new Range(range, options).set.map((comp) => comp.map((c) => c.value).join(" ").trim().split(" "));
|
|
1305
|
+
module.exports = toComparators;
|
|
1306
|
+
});
|
|
1307
|
+
|
|
1308
|
+
// ../node_modules/.bun/semver@7.7.4/node_modules/semver/ranges/max-satisfying.js
|
|
1309
|
+
var require_max_satisfying = __commonJS((exports, module) => {
|
|
1310
|
+
var SemVer = require_semver();
|
|
1311
|
+
var Range = require_range();
|
|
1312
|
+
var maxSatisfying = (versions, range, options) => {
|
|
1313
|
+
let max = null;
|
|
1314
|
+
let maxSV = null;
|
|
1315
|
+
let rangeObj = null;
|
|
1316
|
+
try {
|
|
1317
|
+
rangeObj = new Range(range, options);
|
|
1318
|
+
} catch (er) {
|
|
1319
|
+
return null;
|
|
1320
|
+
}
|
|
1321
|
+
versions.forEach((v) => {
|
|
1322
|
+
if (rangeObj.test(v)) {
|
|
1323
|
+
if (!max || maxSV.compare(v) === -1) {
|
|
1324
|
+
max = v;
|
|
1325
|
+
maxSV = new SemVer(max, options);
|
|
1326
|
+
}
|
|
1327
|
+
}
|
|
1328
|
+
});
|
|
1329
|
+
return max;
|
|
1330
|
+
};
|
|
1331
|
+
module.exports = maxSatisfying;
|
|
1332
|
+
});
|
|
1333
|
+
|
|
1334
|
+
// ../node_modules/.bun/semver@7.7.4/node_modules/semver/ranges/min-satisfying.js
|
|
1335
|
+
var require_min_satisfying = __commonJS((exports, module) => {
|
|
1336
|
+
var SemVer = require_semver();
|
|
1337
|
+
var Range = require_range();
|
|
1338
|
+
var minSatisfying = (versions, range, options) => {
|
|
1339
|
+
let min = null;
|
|
1340
|
+
let minSV = null;
|
|
1341
|
+
let rangeObj = null;
|
|
1342
|
+
try {
|
|
1343
|
+
rangeObj = new Range(range, options);
|
|
1344
|
+
} catch (er) {
|
|
1345
|
+
return null;
|
|
1346
|
+
}
|
|
1347
|
+
versions.forEach((v) => {
|
|
1348
|
+
if (rangeObj.test(v)) {
|
|
1349
|
+
if (!min || minSV.compare(v) === 1) {
|
|
1350
|
+
min = v;
|
|
1351
|
+
minSV = new SemVer(min, options);
|
|
1352
|
+
}
|
|
1353
|
+
}
|
|
1354
|
+
});
|
|
1355
|
+
return min;
|
|
1356
|
+
};
|
|
1357
|
+
module.exports = minSatisfying;
|
|
1358
|
+
});
|
|
1359
|
+
|
|
1360
|
+
// ../node_modules/.bun/semver@7.7.4/node_modules/semver/ranges/min-version.js
|
|
1361
|
+
var require_min_version = __commonJS((exports, module) => {
|
|
1362
|
+
var SemVer = require_semver();
|
|
1363
|
+
var Range = require_range();
|
|
1364
|
+
var gt = require_gt();
|
|
1365
|
+
var minVersion = (range, loose) => {
|
|
1366
|
+
range = new Range(range, loose);
|
|
1367
|
+
let minver = new SemVer("0.0.0");
|
|
1368
|
+
if (range.test(minver)) {
|
|
1369
|
+
return minver;
|
|
1370
|
+
}
|
|
1371
|
+
minver = new SemVer("0.0.0-0");
|
|
1372
|
+
if (range.test(minver)) {
|
|
1373
|
+
return minver;
|
|
1374
|
+
}
|
|
1375
|
+
minver = null;
|
|
1376
|
+
for (let i = 0;i < range.set.length; ++i) {
|
|
1377
|
+
const comparators = range.set[i];
|
|
1378
|
+
let setMin = null;
|
|
1379
|
+
comparators.forEach((comparator) => {
|
|
1380
|
+
const compver = new SemVer(comparator.semver.version);
|
|
1381
|
+
switch (comparator.operator) {
|
|
1382
|
+
case ">":
|
|
1383
|
+
if (compver.prerelease.length === 0) {
|
|
1384
|
+
compver.patch++;
|
|
1385
|
+
} else {
|
|
1386
|
+
compver.prerelease.push(0);
|
|
1387
|
+
}
|
|
1388
|
+
compver.raw = compver.format();
|
|
1389
|
+
case "":
|
|
1390
|
+
case ">=":
|
|
1391
|
+
if (!setMin || gt(compver, setMin)) {
|
|
1392
|
+
setMin = compver;
|
|
1393
|
+
}
|
|
1394
|
+
break;
|
|
1395
|
+
case "<":
|
|
1396
|
+
case "<=":
|
|
1397
|
+
break;
|
|
1398
|
+
default:
|
|
1399
|
+
throw new Error(`Unexpected operation: ${comparator.operator}`);
|
|
1400
|
+
}
|
|
1401
|
+
});
|
|
1402
|
+
if (setMin && (!minver || gt(minver, setMin))) {
|
|
1403
|
+
minver = setMin;
|
|
1404
|
+
}
|
|
1405
|
+
}
|
|
1406
|
+
if (minver && range.test(minver)) {
|
|
1407
|
+
return minver;
|
|
1408
|
+
}
|
|
1409
|
+
return null;
|
|
1410
|
+
};
|
|
1411
|
+
module.exports = minVersion;
|
|
1412
|
+
});
|
|
1413
|
+
|
|
1414
|
+
// ../node_modules/.bun/semver@7.7.4/node_modules/semver/ranges/valid.js
|
|
1415
|
+
var require_valid2 = __commonJS((exports, module) => {
|
|
1416
|
+
var Range = require_range();
|
|
1417
|
+
var validRange = (range, options) => {
|
|
1418
|
+
try {
|
|
1419
|
+
return new Range(range, options).range || "*";
|
|
1420
|
+
} catch (er) {
|
|
1421
|
+
return null;
|
|
1422
|
+
}
|
|
1423
|
+
};
|
|
1424
|
+
module.exports = validRange;
|
|
1425
|
+
});
|
|
1426
|
+
|
|
1427
|
+
// ../node_modules/.bun/semver@7.7.4/node_modules/semver/ranges/outside.js
|
|
1428
|
+
var require_outside = __commonJS((exports, module) => {
|
|
1429
|
+
var SemVer = require_semver();
|
|
1430
|
+
var Comparator = require_comparator();
|
|
1431
|
+
var { ANY } = Comparator;
|
|
1432
|
+
var Range = require_range();
|
|
1433
|
+
var satisfies = require_satisfies();
|
|
1434
|
+
var gt = require_gt();
|
|
1435
|
+
var lt = require_lt();
|
|
1436
|
+
var lte = require_lte();
|
|
1437
|
+
var gte = require_gte();
|
|
1438
|
+
var outside = (version, range, hilo, options) => {
|
|
1439
|
+
version = new SemVer(version, options);
|
|
1440
|
+
range = new Range(range, options);
|
|
1441
|
+
let gtfn, ltefn, ltfn, comp, ecomp;
|
|
1442
|
+
switch (hilo) {
|
|
1443
|
+
case ">":
|
|
1444
|
+
gtfn = gt;
|
|
1445
|
+
ltefn = lte;
|
|
1446
|
+
ltfn = lt;
|
|
1447
|
+
comp = ">";
|
|
1448
|
+
ecomp = ">=";
|
|
1449
|
+
break;
|
|
1450
|
+
case "<":
|
|
1451
|
+
gtfn = lt;
|
|
1452
|
+
ltefn = gte;
|
|
1453
|
+
ltfn = gt;
|
|
1454
|
+
comp = "<";
|
|
1455
|
+
ecomp = "<=";
|
|
1456
|
+
break;
|
|
1457
|
+
default:
|
|
1458
|
+
throw new TypeError('Must provide a hilo val of "<" or ">"');
|
|
1459
|
+
}
|
|
1460
|
+
if (satisfies(version, range, options)) {
|
|
1461
|
+
return false;
|
|
1462
|
+
}
|
|
1463
|
+
for (let i = 0;i < range.set.length; ++i) {
|
|
1464
|
+
const comparators = range.set[i];
|
|
1465
|
+
let high = null;
|
|
1466
|
+
let low = null;
|
|
1467
|
+
comparators.forEach((comparator) => {
|
|
1468
|
+
if (comparator.semver === ANY) {
|
|
1469
|
+
comparator = new Comparator(">=0.0.0");
|
|
1470
|
+
}
|
|
1471
|
+
high = high || comparator;
|
|
1472
|
+
low = low || comparator;
|
|
1473
|
+
if (gtfn(comparator.semver, high.semver, options)) {
|
|
1474
|
+
high = comparator;
|
|
1475
|
+
} else if (ltfn(comparator.semver, low.semver, options)) {
|
|
1476
|
+
low = comparator;
|
|
1477
|
+
}
|
|
1478
|
+
});
|
|
1479
|
+
if (high.operator === comp || high.operator === ecomp) {
|
|
1480
|
+
return false;
|
|
1481
|
+
}
|
|
1482
|
+
if ((!low.operator || low.operator === comp) && ltefn(version, low.semver)) {
|
|
1483
|
+
return false;
|
|
1484
|
+
} else if (low.operator === ecomp && ltfn(version, low.semver)) {
|
|
1485
|
+
return false;
|
|
1486
|
+
}
|
|
1487
|
+
}
|
|
1488
|
+
return true;
|
|
1489
|
+
};
|
|
1490
|
+
module.exports = outside;
|
|
1491
|
+
});
|
|
1492
|
+
|
|
1493
|
+
// ../node_modules/.bun/semver@7.7.4/node_modules/semver/ranges/gtr.js
|
|
1494
|
+
var require_gtr = __commonJS((exports, module) => {
|
|
1495
|
+
var outside = require_outside();
|
|
1496
|
+
var gtr = (version, range, options) => outside(version, range, ">", options);
|
|
1497
|
+
module.exports = gtr;
|
|
1498
|
+
});
|
|
1499
|
+
|
|
1500
|
+
// ../node_modules/.bun/semver@7.7.4/node_modules/semver/ranges/ltr.js
|
|
1501
|
+
var require_ltr = __commonJS((exports, module) => {
|
|
1502
|
+
var outside = require_outside();
|
|
1503
|
+
var ltr = (version, range, options) => outside(version, range, "<", options);
|
|
1504
|
+
module.exports = ltr;
|
|
1505
|
+
});
|
|
1506
|
+
|
|
1507
|
+
// ../node_modules/.bun/semver@7.7.4/node_modules/semver/ranges/intersects.js
|
|
1508
|
+
var require_intersects = __commonJS((exports, module) => {
|
|
1509
|
+
var Range = require_range();
|
|
1510
|
+
var intersects = (r1, r2, options) => {
|
|
1511
|
+
r1 = new Range(r1, options);
|
|
1512
|
+
r2 = new Range(r2, options);
|
|
1513
|
+
return r1.intersects(r2, options);
|
|
1514
|
+
};
|
|
1515
|
+
module.exports = intersects;
|
|
1516
|
+
});
|
|
1517
|
+
|
|
1518
|
+
// ../node_modules/.bun/semver@7.7.4/node_modules/semver/ranges/simplify.js
|
|
1519
|
+
var require_simplify = __commonJS((exports, module) => {
|
|
1520
|
+
var satisfies = require_satisfies();
|
|
1521
|
+
var compare = require_compare();
|
|
1522
|
+
module.exports = (versions, range, options) => {
|
|
1523
|
+
const set = [];
|
|
1524
|
+
let first = null;
|
|
1525
|
+
let prev = null;
|
|
1526
|
+
const v = versions.sort((a, b) => compare(a, b, options));
|
|
1527
|
+
for (const version of v) {
|
|
1528
|
+
const included = satisfies(version, range, options);
|
|
1529
|
+
if (included) {
|
|
1530
|
+
prev = version;
|
|
1531
|
+
if (!first) {
|
|
1532
|
+
first = version;
|
|
1533
|
+
}
|
|
1534
|
+
} else {
|
|
1535
|
+
if (prev) {
|
|
1536
|
+
set.push([first, prev]);
|
|
1537
|
+
}
|
|
1538
|
+
prev = null;
|
|
1539
|
+
first = null;
|
|
1540
|
+
}
|
|
1541
|
+
}
|
|
1542
|
+
if (first) {
|
|
1543
|
+
set.push([first, null]);
|
|
1544
|
+
}
|
|
1545
|
+
const ranges = [];
|
|
1546
|
+
for (const [min, max] of set) {
|
|
1547
|
+
if (min === max) {
|
|
1548
|
+
ranges.push(min);
|
|
1549
|
+
} else if (!max && min === v[0]) {
|
|
1550
|
+
ranges.push("*");
|
|
1551
|
+
} else if (!max) {
|
|
1552
|
+
ranges.push(`>=${min}`);
|
|
1553
|
+
} else if (min === v[0]) {
|
|
1554
|
+
ranges.push(`<=${max}`);
|
|
1555
|
+
} else {
|
|
1556
|
+
ranges.push(`${min} - ${max}`);
|
|
1557
|
+
}
|
|
1558
|
+
}
|
|
1559
|
+
const simplified = ranges.join(" || ");
|
|
1560
|
+
const original = typeof range.raw === "string" ? range.raw : String(range);
|
|
1561
|
+
return simplified.length < original.length ? simplified : range;
|
|
1562
|
+
};
|
|
1563
|
+
});
|
|
1564
|
+
|
|
1565
|
+
// ../node_modules/.bun/semver@7.7.4/node_modules/semver/ranges/subset.js
|
|
1566
|
+
var require_subset = __commonJS((exports, module) => {
|
|
1567
|
+
var Range = require_range();
|
|
1568
|
+
var Comparator = require_comparator();
|
|
1569
|
+
var { ANY } = Comparator;
|
|
1570
|
+
var satisfies = require_satisfies();
|
|
1571
|
+
var compare = require_compare();
|
|
1572
|
+
var subset = (sub, dom, options = {}) => {
|
|
1573
|
+
if (sub === dom) {
|
|
1574
|
+
return true;
|
|
1575
|
+
}
|
|
1576
|
+
sub = new Range(sub, options);
|
|
1577
|
+
dom = new Range(dom, options);
|
|
1578
|
+
let sawNonNull = false;
|
|
1579
|
+
OUTER:
|
|
1580
|
+
for (const simpleSub of sub.set) {
|
|
1581
|
+
for (const simpleDom of dom.set) {
|
|
1582
|
+
const isSub = simpleSubset(simpleSub, simpleDom, options);
|
|
1583
|
+
sawNonNull = sawNonNull || isSub !== null;
|
|
1584
|
+
if (isSub) {
|
|
1585
|
+
continue OUTER;
|
|
1586
|
+
}
|
|
1587
|
+
}
|
|
1588
|
+
if (sawNonNull) {
|
|
1589
|
+
return false;
|
|
1590
|
+
}
|
|
1591
|
+
}
|
|
1592
|
+
return true;
|
|
1593
|
+
};
|
|
1594
|
+
var minimumVersionWithPreRelease = [new Comparator(">=0.0.0-0")];
|
|
1595
|
+
var minimumVersion = [new Comparator(">=0.0.0")];
|
|
1596
|
+
var simpleSubset = (sub, dom, options) => {
|
|
1597
|
+
if (sub === dom) {
|
|
1598
|
+
return true;
|
|
1599
|
+
}
|
|
1600
|
+
if (sub.length === 1 && sub[0].semver === ANY) {
|
|
1601
|
+
if (dom.length === 1 && dom[0].semver === ANY) {
|
|
1602
|
+
return true;
|
|
1603
|
+
} else if (options.includePrerelease) {
|
|
1604
|
+
sub = minimumVersionWithPreRelease;
|
|
1605
|
+
} else {
|
|
1606
|
+
sub = minimumVersion;
|
|
1607
|
+
}
|
|
1608
|
+
}
|
|
1609
|
+
if (dom.length === 1 && dom[0].semver === ANY) {
|
|
1610
|
+
if (options.includePrerelease) {
|
|
1611
|
+
return true;
|
|
1612
|
+
} else {
|
|
1613
|
+
dom = minimumVersion;
|
|
1614
|
+
}
|
|
1615
|
+
}
|
|
1616
|
+
const eqSet = new Set;
|
|
1617
|
+
let gt, lt;
|
|
1618
|
+
for (const c of sub) {
|
|
1619
|
+
if (c.operator === ">" || c.operator === ">=") {
|
|
1620
|
+
gt = higherGT(gt, c, options);
|
|
1621
|
+
} else if (c.operator === "<" || c.operator === "<=") {
|
|
1622
|
+
lt = lowerLT(lt, c, options);
|
|
1623
|
+
} else {
|
|
1624
|
+
eqSet.add(c.semver);
|
|
1625
|
+
}
|
|
1626
|
+
}
|
|
1627
|
+
if (eqSet.size > 1) {
|
|
1628
|
+
return null;
|
|
1629
|
+
}
|
|
1630
|
+
let gtltComp;
|
|
1631
|
+
if (gt && lt) {
|
|
1632
|
+
gtltComp = compare(gt.semver, lt.semver, options);
|
|
1633
|
+
if (gtltComp > 0) {
|
|
1634
|
+
return null;
|
|
1635
|
+
} else if (gtltComp === 0 && (gt.operator !== ">=" || lt.operator !== "<=")) {
|
|
1636
|
+
return null;
|
|
1637
|
+
}
|
|
1638
|
+
}
|
|
1639
|
+
for (const eq of eqSet) {
|
|
1640
|
+
if (gt && !satisfies(eq, String(gt), options)) {
|
|
1641
|
+
return null;
|
|
1642
|
+
}
|
|
1643
|
+
if (lt && !satisfies(eq, String(lt), options)) {
|
|
1644
|
+
return null;
|
|
1645
|
+
}
|
|
1646
|
+
for (const c of dom) {
|
|
1647
|
+
if (!satisfies(eq, String(c), options)) {
|
|
1648
|
+
return false;
|
|
1649
|
+
}
|
|
1650
|
+
}
|
|
1651
|
+
return true;
|
|
1652
|
+
}
|
|
1653
|
+
let higher, lower;
|
|
1654
|
+
let hasDomLT, hasDomGT;
|
|
1655
|
+
let needDomLTPre = lt && !options.includePrerelease && lt.semver.prerelease.length ? lt.semver : false;
|
|
1656
|
+
let needDomGTPre = gt && !options.includePrerelease && gt.semver.prerelease.length ? gt.semver : false;
|
|
1657
|
+
if (needDomLTPre && needDomLTPre.prerelease.length === 1 && lt.operator === "<" && needDomLTPre.prerelease[0] === 0) {
|
|
1658
|
+
needDomLTPre = false;
|
|
1659
|
+
}
|
|
1660
|
+
for (const c of dom) {
|
|
1661
|
+
hasDomGT = hasDomGT || c.operator === ">" || c.operator === ">=";
|
|
1662
|
+
hasDomLT = hasDomLT || c.operator === "<" || c.operator === "<=";
|
|
1663
|
+
if (gt) {
|
|
1664
|
+
if (needDomGTPre) {
|
|
1665
|
+
if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomGTPre.major && c.semver.minor === needDomGTPre.minor && c.semver.patch === needDomGTPre.patch) {
|
|
1666
|
+
needDomGTPre = false;
|
|
1667
|
+
}
|
|
1668
|
+
}
|
|
1669
|
+
if (c.operator === ">" || c.operator === ">=") {
|
|
1670
|
+
higher = higherGT(gt, c, options);
|
|
1671
|
+
if (higher === c && higher !== gt) {
|
|
1672
|
+
return false;
|
|
1673
|
+
}
|
|
1674
|
+
} else if (gt.operator === ">=" && !satisfies(gt.semver, String(c), options)) {
|
|
1675
|
+
return false;
|
|
1676
|
+
}
|
|
1677
|
+
}
|
|
1678
|
+
if (lt) {
|
|
1679
|
+
if (needDomLTPre) {
|
|
1680
|
+
if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomLTPre.major && c.semver.minor === needDomLTPre.minor && c.semver.patch === needDomLTPre.patch) {
|
|
1681
|
+
needDomLTPre = false;
|
|
1682
|
+
}
|
|
1683
|
+
}
|
|
1684
|
+
if (c.operator === "<" || c.operator === "<=") {
|
|
1685
|
+
lower = lowerLT(lt, c, options);
|
|
1686
|
+
if (lower === c && lower !== lt) {
|
|
1687
|
+
return false;
|
|
1688
|
+
}
|
|
1689
|
+
} else if (lt.operator === "<=" && !satisfies(lt.semver, String(c), options)) {
|
|
1690
|
+
return false;
|
|
1691
|
+
}
|
|
1692
|
+
}
|
|
1693
|
+
if (!c.operator && (lt || gt) && gtltComp !== 0) {
|
|
1694
|
+
return false;
|
|
1695
|
+
}
|
|
1696
|
+
}
|
|
1697
|
+
if (gt && hasDomLT && !lt && gtltComp !== 0) {
|
|
1698
|
+
return false;
|
|
1699
|
+
}
|
|
1700
|
+
if (lt && hasDomGT && !gt && gtltComp !== 0) {
|
|
1701
|
+
return false;
|
|
1702
|
+
}
|
|
1703
|
+
if (needDomGTPre || needDomLTPre) {
|
|
1704
|
+
return false;
|
|
1705
|
+
}
|
|
1706
|
+
return true;
|
|
1707
|
+
};
|
|
1708
|
+
var higherGT = (a, b, options) => {
|
|
1709
|
+
if (!a) {
|
|
1710
|
+
return b;
|
|
1711
|
+
}
|
|
1712
|
+
const comp = compare(a.semver, b.semver, options);
|
|
1713
|
+
return comp > 0 ? a : comp < 0 ? b : b.operator === ">" && a.operator === ">=" ? b : a;
|
|
1714
|
+
};
|
|
1715
|
+
var lowerLT = (a, b, options) => {
|
|
1716
|
+
if (!a) {
|
|
1717
|
+
return b;
|
|
1718
|
+
}
|
|
1719
|
+
const comp = compare(a.semver, b.semver, options);
|
|
1720
|
+
return comp < 0 ? a : comp > 0 ? b : b.operator === "<" && a.operator === "<=" ? b : a;
|
|
1721
|
+
};
|
|
1722
|
+
module.exports = subset;
|
|
1723
|
+
});
|
|
1724
|
+
|
|
1725
|
+
// ../node_modules/.bun/semver@7.7.4/node_modules/semver/index.js
|
|
1726
|
+
var require_semver2 = __commonJS((exports, module) => {
|
|
1727
|
+
var internalRe = require_re();
|
|
1728
|
+
var constants = require_constants();
|
|
1729
|
+
var SemVer = require_semver();
|
|
1730
|
+
var identifiers = require_identifiers();
|
|
1731
|
+
var parse2 = require_parse();
|
|
1732
|
+
var valid = require_valid();
|
|
1733
|
+
var clean = require_clean();
|
|
1734
|
+
var inc = require_inc();
|
|
1735
|
+
var diff = require_diff();
|
|
1736
|
+
var major = require_major();
|
|
1737
|
+
var minor = require_minor();
|
|
1738
|
+
var patch = require_patch();
|
|
1739
|
+
var prerelease = require_prerelease();
|
|
1740
|
+
var compare = require_compare();
|
|
1741
|
+
var rcompare = require_rcompare();
|
|
1742
|
+
var compareLoose = require_compare_loose();
|
|
1743
|
+
var compareBuild = require_compare_build();
|
|
1744
|
+
var sort = require_sort();
|
|
1745
|
+
var rsort = require_rsort();
|
|
1746
|
+
var gt = require_gt();
|
|
1747
|
+
var lt = require_lt();
|
|
1748
|
+
var eq = require_eq();
|
|
1749
|
+
var neq = require_neq();
|
|
1750
|
+
var gte = require_gte();
|
|
1751
|
+
var lte = require_lte();
|
|
1752
|
+
var cmp = require_cmp();
|
|
1753
|
+
var coerce = require_coerce();
|
|
1754
|
+
var Comparator = require_comparator();
|
|
1755
|
+
var Range = require_range();
|
|
1756
|
+
var satisfies = require_satisfies();
|
|
1757
|
+
var toComparators = require_to_comparators();
|
|
1758
|
+
var maxSatisfying = require_max_satisfying();
|
|
1759
|
+
var minSatisfying = require_min_satisfying();
|
|
1760
|
+
var minVersion = require_min_version();
|
|
1761
|
+
var validRange = require_valid2();
|
|
1762
|
+
var outside = require_outside();
|
|
1763
|
+
var gtr = require_gtr();
|
|
1764
|
+
var ltr = require_ltr();
|
|
1765
|
+
var intersects = require_intersects();
|
|
1766
|
+
var simplifyRange = require_simplify();
|
|
1767
|
+
var subset = require_subset();
|
|
1768
|
+
module.exports = {
|
|
1769
|
+
parse: parse2,
|
|
1770
|
+
valid,
|
|
1771
|
+
clean,
|
|
1772
|
+
inc,
|
|
1773
|
+
diff,
|
|
1774
|
+
major,
|
|
1775
|
+
minor,
|
|
1776
|
+
patch,
|
|
1777
|
+
prerelease,
|
|
1778
|
+
compare,
|
|
1779
|
+
rcompare,
|
|
1780
|
+
compareLoose,
|
|
1781
|
+
compareBuild,
|
|
1782
|
+
sort,
|
|
1783
|
+
rsort,
|
|
1784
|
+
gt,
|
|
1785
|
+
lt,
|
|
1786
|
+
eq,
|
|
1787
|
+
neq,
|
|
1788
|
+
gte,
|
|
1789
|
+
lte,
|
|
1790
|
+
cmp,
|
|
1791
|
+
coerce,
|
|
1792
|
+
Comparator,
|
|
1793
|
+
Range,
|
|
1794
|
+
satisfies,
|
|
1795
|
+
toComparators,
|
|
1796
|
+
maxSatisfying,
|
|
1797
|
+
minSatisfying,
|
|
1798
|
+
minVersion,
|
|
1799
|
+
validRange,
|
|
1800
|
+
outside,
|
|
1801
|
+
gtr,
|
|
1802
|
+
ltr,
|
|
1803
|
+
intersects,
|
|
1804
|
+
simplifyRange,
|
|
1805
|
+
subset,
|
|
1806
|
+
SemVer,
|
|
1807
|
+
re: internalRe.re,
|
|
1808
|
+
src: internalRe.src,
|
|
1809
|
+
tokens: internalRe.t,
|
|
1810
|
+
SEMVER_SPEC_VERSION: constants.SEMVER_SPEC_VERSION,
|
|
1811
|
+
RELEASE_TYPES: constants.RELEASE_TYPES,
|
|
1812
|
+
compareIdentifiers: identifiers.compareIdentifiers,
|
|
1813
|
+
rcompareIdentifiers: identifiers.rcompareIdentifiers
|
|
1814
|
+
};
|
|
1815
|
+
});
|
|
2
1816
|
|
|
3
1817
|
// src/index.ts
|
|
4
1818
|
import * as fs4 from "node:fs";
|
|
@@ -4114,6 +5928,9 @@ EXAMPLE:
|
|
|
4114
5928
|
NOTES:
|
|
4115
5929
|
- The JSON is a positional argument (not a --json flag)
|
|
4116
5930
|
- Every element and flow needs a unique UUID
|
|
5931
|
+
- Field and subfield UUIDs are generated when omitted
|
|
5932
|
+
- Field flags such as isGenerated, isList, isOptional, and isUserInput are not
|
|
5933
|
+
applied by create slice; add or update them after creation
|
|
4117
5934
|
- Valid flow pairs: screen->command, command->event, command->external-event,
|
|
4118
5935
|
event->readmodel, readmodel->screen, readmodel->processor, processor->command,
|
|
4119
5936
|
external-event->processor
|
|
@@ -4322,10 +6139,10 @@ WHEN TO USE: You need to specify slice behavior as Given-When-Then test cases.
|
|
|
4322
6139
|
## Task: Add a full scenario to a slice (compound command)
|
|
4323
6140
|
|
|
4324
6141
|
COMMAND:
|
|
4325
|
-
eventmodeler
|
|
6142
|
+
eventmodeler create scenario '<json>' --slice <sliceName>
|
|
4326
6143
|
|
|
4327
6144
|
EXAMPLE (happy path — state-change slice):
|
|
4328
|
-
eventmodeler
|
|
6145
|
+
eventmodeler create scenario '{
|
|
4329
6146
|
"name": "Successfully place order",
|
|
4330
6147
|
"given": [
|
|
4331
6148
|
{"entryType": "event", "elementName": "CustomerRegistered", "fieldValues": {"customerId": "cust-001"}}
|
|
@@ -4339,7 +6156,7 @@ EXAMPLE (happy path — state-change slice):
|
|
|
4339
6156
|
}' --slice "Place Order"
|
|
4340
6157
|
|
|
4341
6158
|
EXAMPLE (error case):
|
|
4342
|
-
eventmodeler
|
|
6159
|
+
eventmodeler create scenario '{
|
|
4343
6160
|
"name": "Reject order with no items",
|
|
4344
6161
|
"when": [
|
|
4345
6162
|
{"entryType": "command", "elementName": "PlaceOrder", "fieldValues": {"customerId": "cust-001"}}
|
|
@@ -4350,7 +6167,7 @@ EXAMPLE (error case):
|
|
|
4350
6167
|
}' --slice "Place Order"
|
|
4351
6168
|
|
|
4352
6169
|
EXAMPLE (readmodel assertion in then):
|
|
4353
|
-
eventmodeler
|
|
6170
|
+
eventmodeler create scenario '{
|
|
4354
6171
|
"name": "Order appears in summary",
|
|
4355
6172
|
"given": [
|
|
4356
6173
|
{"entryType": "event", "elementName": "OrderPlaced", "fieldValues": {"orderId": "ord-001", "customerId": "cust-001"}}
|
|
@@ -4815,11 +6632,9 @@ WHEN TO USE: You need the exact JSON shape for a CLI command.
|
|
|
4815
6632
|
|
|
4816
6633
|
Field types: UUID, String, Int, Long, Double, Decimal, Boolean, Date, DateTime, Custom
|
|
4817
6634
|
|
|
4818
|
-
|
|
4819
|
-
|
|
4820
|
-
|
|
4821
|
-
"isList": true
|
|
4822
|
-
"isUserInput": true (screens only)
|
|
6635
|
+
Note: create slice generates field/subfield IDs when omitted. Field metadata
|
|
6636
|
+
flags such as isOptional, isGenerated, isList, and isUserInput are not applied
|
|
6637
|
+
by create slice; add or update those flags after creation.
|
|
4823
6638
|
|
|
4824
6639
|
Custom type with subfields:
|
|
4825
6640
|
{
|
|
@@ -4874,9 +6689,9 @@ WHEN TO USE: You need the exact JSON shape for a CLI command.
|
|
|
4874
6689
|
{ "source": "sourceFieldName", "target": "targetFieldName" }
|
|
4875
6690
|
]
|
|
4876
6691
|
|
|
4877
|
-
##
|
|
6692
|
+
## create scenario '<json>' --slice <sliceName>
|
|
4878
6693
|
|
|
4879
|
-
eventmodeler
|
|
6694
|
+
eventmodeler create scenario '<json>' --slice "Place Order"
|
|
4880
6695
|
|
|
4881
6696
|
SCENARIO JSON:
|
|
4882
6697
|
{
|
|
@@ -5455,6 +7270,65 @@ function registerListCommands(program) {
|
|
|
5455
7270
|
}
|
|
5456
7271
|
}
|
|
5457
7272
|
|
|
7273
|
+
// src/lib/scenario-field-values.ts
|
|
7274
|
+
function isPlainObject(v) {
|
|
7275
|
+
return typeof v === "object" && v !== null && !Array.isArray(v);
|
|
7276
|
+
}
|
|
7277
|
+
function toFieldValueWire(value, path4 = "fieldValues") {
|
|
7278
|
+
if (Array.isArray(value)) {
|
|
7279
|
+
const allObjects = value.length > 0 && value.every(isPlainObject);
|
|
7280
|
+
const anyObject = value.some(isPlainObject);
|
|
7281
|
+
if (allObjects) {
|
|
7282
|
+
return { treeList: value.map((item, i) => toFieldValueWire(item, `${path4}[${i}]`)) };
|
|
7283
|
+
}
|
|
7284
|
+
if (anyObject) {
|
|
7285
|
+
throw new Error(`${path4}: list mixes primitives and objects; use either all scalar values or all objects.`);
|
|
7286
|
+
}
|
|
7287
|
+
return { list: value.map(String) };
|
|
7288
|
+
}
|
|
7289
|
+
if (isPlainObject(value)) {
|
|
7290
|
+
return {
|
|
7291
|
+
tree: Object.fromEntries(Object.entries(value).map(([key, child]) => [key, toFieldValueWire(child, `${path4}.${key}`)]))
|
|
7292
|
+
};
|
|
7293
|
+
}
|
|
7294
|
+
return { scalar: String(value) };
|
|
7295
|
+
}
|
|
7296
|
+
function toFieldValuesWire(values) {
|
|
7297
|
+
if (!values)
|
|
7298
|
+
return {};
|
|
7299
|
+
return Object.fromEntries(Object.entries(values).map(([fieldName, value]) => [fieldName, toFieldValueWire(value, `fieldValues.${fieldName}`)]));
|
|
7300
|
+
}
|
|
7301
|
+
function unwrapFieldValueWire(value) {
|
|
7302
|
+
if (!isPlainObject(value))
|
|
7303
|
+
return value;
|
|
7304
|
+
if ("scalar" in value)
|
|
7305
|
+
return value.scalar;
|
|
7306
|
+
if ("list" in value)
|
|
7307
|
+
return value.list;
|
|
7308
|
+
if ("tree" in value && isPlainObject(value.tree)) {
|
|
7309
|
+
return Object.fromEntries(Object.entries(value.tree).map(([fieldName, child]) => [fieldName, unwrapFieldValueWire(child)]));
|
|
7310
|
+
}
|
|
7311
|
+
if ("treeList" in value && Array.isArray(value.treeList)) {
|
|
7312
|
+
return value.treeList.map((item) => unwrapFieldValueWire(item));
|
|
7313
|
+
}
|
|
7314
|
+
return value;
|
|
7315
|
+
}
|
|
7316
|
+
function unwrapFieldValuesWire(values) {
|
|
7317
|
+
if (!isPlainObject(values))
|
|
7318
|
+
return values;
|
|
7319
|
+
return Object.fromEntries(Object.entries(values).map(([fieldName, value]) => [fieldName, unwrapFieldValueWire(value)]));
|
|
7320
|
+
}
|
|
7321
|
+
function unwrapScenarioFieldValuesInResponse(value) {
|
|
7322
|
+
if (Array.isArray(value))
|
|
7323
|
+
return value.map(unwrapScenarioFieldValuesInResponse);
|
|
7324
|
+
if (!isPlainObject(value))
|
|
7325
|
+
return value;
|
|
7326
|
+
return Object.fromEntries(Object.entries(value).map(([key, child]) => [
|
|
7327
|
+
key,
|
|
7328
|
+
key === "fieldValues" ? unwrapFieldValuesWire(child) : unwrapScenarioFieldValuesInResponse(child)
|
|
7329
|
+
]));
|
|
7330
|
+
}
|
|
7331
|
+
|
|
5458
7332
|
// src/commands/show-schemas.ts
|
|
5459
7333
|
var FIELD_VIEW = `FieldView:
|
|
5460
7334
|
{
|
|
@@ -5713,22 +7587,22 @@ function registerShowCommands(program) {
|
|
|
5713
7587
|
const show = program.command("show").description("Show detailed information");
|
|
5714
7588
|
show.command("model").description("Show full model hierarchy").addHelpText("after", SHOW_MODEL_HELP).action(async () => {
|
|
5715
7589
|
const modelId = requireModelId();
|
|
5716
|
-
out(unwrap(await showModel({ path: { modelId } })));
|
|
7590
|
+
out(unwrapScenarioFieldValuesInResponse(unwrap(await showModel({ path: { modelId } }))));
|
|
5717
7591
|
});
|
|
5718
7592
|
show.command("context [name]").description("Show context with contained chapters and slices").addHelpText("after", SHOW_CONTEXT_HELP).action(async (name, cmd) => {
|
|
5719
7593
|
const modelId = requireModelId();
|
|
5720
7594
|
const contextId = await resolve2(modelId, "context", name ?? "", getGlobalId());
|
|
5721
|
-
out(unwrap(await showContext({ path: { modelId, contextId } })));
|
|
7595
|
+
out(unwrapScenarioFieldValuesInResponse(unwrap(await showContext({ path: { modelId, contextId } }))));
|
|
5722
7596
|
});
|
|
5723
7597
|
show.command("chapter [name]").description("Show chapter with contained slices").addHelpText("after", SHOW_CHAPTER_HELP).action(async (name, cmd) => {
|
|
5724
7598
|
const modelId = requireModelId();
|
|
5725
7599
|
const chapterId = await resolve2(modelId, "chapter", name ?? "", getGlobalId());
|
|
5726
|
-
out(unwrap(await showChapter({ path: { modelId, chapterId } })));
|
|
7600
|
+
out(unwrapScenarioFieldValuesInResponse(unwrap(await showChapter({ path: { modelId, chapterId } }))));
|
|
5727
7601
|
});
|
|
5728
7602
|
show.command("slice [name]").description("Show slice with all elements, flows, and scenarios").addHelpText("after", SHOW_SLICE_HELP).action(async (name, cmd) => {
|
|
5729
7603
|
const modelId = requireModelId();
|
|
5730
7604
|
const sliceId = await resolve2(modelId, "slice", name ?? "", getGlobalId());
|
|
5731
|
-
out(unwrap(await showSlice({ path: { modelId, sliceId } })));
|
|
7605
|
+
out(unwrapScenarioFieldValuesInResponse(unwrap(await showSlice({ path: { modelId, sliceId } }))));
|
|
5732
7606
|
});
|
|
5733
7607
|
for (const type of ["event", "command", "readmodel", "screen", "processor", "external-event"]) {
|
|
5734
7608
|
show.command(`${type} [name]`).description(`Show ${type} detail with fields and flows`).addHelpText("after", SHOW_ELEMENT_HELP).action(async (name, cmd) => {
|
|
@@ -5817,7 +7691,7 @@ var ADD_SUBFIELD_MAP = {
|
|
|
5817
7691
|
processor: addProcessorSubfield,
|
|
5818
7692
|
"external-event": addExternalEventSubfield
|
|
5819
7693
|
};
|
|
5820
|
-
function
|
|
7694
|
+
function isPlainObject2(v) {
|
|
5821
7695
|
return typeof v === "object" && v !== null && !Array.isArray(v);
|
|
5822
7696
|
}
|
|
5823
7697
|
var ENTRY_DISPATCH = {
|
|
@@ -5871,8 +7745,8 @@ async function addEntries(modelId, scenarioId, section, entries, positionOffset
|
|
|
5871
7745
|
if (entry.fieldValues) {
|
|
5872
7746
|
for (const [fieldName, value] of Object.entries(entry.fieldValues)) {
|
|
5873
7747
|
if (Array.isArray(value)) {
|
|
5874
|
-
const allObjects = value.length > 0 && value.every(
|
|
5875
|
-
const anyObject = value.some((v) =>
|
|
7748
|
+
const allObjects = value.length > 0 && value.every(isPlainObject2);
|
|
7749
|
+
const anyObject = value.some((v) => isPlainObject2(v));
|
|
5876
7750
|
if (allObjects) {
|
|
5877
7751
|
if (!info.setFieldCustomListValues)
|
|
5878
7752
|
throw new Error(`Cannot set Custom list values on ${entry.entryType}`);
|
|
@@ -5888,7 +7762,7 @@ async function addEntries(modelId, scenarioId, section, entries, positionOffset
|
|
|
5888
7762
|
body: { modelId, scenarioId, entryId, fieldName, values: value.map(String) }
|
|
5889
7763
|
}));
|
|
5890
7764
|
}
|
|
5891
|
-
} else if (
|
|
7765
|
+
} else if (isPlainObject2(value)) {
|
|
5892
7766
|
if (!info.setFieldCustomValue)
|
|
5893
7767
|
throw new Error(`Cannot set Custom value on ${entry.entryType}`);
|
|
5894
7768
|
unwrap(await info.setFieldCustomValue({
|
|
@@ -5906,6 +7780,60 @@ async function addEntries(modelId, scenarioId, section, entries, positionOffset
|
|
|
5906
7780
|
}
|
|
5907
7781
|
}
|
|
5908
7782
|
}
|
|
7783
|
+
async function createScenarioFromJson(json, sliceName) {
|
|
7784
|
+
const modelId = requireModelId();
|
|
7785
|
+
const sliceId = await resolve2(modelId, "slice", sliceName, getGlobalId());
|
|
7786
|
+
const spec = JSON.parse(json);
|
|
7787
|
+
const scenarioId = randomUUID();
|
|
7788
|
+
const buildEntries = async (section, entries) => {
|
|
7789
|
+
if (!entries)
|
|
7790
|
+
return [];
|
|
7791
|
+
const dispatch = ENTRY_DISPATCH[section];
|
|
7792
|
+
const out2 = [];
|
|
7793
|
+
for (const entry of entries) {
|
|
7794
|
+
const info = dispatch[entry.entryType];
|
|
7795
|
+
if (!info) {
|
|
7796
|
+
throw new Error(`Unknown ${section} entry type: ${entry.entryType}`);
|
|
7797
|
+
}
|
|
7798
|
+
if (entry.entryType === "error") {
|
|
7799
|
+
out2.push({
|
|
7800
|
+
entryType: "error",
|
|
7801
|
+
errorType: entry.errorType ?? "",
|
|
7802
|
+
errorMessage: entry.errorMessage ?? "",
|
|
7803
|
+
fieldValues: {}
|
|
7804
|
+
});
|
|
7805
|
+
} else {
|
|
7806
|
+
if (!entry.elementName) {
|
|
7807
|
+
throw new Error(`${section} ${entry.entryType} entry is missing elementName`);
|
|
7808
|
+
}
|
|
7809
|
+
const elementId = await resolve2(modelId, info.resolveType, entry.elementName);
|
|
7810
|
+
out2.push({
|
|
7811
|
+
entryType: entry.entryType,
|
|
7812
|
+
elementId,
|
|
7813
|
+
fieldValues: toFieldValuesWire(entry.fieldValues)
|
|
7814
|
+
});
|
|
7815
|
+
}
|
|
7816
|
+
}
|
|
7817
|
+
return out2;
|
|
7818
|
+
};
|
|
7819
|
+
const given = await buildEntries("given", spec.given);
|
|
7820
|
+
const when = await buildEntries("when", spec.when);
|
|
7821
|
+
const then = await buildEntries("then", spec.then);
|
|
7822
|
+
unwrap(await createScenario({
|
|
7823
|
+
body: {
|
|
7824
|
+
modelId,
|
|
7825
|
+
sliceId,
|
|
7826
|
+
scenarioId,
|
|
7827
|
+
name: spec.name,
|
|
7828
|
+
...spec.description ? { description: spec.description } : {},
|
|
7829
|
+
given,
|
|
7830
|
+
when,
|
|
7831
|
+
then
|
|
7832
|
+
}
|
|
7833
|
+
}));
|
|
7834
|
+
const entryCount = given.length + when.length + then.length;
|
|
7835
|
+
return { name: spec.name, entryCount };
|
|
7836
|
+
}
|
|
5909
7837
|
function registerAddCommands(program) {
|
|
5910
7838
|
const add = program.command("add").description("Add fields or scenarios");
|
|
5911
7839
|
add.command("field [elementName] <json>").description("Add a field to an element").action(async (elementNameOrJson, jsonOrUndefined, cmd) => {
|
|
@@ -5998,7 +7926,7 @@ element name doesn't resolve, the whole spec is rejected before hitting the
|
|
|
5998
7926
|
backend.
|
|
5999
7927
|
|
|
6000
7928
|
Example (primitives + Custom + list):
|
|
6001
|
-
|
|
7929
|
+
create scenario --slice "Place Order" '{
|
|
6002
7930
|
"name": "happy path",
|
|
6003
7931
|
"when": [{ "entryType": "command", "elementName": "PlaceOrder",
|
|
6004
7932
|
"fieldValues": { "orderId": "uuid-1",
|
|
@@ -6009,58 +7937,8 @@ Example (primitives + Custom + list):
|
|
|
6009
7937
|
{ "sku": "sku-2", "qty": "1" } ] } }]
|
|
6010
7938
|
}'
|
|
6011
7939
|
`).action(async (json, opts, cmd) => {
|
|
6012
|
-
const
|
|
6013
|
-
|
|
6014
|
-
const spec = JSON.parse(json);
|
|
6015
|
-
const scenarioId = randomUUID();
|
|
6016
|
-
const buildEntries = async (section, entries) => {
|
|
6017
|
-
if (!entries)
|
|
6018
|
-
return [];
|
|
6019
|
-
const dispatch = ENTRY_DISPATCH[section];
|
|
6020
|
-
const out2 = [];
|
|
6021
|
-
for (const entry of entries) {
|
|
6022
|
-
const info = dispatch[entry.entryType];
|
|
6023
|
-
if (!info) {
|
|
6024
|
-
throw new Error(`Unknown ${section} entry type: ${entry.entryType}`);
|
|
6025
|
-
}
|
|
6026
|
-
if (entry.entryType === "error") {
|
|
6027
|
-
out2.push({
|
|
6028
|
-
entryType: "error",
|
|
6029
|
-
errorType: entry.errorType ?? "",
|
|
6030
|
-
errorMessage: entry.errorMessage ?? "",
|
|
6031
|
-
fieldValues: {}
|
|
6032
|
-
});
|
|
6033
|
-
} else {
|
|
6034
|
-
if (!entry.elementName) {
|
|
6035
|
-
throw new Error(`${section} ${entry.entryType} entry is missing elementName`);
|
|
6036
|
-
}
|
|
6037
|
-
const elementId = await resolve2(modelId, info.resolveType, entry.elementName);
|
|
6038
|
-
out2.push({
|
|
6039
|
-
entryType: entry.entryType,
|
|
6040
|
-
elementId,
|
|
6041
|
-
fieldValues: entry.fieldValues ?? {}
|
|
6042
|
-
});
|
|
6043
|
-
}
|
|
6044
|
-
}
|
|
6045
|
-
return out2;
|
|
6046
|
-
};
|
|
6047
|
-
const given = await buildEntries("given", spec.given);
|
|
6048
|
-
const when = await buildEntries("when", spec.when);
|
|
6049
|
-
const then = await buildEntries("then", spec.then);
|
|
6050
|
-
unwrap(await createScenario({
|
|
6051
|
-
body: {
|
|
6052
|
-
modelId,
|
|
6053
|
-
sliceId,
|
|
6054
|
-
scenarioId,
|
|
6055
|
-
name: spec.name,
|
|
6056
|
-
...spec.description ? { description: spec.description } : {},
|
|
6057
|
-
given,
|
|
6058
|
-
when,
|
|
6059
|
-
then
|
|
6060
|
-
}
|
|
6061
|
-
}));
|
|
6062
|
-
const entryCount = given.length + when.length + then.length;
|
|
6063
|
-
console.log(`Added scenario "${spec.name}"${entryCount > 0 ? ` with ${entryCount} entries` : ""}.`);
|
|
7940
|
+
const result = await createScenarioFromJson(json, opts.slice);
|
|
7941
|
+
console.log(`Created scenario "${result.name}"${result.entryCount > 0 ? ` with ${result.entryCount} entries` : ""}.`);
|
|
6064
7942
|
});
|
|
6065
7943
|
add.command("entry").description("Add a GWT entry to a scenario").requiredOption("--scenario <name>", "Scenario name").requiredOption("--section <section>", "Section: given, when, or then").requiredOption("--type <type>", "Entry type: event, command, readmodel, or error").option("--element <name>", "Element name (required unless --type error)").option("--error-type <type>", "Error type (for --type error)").option("--error-message <msg>", "Error message (for --type error)").option("--position <n>", "Position within section (appends at end by default)", parseInt).action(async (opts) => {
|
|
6066
7944
|
const modelId = requireModelId();
|
|
@@ -6317,6 +8195,23 @@ function registerResizeCommands(program) {
|
|
|
6317
8195
|
|
|
6318
8196
|
// src/commands/create.ts
|
|
6319
8197
|
import { randomUUID as randomUUID2 } from "node:crypto";
|
|
8198
|
+
function normalizeSliceFields(fields) {
|
|
8199
|
+
return (fields ?? []).map((field) => ({
|
|
8200
|
+
...field,
|
|
8201
|
+
id: field.id ?? randomUUID2(),
|
|
8202
|
+
type: field.type ?? field.fieldType,
|
|
8203
|
+
subfields: normalizeSliceFields(field.subfields)
|
|
8204
|
+
}));
|
|
8205
|
+
}
|
|
8206
|
+
function normalizeSliceSpec(spec) {
|
|
8207
|
+
return {
|
|
8208
|
+
...spec,
|
|
8209
|
+
elements: (spec.elements ?? []).map((element) => ({
|
|
8210
|
+
...element,
|
|
8211
|
+
fields: normalizeSliceFields(element.fields)
|
|
8212
|
+
}))
|
|
8213
|
+
};
|
|
8214
|
+
}
|
|
6320
8215
|
var FLOW_DISPATCH = {
|
|
6321
8216
|
"screen->command": { fn: specifyScreenToCommandFlow, sourceHandle: "bottom-source", targetHandle: "top-target" },
|
|
6322
8217
|
"command->event": { fn: specifyCommandToEventFlow, sourceHandle: "bottom-source", targetHandle: "top-target" },
|
|
@@ -6372,9 +8267,14 @@ function registerCreateCommands(program) {
|
|
|
6372
8267
|
create.command("slice <json>").description("Create a full slice from JSON specification").action(async (json) => {
|
|
6373
8268
|
const modelId = requireModelId();
|
|
6374
8269
|
const spec = JSON.parse(json);
|
|
6375
|
-
|
|
8270
|
+
const body = { modelId, sliceId: randomUUID2(), ...normalizeSliceSpec(spec) };
|
|
8271
|
+
unwrap(await createSlice({ body }));
|
|
6376
8272
|
console.log("Created slice.");
|
|
6377
8273
|
});
|
|
8274
|
+
create.command("scenario <json>").description("Atomically create a full Given/When/Then scenario").requiredOption("--slice <name>", "Slice name").action(async (json, opts) => {
|
|
8275
|
+
const result = await createScenarioFromJson(json, opts.slice);
|
|
8276
|
+
console.log(`Created scenario "${result.name}"${result.entryCount > 0 ? ` with ${result.entryCount} entries` : ""}.`);
|
|
8277
|
+
});
|
|
6378
8278
|
create.command("flow").description("Create a flow between two elements").requiredOption("--from <source>", "Source element name").requiredOption("--to <target>", "Target element name").option("--source-handle <handle>", "Source handle ID (default: auto based on flow type)").option("--target-handle <handle>", "Target handle ID (default: auto based on flow type)").action(async (opts) => {
|
|
6379
8279
|
const modelId = requireModelId();
|
|
6380
8280
|
const source = await resolveAnyElement(modelId, opts.from);
|
|
@@ -7124,11 +9024,131 @@ function sleep(ms) {
|
|
|
7124
9024
|
return new Promise((resolve3) => setTimeout(resolve3, ms));
|
|
7125
9025
|
}
|
|
7126
9026
|
|
|
9027
|
+
// src/lib/update-check.ts
|
|
9028
|
+
var import_semver = __toESM(require_semver2(), 1);
|
|
9029
|
+
import { spawn as spawn2 } from "node:child_process";
|
|
9030
|
+
import * as readline2 from "node:readline";
|
|
9031
|
+
var REGISTRY_LATEST_URL = "https://registry.npmjs.org/eventmodeler/latest";
|
|
9032
|
+
var CHECK_TIMEOUT_MS = 1500;
|
|
9033
|
+
var PROMPT_TIMEOUT_MS = 5000;
|
|
9034
|
+
function getUpdateMode() {
|
|
9035
|
+
const value = process.env.EVENTMODELER_UPDATE?.toLowerCase();
|
|
9036
|
+
if (value === "auto" || value === "yes" || value === "true")
|
|
9037
|
+
return "auto";
|
|
9038
|
+
if (value === "never" || value === "no" || value === "false")
|
|
9039
|
+
return "never";
|
|
9040
|
+
return "prompt";
|
|
9041
|
+
}
|
|
9042
|
+
function shouldSkipForCommand(argv) {
|
|
9043
|
+
return argv.includes("--no-update-check") || argv.includes("--version") || argv.includes("-V") || argv.includes("--help") || argv.includes("-h");
|
|
9044
|
+
}
|
|
9045
|
+
function isInteractive() {
|
|
9046
|
+
return Boolean(process.stdin.isTTY && process.stdout.isTTY && !process.env.CI);
|
|
9047
|
+
}
|
|
9048
|
+
function detectPackageManager() {
|
|
9049
|
+
const userAgent = process.env.npm_config_user_agent ?? "";
|
|
9050
|
+
if (userAgent.startsWith("bun/"))
|
|
9051
|
+
return "bun";
|
|
9052
|
+
if (userAgent.startsWith("pnpm/"))
|
|
9053
|
+
return "pnpm";
|
|
9054
|
+
if (userAgent.startsWith("yarn/"))
|
|
9055
|
+
return "yarn";
|
|
9056
|
+
return "npm";
|
|
9057
|
+
}
|
|
9058
|
+
function updateCommand(packageManager) {
|
|
9059
|
+
switch (packageManager) {
|
|
9060
|
+
case "bun":
|
|
9061
|
+
return ["bun", ["add", "-g", "eventmodeler"]];
|
|
9062
|
+
case "pnpm":
|
|
9063
|
+
return ["pnpm", ["add", "-g", "eventmodeler"]];
|
|
9064
|
+
case "yarn":
|
|
9065
|
+
return ["yarn", ["global", "add", "eventmodeler"]];
|
|
9066
|
+
case "npm":
|
|
9067
|
+
default:
|
|
9068
|
+
return ["npm", ["install", "-g", "eventmodeler"]];
|
|
9069
|
+
}
|
|
9070
|
+
}
|
|
9071
|
+
async function fetchLatestVersion() {
|
|
9072
|
+
const controller = new AbortController;
|
|
9073
|
+
const timeout = setTimeout(() => controller.abort(), CHECK_TIMEOUT_MS);
|
|
9074
|
+
try {
|
|
9075
|
+
const response = await fetch(REGISTRY_LATEST_URL, { signal: controller.signal });
|
|
9076
|
+
if (!response.ok)
|
|
9077
|
+
return null;
|
|
9078
|
+
const data = await response.json();
|
|
9079
|
+
return data.version ?? null;
|
|
9080
|
+
} catch {
|
|
9081
|
+
return null;
|
|
9082
|
+
} finally {
|
|
9083
|
+
clearTimeout(timeout);
|
|
9084
|
+
}
|
|
9085
|
+
}
|
|
9086
|
+
function promptYesNo(question) {
|
|
9087
|
+
return new Promise((resolve3) => {
|
|
9088
|
+
const rl = readline2.createInterface({
|
|
9089
|
+
input: process.stdin,
|
|
9090
|
+
output: process.stdout
|
|
9091
|
+
});
|
|
9092
|
+
const timeout = setTimeout(() => {
|
|
9093
|
+
rl.close();
|
|
9094
|
+
resolve3(false);
|
|
9095
|
+
}, PROMPT_TIMEOUT_MS);
|
|
9096
|
+
rl.question(question, (answer) => {
|
|
9097
|
+
clearTimeout(timeout);
|
|
9098
|
+
rl.close();
|
|
9099
|
+
resolve3(["y", "yes"].includes(answer.trim().toLowerCase()));
|
|
9100
|
+
});
|
|
9101
|
+
});
|
|
9102
|
+
}
|
|
9103
|
+
function runUpdate() {
|
|
9104
|
+
const [command, args] = updateCommand(detectPackageManager());
|
|
9105
|
+
return new Promise((resolve3) => {
|
|
9106
|
+
const child = spawn2(command, args, { stdio: "inherit" });
|
|
9107
|
+
child.on("close", (code) => resolve3(code ?? 1));
|
|
9108
|
+
child.on("error", () => resolve3(1));
|
|
9109
|
+
});
|
|
9110
|
+
}
|
|
9111
|
+
async function maybeUpdateCli(packageName, currentVersion, argv) {
|
|
9112
|
+
if (packageName !== "eventmodeler")
|
|
9113
|
+
return;
|
|
9114
|
+
if (shouldSkipForCommand(argv))
|
|
9115
|
+
return;
|
|
9116
|
+
const mode = getUpdateMode();
|
|
9117
|
+
if (mode === "never")
|
|
9118
|
+
return;
|
|
9119
|
+
const latestVersion = await fetchLatestVersion();
|
|
9120
|
+
if (!latestVersion || !import_semver.default.valid(latestVersion) || !import_semver.default.valid(currentVersion))
|
|
9121
|
+
return;
|
|
9122
|
+
if (!import_semver.default.gt(latestVersion, currentVersion))
|
|
9123
|
+
return;
|
|
9124
|
+
const [command, args] = updateCommand(detectPackageManager());
|
|
9125
|
+
const commandText = [command, ...args].join(" ");
|
|
9126
|
+
if (mode === "auto") {
|
|
9127
|
+
console.error(`Updating eventmodeler ${currentVersion} -> ${latestVersion}...`);
|
|
9128
|
+
const code = await runUpdate();
|
|
9129
|
+
if (code !== 0) {
|
|
9130
|
+
console.error(`Update failed. Run manually: ${commandText}`);
|
|
9131
|
+
}
|
|
9132
|
+
return;
|
|
9133
|
+
}
|
|
9134
|
+
if (!isInteractive()) {
|
|
9135
|
+
console.error(`eventmodeler ${latestVersion} is available. Run: ${commandText}`);
|
|
9136
|
+
return;
|
|
9137
|
+
}
|
|
9138
|
+
const accepted = await promptYesNo(`eventmodeler ${latestVersion} is available (current ${currentVersion}). Update now? [y/N] `);
|
|
9139
|
+
if (accepted) {
|
|
9140
|
+
const code = await runUpdate();
|
|
9141
|
+
if (code !== 0) {
|
|
9142
|
+
console.error(`Update failed. Run manually: ${commandText}`);
|
|
9143
|
+
}
|
|
9144
|
+
}
|
|
9145
|
+
}
|
|
9146
|
+
|
|
7127
9147
|
// src/index.ts
|
|
7128
9148
|
var __filename2 = fileURLToPath(import.meta.url);
|
|
7129
9149
|
var __dirname2 = path4.dirname(__filename2);
|
|
7130
9150
|
var packageJson = JSON.parse(fs4.readFileSync(path4.join(__dirname2, "..", "package.json"), "utf-8"));
|
|
7131
|
-
var program = new Command().name("eventmodeler").version(packageJson.version).description("CLI tool for interacting with Event Model files").option("--id <uuid>", "Skip name resolution, use UUID directly");
|
|
9151
|
+
var program = new Command().name("eventmodeler").version(packageJson.version).description("CLI tool for interacting with Event Model files").option("--id <uuid>", "Skip name resolution, use UUID directly").option("--no-update-check", "Skip checking npm for a newer CLI version");
|
|
7132
9152
|
setProgram(program);
|
|
7133
9153
|
registerAuthCommands(program);
|
|
7134
9154
|
registerInitCommands(program);
|
|
@@ -7149,6 +9169,7 @@ registerMapCommands(program);
|
|
|
7149
9169
|
registerDesignCommands(program);
|
|
7150
9170
|
registerSetCommands(program);
|
|
7151
9171
|
registerLoopCommands(program);
|
|
9172
|
+
await maybeUpdateCli(packageJson.name, packageJson.version, process.argv);
|
|
7152
9173
|
program.parseAsync(process.argv).catch((err) => {
|
|
7153
9174
|
console.error("Error:", err.message);
|
|
7154
9175
|
process.exit(1);
|