+const stripAnsi = stripAnsi$1;
+const isFullwidthCodePoint = isFullwidthCodePoint$2.exports;
+const emojiRegex = emojiRegex$1;
+
+const stringWidth$1 = string => {
+ if (typeof string !== 'string' || string.length === 0) {
+ return 0;
+ }
+
+ string = stripAnsi(string);
+
+ if (string.length === 0) {
+ return 0;
+ }
+
+ string = string.replace(emojiRegex(), ' ');
+ let width = 0;
+
+ for (let i = 0; i < string.length; i++) {
+ const code = string.codePointAt(i); // Ignore control characters
+
+ if (code <= 0x1F || code >= 0x7F && code <= 0x9F) {
+ continue;
+ } // Ignore combining characters
+
+
+ if (code >= 0x300 && code <= 0x36F) {
+ continue;
+ } // Surrogates
+
+
+ if (code > 0xFFFF) {
+ i++;
+ }
+
+ width += isFullwidthCodePoint(code) ? 2 : 1;
+ }
+
+ return width;
+};
+
+stringWidth$2.exports = stringWidth$1; // TODO: remove this in the next major version
+
+stringWidth$2.exports.default = stringWidth$1;
+
+var escapeStringRegexp$3 = string => {
+ if (typeof string !== 'string') {
+ throw new TypeError('Expected a string');
+ } // Escape characters with special meaning either inside or outside character sets.
+ // Use a simple backslash escape when it’s always valid, and a \unnnn escape when the simpler form would be disallowed by Unicode patterns’ stricter grammar.
+
+
+ return string.replace(/[|\\{}()[\]^$+*?.]/g, '\\$&').replace(/-/g, '\\x2d');
+};
+
+const getLast$p = arr => arr[arr.length - 1];
+
+var getLast_1 = getLast$p;
+
+function _objectWithoutPropertiesLoose(source, excluded) {
+ if (source == null) return {};
+ var target = {};
+ var sourceKeys = Object.keys(source);
+ var key, i;
+
+ for (i = 0; i < sourceKeys.length; i++) {
+ key = sourceKeys[i];
+ if (excluded.indexOf(key) >= 0) continue;
+ target[key] = source[key];
+ }
+
+ return target;
+}
+
+function _objectWithoutProperties(source, excluded) {
+ if (source == null) return {};
+
+ var target = _objectWithoutPropertiesLoose(source, excluded);
+
+ var key, i;
+
+ if (Object.getOwnPropertySymbols) {
+ var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+
+ for (i = 0; i < sourceSymbolKeys.length; i++) {
+ key = sourceSymbolKeys[i];
+ if (excluded.indexOf(key) >= 0) continue;
+ if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+ target[key] = source[key];
+ }
+ }
+
+ return target;
+}
+
+var classof$2 = classofRaw$1;
+
+// `IsArray` abstract operation
+// https://tc39.es/ecma262/#sec-isarray
+// eslint-disable-next-line es/no-array-isarray -- safe
+var isArray$e = Array.isArray || function isArray(argument) {
+ return classof$2(argument) == 'Array';
+};
+
+var uncurryThis$1 = functionUncurryThis;
+var aCallable$2 = aCallable$5;
+
+var bind$3 = uncurryThis$1(uncurryThis$1.bind);
+
+// optional / simple context binding
+var functionBindContext = function (fn, that) {
+ aCallable$2(fn);
+ return that === undefined ? fn : bind$3 ? bind$3(fn, that) : function (/* ...args */) {
+ return fn.apply(that, arguments);
+ };
+};
+
+var global$5 = global$s;
+var isArray$d = isArray$e;
+var lengthOfArrayLike$3 = lengthOfArrayLike$6;
+var bind$2 = functionBindContext;
+
+var TypeError$3 = global$5.TypeError;
+
+// `FlattenIntoArray` abstract operation
+// https://tc39.github.io/proposal-flatMap/#sec-FlattenIntoArray
+var flattenIntoArray$2 = function (target, original, source, sourceLen, start, depth, mapper, thisArg) {
+ var targetIndex = start;
+ var sourceIndex = 0;
+ var mapFn = mapper ? bind$2(mapper, thisArg) : false;
+ var element, elementLen;
+
+ while (sourceIndex < sourceLen) {
+ if (sourceIndex in source) {
+ element = mapFn ? mapFn(source[sourceIndex], sourceIndex, original) : source[sourceIndex];
+
+ if (depth > 0 && isArray$d(element)) {
+ elementLen = lengthOfArrayLike$3(element);
+ targetIndex = flattenIntoArray$2(target, original, element, elementLen, targetIndex, depth - 1) - 1;
+ } else {
+ if (targetIndex >= 0x1FFFFFFFFFFFFF) throw TypeError$3('Exceed the acceptable array length');
+ target[targetIndex] = element;
+ }
+
+ targetIndex++;
+ }
+ sourceIndex++;
+ }
+ return targetIndex;
+};
+
+var flattenIntoArray_1 = flattenIntoArray$2;
+
+var uncurryThis = functionUncurryThis;
+var fails = fails$8;
+var isCallable = isCallable$b;
+var classof$1 = classof$4;
+var getBuiltIn$1 = getBuiltIn$5;
+var inspectSource = inspectSource$3;
+
+var noop$3 = function () { /* empty */ };
+var empty = [];
+var construct = getBuiltIn$1('Reflect', 'construct');
+var constructorRegExp = /^\s*(?:class|function)\b/;
+var exec = uncurryThis(constructorRegExp.exec);
+var INCORRECT_TO_STRING = !constructorRegExp.exec(noop$3);
+
+var isConstructorModern = function (argument) {
+ if (!isCallable(argument)) return false;
+ try {
+ construct(noop$3, empty, argument);
+ return true;
+ } catch (error) {
+ return false;
+ }
+};
+
+var isConstructorLegacy = function (argument) {
+ if (!isCallable(argument)) return false;
+ switch (classof$1(argument)) {
+ case 'AsyncFunction':
+ case 'GeneratorFunction':
+ case 'AsyncGeneratorFunction': return false;
+ // we can't check .prototype since constructors produced by .bind haven't it
+ } return INCORRECT_TO_STRING || !!exec(constructorRegExp, inspectSource(argument));
+};
+
+// `IsConstructor` abstract operation
+// https://tc39.es/ecma262/#sec-isconstructor
+var isConstructor$1 = !construct || fails(function () {
+ var called;
+ return isConstructorModern(isConstructorModern.call)
+ || !isConstructorModern(Object)
+ || !isConstructorModern(function () { called = true; })
+ || called;
+}) ? isConstructorLegacy : isConstructorModern;
+
+var global$4 = global$s;
+var isArray$c = isArray$e;
+var isConstructor = isConstructor$1;
+var isObject$6 = isObject$c;
+var wellKnownSymbol$3 = wellKnownSymbol$7;
+
+var SPECIES = wellKnownSymbol$3('species');
+var Array$1 = global$4.Array;
+
+// a part of `ArraySpeciesCreate` abstract operation
+// https://tc39.es/ecma262/#sec-arrayspeciescreate
+var arraySpeciesConstructor$1 = function (originalArray) {
+ var C;
+ if (isArray$c(originalArray)) {
+ C = originalArray.constructor;
+ // cross-realm fallback
+ if (isConstructor(C) && (C === Array$1 || isArray$c(C.prototype))) C = undefined;
+ else if (isObject$6(C)) {
+ C = C[SPECIES];
+ if (C === null) C = undefined;
+ }
+ } return C === undefined ? Array$1 : C;
+};
+
+var arraySpeciesConstructor = arraySpeciesConstructor$1;
+
+// `ArraySpeciesCreate` abstract operation
+// https://tc39.es/ecma262/#sec-arrayspeciescreate
+var arraySpeciesCreate$2 = function (originalArray, length) {
+ return new (arraySpeciesConstructor(originalArray))(length === 0 ? 0 : length);
+};
+
+var $$2 = _export;
+var flattenIntoArray$1 = flattenIntoArray_1;
+var aCallable$1 = aCallable$5;
+var toObject$1 = toObject$4;
+var lengthOfArrayLike$2 = lengthOfArrayLike$6;
+var arraySpeciesCreate$1 = arraySpeciesCreate$2;
+
+// `Array.prototype.flatMap` method
+// https://tc39.es/ecma262/#sec-array.prototype.flatmap
+$$2({ target: 'Array', proto: true }, {
+ flatMap: function flatMap(callbackfn /* , thisArg */) {
+ var O = toObject$1(this);
+ var sourceLen = lengthOfArrayLike$2(O);
+ var A;
+ aCallable$1(callbackfn);
+ A = arraySpeciesCreate$1(O, 0);
+ A.length = flattenIntoArray$1(A, O, O, sourceLen, 0, 1, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
+ return A;
+ }
+});
+
+var iterators = {};
+
+var wellKnownSymbol$2 = wellKnownSymbol$7;
+var Iterators$1 = iterators;
+
+var ITERATOR$1 = wellKnownSymbol$2('iterator');
+var ArrayPrototype$1 = Array.prototype;
+
+// check on default Array iterator
+var isArrayIteratorMethod$1 = function (it) {
+ return it !== undefined && (Iterators$1.Array === it || ArrayPrototype$1[ITERATOR$1] === it);
+};
+
+var classof = classof$4;
+var getMethod$1 = getMethod$3;
+var Iterators = iterators;
+var wellKnownSymbol$1 = wellKnownSymbol$7;
+
+var ITERATOR = wellKnownSymbol$1('iterator');
+
+var getIteratorMethod$2 = function (it) {
+ if (it != undefined) return getMethod$1(it, ITERATOR)
+ || getMethod$1(it, '@@iterator')
+ || Iterators[classof(it)];
+};
+
+var global$3 = global$s;
+var call$2 = functionCall;
+var aCallable = aCallable$5;
+var anObject$4 = anObject$7;
+var tryToString$1 = tryToString$3;
+var getIteratorMethod$1 = getIteratorMethod$2;
+
+var TypeError$2 = global$3.TypeError;
+
+var getIterator$1 = function (argument, usingIterator) {
+ var iteratorMethod = arguments.length < 2 ? getIteratorMethod$1(argument) : usingIterator;
+ if (aCallable(iteratorMethod)) return anObject$4(call$2(iteratorMethod, argument));
+ throw TypeError$2(tryToString$1(argument) + ' is not iterable');
+};
+
+var call$1 = functionCall;
+var anObject$3 = anObject$7;
+var getMethod = getMethod$3;
+
+var iteratorClose$1 = function (iterator, kind, value) {
+ var innerResult, innerError;
+ anObject$3(iterator);
+ try {
+ innerResult = getMethod(iterator, 'return');
+ if (!innerResult) {
+ if (kind === 'throw') throw value;
+ return value;
+ }
+ innerResult = call$1(innerResult, iterator);
+ } catch (error) {
+ innerError = true;
+ innerResult = error;
+ }
+ if (kind === 'throw') throw value;
+ if (innerError) throw innerResult;
+ anObject$3(innerResult);
+ return value;
+};
+
+var global$2 = global$s;
+var bind$1 = functionBindContext;
+var call = functionCall;
+var anObject$2 = anObject$7;
+var tryToString = tryToString$3;
+var isArrayIteratorMethod = isArrayIteratorMethod$1;
+var lengthOfArrayLike$1 = lengthOfArrayLike$6;
+var isPrototypeOf = objectIsPrototypeOf;
+var getIterator = getIterator$1;
+var getIteratorMethod = getIteratorMethod$2;
+var iteratorClose = iteratorClose$1;
+
+var TypeError$1 = global$2.TypeError;
+
+var Result = function (stopped, result) {
+ this.stopped = stopped;
+ this.result = result;
+};
+
+var ResultPrototype = Result.prototype;
+
+var iterate$1 = function (iterable, unboundFunction, options) {
+ var that = options && options.that;
+ var AS_ENTRIES = !!(options && options.AS_ENTRIES);
+ var IS_ITERATOR = !!(options && options.IS_ITERATOR);
+ var INTERRUPTED = !!(options && options.INTERRUPTED);
+ var fn = bind$1(unboundFunction, that);
+ var iterator, iterFn, index, length, result, next, step;
+
+ var stop = function (condition) {
+ if (iterator) iteratorClose(iterator, 'normal', condition);
+ return new Result(true, condition);
+ };
+
+ var callFn = function (value) {
+ if (AS_ENTRIES) {
+ anObject$2(value);
+ return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);
+ } return INTERRUPTED ? fn(value, stop) : fn(value);
+ };
+
+ if (IS_ITERATOR) {
+ iterator = iterable;
+ } else {
+ iterFn = getIteratorMethod(iterable);
+ if (!iterFn) throw TypeError$1(tryToString(iterable) + ' is not iterable');
+ // optimisation for array iterators
+ if (isArrayIteratorMethod(iterFn)) {
+ for (index = 0, length = lengthOfArrayLike$1(iterable); length > index; index++) {
+ result = callFn(iterable[index]);
+ if (result && isPrototypeOf(ResultPrototype, result)) return result;
+ } return new Result(false);
+ }
+ iterator = getIterator(iterable, iterFn);
+ }
+
+ next = iterator.next;
+ while (!(step = call(next, iterator)).done) {
+ try {
+ result = callFn(step.value);
+ } catch (error) {
+ iteratorClose(iterator, 'throw', error);
+ }
+ if (typeof result == 'object' && result && isPrototypeOf(ResultPrototype, result)) return result;
+ } return new Result(false);
+};
+
+var toPropertyKey = toPropertyKey$3;
+var definePropertyModule$2 = objectDefineProperty;
+var createPropertyDescriptor = createPropertyDescriptor$3;
+
+var createProperty$1 = function (object, key, value) {
+ var propertyKey = toPropertyKey(key);
+ if (propertyKey in object) definePropertyModule$2.f(object, propertyKey, createPropertyDescriptor(0, value));
+ else object[propertyKey] = value;
+};
+
+var $$1 = _export;
+var iterate = iterate$1;
+var createProperty = createProperty$1;
+
+// `Object.fromEntries` method
+// https://github.com/tc39/proposal-object-from-entries
+$$1({ target: 'Object', stat: true }, {
+ fromEntries: function fromEntries(iterable) {
+ var obj = {};
+ iterate(iterable, function (k, v) {
+ createProperty(obj, k, v);
+ }, { AS_ENTRIES: true });
+ return obj;
+ }
+});
+
+const debug$1 = typeof process === 'object' && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error('SEMVER', ...args) : () => {};
+var debug_1 = debug$1;
+
+// Not necessarily the package version of this code.
+
+const SEMVER_SPEC_VERSION = '2.0.0';
+const MAX_LENGTH$3 = 256;
+const MAX_SAFE_INTEGER$3 = Number.MAX_SAFE_INTEGER ||
+/* istanbul ignore next */
+9007199254740991; // Max safe segment length for coercion.
+
+const MAX_SAFE_COMPONENT_LENGTH = 16;
+var constants$7 = {
+ SEMVER_SPEC_VERSION,
+ MAX_LENGTH: MAX_LENGTH$3,
+ MAX_SAFE_INTEGER: MAX_SAFE_INTEGER$3,
+ MAX_SAFE_COMPONENT_LENGTH
+};
+
+var re$1 = {exports: {}};
+
+(function (module, exports) {
+ const {
+ MAX_SAFE_COMPONENT_LENGTH
+ } = constants$7;
+ const debug = debug_1;
+ exports = module.exports = {}; // The actual regexps go on exports.re
+
+ const re = exports.re = [];
+ const src = exports.src = [];
+ const t = exports.t = {};
+ let R = 0;
+
+ const createToken = (name, value, isGlobal) => {
+ const index = R++;
+ debug(index, value);
+ t[name] = index;
+ src[index] = value;
+ re[index] = new RegExp(value, isGlobal ? 'g' : undefined);
+ }; // The following Regular Expressions can be used for tokenizing,
+ // validating, and parsing SemVer version strings.
+ // ## Numeric Identifier
+ // A single `0`, or a non-zero digit followed by zero or more digits.
+
+
+ createToken('NUMERICIDENTIFIER', '0|[1-9]\\d*');
+ createToken('NUMERICIDENTIFIERLOOSE', '[0-9]+'); // ## Non-numeric Identifier
+ // Zero or more digits, followed by a letter or hyphen, and then zero or
+ // more letters, digits, or hyphens.
+
+ createToken('NONNUMERICIDENTIFIER', '\\d*[a-zA-Z-][a-zA-Z0-9-]*'); // ## Main Version
+ // Three dot-separated numeric identifiers.
+
+ createToken('MAINVERSION', `(${src[t.NUMERICIDENTIFIER]})\\.` + `(${src[t.NUMERICIDENTIFIER]})\\.` + `(${src[t.NUMERICIDENTIFIER]})`);
+ createToken('MAINVERSIONLOOSE', `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` + `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` + `(${src[t.NUMERICIDENTIFIERLOOSE]})`); // ## Pre-release Version Identifier
+ // A numeric identifier, or a non-numeric identifier.
+
+ createToken('PRERELEASEIDENTIFIER', `(?:${src[t.NUMERICIDENTIFIER]}|${src[t.NONNUMERICIDENTIFIER]})`);
+ createToken('PRERELEASEIDENTIFIERLOOSE', `(?:${src[t.NUMERICIDENTIFIERLOOSE]}|${src[t.NONNUMERICIDENTIFIER]})`); // ## Pre-release Version
+ // Hyphen, followed by one or more dot-separated pre-release version
+ // identifiers.
+
+ createToken('PRERELEASE', `(?:-(${src[t.PRERELEASEIDENTIFIER]}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`);
+ createToken('PRERELEASELOOSE', `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`); // ## Build Metadata Identifier
+ // Any combination of digits, letters, or hyphens.
+
+ createToken('BUILDIDENTIFIER', '[0-9A-Za-z-]+'); // ## Build Metadata
+ // Plus sign, followed by one or more period-separated build metadata
+ // identifiers.
+
+ createToken('BUILD', `(?:\\+(${src[t.BUILDIDENTIFIER]}(?:\\.${src[t.BUILDIDENTIFIER]})*))`); // ## Full Version String
+ // A main version, followed optionally by a pre-release version and
+ // build metadata.
+ // Note that the only major, minor, patch, and pre-release sections of
+ // the version string are capturing groups. The build metadata is not a
+ // capturing group, because it should not ever be used in version
+ // comparison.
+
+ createToken('FULLPLAIN', `v?${src[t.MAINVERSION]}${src[t.PRERELEASE]}?${src[t.BUILD]}?`);
+ createToken('FULL', `^${src[t.FULLPLAIN]}$`); // like full, but allows v1.2.3 and =1.2.3, which people do sometimes.
+ // also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty
+ // common in the npm registry.
+
+ createToken('LOOSEPLAIN', `[v=\\s]*${src[t.MAINVERSIONLOOSE]}${src[t.PRERELEASELOOSE]}?${src[t.BUILD]}?`);
+ createToken('LOOSE', `^${src[t.LOOSEPLAIN]}$`);
+ createToken('GTLT', '((?:<|>)?=?)'); // Something like "2.*" or "1.2.x".
+ // Note that "x.x" is a valid xRange identifer, meaning "any version"
+ // Only the first item is strictly required.
+
+ createToken('XRANGEIDENTIFIERLOOSE', `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
+ 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]}?` + `)?)?`);
+ createToken('XRANGEPLAINLOOSE', `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})` + `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` + `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` + `(?:${src[t.PRERELEASELOOSE]})?${src[t.BUILD]}?` + `)?)?`);
+ createToken('XRANGE', `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`);
+ createToken('XRANGELOOSE', `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`); // Coercion.
+ // Extract anything that could conceivably be a part of a valid semver
+
+ createToken('COERCE', `${'(^|[^\\d])' + '(\\d{1,'}${MAX_SAFE_COMPONENT_LENGTH}})` + `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` + `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` + `(?:$|[^\\d])`);
+ createToken('COERCERTL', src[t.COERCE], true); // Tilde ranges.
+ // Meaning is "reasonably at or greater than"
+
+ createToken('LONETILDE', '(?:~>?)');
+ createToken('TILDETRIM', `(\\s*)${src[t.LONETILDE]}\\s+`, true);
+ exports.tildeTrimReplace = '$1~';
+ createToken('TILDE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`);
+ createToken('TILDELOOSE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`); // Caret ranges.
+ // Meaning is "at least and backwards compatible with"
+
+ createToken('LONECARET', '(?:\\^)');
+ createToken('CARETTRIM', `(\\s*)${src[t.LONECARET]}\\s+`, true);
+ exports.caretTrimReplace = '$1^';
+ createToken('CARET', `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`);
+ createToken('CARETLOOSE', `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`); // A simple gt/lt/eq thing, or just "" to indicate "any version"
+
+ createToken('COMPARATORLOOSE', `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`);
+ createToken('COMPARATOR', `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`); // An expression to strip any whitespace between the gtlt and the thing
+ // it modifies, so that `> 1.2.3` ==> `>1.2.3`