@jsii/runtime 1.64.0 → 1.66.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (3) hide show
  1. package/package.json +7 -7
  2. package/webpack/bin/jsii-runtime.js +984 -2651
  3. package/webpack/lib/program.js +4963 -10070
package/webpack/bin/jsii-runtime.js CHANGED
@@ -2,154 +2,115 @@ var __webpack_modules__ = {
2
2
  5756: (module, __unused_webpack_exports, __webpack_require__) => {
3
3
  "use strict";
4
4
  module = __webpack_require__.nmd(module);
5
- const wrapAnsi16 = (fn, offset) => (...args) => {
6
- const code = fn(...args);
7
- return `[${code + offset}m`;
8
- };
9
- const wrapAnsi256 = (fn, offset) => (...args) => {
5
+ const wrapAnsi16 = (fn, offset) => (...args) => `[${fn(...args) + offset}m`, wrapAnsi256 = (fn, offset) => (...args) => {
10
6
  const code = fn(...args);
11
7
  return `[${38 + offset};5;${code}m`;
12
- };
13
- const wrapAnsi16m = (fn, offset) => (...args) => {
8
+ }, wrapAnsi16m = (fn, offset) => (...args) => {
14
9
  const rgb = fn(...args);
15
10
  return `[${38 + offset};2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
16
- };
17
- const ansi2ansi = n => n;
18
- const rgb2rgb = (r, g, b) => [ r, g, b ];
19
- const setLazyProperty = (object, property, get) => {
11
+ }, ansi2ansi = n => n, rgb2rgb = (r, g, b) => [ r, g, b ], setLazyProperty = (object, property, get) => {
20
12
  Object.defineProperty(object, property, {
21
13
  get: () => {
22
14
  const value = get();
23
- Object.defineProperty(object, property, {
15
+ return Object.defineProperty(object, property, {
24
16
  value,
25
- enumerable: true,
26
- configurable: true
27
- });
28
- return value;
17
+ enumerable: !0,
18
+ configurable: !0
19
+ }), value;
29
20
  },
30
- enumerable: true,
31
- configurable: true
21
+ enumerable: !0,
22
+ configurable: !0
32
23
  });
33
24
  };
34
25
  let colorConvert;
35
26
  const makeDynamicStyles = (wrap, targetSpace, identity, isBackground) => {
36
- if (colorConvert === undefined) {
37
- colorConvert = __webpack_require__(9208);
38
- }
39
- const offset = isBackground ? 10 : 0;
40
- const styles = {};
27
+ void 0 === colorConvert && (colorConvert = __webpack_require__(9208));
28
+ const offset = isBackground ? 10 : 0, styles = {};
41
29
  for (const [sourceSpace, suite] of Object.entries(colorConvert)) {
42
- const name = sourceSpace === "ansi16" ? "ansi" : sourceSpace;
43
- if (sourceSpace === targetSpace) {
44
- styles[name] = wrap(identity, offset);
45
- } else if (typeof suite === "object") {
46
- styles[name] = wrap(suite[targetSpace], offset);
47
- }
30
+ const name = "ansi16" === sourceSpace ? "ansi" : sourceSpace;
31
+ sourceSpace === targetSpace ? styles[name] = wrap(identity, offset) : "object" == typeof suite && (styles[name] = wrap(suite[targetSpace], offset));
48
32
  }
49
33
  return styles;
50
34
  };
51
- function assembleStyles() {
52
- const codes = new Map;
53
- const styles = {
54
- modifier: {
55
- reset: [ 0, 0 ],
56
- bold: [ 1, 22 ],
57
- dim: [ 2, 22 ],
58
- italic: [ 3, 23 ],
59
- underline: [ 4, 24 ],
60
- inverse: [ 7, 27 ],
61
- hidden: [ 8, 28 ],
62
- strikethrough: [ 9, 29 ]
63
- },
64
- color: {
65
- black: [ 30, 39 ],
66
- red: [ 31, 39 ],
67
- green: [ 32, 39 ],
68
- yellow: [ 33, 39 ],
69
- blue: [ 34, 39 ],
70
- magenta: [ 35, 39 ],
71
- cyan: [ 36, 39 ],
72
- white: [ 37, 39 ],
73
- blackBright: [ 90, 39 ],
74
- redBright: [ 91, 39 ],
75
- greenBright: [ 92, 39 ],
76
- yellowBright: [ 93, 39 ],
77
- blueBright: [ 94, 39 ],
78
- magentaBright: [ 95, 39 ],
79
- cyanBright: [ 96, 39 ],
80
- whiteBright: [ 97, 39 ]
81
- },
82
- bgColor: {
83
- bgBlack: [ 40, 49 ],
84
- bgRed: [ 41, 49 ],
85
- bgGreen: [ 42, 49 ],
86
- bgYellow: [ 43, 49 ],
87
- bgBlue: [ 44, 49 ],
88
- bgMagenta: [ 45, 49 ],
89
- bgCyan: [ 46, 49 ],
90
- bgWhite: [ 47, 49 ],
91
- bgBlackBright: [ 100, 49 ],
92
- bgRedBright: [ 101, 49 ],
93
- bgGreenBright: [ 102, 49 ],
94
- bgYellowBright: [ 103, 49 ],
95
- bgBlueBright: [ 104, 49 ],
96
- bgMagentaBright: [ 105, 49 ],
97
- bgCyanBright: [ 106, 49 ],
98
- bgWhiteBright: [ 107, 49 ]
99
- }
100
- };
101
- styles.color.gray = styles.color.blackBright;
102
- styles.bgColor.bgGray = styles.bgColor.bgBlackBright;
103
- styles.color.grey = styles.color.blackBright;
104
- styles.bgColor.bgGrey = styles.bgColor.bgBlackBright;
105
- for (const [groupName, group] of Object.entries(styles)) {
106
- for (const [styleName, style] of Object.entries(group)) {
107
- styles[styleName] = {
35
+ Object.defineProperty(module, "exports", {
36
+ enumerable: !0,
37
+ get: function() {
38
+ const codes = new Map, styles = {
39
+ modifier: {
40
+ reset: [ 0, 0 ],
41
+ bold: [ 1, 22 ],
42
+ dim: [ 2, 22 ],
43
+ italic: [ 3, 23 ],
44
+ underline: [ 4, 24 ],
45
+ inverse: [ 7, 27 ],
46
+ hidden: [ 8, 28 ],
47
+ strikethrough: [ 9, 29 ]
48
+ },
49
+ color: {
50
+ black: [ 30, 39 ],
51
+ red: [ 31, 39 ],
52
+ green: [ 32, 39 ],
53
+ yellow: [ 33, 39 ],
54
+ blue: [ 34, 39 ],
55
+ magenta: [ 35, 39 ],
56
+ cyan: [ 36, 39 ],
57
+ white: [ 37, 39 ],
58
+ blackBright: [ 90, 39 ],
59
+ redBright: [ 91, 39 ],
60
+ greenBright: [ 92, 39 ],
61
+ yellowBright: [ 93, 39 ],
62
+ blueBright: [ 94, 39 ],
63
+ magentaBright: [ 95, 39 ],
64
+ cyanBright: [ 96, 39 ],
65
+ whiteBright: [ 97, 39 ]
66
+ },
67
+ bgColor: {
68
+ bgBlack: [ 40, 49 ],
69
+ bgRed: [ 41, 49 ],
70
+ bgGreen: [ 42, 49 ],
71
+ bgYellow: [ 43, 49 ],
72
+ bgBlue: [ 44, 49 ],
73
+ bgMagenta: [ 45, 49 ],
74
+ bgCyan: [ 46, 49 ],
75
+ bgWhite: [ 47, 49 ],
76
+ bgBlackBright: [ 100, 49 ],
77
+ bgRedBright: [ 101, 49 ],
78
+ bgGreenBright: [ 102, 49 ],
79
+ bgYellowBright: [ 103, 49 ],
80
+ bgBlueBright: [ 104, 49 ],
81
+ bgMagentaBright: [ 105, 49 ],
82
+ bgCyanBright: [ 106, 49 ],
83
+ bgWhiteBright: [ 107, 49 ]
84
+ }
85
+ };
86
+ styles.color.gray = styles.color.blackBright, styles.bgColor.bgGray = styles.bgColor.bgBlackBright,
87
+ styles.color.grey = styles.color.blackBright, styles.bgColor.bgGrey = styles.bgColor.bgBlackBright;
88
+ for (const [groupName, group] of Object.entries(styles)) {
89
+ for (const [styleName, style] of Object.entries(group)) styles[styleName] = {
108
90
  open: `[${style[0]}m`,
109
91
  close: `[${style[1]}m`
110
- };
111
- group[styleName] = styles[styleName];
112
- codes.set(style[0], style[1]);
92
+ }, group[styleName] = styles[styleName], codes.set(style[0], style[1]);
93
+ Object.defineProperty(styles, groupName, {
94
+ value: group,
95
+ enumerable: !1
96
+ });
113
97
  }
114
- Object.defineProperty(styles, groupName, {
115
- value: group,
116
- enumerable: false
117
- });
118
- }
119
- Object.defineProperty(styles, "codes", {
120
- value: codes,
121
- enumerable: false
122
- });
123
- styles.color.close = "";
124
- styles.bgColor.close = "";
125
- setLazyProperty(styles.color, "ansi", (() => makeDynamicStyles(wrapAnsi16, "ansi16", ansi2ansi, false)));
126
- setLazyProperty(styles.color, "ansi256", (() => makeDynamicStyles(wrapAnsi256, "ansi256", ansi2ansi, false)));
127
- setLazyProperty(styles.color, "ansi16m", (() => makeDynamicStyles(wrapAnsi16m, "rgb", rgb2rgb, false)));
128
- setLazyProperty(styles.bgColor, "ansi", (() => makeDynamicStyles(wrapAnsi16, "ansi16", ansi2ansi, true)));
129
- setLazyProperty(styles.bgColor, "ansi256", (() => makeDynamicStyles(wrapAnsi256, "ansi256", ansi2ansi, true)));
130
- setLazyProperty(styles.bgColor, "ansi16m", (() => makeDynamicStyles(wrapAnsi16m, "rgb", rgb2rgb, true)));
131
- return styles;
132
- }
133
- Object.defineProperty(module, "exports", {
134
- enumerable: true,
135
- get: assembleStyles
98
+ return Object.defineProperty(styles, "codes", {
99
+ value: codes,
100
+ enumerable: !1
101
+ }), styles.color.close = "", styles.bgColor.close = "", setLazyProperty(styles.color, "ansi", (() => makeDynamicStyles(wrapAnsi16, "ansi16", ansi2ansi, !1))),
102
+ setLazyProperty(styles.color, "ansi256", (() => makeDynamicStyles(wrapAnsi256, "ansi256", ansi2ansi, !1))),
103
+ setLazyProperty(styles.color, "ansi16m", (() => makeDynamicStyles(wrapAnsi16m, "rgb", rgb2rgb, !1))),
104
+ setLazyProperty(styles.bgColor, "ansi", (() => makeDynamicStyles(wrapAnsi16, "ansi16", ansi2ansi, !0))),
105
+ setLazyProperty(styles.bgColor, "ansi256", (() => makeDynamicStyles(wrapAnsi256, "ansi256", ansi2ansi, !0))),
106
+ setLazyProperty(styles.bgColor, "ansi16m", (() => makeDynamicStyles(wrapAnsi16m, "rgb", rgb2rgb, !0))),
107
+ styles;
108
+ }
136
109
  });
137
110
  },
138
111
  1201: (module, __unused_webpack_exports, __webpack_require__) => {
139
112
  "use strict";
140
- const ansiStyles = __webpack_require__(5756);
141
- const {stdout: stdoutColor, stderr: stderrColor} = __webpack_require__(9797);
142
- const {stringReplaceAll, stringEncaseCRLFWithFirstIndex} = __webpack_require__(8564);
143
- const {isArray} = Array;
144
- const levelMapping = [ "ansi", "ansi", "ansi256", "ansi16m" ];
145
- const styles = Object.create(null);
146
- const applyOptions = (object, options = {}) => {
147
- if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
148
- throw new Error("The `level` option should be an integer from 0 to 3");
149
- }
150
- const colorLevel = stdoutColor ? stdoutColor.level : 0;
151
- object.level = options.level === undefined ? colorLevel : options.level;
152
- };
113
+ const ansiStyles = __webpack_require__(5756), {stdout: stdoutColor, stderr: stderrColor} = __webpack_require__(9797), {stringReplaceAll, stringEncaseCRLFWithFirstIndex} = __webpack_require__(8564), {isArray} = Array, levelMapping = [ "ansi", "ansi", "ansi256", "ansi16m" ], styles = Object.create(null);
153
114
  class ChalkClass {
154
115
  constructor(options) {
155
116
  return chalkFactory(options);
@@ -157,54 +118,47 @@ var __webpack_modules__ = {
157
118
  }
158
119
  const chalkFactory = options => {
159
120
  const chalk = {};
160
- applyOptions(chalk, options);
161
- chalk.template = (...arguments_) => chalkTag(chalk.template, ...arguments_);
162
- Object.setPrototypeOf(chalk, Chalk.prototype);
163
- Object.setPrototypeOf(chalk.template, chalk);
121
+ return ((object, options = {}) => {
122
+ if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) throw new Error("The `level` option should be an integer from 0 to 3");
123
+ const colorLevel = stdoutColor ? stdoutColor.level : 0;
124
+ object.level = void 0 === options.level ? colorLevel : options.level;
125
+ })(chalk, options), chalk.template = (...arguments_) => chalkTag(chalk.template, ...arguments_),
126
+ Object.setPrototypeOf(chalk, Chalk.prototype), Object.setPrototypeOf(chalk.template, chalk),
164
127
  chalk.template.constructor = () => {
165
128
  throw new Error("`chalk.constructor()` is deprecated. Use `new chalk.Instance()` instead.");
166
- };
167
- chalk.template.Instance = ChalkClass;
168
- return chalk.template;
129
+ }, chalk.template.Instance = ChalkClass, chalk.template;
169
130
  };
170
131
  function Chalk(options) {
171
132
  return chalkFactory(options);
172
133
  }
173
- for (const [styleName, style] of Object.entries(ansiStyles)) {
174
- styles[styleName] = {
175
- get() {
176
- const builder = createBuilder(this, createStyler(style.open, style.close, this._styler), this._isEmpty);
177
- Object.defineProperty(this, styleName, {
178
- value: builder
179
- });
180
- return builder;
181
- }
182
- };
183
- }
134
+ for (const [styleName, style] of Object.entries(ansiStyles)) styles[styleName] = {
135
+ get() {
136
+ const builder = createBuilder(this, createStyler(style.open, style.close, this._styler), this._isEmpty);
137
+ return Object.defineProperty(this, styleName, {
138
+ value: builder
139
+ }), builder;
140
+ }
141
+ };
184
142
  styles.visible = {
185
143
  get() {
186
- const builder = createBuilder(this, this._styler, true);
187
- Object.defineProperty(this, "visible", {
144
+ const builder = createBuilder(this, this._styler, !0);
145
+ return Object.defineProperty(this, "visible", {
188
146
  value: builder
189
- });
190
- return builder;
147
+ }), builder;
191
148
  }
192
149
  };
193
150
  const usedModels = [ "rgb", "hex", "keyword", "hsl", "hsv", "hwb", "ansi", "ansi256" ];
151
+ for (const model of usedModels) styles[model] = {
152
+ get() {
153
+ const {level} = this;
154
+ return function(...arguments_) {
155
+ const styler = createStyler(ansiStyles.color[levelMapping[level]][model](...arguments_), ansiStyles.color.close, this._styler);
156
+ return createBuilder(this, styler, this._isEmpty);
157
+ };
158
+ }
159
+ };
194
160
  for (const model of usedModels) {
195
- styles[model] = {
196
- get() {
197
- const {level} = this;
198
- return function(...arguments_) {
199
- const styler = createStyler(ansiStyles.color[levelMapping[level]][model](...arguments_), ansiStyles.color.close, this._styler);
200
- return createBuilder(this, styler, this._isEmpty);
201
- };
202
- }
203
- };
204
- }
205
- for (const model of usedModels) {
206
- const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
207
- styles[bgModel] = {
161
+ styles["bg" + model[0].toUpperCase() + model.slice(1)] = {
208
162
  get() {
209
163
  const {level} = this;
210
164
  return function(...arguments_) {
@@ -217,7 +171,7 @@ var __webpack_modules__ = {
217
171
  const proto = Object.defineProperties((() => {}), {
218
172
  ...styles,
219
173
  level: {
220
- enumerable: true,
174
+ enumerable: !0,
221
175
  get() {
222
176
  return this._generator.level;
223
177
  },
@@ -225,115 +179,61 @@ var __webpack_modules__ = {
225
179
  this._generator.level = level;
226
180
  }
227
181
  }
228
- });
229
- const createStyler = (open, close, parent) => {
230
- let openAll;
231
- let closeAll;
232
- if (parent === undefined) {
233
- openAll = open;
234
- closeAll = close;
235
- } else {
236
- openAll = parent.openAll + open;
237
- closeAll = close + parent.closeAll;
238
- }
239
- return {
182
+ }), createStyler = (open, close, parent) => {
183
+ let openAll, closeAll;
184
+ return void 0 === parent ? (openAll = open, closeAll = close) : (openAll = parent.openAll + open,
185
+ closeAll = close + parent.closeAll), {
240
186
  open,
241
187
  close,
242
188
  openAll,
243
189
  closeAll,
244
190
  parent
245
191
  };
246
- };
247
- const createBuilder = (self, _styler, _isEmpty) => {
248
- const builder = (...arguments_) => {
249
- if (isArray(arguments_[0]) && isArray(arguments_[0].raw)) {
250
- return applyStyle(builder, chalkTag(builder, ...arguments_));
251
- }
252
- return applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
253
- };
254
- Object.setPrototypeOf(builder, proto);
255
- builder._generator = self;
256
- builder._styler = _styler;
257
- builder._isEmpty = _isEmpty;
258
- return builder;
259
- };
260
- const applyStyle = (self, string) => {
261
- if (self.level <= 0 || !string) {
262
- return self._isEmpty ? "" : string;
263
- }
192
+ }, createBuilder = (self, _styler, _isEmpty) => {
193
+ const builder = (...arguments_) => isArray(arguments_[0]) && isArray(arguments_[0].raw) ? applyStyle(builder, chalkTag(builder, ...arguments_)) : applyStyle(builder, 1 === arguments_.length ? "" + arguments_[0] : arguments_.join(" "));
194
+ return Object.setPrototypeOf(builder, proto), builder._generator = self, builder._styler = _styler,
195
+ builder._isEmpty = _isEmpty, builder;
196
+ }, applyStyle = (self, string) => {
197
+ if (self.level <= 0 || !string) return self._isEmpty ? "" : string;
264
198
  let styler = self._styler;
265
- if (styler === undefined) {
266
- return string;
267
- }
199
+ if (void 0 === styler) return string;
268
200
  const {openAll, closeAll} = styler;
269
- if (string.indexOf("") !== -1) {
270
- while (styler !== undefined) {
271
- string = stringReplaceAll(string, styler.close, styler.open);
272
- styler = styler.parent;
273
- }
274
- }
201
+ if (-1 !== string.indexOf("")) for (;void 0 !== styler; ) string = stringReplaceAll(string, styler.close, styler.open),
202
+ styler = styler.parent;
275
203
  const lfIndex = string.indexOf("\n");
276
- if (lfIndex !== -1) {
277
- string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
278
- }
279
- return openAll + string + closeAll;
204
+ return -1 !== lfIndex && (string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex)),
205
+ openAll + string + closeAll;
280
206
  };
281
207
  let template;
282
208
  const chalkTag = (chalk, ...strings) => {
283
209
  const [firstString] = strings;
284
- if (!isArray(firstString) || !isArray(firstString.raw)) {
285
- return strings.join(" ");
286
- }
287
- const arguments_ = strings.slice(1);
288
- const parts = [ firstString.raw[0] ];
289
- for (let i = 1; i < firstString.length; i++) {
290
- parts.push(String(arguments_[i - 1]).replace(/[{}\\]/g, "\\$&"), String(firstString.raw[i]));
291
- }
292
- if (template === undefined) {
293
- template = __webpack_require__(2154);
294
- }
295
- return template(chalk, parts.join(""));
210
+ if (!isArray(firstString) || !isArray(firstString.raw)) return strings.join(" ");
211
+ const arguments_ = strings.slice(1), parts = [ firstString.raw[0] ];
212
+ for (let i = 1; i < firstString.length; i++) parts.push(String(arguments_[i - 1]).replace(/[{}\\]/g, "\\$&"), String(firstString.raw[i]));
213
+ return void 0 === template && (template = __webpack_require__(2154)), template(chalk, parts.join(""));
296
214
  };
297
215
  Object.defineProperties(Chalk.prototype, styles);
298
216
  const chalk = Chalk();
299
- chalk.supportsColor = stdoutColor;
300
- chalk.stderr = Chalk({
217
+ chalk.supportsColor = stdoutColor, chalk.stderr = Chalk({
301
218
  level: stderrColor ? stderrColor.level : 0
302
- });
303
- chalk.stderr.supportsColor = stderrColor;
304
- module.exports = chalk;
219
+ }), chalk.stderr.supportsColor = stderrColor, module.exports = chalk;
305
220
  },
306
221
  2154: module => {
307
222
  "use strict";
308
- const TEMPLATE_REGEX = /(?:\\(u(?:[a-f\d]{4}|\{[a-f\d]{1,6}\})|x[a-f\d]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([^)]*\))?)*)(?:[ \t]|(?=\r?\n)))|(\})|((?:.|[\r\n\f])+?)/gi;
309
- const STYLE_REGEX = /(?:^|\.)(\w+)(?:\(([^)]*)\))?/g;
310
- const STRING_REGEX = /^(['"])((?:\\.|(?!\1)[^\\])*)\1$/;
311
- const ESCAPE_REGEX = /\\(u(?:[a-f\d]{4}|{[a-f\d]{1,6}})|x[a-f\d]{2}|.)|([^\\])/gi;
312
- const ESCAPES = new Map([ [ "n", "\n" ], [ "r", "\r" ], [ "t", "\t" ], [ "b", "\b" ], [ "f", "\f" ], [ "v", "\v" ], [ "0", "\0" ], [ "\\", "\\" ], [ "e", "" ], [ "a", "" ] ]);
223
+ const TEMPLATE_REGEX = /(?:\\(u(?:[a-f\d]{4}|\{[a-f\d]{1,6}\})|x[a-f\d]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([^)]*\))?)*)(?:[ \t]|(?=\r?\n)))|(\})|((?:.|[\r\n\f])+?)/gi, STYLE_REGEX = /(?:^|\.)(\w+)(?:\(([^)]*)\))?/g, STRING_REGEX = /^(['"])((?:\\.|(?!\1)[^\\])*)\1$/, ESCAPE_REGEX = /\\(u(?:[a-f\d]{4}|{[a-f\d]{1,6}})|x[a-f\d]{2}|.)|([^\\])/gi, ESCAPES = new Map([ [ "n", "\n" ], [ "r", "\r" ], [ "t", "\t" ], [ "b", "\b" ], [ "f", "\f" ], [ "v", "\v" ], [ "0", "\0" ], [ "\\", "\\" ], [ "e", "" ], [ "a", "" ] ]);
313
224
  function unescape(c) {
314
- const u = c[0] === "u";
315
- const bracket = c[1] === "{";
316
- if (u && !bracket && c.length === 5 || c[0] === "x" && c.length === 3) {
317
- return String.fromCharCode(parseInt(c.slice(1), 16));
318
- }
319
- if (u && bracket) {
320
- return String.fromCodePoint(parseInt(c.slice(2, -1), 16));
321
- }
322
- return ESCAPES.get(c) || c;
225
+ const u = "u" === c[0], bracket = "{" === c[1];
226
+ return u && !bracket && 5 === c.length || "x" === c[0] && 3 === c.length ? String.fromCharCode(parseInt(c.slice(1), 16)) : u && bracket ? String.fromCodePoint(parseInt(c.slice(2, -1), 16)) : ESCAPES.get(c) || c;
323
227
  }
324
228
  function parseArguments(name, arguments_) {
325
- const results = [];
326
- const chunks = arguments_.trim().split(/\s*,\s*/g);
229
+ const results = [], chunks = arguments_.trim().split(/\s*,\s*/g);
327
230
  let matches;
328
231
  for (const chunk of chunks) {
329
232
  const number = Number(chunk);
330
- if (!Number.isNaN(number)) {
331
- results.push(number);
332
- } else if (matches = chunk.match(STRING_REGEX)) {
233
+ if (Number.isNaN(number)) {
234
+ if (!(matches = chunk.match(STRING_REGEX))) throw new Error(`Invalid Chalk template style argument: ${chunk} (in style '${name}')`);
333
235
  results.push(matches[2].replace(ESCAPE_REGEX, ((m, escape, character) => escape ? unescape(escape) : character)));
334
- } else {
335
- throw new Error(`Invalid Chalk template style argument: ${chunk} (in style '${name}')`);
336
- }
236
+ } else results.push(number);
337
237
  }
338
238
  return results;
339
239
  }
@@ -341,65 +241,42 @@ var __webpack_modules__ = {
341
241
  STYLE_REGEX.lastIndex = 0;
342
242
  const results = [];
343
243
  let matches;
344
- while ((matches = STYLE_REGEX.exec(style)) !== null) {
244
+ for (;null !== (matches = STYLE_REGEX.exec(style)); ) {
345
245
  const name = matches[1];
346
246
  if (matches[2]) {
347
247
  const args = parseArguments(name, matches[2]);
348
248
  results.push([ name ].concat(args));
349
- } else {
350
- results.push([ name ]);
351
- }
249
+ } else results.push([ name ]);
352
250
  }
353
251
  return results;
354
252
  }
355
253
  function buildStyle(chalk, styles) {
356
254
  const enabled = {};
357
- for (const layer of styles) {
358
- for (const style of layer.styles) {
359
- enabled[style[0]] = layer.inverse ? null : style.slice(1);
360
- }
361
- }
255
+ for (const layer of styles) for (const style of layer.styles) enabled[style[0]] = layer.inverse ? null : style.slice(1);
362
256
  let current = chalk;
363
- for (const [styleName, styles] of Object.entries(enabled)) {
364
- if (!Array.isArray(styles)) {
365
- continue;
366
- }
367
- if (!(styleName in current)) {
368
- throw new Error(`Unknown Chalk style: ${styleName}`);
369
- }
257
+ for (const [styleName, styles] of Object.entries(enabled)) if (Array.isArray(styles)) {
258
+ if (!(styleName in current)) throw new Error(`Unknown Chalk style: ${styleName}`);
370
259
  current = styles.length > 0 ? current[styleName](...styles) : current[styleName];
371
260
  }
372
261
  return current;
373
262
  }
374
263
  module.exports = (chalk, temporary) => {
375
- const styles = [];
376
- const chunks = [];
264
+ const styles = [], chunks = [];
377
265
  let chunk = [];
378
- temporary.replace(TEMPLATE_REGEX, ((m, escapeCharacter, inverse, style, close, character) => {
379
- if (escapeCharacter) {
380
- chunk.push(unescape(escapeCharacter));
381
- } else if (style) {
266
+ if (temporary.replace(TEMPLATE_REGEX, ((m, escapeCharacter, inverse, style, close, character) => {
267
+ if (escapeCharacter) chunk.push(unescape(escapeCharacter)); else if (style) {
382
268
  const string = chunk.join("");
383
- chunk = [];
384
- chunks.push(styles.length === 0 ? string : buildStyle(chalk, styles)(string));
269
+ chunk = [], chunks.push(0 === styles.length ? string : buildStyle(chalk, styles)(string)),
385
270
  styles.push({
386
271
  inverse,
387
272
  styles: parseStyle(style)
388
273
  });
389
274
  } else if (close) {
390
- if (styles.length === 0) {
391
- throw new Error("Found extraneous } in Chalk template literal");
392
- }
393
- chunks.push(buildStyle(chalk, styles)(chunk.join("")));
394
- chunk = [];
395
- styles.pop();
396
- } else {
397
- chunk.push(character);
398
- }
399
- }));
400
- chunks.push(chunk.join(""));
401
- if (styles.length > 0) {
402
- const errMessage = `Chalk template literal is missing ${styles.length} closing bracket${styles.length === 1 ? "" : "s"} (\`}\`)`;
275
+ if (0 === styles.length) throw new Error("Found extraneous } in Chalk template literal");
276
+ chunks.push(buildStyle(chalk, styles)(chunk.join(""))), chunk = [], styles.pop();
277
+ } else chunk.push(character);
278
+ })), chunks.push(chunk.join("")), styles.length > 0) {
279
+ const errMessage = `Chalk template literal is missing ${styles.length} closing bracket${1 === styles.length ? "" : "s"} (\`}\`)`;
403
280
  throw new Error(errMessage);
404
281
  }
405
282
  return chunks.join("");
@@ -407,45 +284,32 @@ var __webpack_modules__ = {
407
284
  },
408
285
  8564: module => {
409
286
  "use strict";
410
- const stringReplaceAll = (string, substring, replacer) => {
411
- let index = string.indexOf(substring);
412
- if (index === -1) {
413
- return string;
414
- }
415
- const substringLength = substring.length;
416
- let endIndex = 0;
417
- let returnValue = "";
418
- do {
419
- returnValue += string.substr(endIndex, index - endIndex) + substring + replacer;
420
- endIndex = index + substringLength;
421
- index = string.indexOf(substring, endIndex);
422
- } while (index !== -1);
423
- returnValue += string.substr(endIndex);
424
- return returnValue;
425
- };
426
- const stringEncaseCRLFWithFirstIndex = (string, prefix, postfix, index) => {
427
- let endIndex = 0;
428
- let returnValue = "";
429
- do {
430
- const gotCR = string[index - 1] === "\r";
431
- returnValue += string.substr(endIndex, (gotCR ? index - 1 : index) - endIndex) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
432
- endIndex = index + 1;
433
- index = string.indexOf("\n", endIndex);
434
- } while (index !== -1);
435
- returnValue += string.substr(endIndex);
436
- return returnValue;
437
- };
438
287
  module.exports = {
439
- stringReplaceAll,
440
- stringEncaseCRLFWithFirstIndex
288
+ stringReplaceAll: (string, substring, replacer) => {
289
+ let index = string.indexOf(substring);
290
+ if (-1 === index) return string;
291
+ const substringLength = substring.length;
292
+ let endIndex = 0, returnValue = "";
293
+ do {
294
+ returnValue += string.substr(endIndex, index - endIndex) + substring + replacer,
295
+ endIndex = index + substringLength, index = string.indexOf(substring, endIndex);
296
+ } while (-1 !== index);
297
+ return returnValue += string.substr(endIndex), returnValue;
298
+ },
299
+ stringEncaseCRLFWithFirstIndex: (string, prefix, postfix, index) => {
300
+ let endIndex = 0, returnValue = "";
301
+ do {
302
+ const gotCR = "\r" === string[index - 1];
303
+ returnValue += string.substr(endIndex, (gotCR ? index - 1 : index) - endIndex) + prefix + (gotCR ? "\r\n" : "\n") + postfix,
304
+ endIndex = index + 1, index = string.indexOf("\n", endIndex);
305
+ } while (-1 !== index);
306
+ return returnValue += string.substr(endIndex), returnValue;
307
+ }
441
308
  };
442
309
  },
443
310
  2538: (module, __unused_webpack_exports, __webpack_require__) => {
444
- const cssKeywords = __webpack_require__(6150);
445
- const reverseKeywords = {};
446
- for (const key of Object.keys(cssKeywords)) {
447
- reverseKeywords[cssKeywords[key]] = key;
448
- }
311
+ const cssKeywords = __webpack_require__(6150), reverseKeywords = {};
312
+ for (const key of Object.keys(cssKeywords)) reverseKeywords[cssKeywords[key]] = key;
449
313
  const convert = {
450
314
  rgb: {
451
315
  channels: 3,
@@ -510,227 +374,84 @@ var __webpack_modules__ = {
510
374
  };
511
375
  module.exports = convert;
512
376
  for (const model of Object.keys(convert)) {
513
- if (!("channels" in convert[model])) {
514
- throw new Error("missing channels property: " + model);
515
- }
516
- if (!("labels" in convert[model])) {
517
- throw new Error("missing channel labels property: " + model);
518
- }
519
- if (convert[model].labels.length !== convert[model].channels) {
520
- throw new Error("channel and label counts mismatch: " + model);
521
- }
377
+ if (!("channels" in convert[model])) throw new Error("missing channels property: " + model);
378
+ if (!("labels" in convert[model])) throw new Error("missing channel labels property: " + model);
379
+ if (convert[model].labels.length !== convert[model].channels) throw new Error("channel and label counts mismatch: " + model);
522
380
  const {channels, labels} = convert[model];
523
- delete convert[model].channels;
524
- delete convert[model].labels;
525
- Object.defineProperty(convert[model], "channels", {
381
+ delete convert[model].channels, delete convert[model].labels, Object.defineProperty(convert[model], "channels", {
526
382
  value: channels
527
- });
528
- Object.defineProperty(convert[model], "labels", {
383
+ }), Object.defineProperty(convert[model], "labels", {
529
384
  value: labels
530
385
  });
531
386
  }
532
387
  convert.rgb.hsl = function(rgb) {
533
- const r = rgb[0] / 255;
534
- const g = rgb[1] / 255;
535
- const b = rgb[2] / 255;
536
- const min = Math.min(r, g, b);
537
- const max = Math.max(r, g, b);
538
- const delta = max - min;
539
- let h;
540
- let s;
541
- if (max === min) {
542
- h = 0;
543
- } else if (r === max) {
544
- h = (g - b) / delta;
545
- } else if (g === max) {
546
- h = 2 + (b - r) / delta;
547
- } else if (b === max) {
548
- h = 4 + (r - g) / delta;
549
- }
550
- h = Math.min(h * 60, 360);
551
- if (h < 0) {
552
- h += 360;
553
- }
388
+ const r = rgb[0] / 255, g = rgb[1] / 255, b = rgb[2] / 255, min = Math.min(r, g, b), max = Math.max(r, g, b), delta = max - min;
389
+ let h, s;
390
+ max === min ? h = 0 : r === max ? h = (g - b) / delta : g === max ? h = 2 + (b - r) / delta : b === max && (h = 4 + (r - g) / delta),
391
+ h = Math.min(60 * h, 360), h < 0 && (h += 360);
554
392
  const l = (min + max) / 2;
555
- if (max === min) {
556
- s = 0;
557
- } else if (l <= .5) {
558
- s = delta / (max + min);
559
- } else {
560
- s = delta / (2 - max - min);
561
- }
562
- return [ h, s * 100, l * 100 ];
563
- };
564
- convert.rgb.hsv = function(rgb) {
565
- let rdif;
566
- let gdif;
567
- let bdif;
568
- let h;
569
- let s;
570
- const r = rgb[0] / 255;
571
- const g = rgb[1] / 255;
572
- const b = rgb[2] / 255;
573
- const v = Math.max(r, g, b);
574
- const diff = v - Math.min(r, g, b);
575
- const diffc = function(c) {
576
- return (v - c) / 6 / diff + 1 / 2;
393
+ return s = max === min ? 0 : l <= .5 ? delta / (max + min) : delta / (2 - max - min),
394
+ [ h, 100 * s, 100 * l ];
395
+ }, convert.rgb.hsv = function(rgb) {
396
+ let rdif, gdif, bdif, h, s;
397
+ const r = rgb[0] / 255, g = rgb[1] / 255, b = rgb[2] / 255, v = Math.max(r, g, b), diff = v - Math.min(r, g, b), diffc = function(c) {
398
+ return (v - c) / 6 / diff + .5;
577
399
  };
578
- if (diff === 0) {
579
- h = 0;
580
- s = 0;
581
- } else {
582
- s = diff / v;
583
- rdif = diffc(r);
584
- gdif = diffc(g);
585
- bdif = diffc(b);
586
- if (r === v) {
587
- h = bdif - gdif;
588
- } else if (g === v) {
589
- h = 1 / 3 + rdif - bdif;
590
- } else if (b === v) {
591
- h = 2 / 3 + gdif - rdif;
592
- }
593
- if (h < 0) {
594
- h += 1;
595
- } else if (h > 1) {
596
- h -= 1;
597
- }
598
- }
599
- return [ h * 360, s * 100, v * 100 ];
600
- };
601
- convert.rgb.hwb = function(rgb) {
602
- const r = rgb[0];
603
- const g = rgb[1];
400
+ return 0 === diff ? (h = 0, s = 0) : (s = diff / v, rdif = diffc(r), gdif = diffc(g),
401
+ bdif = diffc(b), r === v ? h = bdif - gdif : g === v ? h = 1 / 3 + rdif - bdif : b === v && (h = 2 / 3 + gdif - rdif),
402
+ h < 0 ? h += 1 : h > 1 && (h -= 1)), [ 360 * h, 100 * s, 100 * v ];
403
+ }, convert.rgb.hwb = function(rgb) {
404
+ const r = rgb[0], g = rgb[1];
604
405
  let b = rgb[2];
605
- const h = convert.rgb.hsl(rgb)[0];
606
- const w = 1 / 255 * Math.min(r, Math.min(g, b));
607
- b = 1 - 1 / 255 * Math.max(r, Math.max(g, b));
608
- return [ h, w * 100, b * 100 ];
609
- };
610
- convert.rgb.cmyk = function(rgb) {
611
- const r = rgb[0] / 255;
612
- const g = rgb[1] / 255;
613
- const b = rgb[2] / 255;
614
- const k = Math.min(1 - r, 1 - g, 1 - b);
615
- const c = (1 - r - k) / (1 - k) || 0;
616
- const m = (1 - g - k) / (1 - k) || 0;
617
- const y = (1 - b - k) / (1 - k) || 0;
618
- return [ c * 100, m * 100, y * 100, k * 100 ];
619
- };
620
- function comparativeDistance(x, y) {
621
- return (x[0] - y[0]) ** 2 + (x[1] - y[1]) ** 2 + (x[2] - y[2]) ** 2;
622
- }
623
- convert.rgb.keyword = function(rgb) {
406
+ const h = convert.rgb.hsl(rgb)[0], w = 1 / 255 * Math.min(r, Math.min(g, b));
407
+ return b = 1 - 1 / 255 * Math.max(r, Math.max(g, b)), [ h, 100 * w, 100 * b ];
408
+ }, convert.rgb.cmyk = function(rgb) {
409
+ const r = rgb[0] / 255, g = rgb[1] / 255, b = rgb[2] / 255, k = Math.min(1 - r, 1 - g, 1 - b);
410
+ return [ 100 * ((1 - r - k) / (1 - k) || 0), 100 * ((1 - g - k) / (1 - k) || 0), 100 * ((1 - b - k) / (1 - k) || 0), 100 * k ];
411
+ }, convert.rgb.keyword = function(rgb) {
624
412
  const reversed = reverseKeywords[rgb];
625
- if (reversed) {
626
- return reversed;
627
- }
628
- let currentClosestDistance = Infinity;
629
- let currentClosestKeyword;
413
+ if (reversed) return reversed;
414
+ let currentClosestKeyword, currentClosestDistance = 1 / 0;
630
415
  for (const keyword of Object.keys(cssKeywords)) {
631
- const value = cssKeywords[keyword];
632
- const distance = comparativeDistance(rgb, value);
633
- if (distance < currentClosestDistance) {
634
- currentClosestDistance = distance;
635
- currentClosestKeyword = keyword;
636
- }
416
+ const value = cssKeywords[keyword], distance = (y = value, ((x = rgb)[0] - y[0]) ** 2 + (x[1] - y[1]) ** 2 + (x[2] - y[2]) ** 2);
417
+ distance < currentClosestDistance && (currentClosestDistance = distance, currentClosestKeyword = keyword);
637
418
  }
419
+ var x, y;
638
420
  return currentClosestKeyword;
639
- };
640
- convert.keyword.rgb = function(keyword) {
421
+ }, convert.keyword.rgb = function(keyword) {
641
422
  return cssKeywords[keyword];
642
- };
643
- convert.rgb.xyz = function(rgb) {
644
- let r = rgb[0] / 255;
645
- let g = rgb[1] / 255;
646
- let b = rgb[2] / 255;
647
- r = r > .04045 ? ((r + .055) / 1.055) ** 2.4 : r / 12.92;
648
- g = g > .04045 ? ((g + .055) / 1.055) ** 2.4 : g / 12.92;
423
+ }, convert.rgb.xyz = function(rgb) {
424
+ let r = rgb[0] / 255, g = rgb[1] / 255, b = rgb[2] / 255;
425
+ r = r > .04045 ? ((r + .055) / 1.055) ** 2.4 : r / 12.92, g = g > .04045 ? ((g + .055) / 1.055) ** 2.4 : g / 12.92,
649
426
  b = b > .04045 ? ((b + .055) / 1.055) ** 2.4 : b / 12.92;
650
- const x = r * .4124 + g * .3576 + b * .1805;
651
- const y = r * .2126 + g * .7152 + b * .0722;
652
- const z = r * .0193 + g * .1192 + b * .9505;
653
- return [ x * 100, y * 100, z * 100 ];
654
- };
655
- convert.rgb.lab = function(rgb) {
427
+ return [ 100 * (.4124 * r + .3576 * g + .1805 * b), 100 * (.2126 * r + .7152 * g + .0722 * b), 100 * (.0193 * r + .1192 * g + .9505 * b) ];
428
+ }, convert.rgb.lab = function(rgb) {
656
429
  const xyz = convert.rgb.xyz(rgb);
657
- let x = xyz[0];
658
- let y = xyz[1];
659
- let z = xyz[2];
660
- x /= 95.047;
661
- y /= 100;
662
- z /= 108.883;
663
- x = x > .008856 ? x ** (1 / 3) : 7.787 * x + 16 / 116;
664
- y = y > .008856 ? y ** (1 / 3) : 7.787 * y + 16 / 116;
665
- z = z > .008856 ? z ** (1 / 3) : 7.787 * z + 16 / 116;
666
- const l = 116 * y - 16;
667
- const a = 500 * (x - y);
668
- const b = 200 * (y - z);
669
- return [ l, a, b ];
670
- };
671
- convert.hsl.rgb = function(hsl) {
672
- const h = hsl[0] / 360;
673
- const s = hsl[1] / 100;
674
- const l = hsl[2] / 100;
675
- let t2;
676
- let t3;
677
- let val;
678
- if (s === 0) {
679
- val = l * 255;
680
- return [ val, val, val ];
681
- }
682
- if (l < .5) {
683
- t2 = l * (1 + s);
684
- } else {
685
- t2 = l + s - l * s;
686
- }
687
- const t1 = 2 * l - t2;
688
- const rgb = [ 0, 0, 0 ];
689
- for (let i = 0; i < 3; i++) {
690
- t3 = h + 1 / 3 * -(i - 1);
691
- if (t3 < 0) {
692
- t3++;
693
- }
694
- if (t3 > 1) {
695
- t3--;
696
- }
697
- if (6 * t3 < 1) {
698
- val = t1 + (t2 - t1) * 6 * t3;
699
- } else if (2 * t3 < 1) {
700
- val = t2;
701
- } else if (3 * t3 < 2) {
702
- val = t1 + (t2 - t1) * (2 / 3 - t3) * 6;
703
- } else {
704
- val = t1;
705
- }
706
- rgb[i] = val * 255;
707
- }
430
+ let x = xyz[0], y = xyz[1], z = xyz[2];
431
+ x /= 95.047, y /= 100, z /= 108.883, x = x > .008856 ? x ** (1 / 3) : 7.787 * x + 16 / 116,
432
+ y = y > .008856 ? y ** (1 / 3) : 7.787 * y + 16 / 116, z = z > .008856 ? z ** (1 / 3) : 7.787 * z + 16 / 116;
433
+ return [ 116 * y - 16, 500 * (x - y), 200 * (y - z) ];
434
+ }, convert.hsl.rgb = function(hsl) {
435
+ const h = hsl[0] / 360, s = hsl[1] / 100, l = hsl[2] / 100;
436
+ let t2, t3, val;
437
+ if (0 === s) return val = 255 * l, [ val, val, val ];
438
+ t2 = l < .5 ? l * (1 + s) : l + s - l * s;
439
+ const t1 = 2 * l - t2, rgb = [ 0, 0, 0 ];
440
+ for (let i = 0; i < 3; i++) t3 = h + 1 / 3 * -(i - 1), t3 < 0 && t3++, t3 > 1 && t3--,
441
+ val = 6 * t3 < 1 ? t1 + 6 * (t2 - t1) * t3 : 2 * t3 < 1 ? t2 : 3 * t3 < 2 ? t1 + (t2 - t1) * (2 / 3 - t3) * 6 : t1,
442
+ rgb[i] = 255 * val;
708
443
  return rgb;
709
- };
710
- convert.hsl.hsv = function(hsl) {
444
+ }, convert.hsl.hsv = function(hsl) {
711
445
  const h = hsl[0];
712
- let s = hsl[1] / 100;
713
- let l = hsl[2] / 100;
714
- let smin = s;
446
+ let s = hsl[1] / 100, l = hsl[2] / 100, smin = s;
715
447
  const lmin = Math.max(l, .01);
716
- l *= 2;
717
- s *= l <= 1 ? l : 2 - l;
718
- smin *= lmin <= 1 ? lmin : 2 - lmin;
719
- const v = (l + s) / 2;
720
- const sv = l === 0 ? 2 * smin / (lmin + smin) : 2 * s / (l + s);
721
- return [ h, sv * 100, v * 100 ];
722
- };
723
- convert.hsv.rgb = function(hsv) {
724
- const h = hsv[0] / 60;
725
- const s = hsv[1] / 100;
448
+ l *= 2, s *= l <= 1 ? l : 2 - l, smin *= lmin <= 1 ? lmin : 2 - lmin;
449
+ return [ h, 100 * (0 === l ? 2 * smin / (lmin + smin) : 2 * s / (l + s)), 100 * ((l + s) / 2) ];
450
+ }, convert.hsv.rgb = function(hsv) {
451
+ const h = hsv[0] / 60, s = hsv[1] / 100;
726
452
  let v = hsv[2] / 100;
727
- const hi = Math.floor(h) % 6;
728
- const f = h - Math.floor(h);
729
- const p = 255 * v * (1 - s);
730
- const q = 255 * v * (1 - s * f);
731
- const t = 255 * v * (1 - s * (1 - f));
732
- v *= 255;
733
- switch (hi) {
453
+ const hi = Math.floor(h) % 6, f = h - Math.floor(h), p = 255 * v * (1 - s), q = 255 * v * (1 - s * f), t = 255 * v * (1 - s * (1 - f));
454
+ switch (v *= 255, hi) {
734
455
  case 0:
735
456
  return [ v, t, p ];
736
457
 
@@ -749,507 +470,244 @@ var __webpack_modules__ = {
749
470
  case 5:
750
471
  return [ v, p, q ];
751
472
  }
752
- };
753
- convert.hsv.hsl = function(hsv) {
754
- const h = hsv[0];
755
- const s = hsv[1] / 100;
756
- const v = hsv[2] / 100;
757
- const vmin = Math.max(v, .01);
758
- let sl;
759
- let l;
473
+ }, convert.hsv.hsl = function(hsv) {
474
+ const h = hsv[0], s = hsv[1] / 100, v = hsv[2] / 100, vmin = Math.max(v, .01);
475
+ let sl, l;
760
476
  l = (2 - s) * v;
761
477
  const lmin = (2 - s) * vmin;
762
- sl = s * vmin;
763
- sl /= lmin <= 1 ? lmin : 2 - lmin;
764
- sl = sl || 0;
765
- l /= 2;
766
- return [ h, sl * 100, l * 100 ];
767
- };
768
- convert.hwb.rgb = function(hwb) {
478
+ return sl = s * vmin, sl /= lmin <= 1 ? lmin : 2 - lmin, sl = sl || 0, l /= 2, [ h, 100 * sl, 100 * l ];
479
+ }, convert.hwb.rgb = function(hwb) {
769
480
  const h = hwb[0] / 360;
770
- let wh = hwb[1] / 100;
771
- let bl = hwb[2] / 100;
481
+ let wh = hwb[1] / 100, bl = hwb[2] / 100;
772
482
  const ratio = wh + bl;
773
483
  let f;
774
- if (ratio > 1) {
775
- wh /= ratio;
776
- bl /= ratio;
777
- }
778
- const i = Math.floor(6 * h);
779
- const v = 1 - bl;
780
- f = 6 * h - i;
781
- if ((i & 1) !== 0) {
782
- f = 1 - f;
783
- }
484
+ ratio > 1 && (wh /= ratio, bl /= ratio);
485
+ const i = Math.floor(6 * h), v = 1 - bl;
486
+ f = 6 * h - i, 0 != (1 & i) && (f = 1 - f);
784
487
  const n = wh + f * (v - wh);
785
- let r;
786
- let g;
787
- let b;
488
+ let r, g, b;
788
489
  switch (i) {
789
490
  default:
790
491
  case 6:
791
492
  case 0:
792
- r = v;
793
- g = n;
794
- b = wh;
493
+ r = v, g = n, b = wh;
795
494
  break;
796
495
 
797
496
  case 1:
798
- r = n;
799
- g = v;
800
- b = wh;
497
+ r = n, g = v, b = wh;
801
498
  break;
802
499
 
803
500
  case 2:
804
- r = wh;
805
- g = v;
806
- b = n;
501
+ r = wh, g = v, b = n;
807
502
  break;
808
503
 
809
504
  case 3:
810
- r = wh;
811
- g = n;
812
- b = v;
505
+ r = wh, g = n, b = v;
813
506
  break;
814
507
 
815
508
  case 4:
816
- r = n;
817
- g = wh;
818
- b = v;
509
+ r = n, g = wh, b = v;
819
510
  break;
820
511
 
821
512
  case 5:
822
- r = v;
823
- g = wh;
824
- b = n;
825
- break;
826
- }
827
- return [ r * 255, g * 255, b * 255 ];
828
- };
829
- convert.cmyk.rgb = function(cmyk) {
830
- const c = cmyk[0] / 100;
831
- const m = cmyk[1] / 100;
832
- const y = cmyk[2] / 100;
833
- const k = cmyk[3] / 100;
834
- const r = 1 - Math.min(1, c * (1 - k) + k);
835
- const g = 1 - Math.min(1, m * (1 - k) + k);
836
- const b = 1 - Math.min(1, y * (1 - k) + k);
837
- return [ r * 255, g * 255, b * 255 ];
838
- };
839
- convert.xyz.rgb = function(xyz) {
840
- const x = xyz[0] / 100;
841
- const y = xyz[1] / 100;
842
- const z = xyz[2] / 100;
843
- let r;
844
- let g;
845
- let b;
846
- r = x * 3.2406 + y * -1.5372 + z * -.4986;
847
- g = x * -.9689 + y * 1.8758 + z * .0415;
848
- b = x * .0557 + y * -.204 + z * 1.057;
849
- r = r > .0031308 ? 1.055 * r ** (1 / 2.4) - .055 : r * 12.92;
850
- g = g > .0031308 ? 1.055 * g ** (1 / 2.4) - .055 : g * 12.92;
851
- b = b > .0031308 ? 1.055 * b ** (1 / 2.4) - .055 : b * 12.92;
852
- r = Math.min(Math.max(0, r), 1);
853
- g = Math.min(Math.max(0, g), 1);
854
- b = Math.min(Math.max(0, b), 1);
855
- return [ r * 255, g * 255, b * 255 ];
856
- };
857
- convert.xyz.lab = function(xyz) {
858
- let x = xyz[0];
859
- let y = xyz[1];
860
- let z = xyz[2];
861
- x /= 95.047;
862
- y /= 100;
863
- z /= 108.883;
864
- x = x > .008856 ? x ** (1 / 3) : 7.787 * x + 16 / 116;
865
- y = y > .008856 ? y ** (1 / 3) : 7.787 * y + 16 / 116;
866
- z = z > .008856 ? z ** (1 / 3) : 7.787 * z + 16 / 116;
867
- const l = 116 * y - 16;
868
- const a = 500 * (x - y);
869
- const b = 200 * (y - z);
870
- return [ l, a, b ];
871
- };
872
- convert.lab.xyz = function(lab) {
873
- const l = lab[0];
874
- const a = lab[1];
875
- const b = lab[2];
876
- let x;
877
- let y;
878
- let z;
879
- y = (l + 16) / 116;
880
- x = a / 500 + y;
881
- z = y - b / 200;
882
- const y2 = y ** 3;
883
- const x2 = x ** 3;
884
- const z2 = z ** 3;
885
- y = y2 > .008856 ? y2 : (y - 16 / 116) / 7.787;
886
- x = x2 > .008856 ? x2 : (x - 16 / 116) / 7.787;
887
- z = z2 > .008856 ? z2 : (z - 16 / 116) / 7.787;
888
- x *= 95.047;
889
- y *= 100;
890
- z *= 108.883;
891
- return [ x, y, z ];
892
- };
893
- convert.lab.lch = function(lab) {
894
- const l = lab[0];
895
- const a = lab[1];
896
- const b = lab[2];
513
+ r = v, g = wh, b = n;
514
+ }
515
+ return [ 255 * r, 255 * g, 255 * b ];
516
+ }, convert.cmyk.rgb = function(cmyk) {
517
+ const c = cmyk[0] / 100, m = cmyk[1] / 100, y = cmyk[2] / 100, k = cmyk[3] / 100;
518
+ return [ 255 * (1 - Math.min(1, c * (1 - k) + k)), 255 * (1 - Math.min(1, m * (1 - k) + k)), 255 * (1 - Math.min(1, y * (1 - k) + k)) ];
519
+ }, convert.xyz.rgb = function(xyz) {
520
+ const x = xyz[0] / 100, y = xyz[1] / 100, z = xyz[2] / 100;
521
+ let r, g, b;
522
+ return r = 3.2406 * x + -1.5372 * y + -.4986 * z, g = -.9689 * x + 1.8758 * y + .0415 * z,
523
+ b = .0557 * x + -.204 * y + 1.057 * z, r = r > .0031308 ? 1.055 * r ** (1 / 2.4) - .055 : 12.92 * r,
524
+ g = g > .0031308 ? 1.055 * g ** (1 / 2.4) - .055 : 12.92 * g, b = b > .0031308 ? 1.055 * b ** (1 / 2.4) - .055 : 12.92 * b,
525
+ r = Math.min(Math.max(0, r), 1), g = Math.min(Math.max(0, g), 1), b = Math.min(Math.max(0, b), 1),
526
+ [ 255 * r, 255 * g, 255 * b ];
527
+ }, convert.xyz.lab = function(xyz) {
528
+ let x = xyz[0], y = xyz[1], z = xyz[2];
529
+ x /= 95.047, y /= 100, z /= 108.883, x = x > .008856 ? x ** (1 / 3) : 7.787 * x + 16 / 116,
530
+ y = y > .008856 ? y ** (1 / 3) : 7.787 * y + 16 / 116, z = z > .008856 ? z ** (1 / 3) : 7.787 * z + 16 / 116;
531
+ return [ 116 * y - 16, 500 * (x - y), 200 * (y - z) ];
532
+ }, convert.lab.xyz = function(lab) {
533
+ let x, y, z;
534
+ y = (lab[0] + 16) / 116, x = lab[1] / 500 + y, z = y - lab[2] / 200;
535
+ const y2 = y ** 3, x2 = x ** 3, z2 = z ** 3;
536
+ return y = y2 > .008856 ? y2 : (y - 16 / 116) / 7.787, x = x2 > .008856 ? x2 : (x - 16 / 116) / 7.787,
537
+ z = z2 > .008856 ? z2 : (z - 16 / 116) / 7.787, x *= 95.047, y *= 100, z *= 108.883,
538
+ [ x, y, z ];
539
+ }, convert.lab.lch = function(lab) {
540
+ const l = lab[0], a = lab[1], b = lab[2];
897
541
  let h;
898
- const hr = Math.atan2(b, a);
899
- h = hr * 360 / 2 / Math.PI;
900
- if (h < 0) {
901
- h += 360;
902
- }
903
- const c = Math.sqrt(a * a + b * b);
904
- return [ l, c, h ];
905
- };
906
- convert.lch.lab = function(lch) {
907
- const l = lch[0];
908
- const c = lch[1];
909
- const h = lch[2];
910
- const hr = h / 360 * 2 * Math.PI;
911
- const a = c * Math.cos(hr);
912
- const b = c * Math.sin(hr);
913
- return [ l, a, b ];
914
- };
915
- convert.rgb.ansi16 = function(args, saturation = null) {
542
+ h = 360 * Math.atan2(b, a) / 2 / Math.PI, h < 0 && (h += 360);
543
+ return [ l, Math.sqrt(a * a + b * b), h ];
544
+ }, convert.lch.lab = function(lch) {
545
+ const l = lch[0], c = lch[1], hr = lch[2] / 360 * 2 * Math.PI;
546
+ return [ l, c * Math.cos(hr), c * Math.sin(hr) ];
547
+ }, convert.rgb.ansi16 = function(args, saturation = null) {
916
548
  const [r, g, b] = args;
917
- let value = saturation === null ? convert.rgb.hsv(args)[2] : saturation;
918
- value = Math.round(value / 50);
919
- if (value === 0) {
920
- return 30;
921
- }
549
+ let value = null === saturation ? convert.rgb.hsv(args)[2] : saturation;
550
+ if (value = Math.round(value / 50), 0 === value) return 30;
922
551
  let ansi = 30 + (Math.round(b / 255) << 2 | Math.round(g / 255) << 1 | Math.round(r / 255));
923
- if (value === 2) {
924
- ansi += 60;
925
- }
926
- return ansi;
927
- };
928
- convert.hsv.ansi16 = function(args) {
552
+ return 2 === value && (ansi += 60), ansi;
553
+ }, convert.hsv.ansi16 = function(args) {
929
554
  return convert.rgb.ansi16(convert.hsv.rgb(args), args[2]);
930
- };
931
- convert.rgb.ansi256 = function(args) {
932
- const r = args[0];
933
- const g = args[1];
934
- const b = args[2];
935
- if (r === g && g === b) {
936
- if (r < 8) {
937
- return 16;
938
- }
939
- if (r > 248) {
940
- return 231;
941
- }
942
- return Math.round((r - 8) / 247 * 24) + 232;
943
- }
944
- const ansi = 16 + 36 * Math.round(r / 255 * 5) + 6 * Math.round(g / 255 * 5) + Math.round(b / 255 * 5);
945
- return ansi;
946
- };
947
- convert.ansi16.rgb = function(args) {
555
+ }, convert.rgb.ansi256 = function(args) {
556
+ const r = args[0], g = args[1], b = args[2];
557
+ if (r === g && g === b) return r < 8 ? 16 : r > 248 ? 231 : Math.round((r - 8) / 247 * 24) + 232;
558
+ return 16 + 36 * Math.round(r / 255 * 5) + 6 * Math.round(g / 255 * 5) + Math.round(b / 255 * 5);
559
+ }, convert.ansi16.rgb = function(args) {
948
560
  let color = args % 10;
949
- if (color === 0 || color === 7) {
950
- if (args > 50) {
951
- color += 3.5;
952
- }
953
- color = color / 10.5 * 255;
954
- return [ color, color, color ];
955
- }
956
- const mult = (~~(args > 50) + 1) * .5;
957
- const r = (color & 1) * mult * 255;
958
- const g = (color >> 1 & 1) * mult * 255;
959
- const b = (color >> 2 & 1) * mult * 255;
960
- return [ r, g, b ];
961
- };
962
- convert.ansi256.rgb = function(args) {
561
+ if (0 === color || 7 === color) return args > 50 && (color += 3.5), color = color / 10.5 * 255,
562
+ [ color, color, color ];
563
+ const mult = .5 * (1 + ~~(args > 50));
564
+ return [ (1 & color) * mult * 255, (color >> 1 & 1) * mult * 255, (color >> 2 & 1) * mult * 255 ];
565
+ }, convert.ansi256.rgb = function(args) {
963
566
  if (args >= 232) {
964
- const c = (args - 232) * 10 + 8;
567
+ const c = 10 * (args - 232) + 8;
965
568
  return [ c, c, c ];
966
569
  }
967
- args -= 16;
968
570
  let rem;
969
- const r = Math.floor(args / 36) / 5 * 255;
970
- const g = Math.floor((rem = args % 36) / 6) / 5 * 255;
971
- const b = rem % 6 / 5 * 255;
972
- return [ r, g, b ];
973
- };
974
- convert.rgb.hex = function(args) {
975
- const integer = ((Math.round(args[0]) & 255) << 16) + ((Math.round(args[1]) & 255) << 8) + (Math.round(args[2]) & 255);
976
- const string = integer.toString(16).toUpperCase();
571
+ args -= 16;
572
+ return [ Math.floor(args / 36) / 5 * 255, Math.floor((rem = args % 36) / 6) / 5 * 255, rem % 6 / 5 * 255 ];
573
+ }, convert.rgb.hex = function(args) {
574
+ const string = (((255 & Math.round(args[0])) << 16) + ((255 & Math.round(args[1])) << 8) + (255 & Math.round(args[2]))).toString(16).toUpperCase();
977
575
  return "000000".substring(string.length) + string;
978
- };
979
- convert.hex.rgb = function(args) {
576
+ }, convert.hex.rgb = function(args) {
980
577
  const match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
981
- if (!match) {
982
- return [ 0, 0, 0 ];
983
- }
578
+ if (!match) return [ 0, 0, 0 ];
984
579
  let colorString = match[0];
985
- if (match[0].length === 3) {
986
- colorString = colorString.split("").map((char => char + char)).join("");
987
- }
580
+ 3 === match[0].length && (colorString = colorString.split("").map((char => char + char)).join(""));
988
581
  const integer = parseInt(colorString, 16);
989
- const r = integer >> 16 & 255;
990
- const g = integer >> 8 & 255;
991
- const b = integer & 255;
992
- return [ r, g, b ];
993
- };
994
- convert.rgb.hcg = function(rgb) {
995
- const r = rgb[0] / 255;
996
- const g = rgb[1] / 255;
997
- const b = rgb[2] / 255;
998
- const max = Math.max(Math.max(r, g), b);
999
- const min = Math.min(Math.min(r, g), b);
1000
- const chroma = max - min;
1001
- let grayscale;
1002
- let hue;
1003
- if (chroma < 1) {
1004
- grayscale = min / (1 - chroma);
1005
- } else {
1006
- grayscale = 0;
1007
- }
1008
- if (chroma <= 0) {
1009
- hue = 0;
1010
- } else if (max === r) {
1011
- hue = (g - b) / chroma % 6;
1012
- } else if (max === g) {
1013
- hue = 2 + (b - r) / chroma;
1014
- } else {
1015
- hue = 4 + (r - g) / chroma;
1016
- }
1017
- hue /= 6;
1018
- hue %= 1;
1019
- return [ hue * 360, chroma * 100, grayscale * 100 ];
1020
- };
1021
- convert.hsl.hcg = function(hsl) {
1022
- const s = hsl[1] / 100;
1023
- const l = hsl[2] / 100;
1024
- const c = l < .5 ? 2 * s * l : 2 * s * (1 - l);
582
+ return [ integer >> 16 & 255, integer >> 8 & 255, 255 & integer ];
583
+ }, convert.rgb.hcg = function(rgb) {
584
+ const r = rgb[0] / 255, g = rgb[1] / 255, b = rgb[2] / 255, max = Math.max(Math.max(r, g), b), min = Math.min(Math.min(r, g), b), chroma = max - min;
585
+ let grayscale, hue;
586
+ return grayscale = chroma < 1 ? min / (1 - chroma) : 0, hue = chroma <= 0 ? 0 : max === r ? (g - b) / chroma % 6 : max === g ? 2 + (b - r) / chroma : 4 + (r - g) / chroma,
587
+ hue /= 6, hue %= 1, [ 360 * hue, 100 * chroma, 100 * grayscale ];
588
+ }, convert.hsl.hcg = function(hsl) {
589
+ const s = hsl[1] / 100, l = hsl[2] / 100, c = l < .5 ? 2 * s * l : 2 * s * (1 - l);
1025
590
  let f = 0;
1026
- if (c < 1) {
1027
- f = (l - .5 * c) / (1 - c);
1028
- }
1029
- return [ hsl[0], c * 100, f * 100 ];
1030
- };
1031
- convert.hsv.hcg = function(hsv) {
1032
- const s = hsv[1] / 100;
1033
- const v = hsv[2] / 100;
1034
- const c = s * v;
591
+ return c < 1 && (f = (l - .5 * c) / (1 - c)), [ hsl[0], 100 * c, 100 * f ];
592
+ }, convert.hsv.hcg = function(hsv) {
593
+ const s = hsv[1] / 100, v = hsv[2] / 100, c = s * v;
1035
594
  let f = 0;
1036
- if (c < 1) {
1037
- f = (v - c) / (1 - c);
1038
- }
1039
- return [ hsv[0], c * 100, f * 100 ];
1040
- };
1041
- convert.hcg.rgb = function(hcg) {
1042
- const h = hcg[0] / 360;
1043
- const c = hcg[1] / 100;
1044
- const g = hcg[2] / 100;
1045
- if (c === 0) {
1046
- return [ g * 255, g * 255, g * 255 ];
1047
- }
1048
- const pure = [ 0, 0, 0 ];
1049
- const hi = h % 1 * 6;
1050
- const v = hi % 1;
1051
- const w = 1 - v;
595
+ return c < 1 && (f = (v - c) / (1 - c)), [ hsv[0], 100 * c, 100 * f ];
596
+ }, convert.hcg.rgb = function(hcg) {
597
+ const h = hcg[0] / 360, c = hcg[1] / 100, g = hcg[2] / 100;
598
+ if (0 === c) return [ 255 * g, 255 * g, 255 * g ];
599
+ const pure = [ 0, 0, 0 ], hi = h % 1 * 6, v = hi % 1, w = 1 - v;
1052
600
  let mg = 0;
1053
601
  switch (Math.floor(hi)) {
1054
602
  case 0:
1055
- pure[0] = 1;
1056
- pure[1] = v;
1057
- pure[2] = 0;
603
+ pure[0] = 1, pure[1] = v, pure[2] = 0;
1058
604
  break;
1059
605
 
1060
606
  case 1:
1061
- pure[0] = w;
1062
- pure[1] = 1;
1063
- pure[2] = 0;
607
+ pure[0] = w, pure[1] = 1, pure[2] = 0;
1064
608
  break;
1065
609
 
1066
610
  case 2:
1067
- pure[0] = 0;
1068
- pure[1] = 1;
1069
- pure[2] = v;
611
+ pure[0] = 0, pure[1] = 1, pure[2] = v;
1070
612
  break;
1071
613
 
1072
614
  case 3:
1073
- pure[0] = 0;
1074
- pure[1] = w;
1075
- pure[2] = 1;
615
+ pure[0] = 0, pure[1] = w, pure[2] = 1;
1076
616
  break;
1077
617
 
1078
618
  case 4:
1079
- pure[0] = v;
1080
- pure[1] = 0;
1081
- pure[2] = 1;
619
+ pure[0] = v, pure[1] = 0, pure[2] = 1;
1082
620
  break;
1083
621
 
1084
622
  default:
1085
- pure[0] = 1;
1086
- pure[1] = 0;
1087
- pure[2] = w;
623
+ pure[0] = 1, pure[1] = 0, pure[2] = w;
1088
624
  }
1089
- mg = (1 - c) * g;
1090
- return [ (c * pure[0] + mg) * 255, (c * pure[1] + mg) * 255, (c * pure[2] + mg) * 255 ];
1091
- };
1092
- convert.hcg.hsv = function(hcg) {
1093
- const c = hcg[1] / 100;
1094
- const g = hcg[2] / 100;
1095
- const v = c + g * (1 - c);
625
+ return mg = (1 - c) * g, [ 255 * (c * pure[0] + mg), 255 * (c * pure[1] + mg), 255 * (c * pure[2] + mg) ];
626
+ }, convert.hcg.hsv = function(hcg) {
627
+ const c = hcg[1] / 100, v = c + hcg[2] / 100 * (1 - c);
1096
628
  let f = 0;
1097
- if (v > 0) {
1098
- f = c / v;
1099
- }
1100
- return [ hcg[0], f * 100, v * 100 ];
1101
- };
1102
- convert.hcg.hsl = function(hcg) {
1103
- const c = hcg[1] / 100;
1104
- const g = hcg[2] / 100;
1105
- const l = g * (1 - c) + .5 * c;
629
+ return v > 0 && (f = c / v), [ hcg[0], 100 * f, 100 * v ];
630
+ }, convert.hcg.hsl = function(hcg) {
631
+ const c = hcg[1] / 100, l = hcg[2] / 100 * (1 - c) + .5 * c;
1106
632
  let s = 0;
1107
- if (l > 0 && l < .5) {
1108
- s = c / (2 * l);
1109
- } else if (l >= .5 && l < 1) {
1110
- s = c / (2 * (1 - l));
1111
- }
1112
- return [ hcg[0], s * 100, l * 100 ];
1113
- };
1114
- convert.hcg.hwb = function(hcg) {
1115
- const c = hcg[1] / 100;
1116
- const g = hcg[2] / 100;
1117
- const v = c + g * (1 - c);
1118
- return [ hcg[0], (v - c) * 100, (1 - v) * 100 ];
1119
- };
1120
- convert.hwb.hcg = function(hwb) {
1121
- const w = hwb[1] / 100;
1122
- const b = hwb[2] / 100;
1123
- const v = 1 - b;
1124
- const c = v - w;
633
+ return l > 0 && l < .5 ? s = c / (2 * l) : l >= .5 && l < 1 && (s = c / (2 * (1 - l))),
634
+ [ hcg[0], 100 * s, 100 * l ];
635
+ }, convert.hcg.hwb = function(hcg) {
636
+ const c = hcg[1] / 100, v = c + hcg[2] / 100 * (1 - c);
637
+ return [ hcg[0], 100 * (v - c), 100 * (1 - v) ];
638
+ }, convert.hwb.hcg = function(hwb) {
639
+ const w = hwb[1] / 100, v = 1 - hwb[2] / 100, c = v - w;
1125
640
  let g = 0;
1126
- if (c < 1) {
1127
- g = (v - c) / (1 - c);
1128
- }
1129
- return [ hwb[0], c * 100, g * 100 ];
1130
- };
1131
- convert.apple.rgb = function(apple) {
641
+ return c < 1 && (g = (v - c) / (1 - c)), [ hwb[0], 100 * c, 100 * g ];
642
+ }, convert.apple.rgb = function(apple) {
1132
643
  return [ apple[0] / 65535 * 255, apple[1] / 65535 * 255, apple[2] / 65535 * 255 ];
1133
- };
1134
- convert.rgb.apple = function(rgb) {
644
+ }, convert.rgb.apple = function(rgb) {
1135
645
  return [ rgb[0] / 255 * 65535, rgb[1] / 255 * 65535, rgb[2] / 255 * 65535 ];
1136
- };
1137
- convert.gray.rgb = function(args) {
646
+ }, convert.gray.rgb = function(args) {
1138
647
  return [ args[0] / 100 * 255, args[0] / 100 * 255, args[0] / 100 * 255 ];
1139
- };
1140
- convert.gray.hsl = function(args) {
648
+ }, convert.gray.hsl = function(args) {
1141
649
  return [ 0, 0, args[0] ];
1142
- };
1143
- convert.gray.hsv = convert.gray.hsl;
1144
- convert.gray.hwb = function(gray) {
650
+ }, convert.gray.hsv = convert.gray.hsl, convert.gray.hwb = function(gray) {
1145
651
  return [ 0, 100, gray[0] ];
1146
- };
1147
- convert.gray.cmyk = function(gray) {
652
+ }, convert.gray.cmyk = function(gray) {
1148
653
  return [ 0, 0, 0, gray[0] ];
1149
- };
1150
- convert.gray.lab = function(gray) {
654
+ }, convert.gray.lab = function(gray) {
1151
655
  return [ gray[0], 0, 0 ];
1152
- };
1153
- convert.gray.hex = function(gray) {
1154
- const val = Math.round(gray[0] / 100 * 255) & 255;
1155
- const integer = (val << 16) + (val << 8) + val;
1156
- const string = integer.toString(16).toUpperCase();
656
+ }, convert.gray.hex = function(gray) {
657
+ const val = 255 & Math.round(gray[0] / 100 * 255), string = ((val << 16) + (val << 8) + val).toString(16).toUpperCase();
1157
658
  return "000000".substring(string.length) + string;
1158
- };
1159
- convert.rgb.gray = function(rgb) {
1160
- const val = (rgb[0] + rgb[1] + rgb[2]) / 3;
1161
- return [ val / 255 * 100 ];
659
+ }, convert.rgb.gray = function(rgb) {
660
+ return [ (rgb[0] + rgb[1] + rgb[2]) / 3 / 255 * 100 ];
1162
661
  };
1163
662
  },
1164
663
  9208: (module, __unused_webpack_exports, __webpack_require__) => {
1165
- const conversions = __webpack_require__(2538);
1166
- const route = __webpack_require__(2051);
1167
- const convert = {};
1168
- const models = Object.keys(conversions);
1169
- function wrapRaw(fn) {
1170
- const wrappedFn = function(...args) {
1171
- const arg0 = args[0];
1172
- if (arg0 === undefined || arg0 === null) {
1173
- return arg0;
1174
- }
1175
- if (arg0.length > 1) {
1176
- args = arg0;
1177
- }
1178
- return fn(args);
1179
- };
1180
- if ("conversion" in fn) {
1181
- wrappedFn.conversion = fn.conversion;
1182
- }
1183
- return wrappedFn;
1184
- }
1185
- function wrapRounded(fn) {
1186
- const wrappedFn = function(...args) {
1187
- const arg0 = args[0];
1188
- if (arg0 === undefined || arg0 === null) {
1189
- return arg0;
1190
- }
1191
- if (arg0.length > 1) {
1192
- args = arg0;
1193
- }
1194
- const result = fn(args);
1195
- if (typeof result === "object") {
1196
- for (let len = result.length, i = 0; i < len; i++) {
1197
- result[i] = Math.round(result[i]);
1198
- }
1199
- }
1200
- return result;
1201
- };
1202
- if ("conversion" in fn) {
1203
- wrappedFn.conversion = fn.conversion;
1204
- }
1205
- return wrappedFn;
1206
- }
1207
- models.forEach((fromModel => {
1208
- convert[fromModel] = {};
1209
- Object.defineProperty(convert[fromModel], "channels", {
664
+ const conversions = __webpack_require__(2538), route = __webpack_require__(2051), convert = {};
665
+ Object.keys(conversions).forEach((fromModel => {
666
+ convert[fromModel] = {}, Object.defineProperty(convert[fromModel], "channels", {
1210
667
  value: conversions[fromModel].channels
1211
- });
1212
- Object.defineProperty(convert[fromModel], "labels", {
668
+ }), Object.defineProperty(convert[fromModel], "labels", {
1213
669
  value: conversions[fromModel].labels
1214
670
  });
1215
671
  const routes = route(fromModel);
1216
- const routeModels = Object.keys(routes);
1217
- routeModels.forEach((toModel => {
672
+ Object.keys(routes).forEach((toModel => {
1218
673
  const fn = routes[toModel];
1219
- convert[fromModel][toModel] = wrapRounded(fn);
1220
- convert[fromModel][toModel].raw = wrapRaw(fn);
674
+ convert[fromModel][toModel] = function(fn) {
675
+ const wrappedFn = function(...args) {
676
+ const arg0 = args[0];
677
+ if (null == arg0) return arg0;
678
+ arg0.length > 1 && (args = arg0);
679
+ const result = fn(args);
680
+ if ("object" == typeof result) for (let len = result.length, i = 0; i < len; i++) result[i] = Math.round(result[i]);
681
+ return result;
682
+ };
683
+ return "conversion" in fn && (wrappedFn.conversion = fn.conversion), wrappedFn;
684
+ }(fn), convert[fromModel][toModel].raw = function(fn) {
685
+ const wrappedFn = function(...args) {
686
+ const arg0 = args[0];
687
+ return null == arg0 ? arg0 : (arg0.length > 1 && (args = arg0), fn(args));
688
+ };
689
+ return "conversion" in fn && (wrappedFn.conversion = fn.conversion), wrappedFn;
690
+ }(fn);
1221
691
  }));
1222
- }));
1223
- module.exports = convert;
692
+ })), module.exports = convert;
1224
693
  },
1225
694
  2051: (module, __unused_webpack_exports, __webpack_require__) => {
1226
695
  const conversions = __webpack_require__(2538);
1227
- function buildGraph() {
1228
- const graph = {};
1229
- const models = Object.keys(conversions);
1230
- for (let len = models.length, i = 0; i < len; i++) {
1231
- graph[models[i]] = {
696
+ function deriveBFS(fromModel) {
697
+ const graph = function() {
698
+ const graph = {}, models = Object.keys(conversions);
699
+ for (let len = models.length, i = 0; i < len; i++) graph[models[i]] = {
1232
700
  distance: -1,
1233
701
  parent: null
1234
702
  };
1235
- }
1236
- return graph;
1237
- }
1238
- function deriveBFS(fromModel) {
1239
- const graph = buildGraph();
1240
- const queue = [ fromModel ];
1241
- graph[fromModel].distance = 0;
1242
- while (queue.length) {
1243
- const current = queue.pop();
1244
- const adjacents = Object.keys(conversions[current]);
703
+ return graph;
704
+ }(), queue = [ fromModel ];
705
+ for (graph[fromModel].distance = 0; queue.length; ) {
706
+ const current = queue.pop(), adjacents = Object.keys(conversions[current]);
1245
707
  for (let len = adjacents.length, i = 0; i < len; i++) {
1246
- const adjacent = adjacents[i];
1247
- const node = graph[adjacent];
1248
- if (node.distance === -1) {
1249
- node.distance = graph[current].distance + 1;
1250
- node.parent = current;
1251
- queue.unshift(adjacent);
1252
- }
708
+ const adjacent = adjacents[i], node = graph[adjacent];
709
+ -1 === node.distance && (node.distance = graph[current].distance + 1, node.parent = current,
710
+ queue.unshift(adjacent));
1253
711
  }
1254
712
  }
1255
713
  return graph;
@@ -1261,27 +719,16 @@ var __webpack_modules__ = {
1261
719
  }
1262
720
  function wrapConversion(toModel, graph) {
1263
721
  const path = [ graph[toModel].parent, toModel ];
1264
- let fn = conversions[graph[toModel].parent][toModel];
1265
- let cur = graph[toModel].parent;
1266
- while (graph[cur].parent) {
1267
- path.unshift(graph[cur].parent);
1268
- fn = link(conversions[graph[cur].parent][cur], fn);
1269
- cur = graph[cur].parent;
1270
- }
1271
- fn.conversion = path;
1272
- return fn;
722
+ let fn = conversions[graph[toModel].parent][toModel], cur = graph[toModel].parent;
723
+ for (;graph[cur].parent; ) path.unshift(graph[cur].parent), fn = link(conversions[graph[cur].parent][cur], fn),
724
+ cur = graph[cur].parent;
725
+ return fn.conversion = path, fn;
1273
726
  }
1274
727
  module.exports = function(fromModel) {
1275
- const graph = deriveBFS(fromModel);
1276
- const conversion = {};
1277
- const models = Object.keys(graph);
728
+ const graph = deriveBFS(fromModel), conversion = {}, models = Object.keys(graph);
1278
729
  for (let len = models.length, i = 0; i < len; i++) {
1279
730
  const toModel = models[i];
1280
- const node = graph[toModel];
1281
- if (node.parent === null) {
1282
- continue;
1283
- }
1284
- conversion[toModel] = wrapConversion(toModel, graph);
731
+ null !== graph[toModel].parent && (conversion[toModel] = wrapConversion(toModel, graph));
1285
732
  }
1286
733
  return conversion;
1287
734
  };
@@ -1442,48 +889,62 @@ var __webpack_modules__ = {
1442
889
  4288: module => {
1443
890
  "use strict";
1444
891
  module.exports = (flag, argv = process.argv) => {
1445
- const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
1446
- const position = argv.indexOf(prefix + flag);
1447
- const terminatorPosition = argv.indexOf("--");
1448
- return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
892
+ const prefix = flag.startsWith("-") ? "" : 1 === flag.length ? "-" : "--", position = argv.indexOf(prefix + flag), terminatorPosition = argv.indexOf("--");
893
+ return -1 !== position && (-1 === terminatorPosition || position < terminatorPosition);
1449
894
  };
1450
895
  },
1451
896
  3437: (module, __unused_webpack_exports, __webpack_require__) => {
1452
897
  "use strict";
1453
- const Yallist = __webpack_require__(1455);
1454
- const MAX = Symbol("max");
1455
- const LENGTH = Symbol("length");
1456
- const LENGTH_CALCULATOR = Symbol("lengthCalculator");
1457
- const ALLOW_STALE = Symbol("allowStale");
1458
- const MAX_AGE = Symbol("maxAge");
1459
- const DISPOSE = Symbol("dispose");
1460
- const NO_DISPOSE_ON_SET = Symbol("noDisposeOnSet");
1461
- const LRU_LIST = Symbol("lruList");
1462
- const CACHE = Symbol("cache");
1463
- const UPDATE_AGE_ON_GET = Symbol("updateAgeOnGet");
1464
- const naiveLength = () => 1;
1465
- class LRUCache {
898
+ const Yallist = __webpack_require__(1455), MAX = Symbol("max"), LENGTH = Symbol("length"), LENGTH_CALCULATOR = Symbol("lengthCalculator"), ALLOW_STALE = Symbol("allowStale"), MAX_AGE = Symbol("maxAge"), DISPOSE = Symbol("dispose"), NO_DISPOSE_ON_SET = Symbol("noDisposeOnSet"), LRU_LIST = Symbol("lruList"), CACHE = Symbol("cache"), UPDATE_AGE_ON_GET = Symbol("updateAgeOnGet"), naiveLength = () => 1;
899
+ const get = (self, key, doUse) => {
900
+ const node = self[CACHE].get(key);
901
+ if (node) {
902
+ const hit = node.value;
903
+ if (isStale(self, hit)) {
904
+ if (del(self, node), !self[ALLOW_STALE]) return;
905
+ } else doUse && (self[UPDATE_AGE_ON_GET] && (node.value.now = Date.now()), self[LRU_LIST].unshiftNode(node));
906
+ return hit.value;
907
+ }
908
+ }, isStale = (self, hit) => {
909
+ if (!hit || !hit.maxAge && !self[MAX_AGE]) return !1;
910
+ const diff = Date.now() - hit.now;
911
+ return hit.maxAge ? diff > hit.maxAge : self[MAX_AGE] && diff > self[MAX_AGE];
912
+ }, trim = self => {
913
+ if (self[LENGTH] > self[MAX]) for (let walker = self[LRU_LIST].tail; self[LENGTH] > self[MAX] && null !== walker; ) {
914
+ const prev = walker.prev;
915
+ del(self, walker), walker = prev;
916
+ }
917
+ }, del = (self, node) => {
918
+ if (node) {
919
+ const hit = node.value;
920
+ self[DISPOSE] && self[DISPOSE](hit.key, hit.value), self[LENGTH] -= hit.length,
921
+ self[CACHE].delete(hit.key), self[LRU_LIST].removeNode(node);
922
+ }
923
+ };
924
+ class Entry {
925
+ constructor(key, value, length, now, maxAge) {
926
+ this.key = key, this.value = value, this.length = length, this.now = now, this.maxAge = maxAge || 0;
927
+ }
928
+ }
929
+ const forEachStep = (self, fn, node, thisp) => {
930
+ let hit = node.value;
931
+ isStale(self, hit) && (del(self, node), self[ALLOW_STALE] || (hit = void 0)), hit && fn.call(thisp, hit.value, hit.key, self);
932
+ };
933
+ module.exports = class {
1466
934
  constructor(options) {
1467
- if (typeof options === "number") options = {
935
+ if ("number" == typeof options && (options = {
1468
936
  max: options
1469
- };
1470
- if (!options) options = {};
1471
- if (options.max && (typeof options.max !== "number" || options.max < 0)) throw new TypeError("max must be a non-negative number");
1472
- const max = this[MAX] = options.max || Infinity;
937
+ }), options || (options = {}), options.max && ("number" != typeof options.max || options.max < 0)) throw new TypeError("max must be a non-negative number");
938
+ this[MAX] = options.max || 1 / 0;
1473
939
  const lc = options.length || naiveLength;
1474
- this[LENGTH_CALCULATOR] = typeof lc !== "function" ? naiveLength : lc;
1475
- this[ALLOW_STALE] = options.stale || false;
1476
- if (options.maxAge && typeof options.maxAge !== "number") throw new TypeError("maxAge must be a number");
1477
- this[MAX_AGE] = options.maxAge || 0;
1478
- this[DISPOSE] = options.dispose;
1479
- this[NO_DISPOSE_ON_SET] = options.noDisposeOnSet || false;
1480
- this[UPDATE_AGE_ON_GET] = options.updateAgeOnGet || false;
1481
- this.reset();
940
+ if (this[LENGTH_CALCULATOR] = "function" != typeof lc ? naiveLength : lc, this[ALLOW_STALE] = options.stale || !1,
941
+ options.maxAge && "number" != typeof options.maxAge) throw new TypeError("maxAge must be a number");
942
+ this[MAX_AGE] = options.maxAge || 0, this[DISPOSE] = options.dispose, this[NO_DISPOSE_ON_SET] = options.noDisposeOnSet || !1,
943
+ this[UPDATE_AGE_ON_GET] = options.updateAgeOnGet || !1, this.reset();
1482
944
  }
1483
945
  set max(mL) {
1484
- if (typeof mL !== "number" || mL < 0) throw new TypeError("max must be a non-negative number");
1485
- this[MAX] = mL || Infinity;
1486
- trim(this);
946
+ if ("number" != typeof mL || mL < 0) throw new TypeError("max must be a non-negative number");
947
+ this[MAX] = mL || 1 / 0, trim(this);
1487
948
  }
1488
949
  get max() {
1489
950
  return this[MAX];
@@ -1495,24 +956,17 @@ var __webpack_modules__ = {
1495
956
  return this[ALLOW_STALE];
1496
957
  }
1497
958
  set maxAge(mA) {
1498
- if (typeof mA !== "number") throw new TypeError("maxAge must be a non-negative number");
1499
- this[MAX_AGE] = mA;
1500
- trim(this);
959
+ if ("number" != typeof mA) throw new TypeError("maxAge must be a non-negative number");
960
+ this[MAX_AGE] = mA, trim(this);
1501
961
  }
1502
962
  get maxAge() {
1503
963
  return this[MAX_AGE];
1504
964
  }
1505
965
  set lengthCalculator(lC) {
1506
- if (typeof lC !== "function") lC = naiveLength;
1507
- if (lC !== this[LENGTH_CALCULATOR]) {
1508
- this[LENGTH_CALCULATOR] = lC;
1509
- this[LENGTH] = 0;
1510
- this[LRU_LIST].forEach((hit => {
1511
- hit.length = this[LENGTH_CALCULATOR](hit.value, hit.key);
1512
- this[LENGTH] += hit.length;
1513
- }));
1514
- }
1515
- trim(this);
966
+ "function" != typeof lC && (lC = naiveLength), lC !== this[LENGTH_CALCULATOR] && (this[LENGTH_CALCULATOR] = lC,
967
+ this[LENGTH] = 0, this[LRU_LIST].forEach((hit => {
968
+ hit.length = this[LENGTH_CALCULATOR](hit.value, hit.key), this[LENGTH] += hit.length;
969
+ }))), trim(this);
1516
970
  }
1517
971
  get lengthCalculator() {
1518
972
  return this[LENGTH_CALCULATOR];
@@ -1525,18 +979,16 @@ var __webpack_modules__ = {
1525
979
  }
1526
980
  rforEach(fn, thisp) {
1527
981
  thisp = thisp || this;
1528
- for (let walker = this[LRU_LIST].tail; walker !== null; ) {
982
+ for (let walker = this[LRU_LIST].tail; null !== walker; ) {
1529
983
  const prev = walker.prev;
1530
- forEachStep(this, fn, walker, thisp);
1531
- walker = prev;
984
+ forEachStep(this, fn, walker, thisp), walker = prev;
1532
985
  }
1533
986
  }
1534
987
  forEach(fn, thisp) {
1535
988
  thisp = thisp || this;
1536
- for (let walker = this[LRU_LIST].head; walker !== null; ) {
989
+ for (let walker = this[LRU_LIST].head; null !== walker; ) {
1537
990
  const next = walker.next;
1538
- forEachStep(this, fn, walker, thisp);
1539
- walker = next;
991
+ forEachStep(this, fn, walker, thisp), walker = next;
1540
992
  }
1541
993
  }
1542
994
  keys() {
@@ -1546,15 +998,11 @@ var __webpack_modules__ = {
1546
998
  return this[LRU_LIST].toArray().map((k => k.value));
1547
999
  }
1548
1000
  reset() {
1549
- if (this[DISPOSE] && this[LRU_LIST] && this[LRU_LIST].length) {
1550
- this[LRU_LIST].forEach((hit => this[DISPOSE](hit.key, hit.value)));
1551
- }
1552
- this[CACHE] = new Map;
1553
- this[LRU_LIST] = new Yallist;
1554
- this[LENGTH] = 0;
1001
+ this[DISPOSE] && this[LRU_LIST] && this[LRU_LIST].length && this[LRU_LIST].forEach((hit => this[DISPOSE](hit.key, hit.value))),
1002
+ this[CACHE] = new Map, this[LRU_LIST] = new Yallist, this[LENGTH] = 0;
1555
1003
  }
1556
1004
  dump() {
1557
- return this[LRU_LIST].map((hit => isStale(this, hit) ? false : {
1005
+ return this[LRU_LIST].map((hit => !isStale(this, hit) && {
1558
1006
  k: hit.key,
1559
1007
  v: hit.value,
1560
1008
  e: hit.now + (hit.maxAge || 0)
@@ -1564,56 +1012,34 @@ var __webpack_modules__ = {
1564
1012
  return this[LRU_LIST];
1565
1013
  }
1566
1014
  set(key, value, maxAge) {
1567
- maxAge = maxAge || this[MAX_AGE];
1568
- if (maxAge && typeof maxAge !== "number") throw new TypeError("maxAge must be a number");
1569
- const now = maxAge ? Date.now() : 0;
1570
- const len = this[LENGTH_CALCULATOR](value, key);
1015
+ if ((maxAge = maxAge || this[MAX_AGE]) && "number" != typeof maxAge) throw new TypeError("maxAge must be a number");
1016
+ const now = maxAge ? Date.now() : 0, len = this[LENGTH_CALCULATOR](value, key);
1571
1017
  if (this[CACHE].has(key)) {
1572
- if (len > this[MAX]) {
1573
- del(this, this[CACHE].get(key));
1574
- return false;
1575
- }
1576
- const node = this[CACHE].get(key);
1577
- const item = node.value;
1578
- if (this[DISPOSE]) {
1579
- if (!this[NO_DISPOSE_ON_SET]) this[DISPOSE](key, item.value);
1580
- }
1581
- item.now = now;
1582
- item.maxAge = maxAge;
1583
- item.value = value;
1584
- this[LENGTH] += len - item.length;
1585
- item.length = len;
1586
- this.get(key);
1587
- trim(this);
1588
- return true;
1018
+ if (len > this[MAX]) return del(this, this[CACHE].get(key)), !1;
1019
+ const item = this[CACHE].get(key).value;
1020
+ return this[DISPOSE] && (this[NO_DISPOSE_ON_SET] || this[DISPOSE](key, item.value)),
1021
+ item.now = now, item.maxAge = maxAge, item.value = value, this[LENGTH] += len - item.length,
1022
+ item.length = len, this.get(key), trim(this), !0;
1589
1023
  }
1590
1024
  const hit = new Entry(key, value, len, now, maxAge);
1591
- if (hit.length > this[MAX]) {
1592
- if (this[DISPOSE]) this[DISPOSE](key, value);
1593
- return false;
1594
- }
1595
- this[LENGTH] += hit.length;
1596
- this[LRU_LIST].unshift(hit);
1597
- this[CACHE].set(key, this[LRU_LIST].head);
1598
- trim(this);
1599
- return true;
1025
+ return hit.length > this[MAX] ? (this[DISPOSE] && this[DISPOSE](key, value), !1) : (this[LENGTH] += hit.length,
1026
+ this[LRU_LIST].unshift(hit), this[CACHE].set(key, this[LRU_LIST].head), trim(this),
1027
+ !0);
1600
1028
  }
1601
1029
  has(key) {
1602
- if (!this[CACHE].has(key)) return false;
1030
+ if (!this[CACHE].has(key)) return !1;
1603
1031
  const hit = this[CACHE].get(key).value;
1604
1032
  return !isStale(this, hit);
1605
1033
  }
1606
1034
  get(key) {
1607
- return get(this, key, true);
1035
+ return get(this, key, !0);
1608
1036
  }
1609
1037
  peek(key) {
1610
- return get(this, key, false);
1038
+ return get(this, key, !1);
1611
1039
  }
1612
1040
  pop() {
1613
1041
  const node = this[LRU_LIST].tail;
1614
- if (!node) return null;
1615
- del(this, node);
1616
- return node.value;
1042
+ return node ? (del(this, node), node.value) : null;
1617
1043
  }
1618
1044
  del(key) {
1619
1045
  del(this, this[CACHE].get(key));
@@ -1622,77 +1048,17 @@ var __webpack_modules__ = {
1622
1048
  this.reset();
1623
1049
  const now = Date.now();
1624
1050
  for (let l = arr.length - 1; l >= 0; l--) {
1625
- const hit = arr[l];
1626
- const expiresAt = hit.e || 0;
1627
- if (expiresAt === 0) this.set(hit.k, hit.v); else {
1051
+ const hit = arr[l], expiresAt = hit.e || 0;
1052
+ if (0 === expiresAt) this.set(hit.k, hit.v); else {
1628
1053
  const maxAge = expiresAt - now;
1629
- if (maxAge > 0) {
1630
- this.set(hit.k, hit.v, maxAge);
1631
- }
1054
+ maxAge > 0 && this.set(hit.k, hit.v, maxAge);
1632
1055
  }
1633
1056
  }
1634
1057
  }
1635
1058
  prune() {
1636
- this[CACHE].forEach(((value, key) => get(this, key, false)));
1637
- }
1638
- }
1639
- const get = (self, key, doUse) => {
1640
- const node = self[CACHE].get(key);
1641
- if (node) {
1642
- const hit = node.value;
1643
- if (isStale(self, hit)) {
1644
- del(self, node);
1645
- if (!self[ALLOW_STALE]) return undefined;
1646
- } else {
1647
- if (doUse) {
1648
- if (self[UPDATE_AGE_ON_GET]) node.value.now = Date.now();
1649
- self[LRU_LIST].unshiftNode(node);
1650
- }
1651
- }
1652
- return hit.value;
1653
- }
1654
- };
1655
- const isStale = (self, hit) => {
1656
- if (!hit || !hit.maxAge && !self[MAX_AGE]) return false;
1657
- const diff = Date.now() - hit.now;
1658
- return hit.maxAge ? diff > hit.maxAge : self[MAX_AGE] && diff > self[MAX_AGE];
1659
- };
1660
- const trim = self => {
1661
- if (self[LENGTH] > self[MAX]) {
1662
- for (let walker = self[LRU_LIST].tail; self[LENGTH] > self[MAX] && walker !== null; ) {
1663
- const prev = walker.prev;
1664
- del(self, walker);
1665
- walker = prev;
1666
- }
1667
- }
1668
- };
1669
- const del = (self, node) => {
1670
- if (node) {
1671
- const hit = node.value;
1672
- if (self[DISPOSE]) self[DISPOSE](hit.key, hit.value);
1673
- self[LENGTH] -= hit.length;
1674
- self[CACHE].delete(hit.key);
1675
- self[LRU_LIST].removeNode(node);
1676
- }
1677
- };
1678
- class Entry {
1679
- constructor(key, value, length, now, maxAge) {
1680
- this.key = key;
1681
- this.value = value;
1682
- this.length = length;
1683
- this.now = now;
1684
- this.maxAge = maxAge || 0;
1685
- }
1686
- }
1687
- const forEachStep = (self, fn, node, thisp) => {
1688
- let hit = node.value;
1689
- if (isStale(self, hit)) {
1690
- del(self, node);
1691
- if (!self[ALLOW_STALE]) hit = undefined;
1059
+ this[CACHE].forEach(((value, key) => get(this, key, !1)));
1692
1060
  }
1693
- if (hit) fn.call(thisp, hit.value, hit.key, self);
1694
1061
  };
1695
- module.exports = LRUCache;
1696
1062
  },
1697
1063
  7706: (module, __unused_webpack_exports, __webpack_require__) => {
1698
1064
  const ANY = Symbol("SemVer ANY");
@@ -1701,691 +1067,297 @@ var __webpack_modules__ = {
1701
1067
  return ANY;
1702
1068
  }
1703
1069
  constructor(comp, options) {
1704
- options = parseOptions(options);
1705
- if (comp instanceof Comparator) {
1706
- if (comp.loose === !!options.loose) {
1707
- return comp;
1708
- } else {
1709
- comp = comp.value;
1710
- }
1711
- }
1712
- debug("comparator", comp, options);
1713
- this.options = options;
1714
- this.loose = !!options.loose;
1715
- this.parse(comp);
1716
- if (this.semver === ANY) {
1717
- this.value = "";
1718
- } else {
1719
- this.value = this.operator + this.semver.version;
1070
+ if (options = parseOptions(options), comp instanceof Comparator) {
1071
+ if (comp.loose === !!options.loose) return comp;
1072
+ comp = comp.value;
1720
1073
  }
1074
+ debug("comparator", comp, options), this.options = options, this.loose = !!options.loose,
1075
+ this.parse(comp), this.semver === ANY ? this.value = "" : this.value = this.operator + this.semver.version,
1721
1076
  debug("comp", this);
1722
1077
  }
1723
1078
  parse(comp) {
1724
- const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR];
1725
- const m = comp.match(r);
1726
- if (!m) {
1727
- throw new TypeError(`Invalid comparator: ${comp}`);
1728
- }
1729
- this.operator = m[1] !== undefined ? m[1] : "";
1730
- if (this.operator === "=") {
1731
- this.operator = "";
1732
- }
1733
- if (!m[2]) {
1734
- this.semver = ANY;
1735
- } else {
1736
- this.semver = new SemVer(m[2], this.options.loose);
1737
- }
1079
+ const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR], m = comp.match(r);
1080
+ if (!m) throw new TypeError(`Invalid comparator: ${comp}`);
1081
+ this.operator = void 0 !== m[1] ? m[1] : "", "=" === this.operator && (this.operator = ""),
1082
+ m[2] ? this.semver = new SemVer(m[2], this.options.loose) : this.semver = ANY;
1738
1083
  }
1739
1084
  toString() {
1740
1085
  return this.value;
1741
1086
  }
1742
1087
  test(version) {
1743
- debug("Comparator.test", version, this.options.loose);
1744
- if (this.semver === ANY || version === ANY) {
1745
- return true;
1746
- }
1747
- if (typeof version === "string") {
1748
- try {
1749
- version = new SemVer(version, this.options);
1750
- } catch (er) {
1751
- return false;
1752
- }
1088
+ if (debug("Comparator.test", version, this.options.loose), this.semver === ANY || version === ANY) return !0;
1089
+ if ("string" == typeof version) try {
1090
+ version = new SemVer(version, this.options);
1091
+ } catch (er) {
1092
+ return !1;
1753
1093
  }
1754
1094
  return cmp(version, this.operator, this.semver, this.options);
1755
1095
  }
1756
1096
  intersects(comp, options) {
1757
- if (!(comp instanceof Comparator)) {
1758
- throw new TypeError("a Comparator is required");
1759
- }
1760
- if (!options || typeof options !== "object") {
1761
- options = {
1762
- loose: !!options,
1763
- includePrerelease: false
1764
- };
1765
- }
1766
- if (this.operator === "") {
1767
- if (this.value === "") {
1768
- return true;
1769
- }
1770
- return new Range(comp.value, options).test(this.value);
1771
- } else if (comp.operator === "") {
1772
- if (comp.value === "") {
1773
- return true;
1774
- }
1775
- return new Range(this.value, options).test(comp.semver);
1776
- }
1777
- const sameDirectionIncreasing = (this.operator === ">=" || this.operator === ">") && (comp.operator === ">=" || comp.operator === ">");
1778
- const sameDirectionDecreasing = (this.operator === "<=" || this.operator === "<") && (comp.operator === "<=" || comp.operator === "<");
1779
- const sameSemVer = this.semver.version === comp.semver.version;
1780
- const differentDirectionsInclusive = (this.operator === ">=" || this.operator === "<=") && (comp.operator === ">=" || comp.operator === "<=");
1781
- const oppositeDirectionsLessThan = cmp(this.semver, "<", comp.semver, options) && (this.operator === ">=" || this.operator === ">") && (comp.operator === "<=" || comp.operator === "<");
1782
- const oppositeDirectionsGreaterThan = cmp(this.semver, ">", comp.semver, options) && (this.operator === "<=" || this.operator === "<") && (comp.operator === ">=" || comp.operator === ">");
1097
+ if (!(comp instanceof Comparator)) throw new TypeError("a Comparator is required");
1098
+ if (options && "object" == typeof options || (options = {
1099
+ loose: !!options,
1100
+ includePrerelease: !1
1101
+ }), "" === this.operator) return "" === this.value || new Range(comp.value, options).test(this.value);
1102
+ if ("" === comp.operator) return "" === comp.value || new Range(this.value, options).test(comp.semver);
1103
+ const sameDirectionIncreasing = !(">=" !== this.operator && ">" !== this.operator || ">=" !== comp.operator && ">" !== comp.operator), sameDirectionDecreasing = !("<=" !== this.operator && "<" !== this.operator || "<=" !== comp.operator && "<" !== comp.operator), sameSemVer = this.semver.version === comp.semver.version, differentDirectionsInclusive = !(">=" !== this.operator && "<=" !== this.operator || ">=" !== comp.operator && "<=" !== comp.operator), oppositeDirectionsLessThan = cmp(this.semver, "<", comp.semver, options) && (">=" === this.operator || ">" === this.operator) && ("<=" === comp.operator || "<" === comp.operator), oppositeDirectionsGreaterThan = cmp(this.semver, ">", comp.semver, options) && ("<=" === this.operator || "<" === this.operator) && (">=" === comp.operator || ">" === comp.operator);
1783
1104
  return sameDirectionIncreasing || sameDirectionDecreasing || sameSemVer && differentDirectionsInclusive || oppositeDirectionsLessThan || oppositeDirectionsGreaterThan;
1784
1105
  }
1785
1106
  }
1786
1107
  module.exports = Comparator;
1787
- const parseOptions = __webpack_require__(3867);
1788
- const {re, t} = __webpack_require__(9541);
1789
- const cmp = __webpack_require__(1918);
1790
- const debug = __webpack_require__(5432);
1791
- const SemVer = __webpack_require__(3013);
1792
- const Range = __webpack_require__(6833);
1108
+ const parseOptions = __webpack_require__(3867), {re, t} = __webpack_require__(9541), cmp = __webpack_require__(1918), debug = __webpack_require__(5432), SemVer = __webpack_require__(3013), Range = __webpack_require__(6833);
1793
1109
  },
1794
1110
  6833: (module, __unused_webpack_exports, __webpack_require__) => {
1795
1111
  class Range {
1796
1112
  constructor(range, options) {
1797
- options = parseOptions(options);
1798
- if (range instanceof Range) {
1799
- if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) {
1800
- return range;
1801
- } else {
1802
- return new Range(range.raw, options);
1803
- }
1804
- }
1805
- if (range instanceof Comparator) {
1806
- this.raw = range.value;
1807
- this.set = [ [ range ] ];
1808
- this.format();
1809
- return this;
1810
- }
1811
- this.options = options;
1812
- this.loose = !!options.loose;
1813
- this.includePrerelease = !!options.includePrerelease;
1814
- this.raw = range;
1815
- this.set = range.split("||").map((r => this.parseRange(r.trim()))).filter((c => c.length));
1816
- if (!this.set.length) {
1817
- throw new TypeError(`Invalid SemVer Range: ${range}`);
1818
- }
1113
+ if (options = parseOptions(options), range instanceof Range) return range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease ? range : new Range(range.raw, options);
1114
+ if (range instanceof Comparator) return this.raw = range.value, this.set = [ [ range ] ],
1115
+ this.format(), this;
1116
+ if (this.options = options, this.loose = !!options.loose, this.includePrerelease = !!options.includePrerelease,
1117
+ this.raw = range, this.set = range.split("||").map((r => this.parseRange(r.trim()))).filter((c => c.length)),
1118
+ !this.set.length) throw new TypeError(`Invalid SemVer Range: ${range}`);
1819
1119
  if (this.set.length > 1) {
1820
1120
  const first = this.set[0];
1821
- this.set = this.set.filter((c => !isNullSet(c[0])));
1822
- if (this.set.length === 0) {
1823
- this.set = [ first ];
1824
- } else if (this.set.length > 1) {
1825
- for (const c of this.set) {
1826
- if (c.length === 1 && isAny(c[0])) {
1827
- this.set = [ c ];
1828
- break;
1829
- }
1830
- }
1121
+ if (this.set = this.set.filter((c => !isNullSet(c[0]))), 0 === this.set.length) this.set = [ first ]; else if (this.set.length > 1) for (const c of this.set) if (1 === c.length && isAny(c[0])) {
1122
+ this.set = [ c ];
1123
+ break;
1831
1124
  }
1832
1125
  }
1833
1126
  this.format();
1834
1127
  }
1835
1128
  format() {
1836
- this.range = this.set.map((comps => comps.join(" ").trim())).join("||").trim();
1837
- return this.range;
1129
+ return this.range = this.set.map((comps => comps.join(" ").trim())).join("||").trim(),
1130
+ this.range;
1838
1131
  }
1839
1132
  toString() {
1840
1133
  return this.range;
1841
1134
  }
1842
1135
  parseRange(range) {
1843
1136
  range = range.trim();
1844
- const memoOpts = Object.keys(this.options).join(",");
1845
- const memoKey = `parseRange:${memoOpts}:${range}`;
1846
- const cached = cache.get(memoKey);
1847
- if (cached) {
1848
- return cached;
1849
- }
1850
- const loose = this.options.loose;
1851
- const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE];
1852
- range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
1853
- debug("hyphen replace", range);
1854
- range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);
1855
- debug("comparator trim", range);
1856
- range = range.replace(re[t.TILDETRIM], tildeTrimReplace);
1857
- range = range.replace(re[t.CARETTRIM], caretTrimReplace);
1858
- range = range.split(/\s+/).join(" ");
1859
- let rangeList = range.split(" ").map((comp => parseComparator(comp, this.options))).join(" ").split(/\s+/).map((comp => replaceGTE0(comp, this.options)));
1860
- if (loose) {
1861
- rangeList = rangeList.filter((comp => {
1862
- debug("loose invalid filter", comp, this.options);
1863
- return !!comp.match(re[t.COMPARATORLOOSE]);
1864
- }));
1865
- }
1866
- debug("range list", rangeList);
1867
- const rangeMap = new Map;
1868
- const comparators = rangeList.map((comp => new Comparator(comp, this.options)));
1137
+ const memoKey = `parseRange:${Object.keys(this.options).join(",")}:${range}`, cached = cache.get(memoKey);
1138
+ if (cached) return cached;
1139
+ const loose = this.options.loose, hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE];
1140
+ range = range.replace(hr, hyphenReplace(this.options.includePrerelease)), debug("hyphen replace", range),
1141
+ range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace), debug("comparator trim", range);
1142
+ let rangeList = (range = (range = (range = range.replace(re[t.TILDETRIM], tildeTrimReplace)).replace(re[t.CARETTRIM], caretTrimReplace)).split(/\s+/).join(" ")).split(" ").map((comp => parseComparator(comp, this.options))).join(" ").split(/\s+/).map((comp => replaceGTE0(comp, this.options)));
1143
+ loose && (rangeList = rangeList.filter((comp => (debug("loose invalid filter", comp, this.options),
1144
+ !!comp.match(re[t.COMPARATORLOOSE]))))), debug("range list", rangeList);
1145
+ const rangeMap = new Map, comparators = rangeList.map((comp => new Comparator(comp, this.options)));
1869
1146
  for (const comp of comparators) {
1870
- if (isNullSet(comp)) {
1871
- return [ comp ];
1872
- }
1147
+ if (isNullSet(comp)) return [ comp ];
1873
1148
  rangeMap.set(comp.value, comp);
1874
1149
  }
1875
- if (rangeMap.size > 1 && rangeMap.has("")) {
1876
- rangeMap.delete("");
1877
- }
1150
+ rangeMap.size > 1 && rangeMap.has("") && rangeMap.delete("");
1878
1151
  const result = [ ...rangeMap.values() ];
1879
- cache.set(memoKey, result);
1880
- return result;
1152
+ return cache.set(memoKey, result), result;
1881
1153
  }
1882
1154
  intersects(range, options) {
1883
- if (!(range instanceof Range)) {
1884
- throw new TypeError("a Range is required");
1885
- }
1155
+ if (!(range instanceof Range)) throw new TypeError("a Range is required");
1886
1156
  return this.set.some((thisComparators => isSatisfiable(thisComparators, options) && range.set.some((rangeComparators => isSatisfiable(rangeComparators, options) && thisComparators.every((thisComparator => rangeComparators.every((rangeComparator => thisComparator.intersects(rangeComparator, options)))))))));
1887
1157
  }
1888
1158
  test(version) {
1889
- if (!version) {
1890
- return false;
1159
+ if (!version) return !1;
1160
+ if ("string" == typeof version) try {
1161
+ version = new SemVer(version, this.options);
1162
+ } catch (er) {
1163
+ return !1;
1891
1164
  }
1892
- if (typeof version === "string") {
1893
- try {
1894
- version = new SemVer(version, this.options);
1895
- } catch (er) {
1896
- return false;
1897
- }
1898
- }
1899
- for (let i = 0; i < this.set.length; i++) {
1900
- if (testSet(this.set[i], version, this.options)) {
1901
- return true;
1902
- }
1903
- }
1904
- return false;
1165
+ for (let i = 0; i < this.set.length; i++) if (testSet(this.set[i], version, this.options)) return !0;
1166
+ return !1;
1905
1167
  }
1906
1168
  }
1907
1169
  module.exports = Range;
1908
- const LRU = __webpack_require__(3437);
1909
- const cache = new LRU({
1170
+ const cache = new (__webpack_require__(3437))({
1910
1171
  max: 1e3
1911
- });
1912
- const parseOptions = __webpack_require__(3867);
1913
- const Comparator = __webpack_require__(7706);
1914
- const debug = __webpack_require__(5432);
1915
- const SemVer = __webpack_require__(3013);
1916
- const {re, t, comparatorTrimReplace, tildeTrimReplace, caretTrimReplace} = __webpack_require__(9541);
1917
- const isNullSet = c => c.value === "<0.0.0-0";
1918
- const isAny = c => c.value === "";
1919
- const isSatisfiable = (comparators, options) => {
1920
- let result = true;
1172
+ }), parseOptions = __webpack_require__(3867), Comparator = __webpack_require__(7706), debug = __webpack_require__(5432), SemVer = __webpack_require__(3013), {re, t, comparatorTrimReplace, tildeTrimReplace, caretTrimReplace} = __webpack_require__(9541), isNullSet = c => "<0.0.0-0" === c.value, isAny = c => "" === c.value, isSatisfiable = (comparators, options) => {
1173
+ let result = !0;
1921
1174
  const remainingComparators = comparators.slice();
1922
1175
  let testComparator = remainingComparators.pop();
1923
- while (result && remainingComparators.length) {
1924
- result = remainingComparators.every((otherComparator => testComparator.intersects(otherComparator, options)));
1925
- testComparator = remainingComparators.pop();
1926
- }
1176
+ for (;result && remainingComparators.length; ) result = remainingComparators.every((otherComparator => testComparator.intersects(otherComparator, options))),
1177
+ testComparator = remainingComparators.pop();
1927
1178
  return result;
1928
- };
1929
- const parseComparator = (comp, options) => {
1930
- debug("comp", comp, options);
1931
- comp = replaceCarets(comp, options);
1932
- debug("caret", comp);
1933
- comp = replaceTildes(comp, options);
1934
- debug("tildes", comp);
1935
- comp = replaceXRanges(comp, options);
1936
- debug("xrange", comp);
1937
- comp = replaceStars(comp, options);
1938
- debug("stars", comp);
1939
- return comp;
1940
- };
1941
- const isX = id => !id || id.toLowerCase() === "x" || id === "*";
1942
- const replaceTildes = (comp, options) => comp.trim().split(/\s+/).map((c => replaceTilde(c, options))).join(" ");
1943
- const replaceTilde = (comp, options) => {
1179
+ }, parseComparator = (comp, options) => (debug("comp", comp, options), comp = replaceCarets(comp, options),
1180
+ debug("caret", comp), comp = replaceTildes(comp, options), debug("tildes", comp),
1181
+ comp = replaceXRanges(comp, options), debug("xrange", comp), comp = replaceStars(comp, options),
1182
+ debug("stars", comp), comp), isX = id => !id || "x" === id.toLowerCase() || "*" === id, replaceTildes = (comp, options) => comp.trim().split(/\s+/).map((c => replaceTilde(c, options))).join(" "), replaceTilde = (comp, options) => {
1944
1183
  const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE];
1945
1184
  return comp.replace(r, ((_, M, m, p, pr) => {
1946
- debug("tilde", comp, _, M, m, p, pr);
1947
1185
  let ret;
1948
- if (isX(M)) {
1949
- ret = "";
1950
- } else if (isX(m)) {
1951
- ret = `>=${M}.0.0 <${+M + 1}.0.0-0`;
1952
- } else if (isX(p)) {
1953
- ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`;
1954
- } else if (pr) {
1955
- debug("replaceTilde pr", pr);
1956
- ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
1957
- } else {
1958
- ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`;
1959
- }
1960
- debug("tilde return", ret);
1961
- return ret;
1186
+ return debug("tilde", comp, _, M, m, p, pr), isX(M) ? ret = "" : isX(m) ? ret = `>=${M}.0.0 <${+M + 1}.0.0-0` : isX(p) ? ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0` : pr ? (debug("replaceTilde pr", pr),
1187
+ ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`) : ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`,
1188
+ debug("tilde return", ret), ret;
1962
1189
  }));
1963
- };
1964
- const replaceCarets = (comp, options) => comp.trim().split(/\s+/).map((c => replaceCaret(c, options))).join(" ");
1965
- const replaceCaret = (comp, options) => {
1190
+ }, replaceCarets = (comp, options) => comp.trim().split(/\s+/).map((c => replaceCaret(c, options))).join(" "), replaceCaret = (comp, options) => {
1966
1191
  debug("caret", comp, options);
1967
- const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET];
1968
- const z = options.includePrerelease ? "-0" : "";
1192
+ const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET], z = options.includePrerelease ? "-0" : "";
1969
1193
  return comp.replace(r, ((_, M, m, p, pr) => {
1970
- debug("caret", comp, _, M, m, p, pr);
1971
1194
  let ret;
1972
- if (isX(M)) {
1973
- ret = "";
1974
- } else if (isX(m)) {
1975
- ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;
1976
- } else if (isX(p)) {
1977
- if (M === "0") {
1978
- ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;
1979
- } else {
1980
- ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`;
1981
- }
1982
- } else if (pr) {
1983
- debug("replaceCaret pr", pr);
1984
- if (M === "0") {
1985
- if (m === "0") {
1986
- ret = `>=${M}.${m}.${p}-${pr} <${M}.${m}.${+p + 1}-0`;
1987
- } else {
1988
- ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
1989
- }
1990
- } else {
1991
- ret = `>=${M}.${m}.${p}-${pr} <${+M + 1}.0.0-0`;
1992
- }
1993
- } else {
1994
- debug("no pr");
1995
- if (M === "0") {
1996
- if (m === "0") {
1997
- ret = `>=${M}.${m}.${p}${z} <${M}.${m}.${+p + 1}-0`;
1998
- } else {
1999
- ret = `>=${M}.${m}.${p}${z} <${M}.${+m + 1}.0-0`;
2000
- }
2001
- } else {
2002
- ret = `>=${M}.${m}.${p} <${+M + 1}.0.0-0`;
2003
- }
2004
- }
2005
- debug("caret return", ret);
2006
- return ret;
1195
+ return debug("caret", comp, _, M, m, p, pr), isX(M) ? ret = "" : isX(m) ? ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0` : isX(p) ? ret = "0" === M ? `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0` : `>=${M}.${m}.0${z} <${+M + 1}.0.0-0` : pr ? (debug("replaceCaret pr", pr),
1196
+ ret = "0" === M ? "0" === m ? `>=${M}.${m}.${p}-${pr} <${M}.${m}.${+p + 1}-0` : `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0` : `>=${M}.${m}.${p}-${pr} <${+M + 1}.0.0-0`) : (debug("no pr"),
1197
+ ret = "0" === M ? "0" === m ? `>=${M}.${m}.${p}${z} <${M}.${m}.${+p + 1}-0` : `>=${M}.${m}.${p}${z} <${M}.${+m + 1}.0-0` : `>=${M}.${m}.${p} <${+M + 1}.0.0-0`),
1198
+ debug("caret return", ret), ret;
2007
1199
  }));
2008
- };
2009
- const replaceXRanges = (comp, options) => {
2010
- debug("replaceXRanges", comp, options);
2011
- return comp.split(/\s+/).map((c => replaceXRange(c, options))).join(" ");
2012
- };
2013
- const replaceXRange = (comp, options) => {
1200
+ }, replaceXRanges = (comp, options) => (debug("replaceXRanges", comp, options),
1201
+ comp.split(/\s+/).map((c => replaceXRange(c, options))).join(" ")), replaceXRange = (comp, options) => {
2014
1202
  comp = comp.trim();
2015
1203
  const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE];
2016
1204
  return comp.replace(r, ((ret, gtlt, M, m, p, pr) => {
2017
1205
  debug("xRange", comp, ret, gtlt, M, m, p, pr);
2018
- const xM = isX(M);
2019
- const xm = xM || isX(m);
2020
- const xp = xm || isX(p);
2021
- const anyX = xp;
2022
- if (gtlt === "=" && anyX) {
2023
- gtlt = "";
2024
- }
2025
- pr = options.includePrerelease ? "-0" : "";
2026
- if (xM) {
2027
- if (gtlt === ">" || gtlt === "<") {
2028
- ret = "<0.0.0-0";
2029
- } else {
2030
- ret = "*";
2031
- }
2032
- } else if (gtlt && anyX) {
2033
- if (xm) {
2034
- m = 0;
2035
- }
2036
- p = 0;
2037
- if (gtlt === ">") {
2038
- gtlt = ">=";
2039
- if (xm) {
2040
- M = +M + 1;
2041
- m = 0;
2042
- p = 0;
2043
- } else {
2044
- m = +m + 1;
2045
- p = 0;
2046
- }
2047
- } else if (gtlt === "<=") {
2048
- gtlt = "<";
2049
- if (xm) {
2050
- M = +M + 1;
2051
- } else {
2052
- m = +m + 1;
2053
- }
2054
- }
2055
- if (gtlt === "<") {
2056
- pr = "-0";
2057
- }
2058
- ret = `${gtlt + M}.${m}.${p}${pr}`;
2059
- } else if (xm) {
2060
- ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`;
2061
- } else if (xp) {
2062
- ret = `>=${M}.${m}.0${pr} <${M}.${+m + 1}.0-0`;
2063
- }
2064
- debug("xRange return", ret);
2065
- return ret;
1206
+ const xM = isX(M), xm = xM || isX(m), xp = xm || isX(p), anyX = xp;
1207
+ return "=" === gtlt && anyX && (gtlt = ""), pr = options.includePrerelease ? "-0" : "",
1208
+ xM ? ret = ">" === gtlt || "<" === gtlt ? "<0.0.0-0" : "*" : gtlt && anyX ? (xm && (m = 0),
1209
+ p = 0, ">" === gtlt ? (gtlt = ">=", xm ? (M = +M + 1, m = 0, p = 0) : (m = +m + 1,
1210
+ p = 0)) : "<=" === gtlt && (gtlt = "<", xm ? M = +M + 1 : m = +m + 1), "<" === gtlt && (pr = "-0"),
1211
+ ret = `${gtlt + M}.${m}.${p}${pr}`) : xm ? ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0` : xp && (ret = `>=${M}.${m}.0${pr} <${M}.${+m + 1}.0-0`),
1212
+ debug("xRange return", ret), ret;
2066
1213
  }));
2067
- };
2068
- const replaceStars = (comp, options) => {
2069
- debug("replaceStars", comp, options);
2070
- return comp.trim().replace(re[t.STAR], "");
2071
- };
2072
- const replaceGTE0 = (comp, options) => {
2073
- debug("replaceGTE0", comp, options);
2074
- return comp.trim().replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], "");
2075
- };
2076
- const hyphenReplace = incPr => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr, tb) => {
2077
- if (isX(fM)) {
2078
- from = "";
2079
- } else if (isX(fm)) {
2080
- from = `>=${fM}.0.0${incPr ? "-0" : ""}`;
2081
- } else if (isX(fp)) {
2082
- from = `>=${fM}.${fm}.0${incPr ? "-0" : ""}`;
2083
- } else if (fpr) {
2084
- from = `>=${from}`;
2085
- } else {
2086
- from = `>=${from}${incPr ? "-0" : ""}`;
2087
- }
2088
- if (isX(tM)) {
2089
- to = "";
2090
- } else if (isX(tm)) {
2091
- to = `<${+tM + 1}.0.0-0`;
2092
- } else if (isX(tp)) {
2093
- to = `<${tM}.${+tm + 1}.0-0`;
2094
- } else if (tpr) {
2095
- to = `<=${tM}.${tm}.${tp}-${tpr}`;
2096
- } else if (incPr) {
2097
- to = `<${tM}.${tm}.${+tp + 1}-0`;
2098
- } else {
2099
- to = `<=${to}`;
2100
- }
2101
- return `${from} ${to}`.trim();
2102
- };
2103
- const testSet = (set, version, options) => {
2104
- for (let i = 0; i < set.length; i++) {
2105
- if (!set[i].test(version)) {
2106
- return false;
2107
- }
2108
- }
1214
+ }, replaceStars = (comp, options) => (debug("replaceStars", comp, options), comp.trim().replace(re[t.STAR], "")), replaceGTE0 = (comp, options) => (debug("replaceGTE0", comp, options),
1215
+ comp.trim().replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], "")), hyphenReplace = incPr => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr, tb) => `${from = isX(fM) ? "" : isX(fm) ? `>=${fM}.0.0${incPr ? "-0" : ""}` : isX(fp) ? `>=${fM}.${fm}.0${incPr ? "-0" : ""}` : fpr ? `>=${from}` : `>=${from}${incPr ? "-0" : ""}`} ${to = isX(tM) ? "" : isX(tm) ? `<${+tM + 1}.0.0-0` : isX(tp) ? `<${tM}.${+tm + 1}.0-0` : tpr ? `<=${tM}.${tm}.${tp}-${tpr}` : incPr ? `<${tM}.${tm}.${+tp + 1}-0` : `<=${to}`}`.trim(), testSet = (set, version, options) => {
1216
+ for (let i = 0; i < set.length; i++) if (!set[i].test(version)) return !1;
2109
1217
  if (version.prerelease.length && !options.includePrerelease) {
2110
- for (let i = 0; i < set.length; i++) {
2111
- debug(set[i].semver);
2112
- if (set[i].semver === Comparator.ANY) {
2113
- continue;
2114
- }
2115
- if (set[i].semver.prerelease.length > 0) {
2116
- const allowed = set[i].semver;
2117
- if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) {
2118
- return true;
2119
- }
2120
- }
1218
+ for (let i = 0; i < set.length; i++) if (debug(set[i].semver), set[i].semver !== Comparator.ANY && set[i].semver.prerelease.length > 0) {
1219
+ const allowed = set[i].semver;
1220
+ if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) return !0;
2121
1221
  }
2122
- return false;
1222
+ return !1;
2123
1223
  }
2124
- return true;
1224
+ return !0;
2125
1225
  };
2126
1226
  },
2127
1227
  3013: (module, __unused_webpack_exports, __webpack_require__) => {
2128
- const debug = __webpack_require__(5432);
2129
- const {MAX_LENGTH, MAX_SAFE_INTEGER} = __webpack_require__(9041);
2130
- const {re, t} = __webpack_require__(9541);
2131
- const parseOptions = __webpack_require__(3867);
2132
- const {compareIdentifiers} = __webpack_require__(3650);
1228
+ const debug = __webpack_require__(5432), {MAX_LENGTH, MAX_SAFE_INTEGER} = __webpack_require__(9041), {re, t} = __webpack_require__(9541), parseOptions = __webpack_require__(3867), {compareIdentifiers} = __webpack_require__(3650);
2133
1229
  class SemVer {
2134
1230
  constructor(version, options) {
2135
- options = parseOptions(options);
2136
- if (version instanceof SemVer) {
2137
- if (version.loose === !!options.loose && version.includePrerelease === !!options.includePrerelease) {
2138
- return version;
2139
- } else {
2140
- version = version.version;
2141
- }
2142
- } else if (typeof version !== "string") {
2143
- throw new TypeError(`Invalid Version: ${version}`);
2144
- }
2145
- if (version.length > MAX_LENGTH) {
2146
- throw new TypeError(`version is longer than ${MAX_LENGTH} characters`);
2147
- }
2148
- debug("SemVer", version, options);
2149
- this.options = options;
2150
- this.loose = !!options.loose;
1231
+ if (options = parseOptions(options), version instanceof SemVer) {
1232
+ if (version.loose === !!options.loose && version.includePrerelease === !!options.includePrerelease) return version;
1233
+ version = version.version;
1234
+ } else if ("string" != typeof version) throw new TypeError(`Invalid Version: ${version}`);
1235
+ if (version.length > MAX_LENGTH) throw new TypeError(`version is longer than ${MAX_LENGTH} characters`);
1236
+ debug("SemVer", version, options), this.options = options, this.loose = !!options.loose,
2151
1237
  this.includePrerelease = !!options.includePrerelease;
2152
1238
  const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]);
2153
- if (!m) {
2154
- throw new TypeError(`Invalid Version: ${version}`);
2155
- }
2156
- this.raw = version;
2157
- this.major = +m[1];
2158
- this.minor = +m[2];
2159
- this.patch = +m[3];
2160
- if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
2161
- throw new TypeError("Invalid major version");
2162
- }
2163
- if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
2164
- throw new TypeError("Invalid minor version");
2165
- }
2166
- if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
2167
- throw new TypeError("Invalid patch version");
2168
- }
2169
- if (!m[4]) {
2170
- this.prerelease = [];
2171
- } else {
2172
- this.prerelease = m[4].split(".").map((id => {
2173
- if (/^[0-9]+$/.test(id)) {
2174
- const num = +id;
2175
- if (num >= 0 && num < MAX_SAFE_INTEGER) {
2176
- return num;
2177
- }
2178
- }
2179
- return id;
2180
- }));
2181
- }
2182
- this.build = m[5] ? m[5].split(".") : [];
2183
- this.format();
1239
+ if (!m) throw new TypeError(`Invalid Version: ${version}`);
1240
+ if (this.raw = version, this.major = +m[1], this.minor = +m[2], this.patch = +m[3],
1241
+ this.major > MAX_SAFE_INTEGER || this.major < 0) throw new TypeError("Invalid major version");
1242
+ if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) throw new TypeError("Invalid minor version");
1243
+ if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) throw new TypeError("Invalid patch version");
1244
+ m[4] ? this.prerelease = m[4].split(".").map((id => {
1245
+ if (/^[0-9]+$/.test(id)) {
1246
+ const num = +id;
1247
+ if (num >= 0 && num < MAX_SAFE_INTEGER) return num;
1248
+ }
1249
+ return id;
1250
+ })) : this.prerelease = [], this.build = m[5] ? m[5].split(".") : [], this.format();
2184
1251
  }
2185
1252
  format() {
2186
- this.version = `${this.major}.${this.minor}.${this.patch}`;
2187
- if (this.prerelease.length) {
2188
- this.version += `-${this.prerelease.join(".")}`;
2189
- }
2190
- return this.version;
1253
+ return this.version = `${this.major}.${this.minor}.${this.patch}`, this.prerelease.length && (this.version += `-${this.prerelease.join(".")}`),
1254
+ this.version;
2191
1255
  }
2192
1256
  toString() {
2193
1257
  return this.version;
2194
1258
  }
2195
1259
  compare(other) {
2196
- debug("SemVer.compare", this.version, this.options, other);
2197
- if (!(other instanceof SemVer)) {
2198
- if (typeof other === "string" && other === this.version) {
2199
- return 0;
2200
- }
1260
+ if (debug("SemVer.compare", this.version, this.options, other), !(other instanceof SemVer)) {
1261
+ if ("string" == typeof other && other === this.version) return 0;
2201
1262
  other = new SemVer(other, this.options);
2202
1263
  }
2203
- if (other.version === this.version) {
2204
- return 0;
2205
- }
2206
- return this.compareMain(other) || this.comparePre(other);
1264
+ return other.version === this.version ? 0 : this.compareMain(other) || this.comparePre(other);
2207
1265
  }
2208
1266
  compareMain(other) {
2209
- if (!(other instanceof SemVer)) {
2210
- other = new SemVer(other, this.options);
2211
- }
2212
- return compareIdentifiers(this.major, other.major) || compareIdentifiers(this.minor, other.minor) || compareIdentifiers(this.patch, other.patch);
1267
+ return other instanceof SemVer || (other = new SemVer(other, this.options)), compareIdentifiers(this.major, other.major) || compareIdentifiers(this.minor, other.minor) || compareIdentifiers(this.patch, other.patch);
2213
1268
  }
2214
1269
  comparePre(other) {
2215
- if (!(other instanceof SemVer)) {
2216
- other = new SemVer(other, this.options);
2217
- }
2218
- if (this.prerelease.length && !other.prerelease.length) {
2219
- return -1;
2220
- } else if (!this.prerelease.length && other.prerelease.length) {
2221
- return 1;
2222
- } else if (!this.prerelease.length && !other.prerelease.length) {
2223
- return 0;
2224
- }
1270
+ if (other instanceof SemVer || (other = new SemVer(other, this.options)), this.prerelease.length && !other.prerelease.length) return -1;
1271
+ if (!this.prerelease.length && other.prerelease.length) return 1;
1272
+ if (!this.prerelease.length && !other.prerelease.length) return 0;
2225
1273
  let i = 0;
2226
1274
  do {
2227
- const a = this.prerelease[i];
2228
- const b = other.prerelease[i];
2229
- debug("prerelease compare", i, a, b);
2230
- if (a === undefined && b === undefined) {
2231
- return 0;
2232
- } else if (b === undefined) {
2233
- return 1;
2234
- } else if (a === undefined) {
2235
- return -1;
2236
- } else if (a === b) {
2237
- continue;
2238
- } else {
2239
- return compareIdentifiers(a, b);
2240
- }
1275
+ const a = this.prerelease[i], b = other.prerelease[i];
1276
+ if (debug("prerelease compare", i, a, b), void 0 === a && void 0 === b) return 0;
1277
+ if (void 0 === b) return 1;
1278
+ if (void 0 === a) return -1;
1279
+ if (a !== b) return compareIdentifiers(a, b);
2241
1280
  } while (++i);
2242
1281
  }
2243
1282
  compareBuild(other) {
2244
- if (!(other instanceof SemVer)) {
2245
- other = new SemVer(other, this.options);
2246
- }
1283
+ other instanceof SemVer || (other = new SemVer(other, this.options));
2247
1284
  let i = 0;
2248
1285
  do {
2249
- const a = this.build[i];
2250
- const b = other.build[i];
2251
- debug("prerelease compare", i, a, b);
2252
- if (a === undefined && b === undefined) {
2253
- return 0;
2254
- } else if (b === undefined) {
2255
- return 1;
2256
- } else if (a === undefined) {
2257
- return -1;
2258
- } else if (a === b) {
2259
- continue;
2260
- } else {
2261
- return compareIdentifiers(a, b);
2262
- }
1286
+ const a = this.build[i], b = other.build[i];
1287
+ if (debug("prerelease compare", i, a, b), void 0 === a && void 0 === b) return 0;
1288
+ if (void 0 === b) return 1;
1289
+ if (void 0 === a) return -1;
1290
+ if (a !== b) return compareIdentifiers(a, b);
2263
1291
  } while (++i);
2264
1292
  }
2265
1293
  inc(release, identifier) {
2266
1294
  switch (release) {
2267
1295
  case "premajor":
2268
- this.prerelease.length = 0;
2269
- this.patch = 0;
2270
- this.minor = 0;
2271
- this.major++;
2272
- this.inc("pre", identifier);
1296
+ this.prerelease.length = 0, this.patch = 0, this.minor = 0, this.major++, this.inc("pre", identifier);
2273
1297
  break;
2274
1298
 
2275
1299
  case "preminor":
2276
- this.prerelease.length = 0;
2277
- this.patch = 0;
2278
- this.minor++;
2279
- this.inc("pre", identifier);
1300
+ this.prerelease.length = 0, this.patch = 0, this.minor++, this.inc("pre", identifier);
2280
1301
  break;
2281
1302
 
2282
1303
  case "prepatch":
2283
- this.prerelease.length = 0;
2284
- this.inc("patch", identifier);
2285
- this.inc("pre", identifier);
1304
+ this.prerelease.length = 0, this.inc("patch", identifier), this.inc("pre", identifier);
2286
1305
  break;
2287
1306
 
2288
1307
  case "prerelease":
2289
- if (this.prerelease.length === 0) {
2290
- this.inc("patch", identifier);
2291
- }
2292
- this.inc("pre", identifier);
1308
+ 0 === this.prerelease.length && this.inc("patch", identifier), this.inc("pre", identifier);
2293
1309
  break;
2294
1310
 
2295
1311
  case "major":
2296
- if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) {
2297
- this.major++;
2298
- }
2299
- this.minor = 0;
2300
- this.patch = 0;
2301
- this.prerelease = [];
1312
+ 0 === this.minor && 0 === this.patch && 0 !== this.prerelease.length || this.major++,
1313
+ this.minor = 0, this.patch = 0, this.prerelease = [];
2302
1314
  break;
2303
1315
 
2304
1316
  case "minor":
2305
- if (this.patch !== 0 || this.prerelease.length === 0) {
2306
- this.minor++;
2307
- }
2308
- this.patch = 0;
1317
+ 0 === this.patch && 0 !== this.prerelease.length || this.minor++, this.patch = 0,
2309
1318
  this.prerelease = [];
2310
1319
  break;
2311
1320
 
2312
1321
  case "patch":
2313
- if (this.prerelease.length === 0) {
2314
- this.patch++;
2315
- }
2316
- this.prerelease = [];
1322
+ 0 === this.prerelease.length && this.patch++, this.prerelease = [];
2317
1323
  break;
2318
1324
 
2319
1325
  case "pre":
2320
- if (this.prerelease.length === 0) {
2321
- this.prerelease = [ 0 ];
2322
- } else {
1326
+ if (0 === this.prerelease.length) this.prerelease = [ 0 ]; else {
2323
1327
  let i = this.prerelease.length;
2324
- while (--i >= 0) {
2325
- if (typeof this.prerelease[i] === "number") {
2326
- this.prerelease[i]++;
2327
- i = -2;
2328
- }
2329
- }
2330
- if (i === -1) {
2331
- this.prerelease.push(0);
2332
- }
2333
- }
2334
- if (identifier) {
2335
- if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
2336
- if (isNaN(this.prerelease[1])) {
2337
- this.prerelease = [ identifier, 0 ];
2338
- }
2339
- } else {
2340
- this.prerelease = [ identifier, 0 ];
2341
- }
1328
+ for (;--i >= 0; ) "number" == typeof this.prerelease[i] && (this.prerelease[i]++,
1329
+ i = -2);
1330
+ -1 === i && this.prerelease.push(0);
2342
1331
  }
1332
+ identifier && (0 === compareIdentifiers(this.prerelease[0], identifier) ? isNaN(this.prerelease[1]) && (this.prerelease = [ identifier, 0 ]) : this.prerelease = [ identifier, 0 ]);
2343
1333
  break;
2344
1334
 
2345
1335
  default:
2346
1336
  throw new Error(`invalid increment argument: ${release}`);
2347
1337
  }
2348
- this.format();
2349
- this.raw = this.version;
2350
- return this;
1338
+ return this.format(), this.raw = this.version, this;
2351
1339
  }
2352
1340
  }
2353
1341
  module.exports = SemVer;
2354
1342
  },
2355
1343
  3470: (module, __unused_webpack_exports, __webpack_require__) => {
2356
1344
  const parse = __webpack_require__(7507);
2357
- const clean = (version, options) => {
1345
+ module.exports = (version, options) => {
2358
1346
  const s = parse(version.trim().replace(/^[=v]+/, ""), options);
2359
1347
  return s ? s.version : null;
2360
1348
  };
2361
- module.exports = clean;
2362
1349
  },
2363
1350
  1918: (module, __unused_webpack_exports, __webpack_require__) => {
2364
- const eq = __webpack_require__(8443);
2365
- const neq = __webpack_require__(1017);
2366
- const gt = __webpack_require__(6077);
2367
- const gte = __webpack_require__(4578);
2368
- const lt = __webpack_require__(866);
2369
- const lte = __webpack_require__(698);
2370
- const cmp = (a, op, b, loose) => {
1351
+ const eq = __webpack_require__(8443), neq = __webpack_require__(1017), gt = __webpack_require__(6077), gte = __webpack_require__(4578), lt = __webpack_require__(866), lte = __webpack_require__(698);
1352
+ module.exports = (a, op, b, loose) => {
2371
1353
  switch (op) {
2372
1354
  case "===":
2373
- if (typeof a === "object") {
2374
- a = a.version;
2375
- }
2376
- if (typeof b === "object") {
2377
- b = b.version;
2378
- }
2379
- return a === b;
1355
+ return "object" == typeof a && (a = a.version), "object" == typeof b && (b = b.version),
1356
+ a === b;
2380
1357
 
2381
1358
  case "!==":
2382
- if (typeof a === "object") {
2383
- a = a.version;
2384
- }
2385
- if (typeof b === "object") {
2386
- b = b.version;
2387
- }
2388
- return a !== b;
1359
+ return "object" == typeof a && (a = a.version), "object" == typeof b && (b = b.version),
1360
+ a !== b;
2389
1361
 
2390
1362
  case "":
2391
1363
  case "=":
@@ -2411,216 +1383,145 @@ var __webpack_modules__ = {
2411
1383
  throw new TypeError(`Invalid operator: ${op}`);
2412
1384
  }
2413
1385
  };
2414
- module.exports = cmp;
2415
1386
  },
2416
1387
  4115: (module, __unused_webpack_exports, __webpack_require__) => {
2417
- const SemVer = __webpack_require__(3013);
2418
- const parse = __webpack_require__(7507);
2419
- const {re, t} = __webpack_require__(9541);
2420
- const coerce = (version, options) => {
2421
- if (version instanceof SemVer) {
2422
- return version;
2423
- }
2424
- if (typeof version === "number") {
2425
- version = String(version);
2426
- }
2427
- if (typeof version !== "string") {
2428
- return null;
2429
- }
2430
- options = options || {};
1388
+ const SemVer = __webpack_require__(3013), parse = __webpack_require__(7507), {re, t} = __webpack_require__(9541);
1389
+ module.exports = (version, options) => {
1390
+ if (version instanceof SemVer) return version;
1391
+ if ("number" == typeof version && (version = String(version)), "string" != typeof version) return null;
2431
1392
  let match = null;
2432
- if (!options.rtl) {
2433
- match = version.match(re[t.COERCE]);
2434
- } else {
1393
+ if ((options = options || {}).rtl) {
2435
1394
  let next;
2436
- while ((next = re[t.COERCERTL].exec(version)) && (!match || match.index + match[0].length !== version.length)) {
2437
- if (!match || next.index + next[0].length !== match.index + match[0].length) {
2438
- match = next;
2439
- }
2440
- re[t.COERCERTL].lastIndex = next.index + next[1].length + next[2].length;
2441
- }
1395
+ for (;(next = re[t.COERCERTL].exec(version)) && (!match || match.index + match[0].length !== version.length); ) match && next.index + next[0].length === match.index + match[0].length || (match = next),
1396
+ re[t.COERCERTL].lastIndex = next.index + next[1].length + next[2].length;
2442
1397
  re[t.COERCERTL].lastIndex = -1;
2443
- }
2444
- if (match === null) {
2445
- return null;
2446
- }
2447
- return parse(`${match[2]}.${match[3] || "0"}.${match[4] || "0"}`, options);
1398
+ } else match = version.match(re[t.COERCE]);
1399
+ return null === match ? null : parse(`${match[2]}.${match[3] || "0"}.${match[4] || "0"}`, options);
2448
1400
  };
2449
- module.exports = coerce;
2450
1401
  },
2451
1402
  6845: (module, __unused_webpack_exports, __webpack_require__) => {
2452
1403
  const SemVer = __webpack_require__(3013);
2453
- const compareBuild = (a, b, loose) => {
2454
- const versionA = new SemVer(a, loose);
2455
- const versionB = new SemVer(b, loose);
1404
+ module.exports = (a, b, loose) => {
1405
+ const versionA = new SemVer(a, loose), versionB = new SemVer(b, loose);
2456
1406
  return versionA.compare(versionB) || versionA.compareBuild(versionB);
2457
1407
  };
2458
- module.exports = compareBuild;
2459
1408
  },
2460
1409
  2310: (module, __unused_webpack_exports, __webpack_require__) => {
2461
1410
  const compare = __webpack_require__(2247);
2462
- const compareLoose = (a, b) => compare(a, b, true);
2463
- module.exports = compareLoose;
1411
+ module.exports = (a, b) => compare(a, b, !0);
2464
1412
  },
2465
1413
  2247: (module, __unused_webpack_exports, __webpack_require__) => {
2466
1414
  const SemVer = __webpack_require__(3013);
2467
- const compare = (a, b, loose) => new SemVer(a, loose).compare(new SemVer(b, loose));
2468
- module.exports = compare;
1415
+ module.exports = (a, b, loose) => new SemVer(a, loose).compare(new SemVer(b, loose));
2469
1416
  },
2470
1417
  5209: (module, __unused_webpack_exports, __webpack_require__) => {
2471
- const parse = __webpack_require__(7507);
2472
- const eq = __webpack_require__(8443);
2473
- const diff = (version1, version2) => {
2474
- if (eq(version1, version2)) {
2475
- return null;
2476
- } else {
2477
- const v1 = parse(version1);
2478
- const v2 = parse(version2);
2479
- const hasPre = v1.prerelease.length || v2.prerelease.length;
2480
- const prefix = hasPre ? "pre" : "";
2481
- const defaultResult = hasPre ? "prerelease" : "";
2482
- for (const key in v1) {
2483
- if (key === "major" || key === "minor" || key === "patch") {
2484
- if (v1[key] !== v2[key]) {
2485
- return prefix + key;
2486
- }
2487
- }
2488
- }
1418
+ const parse = __webpack_require__(7507), eq = __webpack_require__(8443);
1419
+ module.exports = (version1, version2) => {
1420
+ if (eq(version1, version2)) return null;
1421
+ {
1422
+ const v1 = parse(version1), v2 = parse(version2), hasPre = v1.prerelease.length || v2.prerelease.length, prefix = hasPre ? "pre" : "", defaultResult = hasPre ? "prerelease" : "";
1423
+ for (const key in v1) if (("major" === key || "minor" === key || "patch" === key) && v1[key] !== v2[key]) return prefix + key;
2489
1424
  return defaultResult;
2490
1425
  }
2491
1426
  };
2492
- module.exports = diff;
2493
1427
  },
2494
1428
  8443: (module, __unused_webpack_exports, __webpack_require__) => {
2495
1429
  const compare = __webpack_require__(2247);
2496
- const eq = (a, b, loose) => compare(a, b, loose) === 0;
2497
- module.exports = eq;
1430
+ module.exports = (a, b, loose) => 0 === compare(a, b, loose);
2498
1431
  },
2499
1432
  6077: (module, __unused_webpack_exports, __webpack_require__) => {
2500
1433
  const compare = __webpack_require__(2247);
2501
- const gt = (a, b, loose) => compare(a, b, loose) > 0;
2502
- module.exports = gt;
1434
+ module.exports = (a, b, loose) => compare(a, b, loose) > 0;
2503
1435
  },
2504
1436
  4578: (module, __unused_webpack_exports, __webpack_require__) => {
2505
1437
  const compare = __webpack_require__(2247);
2506
- const gte = (a, b, loose) => compare(a, b, loose) >= 0;
2507
- module.exports = gte;
1438
+ module.exports = (a, b, loose) => compare(a, b, loose) >= 0;
2508
1439
  },
2509
1440
  5210: (module, __unused_webpack_exports, __webpack_require__) => {
2510
1441
  const SemVer = __webpack_require__(3013);
2511
- const inc = (version, release, options, identifier) => {
2512
- if (typeof options === "string") {
2513
- identifier = options;
2514
- options = undefined;
2515
- }
1442
+ module.exports = (version, release, options, identifier) => {
1443
+ "string" == typeof options && (identifier = options, options = void 0);
2516
1444
  try {
2517
1445
  return new SemVer(version instanceof SemVer ? version.version : version, options).inc(release, identifier).version;
2518
1446
  } catch (er) {
2519
1447
  return null;
2520
1448
  }
2521
1449
  };
2522
- module.exports = inc;
2523
1450
  },
2524
1451
  866: (module, __unused_webpack_exports, __webpack_require__) => {
2525
1452
  const compare = __webpack_require__(2247);
2526
- const lt = (a, b, loose) => compare(a, b, loose) < 0;
2527
- module.exports = lt;
1453
+ module.exports = (a, b, loose) => compare(a, b, loose) < 0;
2528
1454
  },
2529
1455
  698: (module, __unused_webpack_exports, __webpack_require__) => {
2530
1456
  const compare = __webpack_require__(2247);
2531
- const lte = (a, b, loose) => compare(a, b, loose) <= 0;
2532
- module.exports = lte;
1457
+ module.exports = (a, b, loose) => compare(a, b, loose) <= 0;
2533
1458
  },
2534
1459
  5847: (module, __unused_webpack_exports, __webpack_require__) => {
2535
1460
  const SemVer = __webpack_require__(3013);
2536
- const major = (a, loose) => new SemVer(a, loose).major;
2537
- module.exports = major;
1461
+ module.exports = (a, loose) => new SemVer(a, loose).major;
2538
1462
  },
2539
1463
  1757: (module, __unused_webpack_exports, __webpack_require__) => {
2540
1464
  const SemVer = __webpack_require__(3013);
2541
- const minor = (a, loose) => new SemVer(a, loose).minor;
2542
- module.exports = minor;
1465
+ module.exports = (a, loose) => new SemVer(a, loose).minor;
2543
1466
  },
2544
1467
  1017: (module, __unused_webpack_exports, __webpack_require__) => {
2545
1468
  const compare = __webpack_require__(2247);
2546
- const neq = (a, b, loose) => compare(a, b, loose) !== 0;
2547
- module.exports = neq;
1469
+ module.exports = (a, b, loose) => 0 !== compare(a, b, loose);
2548
1470
  },
2549
1471
  7507: (module, __unused_webpack_exports, __webpack_require__) => {
2550
- const {MAX_LENGTH} = __webpack_require__(9041);
2551
- const {re, t} = __webpack_require__(9541);
2552
- const SemVer = __webpack_require__(3013);
2553
- const parseOptions = __webpack_require__(3867);
2554
- const parse = (version, options) => {
2555
- options = parseOptions(options);
2556
- if (version instanceof SemVer) {
2557
- return version;
2558
- }
2559
- if (typeof version !== "string") {
2560
- return null;
2561
- }
2562
- if (version.length > MAX_LENGTH) {
2563
- return null;
2564
- }
2565
- const r = options.loose ? re[t.LOOSE] : re[t.FULL];
2566
- if (!r.test(version)) {
2567
- return null;
2568
- }
1472
+ const {MAX_LENGTH} = __webpack_require__(9041), {re, t} = __webpack_require__(9541), SemVer = __webpack_require__(3013), parseOptions = __webpack_require__(3867);
1473
+ module.exports = (version, options) => {
1474
+ if (options = parseOptions(options), version instanceof SemVer) return version;
1475
+ if ("string" != typeof version) return null;
1476
+ if (version.length > MAX_LENGTH) return null;
1477
+ if (!(options.loose ? re[t.LOOSE] : re[t.FULL]).test(version)) return null;
2569
1478
  try {
2570
1479
  return new SemVer(version, options);
2571
1480
  } catch (er) {
2572
1481
  return null;
2573
1482
  }
2574
1483
  };
2575
- module.exports = parse;
2576
1484
  },
2577
1485
  8150: (module, __unused_webpack_exports, __webpack_require__) => {
2578
1486
  const SemVer = __webpack_require__(3013);
2579
- const patch = (a, loose) => new SemVer(a, loose).patch;
2580
- module.exports = patch;
1487
+ module.exports = (a, loose) => new SemVer(a, loose).patch;
2581
1488
  },
2582
1489
  8011: (module, __unused_webpack_exports, __webpack_require__) => {
2583
1490
  const parse = __webpack_require__(7507);
2584
- const prerelease = (version, options) => {
1491
+ module.exports = (version, options) => {
2585
1492
  const parsed = parse(version, options);
2586
1493
  return parsed && parsed.prerelease.length ? parsed.prerelease : null;
2587
1494
  };
2588
- module.exports = prerelease;
2589
1495
  },
2590
1496
  9201: (module, __unused_webpack_exports, __webpack_require__) => {
2591
1497
  const compare = __webpack_require__(2247);
2592
- const rcompare = (a, b, loose) => compare(b, a, loose);
2593
- module.exports = rcompare;
1498
+ module.exports = (a, b, loose) => compare(b, a, loose);
2594
1499
  },
2595
1500
  7391: (module, __unused_webpack_exports, __webpack_require__) => {
2596
1501
  const compareBuild = __webpack_require__(6845);
2597
- const rsort = (list, loose) => list.sort(((a, b) => compareBuild(b, a, loose)));
2598
- module.exports = rsort;
1502
+ module.exports = (list, loose) => list.sort(((a, b) => compareBuild(b, a, loose)));
2599
1503
  },
2600
1504
  8915: (module, __unused_webpack_exports, __webpack_require__) => {
2601
1505
  const Range = __webpack_require__(6833);
2602
- const satisfies = (version, range, options) => {
1506
+ module.exports = (version, range, options) => {
2603
1507
  try {
2604
1508
  range = new Range(range, options);
2605
1509
  } catch (er) {
2606
- return false;
1510
+ return !1;
2607
1511
  }
2608
1512
  return range.test(version);
2609
1513
  };
2610
- module.exports = satisfies;
2611
1514
  },
2612
1515
  1934: (module, __unused_webpack_exports, __webpack_require__) => {
2613
1516
  const compareBuild = __webpack_require__(6845);
2614
- const sort = (list, loose) => list.sort(((a, b) => compareBuild(a, b, loose)));
2615
- module.exports = sort;
1517
+ module.exports = (list, loose) => list.sort(((a, b) => compareBuild(a, b, loose)));
2616
1518
  },
2617
1519
  2555: (module, __unused_webpack_exports, __webpack_require__) => {
2618
1520
  const parse = __webpack_require__(7507);
2619
- const valid = (version, options) => {
1521
+ module.exports = (version, options) => {
2620
1522
  const v = parse(version, options);
2621
1523
  return v ? v.version : null;
2622
1524
  };
2623
- module.exports = valid;
2624
1525
  },
2625
1526
  6027: (module, __unused_webpack_exports, __webpack_require__) => {
2626
1527
  const internalRe = __webpack_require__(9541);
@@ -2672,188 +1573,117 @@ var __webpack_modules__ = {
2672
1573
  };
2673
1574
  },
2674
1575
  9041: module => {
2675
- const SEMVER_SPEC_VERSION = "2.0.0";
2676
- const MAX_LENGTH = 256;
2677
1576
  const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991;
2678
- const MAX_SAFE_COMPONENT_LENGTH = 16;
2679
1577
  module.exports = {
2680
- SEMVER_SPEC_VERSION,
2681
- MAX_LENGTH,
1578
+ SEMVER_SPEC_VERSION: "2.0.0",
1579
+ MAX_LENGTH: 256,
2682
1580
  MAX_SAFE_INTEGER,
2683
- MAX_SAFE_COMPONENT_LENGTH
1581
+ MAX_SAFE_COMPONENT_LENGTH: 16
2684
1582
  };
2685
1583
  },
2686
1584
  5432: module => {
2687
- const debug = typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => {};
1585
+ const debug = "object" == typeof process && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => {};
2688
1586
  module.exports = debug;
2689
1587
  },
2690
1588
  3650: module => {
2691
- const numeric = /^[0-9]+$/;
2692
- const compareIdentifiers = (a, b) => {
2693
- const anum = numeric.test(a);
2694
- const bnum = numeric.test(b);
2695
- if (anum && bnum) {
2696
- a = +a;
2697
- b = +b;
2698
- }
2699
- return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
1589
+ const numeric = /^[0-9]+$/, compareIdentifiers = (a, b) => {
1590
+ const anum = numeric.test(a), bnum = numeric.test(b);
1591
+ return anum && bnum && (a = +a, b = +b), a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
2700
1592
  };
2701
- const rcompareIdentifiers = (a, b) => compareIdentifiers(b, a);
2702
1593
  module.exports = {
2703
1594
  compareIdentifiers,
2704
- rcompareIdentifiers
1595
+ rcompareIdentifiers: (a, b) => compareIdentifiers(b, a)
2705
1596
  };
2706
1597
  },
2707
1598
  3867: module => {
2708
1599
  const opts = [ "includePrerelease", "loose", "rtl" ];
2709
- const parseOptions = options => !options ? {} : typeof options !== "object" ? {
2710
- loose: true
2711
- } : opts.filter((k => options[k])).reduce(((o, k) => {
2712
- o[k] = true;
2713
- return o;
2714
- }), {});
2715
- module.exports = parseOptions;
1600
+ module.exports = options => options ? "object" != typeof options ? {
1601
+ loose: !0
1602
+ } : opts.filter((k => options[k])).reduce(((o, k) => (o[k] = !0, o)), {}) : {};
2716
1603
  },
2717
1604
  9541: (module, exports, __webpack_require__) => {
2718
- const {MAX_SAFE_COMPONENT_LENGTH} = __webpack_require__(9041);
2719
- const debug = __webpack_require__(5432);
2720
- exports = module.exports = {};
2721
- const re = exports.re = [];
2722
- const src = exports.src = [];
2723
- const t = exports.t = {};
1605
+ const {MAX_SAFE_COMPONENT_LENGTH} = __webpack_require__(9041), debug = __webpack_require__(5432), re = (exports = module.exports = {}).re = [], src = exports.src = [], t = exports.t = {};
2724
1606
  let R = 0;
2725
1607
  const createToken = (name, value, isGlobal) => {
2726
1608
  const index = R++;
2727
- debug(name, index, value);
2728
- t[name] = index;
2729
- src[index] = value;
2730
- re[index] = new RegExp(value, isGlobal ? "g" : undefined);
2731
- };
2732
- createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*");
2733
- createToken("NUMERICIDENTIFIERLOOSE", "[0-9]+");
2734
- createToken("NONNUMERICIDENTIFIER", "\\d*[a-zA-Z-][a-zA-Z0-9-]*");
2735
- createToken("MAINVERSION", `(${src[t.NUMERICIDENTIFIER]})\\.` + `(${src[t.NUMERICIDENTIFIER]})\\.` + `(${src[t.NUMERICIDENTIFIER]})`);
2736
- createToken("MAINVERSIONLOOSE", `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` + `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` + `(${src[t.NUMERICIDENTIFIERLOOSE]})`);
2737
- createToken("PRERELEASEIDENTIFIER", `(?:${src[t.NUMERICIDENTIFIER]}|${src[t.NONNUMERICIDENTIFIER]})`);
2738
- createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t.NUMERICIDENTIFIERLOOSE]}|${src[t.NONNUMERICIDENTIFIER]})`);
2739
- createToken("PRERELEASE", `(?:-(${src[t.PRERELEASEIDENTIFIER]}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`);
2740
- createToken("PRERELEASELOOSE", `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`);
2741
- createToken("BUILDIDENTIFIER", "[0-9A-Za-z-]+");
2742
- createToken("BUILD", `(?:\\+(${src[t.BUILDIDENTIFIER]}(?:\\.${src[t.BUILDIDENTIFIER]})*))`);
2743
- createToken("FULLPLAIN", `v?${src[t.MAINVERSION]}${src[t.PRERELEASE]}?${src[t.BUILD]}?`);
2744
- createToken("FULL", `^${src[t.FULLPLAIN]}$`);
2745
- createToken("LOOSEPLAIN", `[v=\\s]*${src[t.MAINVERSIONLOOSE]}${src[t.PRERELEASELOOSE]}?${src[t.BUILD]}?`);
2746
- createToken("LOOSE", `^${src[t.LOOSEPLAIN]}$`);
2747
- createToken("GTLT", "((?:<|>)?=?)");
2748
- createToken("XRANGEIDENTIFIERLOOSE", `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
2749
- createToken("XRANGEIDENTIFIER", `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`);
2750
- createToken("XRANGEPLAIN", `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})` + `(?:\\.(${src[t.XRANGEIDENTIFIER]})` + `(?:\\.(${src[t.XRANGEIDENTIFIER]})` + `(?:${src[t.PRERELEASE]})?${src[t.BUILD]}?` + `)?)?`);
2751
- createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})` + `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` + `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` + `(?:${src[t.PRERELEASELOOSE]})?${src[t.BUILD]}?` + `)?)?`);
2752
- createToken("XRANGE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`);
2753
- createToken("XRANGELOOSE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`);
2754
- createToken("COERCE", `${"(^|[^\\d])" + "(\\d{1,"}${MAX_SAFE_COMPONENT_LENGTH}})` + `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` + `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` + `(?:$|[^\\d])`);
2755
- createToken("COERCERTL", src[t.COERCE], true);
2756
- createToken("LONETILDE", "(?:~>?)");
2757
- createToken("TILDETRIM", `(\\s*)${src[t.LONETILDE]}\\s+`, true);
2758
- exports.tildeTrimReplace = "$1~";
2759
- createToken("TILDE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`);
2760
- createToken("TILDELOOSE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`);
2761
- createToken("LONECARET", "(?:\\^)");
2762
- createToken("CARETTRIM", `(\\s*)${src[t.LONECARET]}\\s+`, true);
2763
- exports.caretTrimReplace = "$1^";
2764
- createToken("CARET", `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`);
2765
- createToken("CARETLOOSE", `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`);
2766
- createToken("COMPARATORLOOSE", `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`);
2767
- createToken("COMPARATOR", `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`);
2768
- createToken("COMPARATORTRIM", `(\\s*)${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true);
2769
- exports.comparatorTrimReplace = "$1$2$3";
2770
- createToken("HYPHENRANGE", `^\\s*(${src[t.XRANGEPLAIN]})` + `\\s+-\\s+` + `(${src[t.XRANGEPLAIN]})` + `\\s*$`);
2771
- createToken("HYPHENRANGELOOSE", `^\\s*(${src[t.XRANGEPLAINLOOSE]})` + `\\s+-\\s+` + `(${src[t.XRANGEPLAINLOOSE]})` + `\\s*$`);
2772
- createToken("STAR", "(<|>)?=?\\s*\\*");
2773
- createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
1609
+ debug(name, index, value), t[name] = index, src[index] = value, re[index] = new RegExp(value, isGlobal ? "g" : void 0);
1610
+ };
1611
+ createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*"), createToken("NUMERICIDENTIFIERLOOSE", "[0-9]+"),
1612
+ createToken("NONNUMERICIDENTIFIER", "\\d*[a-zA-Z-][a-zA-Z0-9-]*"), createToken("MAINVERSION", `(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})`),
1613
+ createToken("MAINVERSIONLOOSE", `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})`),
1614
+ createToken("PRERELEASEIDENTIFIER", `(?:${src[t.NUMERICIDENTIFIER]}|${src[t.NONNUMERICIDENTIFIER]})`),
1615
+ createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t.NUMERICIDENTIFIERLOOSE]}|${src[t.NONNUMERICIDENTIFIER]})`),
1616
+ createToken("PRERELEASE", `(?:-(${src[t.PRERELEASEIDENTIFIER]}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`),
1617
+ createToken("PRERELEASELOOSE", `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`),
1618
+ createToken("BUILDIDENTIFIER", "[0-9A-Za-z-]+"), createToken("BUILD", `(?:\\+(${src[t.BUILDIDENTIFIER]}(?:\\.${src[t.BUILDIDENTIFIER]})*))`),
1619
+ createToken("FULLPLAIN", `v?${src[t.MAINVERSION]}${src[t.PRERELEASE]}?${src[t.BUILD]}?`),
1620
+ createToken("FULL", `^${src[t.FULLPLAIN]}$`), createToken("LOOSEPLAIN", `[v=\\s]*${src[t.MAINVERSIONLOOSE]}${src[t.PRERELEASELOOSE]}?${src[t.BUILD]}?`),
1621
+ createToken("LOOSE", `^${src[t.LOOSEPLAIN]}$`), createToken("GTLT", "((?:<|>)?=?)"),
1622
+ createToken("XRANGEIDENTIFIERLOOSE", `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`),
1623
+ createToken("XRANGEIDENTIFIER", `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`), createToken("XRANGEPLAIN", `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:${src[t.PRERELEASE]})?${src[t.BUILD]}?)?)?`),
1624
+ createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:${src[t.PRERELEASELOOSE]})?${src[t.BUILD]}?)?)?`),
1625
+ createToken("XRANGE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`), createToken("XRANGELOOSE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`),
1626
+ createToken("COERCE", `(^|[^\\d])(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?(?:$|[^\\d])`),
1627
+ createToken("COERCERTL", src[t.COERCE], !0), createToken("LONETILDE", "(?:~>?)"),
1628
+ createToken("TILDETRIM", `(\\s*)${src[t.LONETILDE]}\\s+`, !0), exports.tildeTrimReplace = "$1~",
1629
+ createToken("TILDE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`), createToken("TILDELOOSE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`),
1630
+ createToken("LONECARET", "(?:\\^)"), createToken("CARETTRIM", `(\\s*)${src[t.LONECARET]}\\s+`, !0),
1631
+ exports.caretTrimReplace = "$1^", createToken("CARET", `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`),
1632
+ createToken("CARETLOOSE", `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`), createToken("COMPARATORLOOSE", `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`),
1633
+ createToken("COMPARATOR", `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`), createToken("COMPARATORTRIM", `(\\s*)${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, !0),
1634
+ exports.comparatorTrimReplace = "$1$2$3", createToken("HYPHENRANGE", `^\\s*(${src[t.XRANGEPLAIN]})\\s+-\\s+(${src[t.XRANGEPLAIN]})\\s*$`),
1635
+ createToken("HYPHENRANGELOOSE", `^\\s*(${src[t.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t.XRANGEPLAINLOOSE]})\\s*$`),
1636
+ createToken("STAR", "(<|>)?=?\\s*\\*"), createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$"),
2774
1637
  createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
2775
1638
  },
2776
1639
  4933: (module, __unused_webpack_exports, __webpack_require__) => {
2777
1640
  const outside = __webpack_require__(939);
2778
- const gtr = (version, range, options) => outside(version, range, ">", options);
2779
- module.exports = gtr;
1641
+ module.exports = (version, range, options) => outside(version, range, ">", options);
2780
1642
  },
2781
1643
  8842: (module, __unused_webpack_exports, __webpack_require__) => {
2782
1644
  const Range = __webpack_require__(6833);
2783
- const intersects = (r1, r2, options) => {
2784
- r1 = new Range(r1, options);
2785
- r2 = new Range(r2, options);
2786
- return r1.intersects(r2);
2787
- };
2788
- module.exports = intersects;
1645
+ module.exports = (r1, r2, options) => (r1 = new Range(r1, options), r2 = new Range(r2, options),
1646
+ r1.intersects(r2));
2789
1647
  },
2790
1648
  7233: (module, __unused_webpack_exports, __webpack_require__) => {
2791
1649
  const outside = __webpack_require__(939);
2792
- const ltr = (version, range, options) => outside(version, range, "<", options);
2793
- module.exports = ltr;
1650
+ module.exports = (version, range, options) => outside(version, range, "<", options);
2794
1651
  },
2795
1652
  1678: (module, __unused_webpack_exports, __webpack_require__) => {
2796
- const SemVer = __webpack_require__(3013);
2797
- const Range = __webpack_require__(6833);
2798
- const maxSatisfying = (versions, range, options) => {
2799
- let max = null;
2800
- let maxSV = null;
2801
- let rangeObj = null;
1653
+ const SemVer = __webpack_require__(3013), Range = __webpack_require__(6833);
1654
+ module.exports = (versions, range, options) => {
1655
+ let max = null, maxSV = null, rangeObj = null;
2802
1656
  try {
2803
1657
  rangeObj = new Range(range, options);
2804
1658
  } catch (er) {
2805
1659
  return null;
2806
1660
  }
2807
- versions.forEach((v => {
2808
- if (rangeObj.test(v)) {
2809
- if (!max || maxSV.compare(v) === -1) {
2810
- max = v;
2811
- maxSV = new SemVer(max, options);
2812
- }
2813
- }
2814
- }));
2815
- return max;
1661
+ return versions.forEach((v => {
1662
+ rangeObj.test(v) && (max && -1 !== maxSV.compare(v) || (max = v, maxSV = new SemVer(max, options)));
1663
+ })), max;
2816
1664
  };
2817
- module.exports = maxSatisfying;
2818
1665
  },
2819
1666
  1553: (module, __unused_webpack_exports, __webpack_require__) => {
2820
- const SemVer = __webpack_require__(3013);
2821
- const Range = __webpack_require__(6833);
2822
- const minSatisfying = (versions, range, options) => {
2823
- let min = null;
2824
- let minSV = null;
2825
- let rangeObj = null;
1667
+ const SemVer = __webpack_require__(3013), Range = __webpack_require__(6833);
1668
+ module.exports = (versions, range, options) => {
1669
+ let min = null, minSV = null, rangeObj = null;
2826
1670
  try {
2827
1671
  rangeObj = new Range(range, options);
2828
1672
  } catch (er) {
2829
1673
  return null;
2830
1674
  }
2831
- versions.forEach((v => {
2832
- if (rangeObj.test(v)) {
2833
- if (!min || minSV.compare(v) === 1) {
2834
- min = v;
2835
- minSV = new SemVer(min, options);
2836
- }
2837
- }
2838
- }));
2839
- return min;
1675
+ return versions.forEach((v => {
1676
+ rangeObj.test(v) && (min && 1 !== minSV.compare(v) || (min = v, minSV = new SemVer(min, options)));
1677
+ })), min;
2840
1678
  };
2841
- module.exports = minSatisfying;
2842
1679
  },
2843
1680
  2262: (module, __unused_webpack_exports, __webpack_require__) => {
2844
- const SemVer = __webpack_require__(3013);
2845
- const Range = __webpack_require__(6833);
2846
- const gt = __webpack_require__(6077);
2847
- const minVersion = (range, loose) => {
1681
+ const SemVer = __webpack_require__(3013), Range = __webpack_require__(6833), gt = __webpack_require__(6077);
1682
+ module.exports = (range, loose) => {
2848
1683
  range = new Range(range, loose);
2849
1684
  let minver = new SemVer("0.0.0");
2850
- if (range.test(minver)) {
2851
- return minver;
2852
- }
2853
- minver = new SemVer("0.0.0-0");
2854
- if (range.test(minver)) {
2855
- return minver;
2856
- }
1685
+ if (range.test(minver)) return minver;
1686
+ if (minver = new SemVer("0.0.0-0"), range.test(minver)) return minver;
2857
1687
  minver = null;
2858
1688
  for (let i = 0; i < range.set.length; ++i) {
2859
1689
  const comparators = range.set[i];
@@ -2862,18 +1692,12 @@ var __webpack_modules__ = {
2862
1692
  const compver = new SemVer(comparator.semver.version);
2863
1693
  switch (comparator.operator) {
2864
1694
  case ">":
2865
- if (compver.prerelease.length === 0) {
2866
- compver.patch++;
2867
- } else {
2868
- compver.prerelease.push(0);
2869
- }
1695
+ 0 === compver.prerelease.length ? compver.patch++ : compver.prerelease.push(0),
2870
1696
  compver.raw = compver.format();
2871
1697
 
2872
1698
  case "":
2873
1699
  case ">=":
2874
- if (!setMin || gt(compver, setMin)) {
2875
- setMin = compver;
2876
- }
1700
+ setMin && !gt(compver, setMin) || (setMin = compver);
2877
1701
  break;
2878
1702
 
2879
1703
  case "<":
@@ -2883,368 +1707,162 @@ var __webpack_modules__ = {
2883
1707
  default:
2884
1708
  throw new Error(`Unexpected operation: ${comparator.operator}`);
2885
1709
  }
2886
- }));
2887
- if (setMin && (!minver || gt(minver, setMin))) {
2888
- minver = setMin;
2889
- }
1710
+ })), !setMin || minver && !gt(minver, setMin) || (minver = setMin);
2890
1711
  }
2891
- if (minver && range.test(minver)) {
2892
- return minver;
2893
- }
2894
- return null;
1712
+ return minver && range.test(minver) ? minver : null;
2895
1713
  };
2896
- module.exports = minVersion;
2897
1714
  },
2898
1715
  939: (module, __unused_webpack_exports, __webpack_require__) => {
2899
- const SemVer = __webpack_require__(3013);
2900
- const Comparator = __webpack_require__(7706);
2901
- const {ANY} = Comparator;
2902
- const Range = __webpack_require__(6833);
2903
- const satisfies = __webpack_require__(8915);
2904
- const gt = __webpack_require__(6077);
2905
- const lt = __webpack_require__(866);
2906
- const lte = __webpack_require__(698);
2907
- const gte = __webpack_require__(4578);
2908
- const outside = (version, range, hilo, options) => {
2909
- version = new SemVer(version, options);
2910
- range = new Range(range, options);
1716
+ const SemVer = __webpack_require__(3013), Comparator = __webpack_require__(7706), {ANY} = Comparator, Range = __webpack_require__(6833), satisfies = __webpack_require__(8915), gt = __webpack_require__(6077), lt = __webpack_require__(866), lte = __webpack_require__(698), gte = __webpack_require__(4578);
1717
+ module.exports = (version, range, hilo, options) => {
2911
1718
  let gtfn, ltefn, ltfn, comp, ecomp;
2912
- switch (hilo) {
1719
+ switch (version = new SemVer(version, options), range = new Range(range, options),
1720
+ hilo) {
2913
1721
  case ">":
2914
- gtfn = gt;
2915
- ltefn = lte;
2916
- ltfn = lt;
2917
- comp = ">";
2918
- ecomp = ">=";
1722
+ gtfn = gt, ltefn = lte, ltfn = lt, comp = ">", ecomp = ">=";
2919
1723
  break;
2920
1724
 
2921
1725
  case "<":
2922
- gtfn = lt;
2923
- ltefn = gte;
2924
- ltfn = gt;
2925
- comp = "<";
2926
- ecomp = "<=";
1726
+ gtfn = lt, ltefn = gte, ltfn = gt, comp = "<", ecomp = "<=";
2927
1727
  break;
2928
1728
 
2929
1729
  default:
2930
1730
  throw new TypeError('Must provide a hilo val of "<" or ">"');
2931
1731
  }
2932
- if (satisfies(version, range, options)) {
2933
- return false;
2934
- }
1732
+ if (satisfies(version, range, options)) return !1;
2935
1733
  for (let i = 0; i < range.set.length; ++i) {
2936
1734
  const comparators = range.set[i];
2937
- let high = null;
2938
- let low = null;
2939
- comparators.forEach((comparator => {
2940
- if (comparator.semver === ANY) {
2941
- comparator = new Comparator(">=0.0.0");
2942
- }
2943
- high = high || comparator;
2944
- low = low || comparator;
2945
- if (gtfn(comparator.semver, high.semver, options)) {
2946
- high = comparator;
2947
- } else if (ltfn(comparator.semver, low.semver, options)) {
2948
- low = comparator;
2949
- }
2950
- }));
2951
- if (high.operator === comp || high.operator === ecomp) {
2952
- return false;
2953
- }
2954
- if ((!low.operator || low.operator === comp) && ltefn(version, low.semver)) {
2955
- return false;
2956
- } else if (low.operator === ecomp && ltfn(version, low.semver)) {
2957
- return false;
2958
- }
1735
+ let high = null, low = null;
1736
+ if (comparators.forEach((comparator => {
1737
+ comparator.semver === ANY && (comparator = new Comparator(">=0.0.0")), high = high || comparator,
1738
+ low = low || comparator, gtfn(comparator.semver, high.semver, options) ? high = comparator : ltfn(comparator.semver, low.semver, options) && (low = comparator);
1739
+ })), high.operator === comp || high.operator === ecomp) return !1;
1740
+ if ((!low.operator || low.operator === comp) && ltefn(version, low.semver)) return !1;
1741
+ if (low.operator === ecomp && ltfn(version, low.semver)) return !1;
2959
1742
  }
2960
- return true;
1743
+ return !0;
2961
1744
  };
2962
- module.exports = outside;
2963
1745
  },
2964
1746
  3018: (module, __unused_webpack_exports, __webpack_require__) => {
2965
- const satisfies = __webpack_require__(8915);
2966
- const compare = __webpack_require__(2247);
1747
+ const satisfies = __webpack_require__(8915), compare = __webpack_require__(2247);
2967
1748
  module.exports = (versions, range, options) => {
2968
1749
  const set = [];
2969
- let first = null;
2970
- let prev = null;
1750
+ let first = null, prev = null;
2971
1751
  const v = versions.sort(((a, b) => compare(a, b, options)));
2972
1752
  for (const version of v) {
2973
- const included = satisfies(version, range, options);
2974
- if (included) {
2975
- prev = version;
2976
- if (!first) {
2977
- first = version;
2978
- }
2979
- } else {
2980
- if (prev) {
2981
- set.push([ first, prev ]);
2982
- }
2983
- prev = null;
2984
- first = null;
2985
- }
2986
- }
2987
- if (first) {
2988
- set.push([ first, null ]);
1753
+ satisfies(version, range, options) ? (prev = version, first || (first = version)) : (prev && set.push([ first, prev ]),
1754
+ prev = null, first = null);
2989
1755
  }
1756
+ first && set.push([ first, null ]);
2990
1757
  const ranges = [];
2991
- for (const [min, max] of set) {
2992
- if (min === max) {
2993
- ranges.push(min);
2994
- } else if (!max && min === v[0]) {
2995
- ranges.push("*");
2996
- } else if (!max) {
2997
- ranges.push(`>=${min}`);
2998
- } else if (min === v[0]) {
2999
- ranges.push(`<=${max}`);
3000
- } else {
3001
- ranges.push(`${min} - ${max}`);
3002
- }
3003
- }
3004
- const simplified = ranges.join(" || ");
3005
- const original = typeof range.raw === "string" ? range.raw : String(range);
1758
+ for (const [min, max] of set) min === max ? ranges.push(min) : max || min !== v[0] ? max ? min === v[0] ? ranges.push(`<=${max}`) : ranges.push(`${min} - ${max}`) : ranges.push(`>=${min}`) : ranges.push("*");
1759
+ const simplified = ranges.join(" || "), original = "string" == typeof range.raw ? range.raw : String(range);
3006
1760
  return simplified.length < original.length ? simplified : range;
3007
1761
  };
3008
1762
  },
3009
1763
  8563: (module, __unused_webpack_exports, __webpack_require__) => {
3010
- const Range = __webpack_require__(6833);
3011
- const Comparator = __webpack_require__(7706);
3012
- const {ANY} = Comparator;
3013
- const satisfies = __webpack_require__(8915);
3014
- const compare = __webpack_require__(2247);
3015
- const subset = (sub, dom, options = {}) => {
3016
- if (sub === dom) {
3017
- return true;
1764
+ const Range = __webpack_require__(6833), Comparator = __webpack_require__(7706), {ANY} = Comparator, satisfies = __webpack_require__(8915), compare = __webpack_require__(2247), simpleSubset = (sub, dom, options) => {
1765
+ if (sub === dom) return !0;
1766
+ if (1 === sub.length && sub[0].semver === ANY) {
1767
+ if (1 === dom.length && dom[0].semver === ANY) return !0;
1768
+ sub = options.includePrerelease ? [ new Comparator(">=0.0.0-0") ] : [ new Comparator(">=0.0.0") ];
3018
1769
  }
3019
- sub = new Range(sub, options);
3020
- dom = new Range(dom, options);
3021
- let sawNonNull = false;
3022
- OUTER: for (const simpleSub of sub.set) {
3023
- for (const simpleDom of dom.set) {
3024
- const isSub = simpleSubset(simpleSub, simpleDom, options);
3025
- sawNonNull = sawNonNull || isSub !== null;
3026
- if (isSub) {
3027
- continue OUTER;
3028
- }
3029
- }
3030
- if (sawNonNull) {
3031
- return false;
3032
- }
3033
- }
3034
- return true;
3035
- };
3036
- const simpleSubset = (sub, dom, options) => {
3037
- if (sub === dom) {
3038
- return true;
3039
- }
3040
- if (sub.length === 1 && sub[0].semver === ANY) {
3041
- if (dom.length === 1 && dom[0].semver === ANY) {
3042
- return true;
3043
- } else if (options.includePrerelease) {
3044
- sub = [ new Comparator(">=0.0.0-0") ];
3045
- } else {
3046
- sub = [ new Comparator(">=0.0.0") ];
3047
- }
3048
- }
3049
- if (dom.length === 1 && dom[0].semver === ANY) {
3050
- if (options.includePrerelease) {
3051
- return true;
3052
- } else {
3053
- dom = [ new Comparator(">=0.0.0") ];
3054
- }
1770
+ if (1 === dom.length && dom[0].semver === ANY) {
1771
+ if (options.includePrerelease) return !0;
1772
+ dom = [ new Comparator(">=0.0.0") ];
3055
1773
  }
3056
1774
  const eqSet = new Set;
3057
- let gt, lt;
3058
- for (const c of sub) {
3059
- if (c.operator === ">" || c.operator === ">=") {
3060
- gt = higherGT(gt, c, options);
3061
- } else if (c.operator === "<" || c.operator === "<=") {
3062
- lt = lowerLT(lt, c, options);
3063
- } else {
3064
- eqSet.add(c.semver);
3065
- }
3066
- }
3067
- if (eqSet.size > 1) {
3068
- return null;
3069
- }
3070
- let gtltComp;
1775
+ let gt, lt, gtltComp, higher, lower, hasDomLT, hasDomGT;
1776
+ for (const c of sub) ">" === c.operator || ">=" === c.operator ? gt = higherGT(gt, c, options) : "<" === c.operator || "<=" === c.operator ? lt = lowerLT(lt, c, options) : eqSet.add(c.semver);
1777
+ if (eqSet.size > 1) return null;
3071
1778
  if (gt && lt) {
3072
- gtltComp = compare(gt.semver, lt.semver, options);
3073
- if (gtltComp > 0) {
3074
- return null;
3075
- } else if (gtltComp === 0 && (gt.operator !== ">=" || lt.operator !== "<=")) {
3076
- return null;
3077
- }
1779
+ if (gtltComp = compare(gt.semver, lt.semver, options), gtltComp > 0) return null;
1780
+ if (0 === gtltComp && (">=" !== gt.operator || "<=" !== lt.operator)) return null;
3078
1781
  }
3079
1782
  for (const eq of eqSet) {
3080
- if (gt && !satisfies(eq, String(gt), options)) {
3081
- return null;
3082
- }
3083
- if (lt && !satisfies(eq, String(lt), options)) {
3084
- return null;
3085
- }
3086
- for (const c of dom) {
3087
- if (!satisfies(eq, String(c), options)) {
3088
- return false;
3089
- }
3090
- }
3091
- return true;
3092
- }
3093
- let higher, lower;
3094
- let hasDomLT, hasDomGT;
3095
- let needDomLTPre = lt && !options.includePrerelease && lt.semver.prerelease.length ? lt.semver : false;
3096
- let needDomGTPre = gt && !options.includePrerelease && gt.semver.prerelease.length ? gt.semver : false;
3097
- if (needDomLTPre && needDomLTPre.prerelease.length === 1 && lt.operator === "<" && needDomLTPre.prerelease[0] === 0) {
3098
- needDomLTPre = false;
1783
+ if (gt && !satisfies(eq, String(gt), options)) return null;
1784
+ if (lt && !satisfies(eq, String(lt), options)) return null;
1785
+ for (const c of dom) if (!satisfies(eq, String(c), options)) return !1;
1786
+ return !0;
3099
1787
  }
1788
+ let needDomLTPre = !(!lt || options.includePrerelease || !lt.semver.prerelease.length) && lt.semver, needDomGTPre = !(!gt || options.includePrerelease || !gt.semver.prerelease.length) && gt.semver;
1789
+ needDomLTPre && 1 === needDomLTPre.prerelease.length && "<" === lt.operator && 0 === needDomLTPre.prerelease[0] && (needDomLTPre = !1);
3100
1790
  for (const c of dom) {
3101
- hasDomGT = hasDomGT || c.operator === ">" || c.operator === ">=";
3102
- hasDomLT = hasDomLT || c.operator === "<" || c.operator === "<=";
3103
- if (gt) {
3104
- if (needDomGTPre) {
3105
- if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomGTPre.major && c.semver.minor === needDomGTPre.minor && c.semver.patch === needDomGTPre.patch) {
3106
- needDomGTPre = false;
3107
- }
3108
- }
3109
- if (c.operator === ">" || c.operator === ">=") {
3110
- higher = higherGT(gt, c, options);
3111
- if (higher === c && higher !== gt) {
3112
- return false;
3113
- }
3114
- } else if (gt.operator === ">=" && !satisfies(gt.semver, String(c), options)) {
3115
- return false;
3116
- }
3117
- }
3118
- if (lt) {
3119
- if (needDomLTPre) {
3120
- if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomLTPre.major && c.semver.minor === needDomLTPre.minor && c.semver.patch === needDomLTPre.patch) {
3121
- needDomLTPre = false;
3122
- }
3123
- }
3124
- if (c.operator === "<" || c.operator === "<=") {
3125
- lower = lowerLT(lt, c, options);
3126
- if (lower === c && lower !== lt) {
3127
- return false;
3128
- }
3129
- } else if (lt.operator === "<=" && !satisfies(lt.semver, String(c), options)) {
3130
- return false;
3131
- }
3132
- }
3133
- if (!c.operator && (lt || gt) && gtltComp !== 0) {
3134
- return false;
3135
- }
3136
- }
3137
- if (gt && hasDomLT && !lt && gtltComp !== 0) {
3138
- return false;
3139
- }
3140
- if (lt && hasDomGT && !gt && gtltComp !== 0) {
3141
- return false;
3142
- }
3143
- if (needDomGTPre || needDomLTPre) {
3144
- return false;
3145
- }
3146
- return true;
3147
- };
3148
- const higherGT = (a, b, options) => {
3149
- if (!a) {
3150
- return b;
3151
- }
1791
+ if (hasDomGT = hasDomGT || ">" === c.operator || ">=" === c.operator, hasDomLT = hasDomLT || "<" === c.operator || "<=" === c.operator,
1792
+ gt) if (needDomGTPre && c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomGTPre.major && c.semver.minor === needDomGTPre.minor && c.semver.patch === needDomGTPre.patch && (needDomGTPre = !1),
1793
+ ">" === c.operator || ">=" === c.operator) {
1794
+ if (higher = higherGT(gt, c, options), higher === c && higher !== gt) return !1;
1795
+ } else if (">=" === gt.operator && !satisfies(gt.semver, String(c), options)) return !1;
1796
+ if (lt) if (needDomLTPre && c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomLTPre.major && c.semver.minor === needDomLTPre.minor && c.semver.patch === needDomLTPre.patch && (needDomLTPre = !1),
1797
+ "<" === c.operator || "<=" === c.operator) {
1798
+ if (lower = lowerLT(lt, c, options), lower === c && lower !== lt) return !1;
1799
+ } else if ("<=" === lt.operator && !satisfies(lt.semver, String(c), options)) return !1;
1800
+ if (!c.operator && (lt || gt) && 0 !== gtltComp) return !1;
1801
+ }
1802
+ return !(gt && hasDomLT && !lt && 0 !== gtltComp) && (!(lt && hasDomGT && !gt && 0 !== gtltComp) && (!needDomGTPre && !needDomLTPre));
1803
+ }, higherGT = (a, b, options) => {
1804
+ if (!a) return b;
3152
1805
  const comp = compare(a.semver, b.semver, options);
3153
- return comp > 0 ? a : comp < 0 ? b : b.operator === ">" && a.operator === ">=" ? b : a;
1806
+ return comp > 0 ? a : comp < 0 || ">" === b.operator && ">=" === a.operator ? b : a;
1807
+ }, lowerLT = (a, b, options) => {
1808
+ if (!a) return b;
1809
+ const comp = compare(a.semver, b.semver, options);
1810
+ return comp < 0 ? a : comp > 0 || "<" === b.operator && "<=" === a.operator ? b : a;
3154
1811
  };
3155
- const lowerLT = (a, b, options) => {
3156
- if (!a) {
3157
- return b;
1812
+ module.exports = (sub, dom, options = {}) => {
1813
+ if (sub === dom) return !0;
1814
+ sub = new Range(sub, options), dom = new Range(dom, options);
1815
+ let sawNonNull = !1;
1816
+ OUTER: for (const simpleSub of sub.set) {
1817
+ for (const simpleDom of dom.set) {
1818
+ const isSub = simpleSubset(simpleSub, simpleDom, options);
1819
+ if (sawNonNull = sawNonNull || null !== isSub, isSub) continue OUTER;
1820
+ }
1821
+ if (sawNonNull) return !1;
3158
1822
  }
3159
- const comp = compare(a.semver, b.semver, options);
3160
- return comp < 0 ? a : comp > 0 ? b : b.operator === "<" && a.operator === "<=" ? b : a;
1823
+ return !0;
3161
1824
  };
3162
- module.exports = subset;
3163
1825
  },
3164
1826
  8378: (module, __unused_webpack_exports, __webpack_require__) => {
3165
1827
  const Range = __webpack_require__(6833);
3166
- const toComparators = (range, options) => new Range(range, options).set.map((comp => comp.map((c => c.value)).join(" ").trim().split(" ")));
3167
- module.exports = toComparators;
1828
+ module.exports = (range, options) => new Range(range, options).set.map((comp => comp.map((c => c.value)).join(" ").trim().split(" ")));
3168
1829
  },
3169
1830
  7396: (module, __unused_webpack_exports, __webpack_require__) => {
3170
1831
  const Range = __webpack_require__(6833);
3171
- const validRange = (range, options) => {
1832
+ module.exports = (range, options) => {
3172
1833
  try {
3173
1834
  return new Range(range, options).range || "*";
3174
1835
  } catch (er) {
3175
1836
  return null;
3176
1837
  }
3177
1838
  };
3178
- module.exports = validRange;
3179
1839
  },
3180
1840
  9797: (module, __unused_webpack_exports, __webpack_require__) => {
3181
1841
  "use strict";
3182
- const os = __webpack_require__(2037);
3183
- const tty = __webpack_require__(6224);
3184
- const hasFlag = __webpack_require__(4288);
3185
- const {env} = process;
1842
+ const os = __webpack_require__(2037), tty = __webpack_require__(6224), hasFlag = __webpack_require__(4288), {env} = process;
3186
1843
  let forceColor;
3187
- if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
3188
- forceColor = 0;
3189
- } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
3190
- forceColor = 1;
3191
- }
3192
- if ("FORCE_COLOR" in env) {
3193
- if (env.FORCE_COLOR === "true") {
3194
- forceColor = 1;
3195
- } else if (env.FORCE_COLOR === "false") {
3196
- forceColor = 0;
3197
- } else {
3198
- forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3);
3199
- }
3200
- }
3201
1844
  function translateLevel(level) {
3202
- if (level === 0) {
3203
- return false;
3204
- }
3205
- return {
1845
+ return 0 !== level && {
3206
1846
  level,
3207
- hasBasic: true,
1847
+ hasBasic: !0,
3208
1848
  has256: level >= 2,
3209
1849
  has16m: level >= 3
3210
1850
  };
3211
1851
  }
3212
1852
  function supportsColor(haveStream, streamIsTTY) {
3213
- if (forceColor === 0) {
3214
- return 0;
3215
- }
3216
- if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
3217
- return 3;
3218
- }
3219
- if (hasFlag("color=256")) {
3220
- return 2;
3221
- }
3222
- if (haveStream && !streamIsTTY && forceColor === undefined) {
3223
- return 0;
3224
- }
1853
+ if (0 === forceColor) return 0;
1854
+ if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) return 3;
1855
+ if (hasFlag("color=256")) return 2;
1856
+ if (haveStream && !streamIsTTY && void 0 === forceColor) return 0;
3225
1857
  const min = forceColor || 0;
3226
- if (env.TERM === "dumb") {
3227
- return min;
3228
- }
3229
- if (process.platform === "win32") {
1858
+ if ("dumb" === env.TERM) return min;
1859
+ if ("win32" === process.platform) {
3230
1860
  const osRelease = os.release().split(".");
3231
- if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
3232
- return Number(osRelease[2]) >= 14931 ? 3 : 2;
3233
- }
3234
- return 1;
3235
- }
3236
- if ("CI" in env) {
3237
- if ([ "TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE" ].some((sign => sign in env)) || env.CI_NAME === "codeship") {
3238
- return 1;
3239
- }
3240
- return min;
3241
- }
3242
- if ("TEAMCITY_VERSION" in env) {
3243
- return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
3244
- }
3245
- if (env.COLORTERM === "truecolor") {
3246
- return 3;
1861
+ return Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586 ? Number(osRelease[2]) >= 14931 ? 3 : 2 : 1;
3247
1862
  }
1863
+ if ("CI" in env) return [ "TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE" ].some((sign => sign in env)) || "codeship" === env.CI_NAME ? 1 : min;
1864
+ if ("TEAMCITY_VERSION" in env) return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
1865
+ if ("truecolor" === env.COLORTERM) return 3;
3248
1866
  if ("TERM_PROGRAM" in env) {
3249
1867
  const version = parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
3250
1868
  switch (env.TERM_PROGRAM) {
@@ -3255,397 +1873,172 @@ var __webpack_modules__ = {
3255
1873
  return 2;
3256
1874
  }
3257
1875
  }
3258
- if (/-256(color)?$/i.test(env.TERM)) {
3259
- return 2;
3260
- }
3261
- if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
3262
- return 1;
3263
- }
3264
- if ("COLORTERM" in env) {
3265
- return 1;
3266
- }
3267
- return min;
3268
- }
3269
- function getSupportLevel(stream) {
3270
- const level = supportsColor(stream, stream && stream.isTTY);
3271
- return translateLevel(level);
1876
+ return /-256(color)?$/i.test(env.TERM) ? 2 : /^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM) || "COLORTERM" in env ? 1 : min;
3272
1877
  }
1878
+ hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never") ? forceColor = 0 : (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) && (forceColor = 1),
1879
+ "FORCE_COLOR" in env && (forceColor = "true" === env.FORCE_COLOR ? 1 : "false" === env.FORCE_COLOR ? 0 : 0 === env.FORCE_COLOR.length ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3)),
3273
1880
  module.exports = {
3274
- supportsColor: getSupportLevel,
3275
- stdout: translateLevel(supportsColor(true, tty.isatty(1))),
3276
- stderr: translateLevel(supportsColor(true, tty.isatty(2)))
1881
+ supportsColor: function(stream) {
1882
+ return translateLevel(supportsColor(stream, stream && stream.isTTY));
1883
+ },
1884
+ stdout: translateLevel(supportsColor(!0, tty.isatty(1))),
1885
+ stderr: translateLevel(supportsColor(!0, tty.isatty(2)))
3277
1886
  };
3278
1887
  },
3279
1888
  3278: module => {
3280
1889
  "use strict";
3281
1890
  module.exports = function(Yallist) {
3282
1891
  Yallist.prototype[Symbol.iterator] = function*() {
3283
- for (let walker = this.head; walker; walker = walker.next) {
3284
- yield walker.value;
3285
- }
1892
+ for (let walker = this.head; walker; walker = walker.next) yield walker.value;
3286
1893
  };
3287
1894
  };
3288
1895
  },
3289
1896
  1455: (module, __unused_webpack_exports, __webpack_require__) => {
3290
1897
  "use strict";
3291
- module.exports = Yallist;
3292
- Yallist.Node = Node;
3293
- Yallist.create = Yallist;
3294
1898
  function Yallist(list) {
3295
1899
  var self = this;
3296
- if (!(self instanceof Yallist)) {
3297
- self = new Yallist;
3298
- }
3299
- self.tail = null;
3300
- self.head = null;
3301
- self.length = 0;
3302
- if (list && typeof list.forEach === "function") {
3303
- list.forEach((function(item) {
3304
- self.push(item);
3305
- }));
3306
- } else if (arguments.length > 0) {
3307
- for (var i = 0, l = arguments.length; i < l; i++) {
3308
- self.push(arguments[i]);
3309
- }
3310
- }
1900
+ if (self instanceof Yallist || (self = new Yallist), self.tail = null, self.head = null,
1901
+ self.length = 0, list && "function" == typeof list.forEach) list.forEach((function(item) {
1902
+ self.push(item);
1903
+ })); else if (arguments.length > 0) for (var i = 0, l = arguments.length; i < l; i++) self.push(arguments[i]);
3311
1904
  return self;
3312
1905
  }
3313
- Yallist.prototype.removeNode = function(node) {
3314
- if (node.list !== this) {
3315
- throw new Error("removing node which does not belong to this list");
3316
- }
3317
- var next = node.next;
3318
- var prev = node.prev;
3319
- if (next) {
3320
- next.prev = prev;
3321
- }
3322
- if (prev) {
3323
- prev.next = next;
3324
- }
3325
- if (node === this.head) {
3326
- this.head = next;
3327
- }
3328
- if (node === this.tail) {
3329
- this.tail = prev;
3330
- }
3331
- node.list.length--;
3332
- node.next = null;
3333
- node.prev = null;
3334
- node.list = null;
3335
- return next;
3336
- };
3337
- Yallist.prototype.unshiftNode = function(node) {
3338
- if (node === this.head) {
3339
- return;
3340
- }
3341
- if (node.list) {
3342
- node.list.removeNode(node);
3343
- }
3344
- var head = this.head;
3345
- node.list = this;
3346
- node.next = head;
3347
- if (head) {
3348
- head.prev = node;
3349
- }
3350
- this.head = node;
3351
- if (!this.tail) {
3352
- this.tail = node;
3353
- }
3354
- this.length++;
3355
- };
3356
- Yallist.prototype.pushNode = function(node) {
3357
- if (node === this.tail) {
3358
- return;
3359
- }
3360
- if (node.list) {
3361
- node.list.removeNode(node);
3362
- }
3363
- var tail = this.tail;
3364
- node.list = this;
3365
- node.prev = tail;
3366
- if (tail) {
3367
- tail.next = node;
3368
- }
3369
- this.tail = node;
3370
- if (!this.head) {
3371
- this.head = node;
3372
- }
3373
- this.length++;
3374
- };
3375
- Yallist.prototype.push = function() {
3376
- for (var i = 0, l = arguments.length; i < l; i++) {
3377
- push(this, arguments[i]);
3378
- }
1906
+ function insert(self, node, value) {
1907
+ var inserted = node === self.head ? new Node(value, null, node, self) : new Node(value, node, node.next, self);
1908
+ return null === inserted.next && (self.tail = inserted), null === inserted.prev && (self.head = inserted),
1909
+ self.length++, inserted;
1910
+ }
1911
+ function push(self, item) {
1912
+ self.tail = new Node(item, self.tail, null, self), self.head || (self.head = self.tail),
1913
+ self.length++;
1914
+ }
1915
+ function unshift(self, item) {
1916
+ self.head = new Node(item, null, self.head, self), self.tail || (self.tail = self.head),
1917
+ self.length++;
1918
+ }
1919
+ function Node(value, prev, next, list) {
1920
+ if (!(this instanceof Node)) return new Node(value, prev, next, list);
1921
+ this.list = list, this.value = value, prev ? (prev.next = this, this.prev = prev) : this.prev = null,
1922
+ next ? (next.prev = this, this.next = next) : this.next = null;
1923
+ }
1924
+ module.exports = Yallist, Yallist.Node = Node, Yallist.create = Yallist, Yallist.prototype.removeNode = function(node) {
1925
+ if (node.list !== this) throw new Error("removing node which does not belong to this list");
1926
+ var next = node.next, prev = node.prev;
1927
+ return next && (next.prev = prev), prev && (prev.next = next), node === this.head && (this.head = next),
1928
+ node === this.tail && (this.tail = prev), node.list.length--, node.next = null,
1929
+ node.prev = null, node.list = null, next;
1930
+ }, Yallist.prototype.unshiftNode = function(node) {
1931
+ if (node !== this.head) {
1932
+ node.list && node.list.removeNode(node);
1933
+ var head = this.head;
1934
+ node.list = this, node.next = head, head && (head.prev = node), this.head = node,
1935
+ this.tail || (this.tail = node), this.length++;
1936
+ }
1937
+ }, Yallist.prototype.pushNode = function(node) {
1938
+ if (node !== this.tail) {
1939
+ node.list && node.list.removeNode(node);
1940
+ var tail = this.tail;
1941
+ node.list = this, node.prev = tail, tail && (tail.next = node), this.tail = node,
1942
+ this.head || (this.head = node), this.length++;
1943
+ }
1944
+ }, Yallist.prototype.push = function() {
1945
+ for (var i = 0, l = arguments.length; i < l; i++) push(this, arguments[i]);
3379
1946
  return this.length;
3380
- };
3381
- Yallist.prototype.unshift = function() {
3382
- for (var i = 0, l = arguments.length; i < l; i++) {
3383
- unshift(this, arguments[i]);
3384
- }
1947
+ }, Yallist.prototype.unshift = function() {
1948
+ for (var i = 0, l = arguments.length; i < l; i++) unshift(this, arguments[i]);
3385
1949
  return this.length;
3386
- };
3387
- Yallist.prototype.pop = function() {
3388
- if (!this.tail) {
3389
- return undefined;
3390
- }
3391
- var res = this.tail.value;
3392
- this.tail = this.tail.prev;
1950
+ }, Yallist.prototype.pop = function() {
3393
1951
  if (this.tail) {
3394
- this.tail.next = null;
3395
- } else {
3396
- this.head = null;
1952
+ var res = this.tail.value;
1953
+ return this.tail = this.tail.prev, this.tail ? this.tail.next = null : this.head = null,
1954
+ this.length--, res;
3397
1955
  }
3398
- this.length--;
3399
- return res;
3400
- };
3401
- Yallist.prototype.shift = function() {
3402
- if (!this.head) {
3403
- return undefined;
3404
- }
3405
- var res = this.head.value;
3406
- this.head = this.head.next;
1956
+ }, Yallist.prototype.shift = function() {
3407
1957
  if (this.head) {
3408
- this.head.prev = null;
3409
- } else {
3410
- this.tail = null;
1958
+ var res = this.head.value;
1959
+ return this.head = this.head.next, this.head ? this.head.prev = null : this.tail = null,
1960
+ this.length--, res;
3411
1961
  }
3412
- this.length--;
3413
- return res;
3414
- };
3415
- Yallist.prototype.forEach = function(fn, thisp) {
1962
+ }, Yallist.prototype.forEach = function(fn, thisp) {
3416
1963
  thisp = thisp || this;
3417
- for (var walker = this.head, i = 0; walker !== null; i++) {
3418
- fn.call(thisp, walker.value, i, this);
3419
- walker = walker.next;
3420
- }
3421
- };
3422
- Yallist.prototype.forEachReverse = function(fn, thisp) {
1964
+ for (var walker = this.head, i = 0; null !== walker; i++) fn.call(thisp, walker.value, i, this),
1965
+ walker = walker.next;
1966
+ }, Yallist.prototype.forEachReverse = function(fn, thisp) {
3423
1967
  thisp = thisp || this;
3424
- for (var walker = this.tail, i = this.length - 1; walker !== null; i--) {
3425
- fn.call(thisp, walker.value, i, this);
3426
- walker = walker.prev;
3427
- }
3428
- };
3429
- Yallist.prototype.get = function(n) {
3430
- for (var i = 0, walker = this.head; walker !== null && i < n; i++) {
3431
- walker = walker.next;
3432
- }
3433
- if (i === n && walker !== null) {
3434
- return walker.value;
3435
- }
3436
- };
3437
- Yallist.prototype.getReverse = function(n) {
3438
- for (var i = 0, walker = this.tail; walker !== null && i < n; i++) {
3439
- walker = walker.prev;
3440
- }
3441
- if (i === n && walker !== null) {
3442
- return walker.value;
3443
- }
3444
- };
3445
- Yallist.prototype.map = function(fn, thisp) {
1968
+ for (var walker = this.tail, i = this.length - 1; null !== walker; i--) fn.call(thisp, walker.value, i, this),
1969
+ walker = walker.prev;
1970
+ }, Yallist.prototype.get = function(n) {
1971
+ for (var i = 0, walker = this.head; null !== walker && i < n; i++) walker = walker.next;
1972
+ if (i === n && null !== walker) return walker.value;
1973
+ }, Yallist.prototype.getReverse = function(n) {
1974
+ for (var i = 0, walker = this.tail; null !== walker && i < n; i++) walker = walker.prev;
1975
+ if (i === n && null !== walker) return walker.value;
1976
+ }, Yallist.prototype.map = function(fn, thisp) {
3446
1977
  thisp = thisp || this;
3447
- var res = new Yallist;
3448
- for (var walker = this.head; walker !== null; ) {
3449
- res.push(fn.call(thisp, walker.value, this));
3450
- walker = walker.next;
3451
- }
1978
+ for (var res = new Yallist, walker = this.head; null !== walker; ) res.push(fn.call(thisp, walker.value, this)),
1979
+ walker = walker.next;
3452
1980
  return res;
3453
- };
3454
- Yallist.prototype.mapReverse = function(fn, thisp) {
1981
+ }, Yallist.prototype.mapReverse = function(fn, thisp) {
3455
1982
  thisp = thisp || this;
3456
- var res = new Yallist;
3457
- for (var walker = this.tail; walker !== null; ) {
3458
- res.push(fn.call(thisp, walker.value, this));
3459
- walker = walker.prev;
3460
- }
1983
+ for (var res = new Yallist, walker = this.tail; null !== walker; ) res.push(fn.call(thisp, walker.value, this)),
1984
+ walker = walker.prev;
3461
1985
  return res;
3462
- };
3463
- Yallist.prototype.reduce = function(fn, initial) {
3464
- var acc;
3465
- var walker = this.head;
3466
- if (arguments.length > 1) {
3467
- acc = initial;
3468
- } else if (this.head) {
3469
- walker = this.head.next;
3470
- acc = this.head.value;
3471
- } else {
3472
- throw new TypeError("Reduce of empty list with no initial value");
3473
- }
3474
- for (var i = 0; walker !== null; i++) {
3475
- acc = fn(acc, walker.value, i);
3476
- walker = walker.next;
1986
+ }, Yallist.prototype.reduce = function(fn, initial) {
1987
+ var acc, walker = this.head;
1988
+ if (arguments.length > 1) acc = initial; else {
1989
+ if (!this.head) throw new TypeError("Reduce of empty list with no initial value");
1990
+ walker = this.head.next, acc = this.head.value;
3477
1991
  }
1992
+ for (var i = 0; null !== walker; i++) acc = fn(acc, walker.value, i), walker = walker.next;
3478
1993
  return acc;
3479
- };
3480
- Yallist.prototype.reduceReverse = function(fn, initial) {
3481
- var acc;
3482
- var walker = this.tail;
3483
- if (arguments.length > 1) {
3484
- acc = initial;
3485
- } else if (this.tail) {
3486
- walker = this.tail.prev;
3487
- acc = this.tail.value;
3488
- } else {
3489
- throw new TypeError("Reduce of empty list with no initial value");
3490
- }
3491
- for (var i = this.length - 1; walker !== null; i--) {
3492
- acc = fn(acc, walker.value, i);
3493
- walker = walker.prev;
3494
- }
1994
+ }, Yallist.prototype.reduceReverse = function(fn, initial) {
1995
+ var acc, walker = this.tail;
1996
+ if (arguments.length > 1) acc = initial; else {
1997
+ if (!this.tail) throw new TypeError("Reduce of empty list with no initial value");
1998
+ walker = this.tail.prev, acc = this.tail.value;
1999
+ }
2000
+ for (var i = this.length - 1; null !== walker; i--) acc = fn(acc, walker.value, i),
2001
+ walker = walker.prev;
3495
2002
  return acc;
3496
- };
3497
- Yallist.prototype.toArray = function() {
3498
- var arr = new Array(this.length);
3499
- for (var i = 0, walker = this.head; walker !== null; i++) {
3500
- arr[i] = walker.value;
3501
- walker = walker.next;
3502
- }
2003
+ }, Yallist.prototype.toArray = function() {
2004
+ for (var arr = new Array(this.length), i = 0, walker = this.head; null !== walker; i++) arr[i] = walker.value,
2005
+ walker = walker.next;
3503
2006
  return arr;
3504
- };
3505
- Yallist.prototype.toArrayReverse = function() {
3506
- var arr = new Array(this.length);
3507
- for (var i = 0, walker = this.tail; walker !== null; i++) {
3508
- arr[i] = walker.value;
3509
- walker = walker.prev;
3510
- }
2007
+ }, Yallist.prototype.toArrayReverse = function() {
2008
+ for (var arr = new Array(this.length), i = 0, walker = this.tail; null !== walker; i++) arr[i] = walker.value,
2009
+ walker = walker.prev;
3511
2010
  return arr;
3512
- };
3513
- Yallist.prototype.slice = function(from, to) {
3514
- to = to || this.length;
3515
- if (to < 0) {
3516
- to += this.length;
3517
- }
3518
- from = from || 0;
3519
- if (from < 0) {
3520
- from += this.length;
3521
- }
2011
+ }, Yallist.prototype.slice = function(from, to) {
2012
+ (to = to || this.length) < 0 && (to += this.length), (from = from || 0) < 0 && (from += this.length);
3522
2013
  var ret = new Yallist;
3523
- if (to < from || to < 0) {
3524
- return ret;
3525
- }
3526
- if (from < 0) {
3527
- from = 0;
3528
- }
3529
- if (to > this.length) {
3530
- to = this.length;
3531
- }
3532
- for (var i = 0, walker = this.head; walker !== null && i < from; i++) {
3533
- walker = walker.next;
3534
- }
3535
- for (;walker !== null && i < to; i++, walker = walker.next) {
3536
- ret.push(walker.value);
3537
- }
2014
+ if (to < from || to < 0) return ret;
2015
+ from < 0 && (from = 0), to > this.length && (to = this.length);
2016
+ for (var i = 0, walker = this.head; null !== walker && i < from; i++) walker = walker.next;
2017
+ for (;null !== walker && i < to; i++, walker = walker.next) ret.push(walker.value);
3538
2018
  return ret;
3539
- };
3540
- Yallist.prototype.sliceReverse = function(from, to) {
3541
- to = to || this.length;
3542
- if (to < 0) {
3543
- to += this.length;
3544
- }
3545
- from = from || 0;
3546
- if (from < 0) {
3547
- from += this.length;
3548
- }
2019
+ }, Yallist.prototype.sliceReverse = function(from, to) {
2020
+ (to = to || this.length) < 0 && (to += this.length), (from = from || 0) < 0 && (from += this.length);
3549
2021
  var ret = new Yallist;
3550
- if (to < from || to < 0) {
3551
- return ret;
3552
- }
3553
- if (from < 0) {
3554
- from = 0;
3555
- }
3556
- if (to > this.length) {
3557
- to = this.length;
3558
- }
3559
- for (var i = this.length, walker = this.tail; walker !== null && i > to; i--) {
3560
- walker = walker.prev;
3561
- }
3562
- for (;walker !== null && i > from; i--, walker = walker.prev) {
3563
- ret.push(walker.value);
3564
- }
2022
+ if (to < from || to < 0) return ret;
2023
+ from < 0 && (from = 0), to > this.length && (to = this.length);
2024
+ for (var i = this.length, walker = this.tail; null !== walker && i > to; i--) walker = walker.prev;
2025
+ for (;null !== walker && i > from; i--, walker = walker.prev) ret.push(walker.value);
3565
2026
  return ret;
3566
- };
3567
- Yallist.prototype.splice = function(start, deleteCount, ...nodes) {
3568
- if (start > this.length) {
3569
- start = this.length - 1;
3570
- }
3571
- if (start < 0) {
3572
- start = this.length + start;
3573
- }
3574
- for (var i = 0, walker = this.head; walker !== null && i < start; i++) {
3575
- walker = walker.next;
3576
- }
2027
+ }, Yallist.prototype.splice = function(start, deleteCount, ...nodes) {
2028
+ start > this.length && (start = this.length - 1), start < 0 && (start = this.length + start);
2029
+ for (var i = 0, walker = this.head; null !== walker && i < start; i++) walker = walker.next;
3577
2030
  var ret = [];
3578
- for (var i = 0; walker && i < deleteCount; i++) {
3579
- ret.push(walker.value);
3580
- walker = this.removeNode(walker);
3581
- }
3582
- if (walker === null) {
3583
- walker = this.tail;
3584
- }
3585
- if (walker !== this.head && walker !== this.tail) {
3586
- walker = walker.prev;
3587
- }
3588
- for (var i = 0; i < nodes.length; i++) {
3589
- walker = insert(this, walker, nodes[i]);
3590
- }
2031
+ for (i = 0; walker && i < deleteCount; i++) ret.push(walker.value), walker = this.removeNode(walker);
2032
+ null === walker && (walker = this.tail), walker !== this.head && walker !== this.tail && (walker = walker.prev);
2033
+ for (i = 0; i < nodes.length; i++) walker = insert(this, walker, nodes[i]);
3591
2034
  return ret;
3592
- };
3593
- Yallist.prototype.reverse = function() {
3594
- var head = this.head;
3595
- var tail = this.tail;
3596
- for (var walker = head; walker !== null; walker = walker.prev) {
2035
+ }, Yallist.prototype.reverse = function() {
2036
+ for (var head = this.head, tail = this.tail, walker = head; null !== walker; walker = walker.prev) {
3597
2037
  var p = walker.prev;
3598
- walker.prev = walker.next;
3599
- walker.next = p;
2038
+ walker.prev = walker.next, walker.next = p;
3600
2039
  }
3601
- this.head = tail;
3602
- this.tail = head;
3603
- return this;
2040
+ return this.head = tail, this.tail = head, this;
3604
2041
  };
3605
- function insert(self, node, value) {
3606
- var inserted = node === self.head ? new Node(value, null, node, self) : new Node(value, node, node.next, self);
3607
- if (inserted.next === null) {
3608
- self.tail = inserted;
3609
- }
3610
- if (inserted.prev === null) {
3611
- self.head = inserted;
3612
- }
3613
- self.length++;
3614
- return inserted;
3615
- }
3616
- function push(self, item) {
3617
- self.tail = new Node(item, self.tail, null, self);
3618
- if (!self.head) {
3619
- self.head = self.tail;
3620
- }
3621
- self.length++;
3622
- }
3623
- function unshift(self, item) {
3624
- self.head = new Node(item, null, self.head, self);
3625
- if (!self.tail) {
3626
- self.tail = self.head;
3627
- }
3628
- self.length++;
3629
- }
3630
- function Node(value, prev, next, list) {
3631
- if (!(this instanceof Node)) {
3632
- return new Node(value, prev, next, list);
3633
- }
3634
- this.list = list;
3635
- this.value = value;
3636
- if (prev) {
3637
- prev.next = this;
3638
- this.prev = prev;
3639
- } else {
3640
- this.prev = null;
3641
- }
3642
- if (next) {
3643
- next.prev = this;
3644
- this.next = next;
3645
- } else {
3646
- this.next = null;
3647
- }
3648
- }
3649
2042
  try {
3650
2043
  __webpack_require__(3278)(Yallist);
3651
2044
  } catch (er) {}
@@ -3653,37 +2046,27 @@ var __webpack_modules__ = {
3653
2046
  6829: (__unused_webpack_module, exports, __webpack_require__) => {
3654
2047
  "use strict";
3655
2048
  Object.defineProperty(exports, "__esModule", {
3656
- value: true
3657
- });
3658
- exports.NodeRelease = void 0;
3659
- const process = __webpack_require__(7282);
3660
- const semver_1 = __webpack_require__(6027);
3661
- const ONE_DAY_IN_MILLISECONDS = 864e5;
2049
+ value: !0
2050
+ }), exports.NodeRelease = void 0;
2051
+ const process = __webpack_require__(7282), semver_1 = __webpack_require__(6027);
3662
2052
  class NodeRelease {
3663
2053
  constructor(majorVersion, opts) {
3664
2054
  var _a, _b;
3665
- this.majorVersion = majorVersion;
3666
- this.endOfLifeDate = opts.endOfLife === true ? undefined : opts.endOfLife;
3667
- this.untested = (_a = opts.untested) !== null && _a !== void 0 ? _a : false;
3668
- this.supportedRange = new semver_1.Range((_b = opts.supportedRange) !== null && _b !== void 0 ? _b : `^${majorVersion}.0.0`);
3669
- this.endOfLife = opts.endOfLife === true || opts.endOfLife.getTime() <= Date.now();
3670
- this.deprecated = !this.endOfLife && opts.endOfLife !== true && opts.endOfLife.getTime() - NodeRelease.DEPRECATION_WINDOW_MS <= Date.now();
2055
+ this.majorVersion = majorVersion, this.endOfLifeDate = !0 === opts.endOfLife ? void 0 : opts.endOfLife,
2056
+ this.untested = null !== (_a = opts.untested) && void 0 !== _a && _a, this.supportedRange = new semver_1.Range(null !== (_b = opts.supportedRange) && void 0 !== _b ? _b : `^${majorVersion}.0.0`),
2057
+ this.endOfLife = !0 === opts.endOfLife || opts.endOfLife.getTime() <= Date.now(),
2058
+ this.deprecated = !this.endOfLife && !0 !== opts.endOfLife && opts.endOfLife.getTime() - NodeRelease.DEPRECATION_WINDOW_MS <= Date.now(),
3671
2059
  this.supported = !this.untested && !this.endOfLife;
3672
2060
  }
3673
2061
  static forThisRuntime() {
3674
- const semver = new semver_1.SemVer(process.version);
3675
- const majorVersion = semver.major;
3676
- for (const nodeRelease of this.ALL_RELEASES) {
3677
- if (nodeRelease.majorVersion === majorVersion) {
3678
- return {
3679
- nodeRelease,
3680
- knownBroken: !nodeRelease.supportedRange.test(semver)
3681
- };
3682
- }
3683
- }
2062
+ const semver = new semver_1.SemVer(process.version), majorVersion = semver.major;
2063
+ for (const nodeRelease of this.ALL_RELEASES) if (nodeRelease.majorVersion === majorVersion) return {
2064
+ nodeRelease,
2065
+ knownBroken: !nodeRelease.supportedRange.test(semver)
2066
+ };
3684
2067
  return {
3685
- nodeRelease: undefined,
3686
- knownBroken: false
2068
+ nodeRelease: void 0,
2069
+ knownBroken: !1
3687
2070
  };
3688
2071
  }
3689
2072
  toString() {
@@ -3691,10 +2074,8 @@ var __webpack_modules__ = {
3691
2074
  return `${this.supportedRange.raw}${eolInfo}`;
3692
2075
  }
3693
2076
  }
3694
- exports.NodeRelease = NodeRelease;
3695
- NodeRelease.DEPRECATION_WINDOW_MS = 30 * ONE_DAY_IN_MILLISECONDS;
3696
- NodeRelease.ALL_RELEASES = [ ...[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 ].map((majorVersion => new NodeRelease(majorVersion, {
3697
- endOfLife: true
2077
+ exports.NodeRelease = NodeRelease, NodeRelease.DEPRECATION_WINDOW_MS = 2592e6, NodeRelease.ALL_RELEASES = [ ...[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 ].map((majorVersion => new NodeRelease(majorVersion, {
2078
+ endOfLife: !0
3698
2079
  }))), new NodeRelease(13, {
3699
2080
  endOfLife: new Date("2020-06-01")
3700
2081
  }), new NodeRelease(15, {
@@ -3715,59 +2096,41 @@ var __webpack_modules__ = {
3715
2096
  endOfLife: new Date("2025-04-30")
3716
2097
  }), new NodeRelease(19, {
3717
2098
  endOfLife: new Date("2023-06-01"),
3718
- untested: true
2099
+ untested: !0
3719
2100
  }), new NodeRelease(20, {
3720
2101
  endOfLife: new Date("2026-04-30"),
3721
- untested: true
2102
+ untested: !0
3722
2103
  }) ];
3723
2104
  },
3724
2105
  7962: (__unused_webpack_module, exports, __webpack_require__) => {
3725
2106
  "use strict";
3726
2107
  Object.defineProperty(exports, "__esModule", {
3727
- value: true
3728
- });
3729
- exports.checkNode = void 0;
3730
- const chalk_1 = __webpack_require__(1201);
3731
- const console_1 = __webpack_require__(6206);
3732
- const process_1 = __webpack_require__(7282);
3733
- const constants_1 = __webpack_require__(6829);
3734
- function checkNode() {
2108
+ value: !0
2109
+ }), exports.checkNode = void 0;
2110
+ const chalk_1 = __webpack_require__(1201), console_1 = __webpack_require__(6206), process_1 = __webpack_require__(7282), constants_1 = __webpack_require__(6829);
2111
+ exports.checkNode = function() {
3735
2112
  const {nodeRelease, knownBroken} = constants_1.NodeRelease.forThisRuntime();
3736
- if (nodeRelease === null || nodeRelease === void 0 ? void 0 : nodeRelease.endOfLife) {
2113
+ if (null == nodeRelease ? void 0 : nodeRelease.endOfLife) {
3737
2114
  const qualifier = nodeRelease.endOfLifeDate ? ` on ${nodeRelease.endOfLifeDate.toISOString().slice(0, 10)}` : "";
3738
- veryVisibleMessage(chalk_1.bgRed.white.bold, `Node ${nodeRelease.majorVersion} has reached end-of-life${qualifier} and is not supported.`, `Please upgrade to a supported node version as soon as possible.`);
3739
- } else if (knownBroken) {
3740
- veryVisibleMessage(chalk_1.bgRed.white.bold, `Node ${process_1.version} is unsupported and has known compatibility issues with this software.`);
3741
- } else if (!nodeRelease || nodeRelease.untested) {
3742
- veryVisibleMessage(chalk_1.bgYellow.black, `This software has not been tested with node ${process_1.version}.`);
3743
- } else if (nodeRelease === null || nodeRelease === void 0 ? void 0 : nodeRelease.deprecated) {
2115
+ veryVisibleMessage(chalk_1.bgRed.white.bold, `Node ${nodeRelease.majorVersion} has reached end-of-life${qualifier} and is not supported.`, "Please upgrade to a supported node version as soon as possible.");
2116
+ } else if (knownBroken) veryVisibleMessage(chalk_1.bgRed.white.bold, `Node ${process_1.version} is unsupported and has known compatibility issues with this software.`); else if (!nodeRelease || nodeRelease.untested) veryVisibleMessage(chalk_1.bgYellow.black, `This software has not been tested with node ${process_1.version}.`); else if (null == nodeRelease ? void 0 : nodeRelease.deprecated) {
3744
2117
  const deadline = nodeRelease.endOfLifeDate.toISOString().slice(0, 10);
3745
- veryVisibleMessage(chalk_1.bgYellowBright.black, `Node ${nodeRelease.majorVersion} is approaching end-of-life and will no longer be supported in new releases after ${deadline}.`, `Please upgrade to a supported node version as soon as possible.`);
2118
+ veryVisibleMessage(chalk_1.bgYellowBright.black, `Node ${nodeRelease.majorVersion} is approaching end-of-life and will no longer be supported in new releases after ${deadline}.`, "Please upgrade to a supported node version as soon as possible.");
3746
2119
  }
3747
2120
  function veryVisibleMessage(chalk, message, callToAction = "You may to encounter runtime issues, and should switch to a supported release.") {
3748
2121
  const lines = [ message, callToAction, "", `This software is currently running on node ${process_1.version}.`, "As of the current release of this software, supported node releases are:", ...constants_1.NodeRelease.ALL_RELEASES.filter((release => release.supported)).sort(((l, r) => {
3749
2122
  var _a, _b, _c, _d;
3750
- return ((_b = (_a = r.endOfLifeDate) === null || _a === void 0 ? void 0 : _a.getTime()) !== null && _b !== void 0 ? _b : 0) - ((_d = (_c = l.endOfLifeDate) === null || _c === void 0 ? void 0 : _c.getTime()) !== null && _d !== void 0 ? _d : 0);
3751
- })).map((release => `- ${release.toString()}${release.deprecated ? " [DEPRECATED]" : ""}`)) ];
3752
- const len = Math.max(...lines.map((l => l.length)));
3753
- const border = chalk("!".repeat(len + 8));
3754
- const spacer = chalk(`!! ${" ".repeat(len)} !!`);
3755
- (0, console_1.error)(border);
3756
- (0, console_1.error)(spacer);
3757
- for (const line of lines) {
3758
- (0, console_1.error)(chalk(`!! ${line.padEnd(len, " ")} !!`));
3759
- }
3760
- (0, console_1.error)(spacer);
3761
- (0, console_1.error)(border);
2123
+ return (null !== (_b = null === (_a = r.endOfLifeDate) || void 0 === _a ? void 0 : _a.getTime()) && void 0 !== _b ? _b : 0) - (null !== (_d = null === (_c = l.endOfLifeDate) || void 0 === _c ? void 0 : _c.getTime()) && void 0 !== _d ? _d : 0);
2124
+ })).map((release => `- ${release.toString()}${release.deprecated ? " [DEPRECATED]" : ""}`)) ], len = Math.max(...lines.map((l => l.length))), border = chalk("!".repeat(len + 8)), spacer = chalk(`!! ${" ".repeat(len)} !!`);
2125
+ (0, console_1.error)(border), (0, console_1.error)(spacer);
2126
+ for (const line of lines) (0, console_1.error)(chalk(`!! ${line.padEnd(len, " ")} !!`));
2127
+ (0, console_1.error)(spacer), (0, console_1.error)(border);
3762
2128
  }
3763
- }
3764
- exports.checkNode = checkNode;
2129
+ };
3765
2130
  },
3766
2131
  9317: (module, __unused_webpack_exports, __webpack_require__) => {
3767
2132
  "use strict";
3768
- const index_1 = __webpack_require__(7962);
3769
- (0, index_1.checkNode)();
3770
- module.exports = {};
2133
+ (0, __webpack_require__(7962).checkNode)(), module.exports = {};
3771
2134
  },
3772
2135
  2081: module => {
3773
2136
  "use strict";
@@ -3793,68 +2156,40 @@ var __webpack_modules__ = {
3793
2156
  "use strict";
3794
2157
  module.exports = require("tty");
3795
2158
  }
3796
- };
3797
-
3798
- var __webpack_module_cache__ = {};
2159
+ }, __webpack_module_cache__ = {};
3799
2160
 
3800
2161
  function __webpack_require__(moduleId) {
3801
2162
  var cachedModule = __webpack_module_cache__[moduleId];
3802
- if (cachedModule !== undefined) {
3803
- return cachedModule.exports;
3804
- }
2163
+ if (void 0 !== cachedModule) return cachedModule.exports;
3805
2164
  var module = __webpack_module_cache__[moduleId] = {
3806
2165
  id: moduleId,
3807
- loaded: false,
2166
+ loaded: !1,
3808
2167
  exports: {}
3809
2168
  };
3810
- __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
3811
- module.loaded = true;
3812
- return module.exports;
2169
+ return __webpack_modules__[moduleId](module, module.exports, __webpack_require__),
2170
+ module.loaded = !0, module.exports;
3813
2171
  }
3814
2172
 
3815
- (() => {
3816
- __webpack_require__.nmd = module => {
3817
- module.paths = [];
3818
- if (!module.children) module.children = [];
3819
- return module;
3820
- };
3821
- })();
2173
+ __webpack_require__.nmd = module => (module.paths = [], module.children || (module.children = []),
2174
+ module);
3822
2175
 
3823
2176
  var __webpack_exports__ = {};
3824
2177
 
3825
2178
  (() => {
3826
2179
  "use strict";
3827
- var exports = __webpack_exports__;
3828
- var __webpack_unused_export__;
3829
- __webpack_unused_export__ = {
3830
- value: true
3831
- };
3832
2180
  __webpack_require__(9317);
3833
- const child_process_1 = __webpack_require__(2081);
3834
- const console_1 = __webpack_require__(6206);
3835
- const os_1 = __webpack_require__(2037);
3836
- const path_1 = __webpack_require__(4822);
3837
- const child = (0, child_process_1.spawn)(process.execPath, [ ...process.execArgv, (0,
3838
- path_1.resolve)(__dirname, "..", "lib", "program.js") ], {
2181
+ const child_process_1 = __webpack_require__(2081), console_1 = __webpack_require__(6206), os_1 = __webpack_require__(2037), path_1 = __webpack_require__(4822), child = (0,
2182
+ child_process_1.spawn)(process.execPath, [ ...process.execArgv, (0, path_1.resolve)(__dirname, "..", "lib", "program.js") ], {
3839
2183
  stdio: [ "ignore", "pipe", "pipe", "pipe" ]
3840
2184
  });
3841
2185
  child.once("end", ((code, signal) => {
3842
2186
  var _a;
3843
- if (signal != null) {
3844
- process.exit(128 + ((_a = os_1.constants.signals[signal]) !== null && _a !== void 0 ? _a : 0));
3845
- }
2187
+ null != signal && process.exit(128 + (null !== (_a = os_1.constants.signals[signal]) && void 0 !== _a ? _a : 0)),
3846
2188
  process.exit(code);
2189
+ })), child.once("error", (err => {
2190
+ console.error("Failed to spawn child process:", err.stack), process.exit(-1);
3847
2191
  }));
3848
- child.once("error", (err => {
3849
- console.error("Failed to spawn child process:", err.stack);
3850
- process.exit(-1);
3851
- }));
3852
- for (const signal of Object.keys(os_1.constants.signals)) {
3853
- if (signal === "SIGKILL" || signal === "SIGSTOP") {
3854
- continue;
3855
- }
3856
- process.on(signal, (sig => child.kill(sig)));
3857
- }
2192
+ for (const signal of Object.keys(os_1.constants.signals)) "SIGKILL" !== signal && "SIGSTOP" !== signal && process.on(signal, (sig => child.kill(sig)));
3858
2193
  function makeHandler(tag) {
3859
2194
  return chunk => {
3860
2195
  const buffer = Buffer.from(chunk);
@@ -3863,10 +2198,8 @@ var __webpack_exports__ = {};
3863
2198
  }));
3864
2199
  };
3865
2200
  }
3866
- child.stdout.on("data", makeHandler("stdout"));
3867
- child.stderr.on("data", makeHandler("stderr"));
2201
+ child.stdout.on("data", makeHandler("stdout")), child.stderr.on("data", makeHandler("stderr"));
3868
2202
  const commands = child.stdio[3];
3869
- process.stdin.pipe(commands);
3870
- commands.pipe(process.stdout);
2203
+ process.stdin.pipe(commands), commands.pipe(process.stdout);
3871
2204
  })();
3872
2205
  //# sourceMappingURL=jsii-runtime.js.map