199	199	- run: env
200	200	- name: Check environment variables
201	201	run: |
202		− ${INSTALL_DIR_FOR_ELIXIR}/elixir --version
203		− ${INSTALL_DIR_FOR_GLEAM}/gleam --version
204		− ${INSTALL_DIR_FOR_OTP}/erl -version
205		− ${INSTALL_DIR_FOR_REBAR3}/rebar3 version
	202	+ ${INSTALL_DIR_FOR_ELIXIR}/bin/elixir -v
	203	+ ${INSTALL_DIR_FOR_GLEAM}/bin/gleam --version
	204	+ ${INSTALL_DIR_FOR_OTP}/bin/erl -version
	205	+ ${INSTALL_DIR_FOR_REBAR3}/bin/rebar3 version

137	137	- run: env
138	138	- name: Check environment variables
139	139	run: |
140		− ${INSTALL_DIR_FOR_ELIXIR}/elixir --version
141		− ${INSTALL_DIR_FOR_GLEAM}/gleam --version
142		− ${INSTALL_DIR_FOR_OTP}/erl -version
143		− ${INSTALL_DIR_FOR_REBAR3}/rebar3 version
144		− shell: bash
	140	+ & "$Env:INSTALL_DIR_FOR_ELIXIR/bin/elixir" "-v"
	141	+ & "$Env:INSTALL_DIR_FOR_GLEAM/bin/gleam.exe" "--version"
	142	+ & "$Env:INSTALL_DIR_FOR_OTP/bin/erl.exe" "+V"
	143	+ & "$Env:INSTALL_DIR_FOR_REBAR3/bin/rebar3.cmd" "version"
	144	+ & "$Env:INSTALL_DIR_FOR_REBAR3/bin/rebar3.ps1" "version"

1	1	node_modules/**
2		−dist/.github/workflows
3	2	test/.tool-versions

282	282	- `INSTALL_DIR_FOR_GLEAM`: base folder for Gleam
283	283	- `INSTALL_DIR_FOR_REBAR3`: base folder for `rebar3`
284	284
	285	+In each of these you'll find folder `bin` where the appropriate binaries, platform-dependant,
	286	+are found (i.e. `erl`, `erl.exe`, `rebar3`, `rebar3.exe`, ...).
	287	+
285	288	## Elixir Problem Matchers
286	289
287	290	The Elixir Problem Matchers in this repository are adapted from

2547	2547	};
2548	2548	var _a;
2549	2549	Object.defineProperty(exports, "__esModule", ({ value: true }));
2550		−exports.getCmdPath = exports.tryGetExecutablePath = exports.isRooted = exports.isDirectory = exports.exists = exports.IS_WINDOWS = exports.unlink = exports.symlink = exports.stat = exports.rmdir = exports.rename = exports.readlink = exports.readdir = exports.mkdir = exports.lstat = exports.copyFile = exports.chmod = void 0;
	2550	+exports.getCmdPath = exports.tryGetExecutablePath = exports.isRooted = exports.isDirectory = exports.exists = exports.READONLY = exports.UV_FS_O_EXLOCK = exports.IS_WINDOWS = exports.unlink = exports.symlink = exports.stat = exports.rmdir = exports.rm = exports.rename = exports.readlink = exports.readdir = exports.open = exports.mkdir = exports.lstat = exports.copyFile = exports.chmod = void 0;
2551	2551	const fs = __importStar(__nccwpck_require__(7147));
2552	2552	const path = __importStar(__nccwpck_require__(1017));
2553		−_a = fs.promises, exports.chmod = _a.chmod, exports.copyFile = _a.copyFile, exports.lstat = _a.lstat, exports.mkdir = _a.mkdir, exports.readdir = _a.readdir, exports.readlink = _a.readlink, exports.rename = _a.rename, exports.rmdir = _a.rmdir, exports.stat = _a.stat, exports.symlink = _a.symlink, exports.unlink = _a.unlink;
	2553	+_a = fs.promises
	2554	+// export const {open} = 'fs'
	2555	+, exports.chmod = _a.chmod, exports.copyFile = _a.copyFile, exports.lstat = _a.lstat, exports.mkdir = _a.mkdir, exports.open = _a.open, exports.readdir = _a.readdir, exports.readlink = _a.readlink, exports.rename = _a.rename, exports.rm = _a.rm, exports.rmdir = _a.rmdir, exports.stat = _a.stat, exports.symlink = _a.symlink, exports.unlink = _a.unlink;
	2556	+// export const {open} = 'fs'
2554	2557	exports.IS_WINDOWS = process.platform === 'win32';
	2558	+// See https://github.com/nodejs/node/blob/d0153aee367422d0858105abec186da4dff0a0c5/deps/uv/include/uv/win.h#L691
	2559	+exports.UV_FS_O_EXLOCK = 0x10000000;
	2560	+exports.READONLY = fs.constants.O_RDONLY;
2555	2561	function exists(fsPath) {
2556	2562	return __awaiter(this, void 0, void 0, function* () {
2557	2563	try {

2732	2738	Object.defineProperty(exports, "__esModule", ({ value: true }));
2733	2739	exports.findInPath = exports.which = exports.mkdirP = exports.rmRF = exports.mv = exports.cp = void 0;
2734	2740	const assert_1 = __nccwpck_require__(9491);
2735		−const childProcess = __importStar(__nccwpck_require__(2081));
2736	2741	const path = __importStar(__nccwpck_require__(1017));
2737		−const util_1 = __nccwpck_require__(3837);
2738	2742	const ioUtil = __importStar(__nccwpck_require__(1962));
2739		−const exec = util_1.promisify(childProcess.exec);
2740		−const execFile = util_1.promisify(childProcess.execFile);
2741	2743	/**
2742	2744	* Copies a file or folder.
2743	2745	* Based off of shelljs - https://github.com/shelljs/shelljs/blob/9237f66c52e5daa40458f94f9565e18e8132f5a6/src/cp.js

2818	2820	function rmRF(inputPath) {
2819	2821	return __awaiter(this, void 0, void 0, function* () {
2820	2822	if (ioUtil.IS_WINDOWS) {
2821		− // Node doesn't provide a delete operation, only an unlink function. This means that if the file is being used by another
2822		− // program (e.g. antivirus), it won't be deleted. To address this, we shell out the work to rd/del.
2823	2823	// Check for invalid characters
2824	2824	// https://docs.microsoft.com/en-us/windows/win32/fileio/naming-a-file
2825	2825	if (/[*"<>|]/.test(inputPath)) {
2826	2826	throw new Error('File path must not contain `*`, `"`, `<`, `>` or `|` on Windows');
2827	2827	}
2828		− try {
2829		− const cmdPath = ioUtil.getCmdPath();
2830		− if (yield ioUtil.isDirectory(inputPath, true)) {
2831		− yield exec(`${cmdPath} /s /c "rd /s /q "%inputPath%""`, {
2832		− env: { inputPath }
2833		− });
2834		− }
2835		− else {
2836		− yield exec(`${cmdPath} /s /c "del /f /a "%inputPath%""`, {
2837		− env: { inputPath }
2838		− });
2839		− }
2840		− }
2841		− catch (err) {
2842		− // if you try to delete a file that doesn't exist, desired result is achieved
2843		− // other errors are valid
2844		− if (err.code !== 'ENOENT')
2845		− throw err;
2846		− }
2847		− // Shelling out fails to remove a symlink folder with missing source, this unlink catches that
2848		− try {
2849		− yield ioUtil.unlink(inputPath);
2850		− }
2851		− catch (err) {
2852		− // if you try to delete a file that doesn't exist, desired result is achieved
2853		− // other errors are valid
2854		− if (err.code !== 'ENOENT')
2855		− throw err;
2856		− }
2857	2828	}
2858		− else {
2859		− let isDir = false;
2860		− try {
2861		− isDir = yield ioUtil.isDirectory(inputPath);
2862		− }
2863		− catch (err) {
2864		− // if you try to delete a file that doesn't exist, desired result is achieved
2865		− // other errors are valid
2866		− if (err.code !== 'ENOENT')
2867		− throw err;
2868		− return;
2869		− }
2870		− if (isDir) {
2871		− yield execFile(`rm`, [`-rf`, `${inputPath}`]);
2872		− }
2873		− else {
2874		− yield ioUtil.unlink(inputPath);
2875		− }
	2829	+ try {
	2830	+ // note if path does not exist, error is silent
	2831	+ yield ioUtil.rm(inputPath, {
	2832	+ force: true,
	2833	+ maxRetries: 3,
	2834	+ recursive: true,
	2835	+ retryDelay: 300
	2836	+ });
	2837	+ }
	2838	+ catch (err) {
	2839	+ throw new Error(`File was unable to be removed ${err}`);
2876	2840	}
2877	2841	});
2878	2842	}

3972	3936	// Max safe segment length for coercion.
3973	3937	var MAX_SAFE_COMPONENT_LENGTH = 16
3974	3938
	3939	+var MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6
	3940	+
3975	3941	// The actual regexps go on exports.re
3976	3942	var re = exports.re = []
	3943	+var safeRe = exports.safeRe = []
3977	3944	var src = exports.src = []
3978	3945	var t = exports.tokens = {}
3979	3946	var R = 0

3982	3949	t[n] = R++
3983	3950	}
3984	3951
	3952	+var LETTERDASHNUMBER = '[a-zA-Z0-9-]'
	3953	+
	3954	+// Replace some greedy regex tokens to prevent regex dos issues. These regex are
	3955	+// used internally via the safeRe object since all inputs in this library get
	3956	+// normalized first to trim and collapse all extra whitespace. The original
	3957	+// regexes are exported for userland consumption and lower level usage. A
	3958	+// future breaking change could export the safer regex only with a note that
	3959	+// all input should have extra whitespace removed.
	3960	+var safeRegexReplacements = [
	3961	+ ['\\s', 1],
	3962	+ ['\\d', MAX_LENGTH],
	3963	+ [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH],
	3964	+]
	3965	+
	3966	+function makeSafeRe (value) {
	3967	+ for (var i = 0; i < safeRegexReplacements.length; i++) {
	3968	+ var token = safeRegexReplacements[i][0]
	3969	+ var max = safeRegexReplacements[i][1]
	3970	+ value = value
	3971	+ .split(token + '*').join(token + '{0,' + max + '}')
	3972	+ .split(token + '+').join(token + '{1,' + max + '}')
	3973	+ }
	3974	+ return value
	3975	+}
	3976	+
3985	3977	// The following Regular Expressions can be used for tokenizing,
3986	3978	// validating, and parsing SemVer version strings.
3987	3979

3991	3983	tok('NUMERICIDENTIFIER')
3992	3984	src[t.NUMERICIDENTIFIER] = '0|[1-9]\\d*'
3993	3985	tok('NUMERICIDENTIFIERLOOSE')
3994		−src[t.NUMERICIDENTIFIERLOOSE] = '[0-9]+'
	3986	+src[t.NUMERICIDENTIFIERLOOSE] = '\\d+'
3995	3987
3996	3988	// ## Non-numeric Identifier
3997	3989	// Zero or more digits, followed by a letter or hyphen, and then zero or
3998	3990	// more letters, digits, or hyphens.
3999	3991
4000	3992	tok('NONNUMERICIDENTIFIER')
4001		−src[t.NONNUMERICIDENTIFIER] = '\\d*[a-zA-Z-][a-zA-Z0-9-]*'
	3993	+src[t.NONNUMERICIDENTIFIER] = '\\d*[a-zA-Z-]' + LETTERDASHNUMBER + '*'
4002	3994
4003	3995	// ## Main Version
4004	3996	// Three dot-separated numeric identifiers.

4040	4032	// Any combination of digits, letters, or hyphens.
4041	4033
4042	4034	tok('BUILDIDENTIFIER')
4043		−src[t.BUILDIDENTIFIER] = '[0-9A-Za-z-]+'
	4035	+src[t.BUILDIDENTIFIER] = LETTERDASHNUMBER + '+'
4044	4036
4045	4037	// ## Build Metadata
4046	4038	// Plus sign, followed by one or more period-separated build metadata

4120	4112	'(?:$|[^\\d])'
4121	4113	tok('COERCERTL')
4122	4114	re[t.COERCERTL] = new RegExp(src[t.COERCE], 'g')
	4115	+safeRe[t.COERCERTL] = new RegExp(makeSafeRe(src[t.COERCE]), 'g')
4123	4116
4124	4117	// Tilde ranges.
4125	4118	// Meaning is "reasonably at or greater than"

4129	4122	tok('TILDETRIM')
4130	4123	src[t.TILDETRIM] = '(\\s*)' + src[t.LONETILDE] + '\\s+'
4131	4124	re[t.TILDETRIM] = new RegExp(src[t.TILDETRIM], 'g')
	4125	+safeRe[t.TILDETRIM] = new RegExp(makeSafeRe(src[t.TILDETRIM]), 'g')
4132	4126	var tildeTrimReplace = '$1~'
4133	4127
4134	4128	tok('TILDE')

4144	4138	tok('CARETTRIM')
4145	4139	src[t.CARETTRIM] = '(\\s*)' + src[t.LONECARET] + '\\s+'
4146	4140	re[t.CARETTRIM] = new RegExp(src[t.CARETTRIM], 'g')
	4141	+safeRe[t.CARETTRIM] = new RegExp(makeSafeRe(src[t.CARETTRIM]), 'g')
4147	4142	var caretTrimReplace = '$1^'
4148	4143
4149	4144	tok('CARET')

4165	4160
4166	4161	// this one has to use the /g flag
4167	4162	re[t.COMPARATORTRIM] = new RegExp(src[t.COMPARATORTRIM], 'g')
	4163	+safeRe[t.COMPARATORTRIM] = new RegExp(makeSafeRe(src[t.COMPARATORTRIM]), 'g')
4168	4164	var comparatorTrimReplace = '$1$2$3'
4169	4165
4170	4166	// Something like `1.2.3 - 1.2.4`

4193	4189	debug(i, src[i])
4194	4190	if (!re[i]) {
4195	4191	re[i] = new RegExp(src[i])
	4192	+
	4193	+ // Replace all greedy whitespace to prevent regex dos issues. These regex are
	4194	+ // used internally via the safeRe object since all inputs in this library get
	4195	+ // normalized first to trim and collapse all extra whitespace. The original
	4196	+ // regexes are exported for userland consumption and lower level usage. A
	4197	+ // future breaking change could export the safer regex only with a note that
	4198	+ // all input should have extra whitespace removed.
	4199	+ safeRe[i] = new RegExp(makeSafeRe(src[i]))
4196	4200	}
4197	4201	}
4198	4202

4217	4221	return null
4218	4222	}
4219	4223
4220		− var r = options.loose ? re[t.LOOSE] : re[t.FULL]
	4224	+ var r = options.loose ? safeRe[t.LOOSE] : safeRe[t.FULL]
4221	4225	if (!r.test(version)) {
4222	4226	return null
4223	4227	}

4272	4276	this.options = options
4273	4277	this.loose = !!options.loose
4274	4278
4275		− var m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL])
	4279	+ var m = version.trim().match(options.loose ? safeRe[t.LOOSE] : safeRe[t.FULL])
4276	4280
4277	4281	if (!m) {
4278	4282	throw new TypeError('Invalid Version: ' + version)

4717	4721	return new Comparator(comp, options)
4718	4722	}
4719	4723
	4724	+ comp = comp.trim().split(/\s+/).join(' ')
4720	4725	debug('comparator', comp, options)
4721	4726	this.options = options
4722	4727	this.loose = !!options.loose

4733	4738
4734	4739	var ANY = {}
4735	4740	Comparator.prototype.parse = function (comp) {
4736		− var r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR]
	4741	+ var r = this.options.loose ? safeRe[t.COMPARATORLOOSE] : safeRe[t.COMPARATOR]
4737	4742	var m = comp.match(r)
4738	4743
4739	4744	if (!m) {

4857	4862	this.loose = !!options.loose
4858	4863	this.includePrerelease = !!options.includePrerelease
4859	4864
4860		− // First, split based on boolean or ||
	4865	+ // First reduce all whitespace as much as possible so we do not have to rely
	4866	+ // on potentially slow regexes like \s*. This is then stored and used for
	4867	+ // future error messages as well.
4861	4868	this.raw = range
4862		− this.set = range.split(/\s*\|\|\s*/).map(function (range) {
	4869	+ .trim()
	4870	+ .split(/\s+/)
	4871	+ .join(' ')
	4872	+
	4873	+ // First, split based on boolean or ||
	4874	+ this.set = this.raw.split('||').map(function (range) {
4863	4875	return this.parseRange(range.trim())
4864	4876	}, this).filter(function (c) {
4865	4877	// throw out any that are not relevant for whatever reason

4867	4879	})
4868	4880
4869	4881	if (!this.set.length) {
4870		− throw new TypeError('Invalid SemVer Range: ' + range)
	4882	+ throw new TypeError('Invalid SemVer Range: ' + this.raw)
4871	4883	}
4872	4884
4873	4885	this.format()

4886	4898
4887	4899	Range.prototype.parseRange = function (range) {
4888	4900	var loose = this.options.loose
4889		− range = range.trim()
4890	4901	// `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`
4891		− var hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE]
	4902	+ var hr = loose ? safeRe[t.HYPHENRANGELOOSE] : safeRe[t.HYPHENRANGE]
4892	4903	range = range.replace(hr, hyphenReplace)
4893	4904	debug('hyphen replace', range)
4894	4905	// `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`
4895		− range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace)
4896		− debug('comparator trim', range, re[t.COMPARATORTRIM])
	4906	+ range = range.replace(safeRe[t.COMPARATORTRIM], comparatorTrimReplace)
	4907	+ debug('comparator trim', range, safeRe[t.COMPARATORTRIM])
4897	4908
4898	4909	// `~ 1.2.3` => `~1.2.3`
4899		− range = range.replace(re[t.TILDETRIM], tildeTrimReplace)
	4910	+ range = range.replace(safeRe[t.TILDETRIM], tildeTrimReplace)
4900	4911
4901	4912	// `^ 1.2.3` => `^1.2.3`
4902		− range = range.replace(re[t.CARETTRIM], caretTrimReplace)
	4913	+ range = range.replace(safeRe[t.CARETTRIM], caretTrimReplace)
4903	4914
4904	4915	// normalize spaces
4905	4916	range = range.split(/\s+/).join(' ')

4907	4918	// At this point, the range is completely trimmed and
4908	4919	// ready to be split into comparators.
4909	4920
4910		− var compRe = loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR]
	4921	+ var compRe = loose ? safeRe[t.COMPARATORLOOSE] : safeRe[t.COMPARATOR]
4911	4922	var set = range.split(' ').map(function (comp) {
4912	4923	return parseComparator(comp, this.options)
4913	4924	}, this).join(' ').split(/\s+/)

5007	5018	}
5008	5019
5009	5020	function replaceTilde (comp, options) {
5010		− var r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE]
	5021	+ var r = options.loose ? safeRe[t.TILDELOOSE] : safeRe[t.TILDE]
5011	5022	return comp.replace(r, function (_, M, m, p, pr) {
5012	5023	debug('tilde', comp, _, M, m, p, pr)
5013	5024	var ret

5048	5059
5049	5060	function replaceCaret (comp, options) {
5050	5061	debug('caret', comp, options)
5051		− var r = options.loose ? re[t.CARETLOOSE] : re[t.CARET]
	5062	+ var r = options.loose ? safeRe[t.CARETLOOSE] : safeRe[t.CARET]
5052	5063	return comp.replace(r, function (_, M, m, p, pr) {
5053	5064	debug('caret', comp, _, M, m, p, pr)
5054	5065	var ret

5107	5118
5108	5119	function replaceXRange (comp, options) {
5109	5120	comp = comp.trim()
5110		− var r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE]
	5121	+ var r = options.loose ? safeRe[t.XRANGELOOSE] : safeRe[t.XRANGE]
5111	5122	return comp.replace(r, function (ret, gtlt, M, m, p, pr) {
5112	5123	debug('xRange', comp, ret, gtlt, M, m, p, pr)
5113	5124	var xM = isX(M)

5182	5193	function replaceStars (comp, options) {
5183	5194	debug('replaceStars', comp, options)
5184	5195	// Looseness is ignored here. star is always as loose as it gets!
5185		− return comp.trim().replace(re[t.STAR], '')
	5196	+ return comp.trim().replace(safeRe[t.STAR], '')
5186	5197	}
5187	5198
5188	5199	// This function is passed to string.replace(re[t.HYPHENRANGE])

5508	5519
5509	5520	var match = null
5510	5521	if (!options.rtl) {
5511		− match = version.match(re[t.COERCE])
	5522	+ match = version.match(safeRe[t.COERCE])
5512	5523	} else {
5513	5524	// Find the right-most coercible string that does not share
5514	5525	// a terminus with a more left-ward coercible string.

5519	5530	// Stop when we get a match that ends at the string end, since no
5520	5531	// coercible string can be more right-ward without the same terminus.
5521	5532	var next
5522		− while ((next = re[t.COERCERTL].exec(version)) &&
	5533	+ while ((next = safeRe[t.COERCERTL].exec(version)) &&
5523	5534	(!match || match.index + match[0].length !== version.length)
5524	5535	) {
5525	5536	if (!match ||
5526	5537	next.index + next[0].length !== match.index + match[0].length) {
5527	5538	match = next
5528	5539	}
5529		− re[t.COERCERTL].lastIndex = next.index + next[1].length + next[2].length
	5540	+ safeRe[t.COERCERTL].lastIndex = next.index + next[1].length + next[2].length
5530	5541	}
5531	5542	// leave it in a clean state
5532		− re[t.COERCERTL].lastIndex = -1
	5543	+ safeRe[t.COERCERTL].lastIndex = -1
5533	5544	}
5534	5545
5535	5546	if (match === null) {

5628	5639
5629	5640	/***/ }),
5630	5641
5631		−/***/ 7129:
	5642	+/***/ 1532:
5632	5643	/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
5633	5644
5634		−"use strict";
5635		−
5636		−
5637		−// A linked list to keep track of recently-used-ness
5638		−const Yallist = __nccwpck_require__(665)
5639		−
5640		−const MAX = Symbol('max')
5641		−const LENGTH = Symbol('length')
5642		−const LENGTH_CALCULATOR = Symbol('lengthCalculator')
5643		−const ALLOW_STALE = Symbol('allowStale')
5644		−const MAX_AGE = Symbol('maxAge')
5645		−const DISPOSE = Symbol('dispose')
5646		−const NO_DISPOSE_ON_SET = Symbol('noDisposeOnSet')
5647		−const LRU_LIST = Symbol('lruList')
5648		−const CACHE = Symbol('cache')
5649		−const UPDATE_AGE_ON_GET = Symbol('updateAgeOnGet')
5650		−
5651		−const naiveLength = () => 1
5652		−
5653		−// lruList is a yallist where the head is the youngest
5654		−// item, and the tail is the oldest. the list contains the Hit
5655		−// objects as the entries.
5656		−// Each Hit object has a reference to its Yallist.Node. This
5657		−// never changes.
5658		−//
5659		−// cache is a Map (or PseudoMap) that matches the keys to
5660		−// the Yallist.Node object.
5661		−class LRUCache {
5662		− constructor (options) {
5663		− if (typeof options === 'number')
5664		− options = { max: options }
5665		−
5666		− if (!options)
5667		− options = {}
5668		−
5669		− if (options.max && (typeof options.max !== 'number' || options.max < 0))
5670		− throw new TypeError('max must be a non-negative number')
5671		− // Kind of weird to have a default max of Infinity, but oh well.
5672		− const max = this[MAX] = options.max || Infinity
5673		−
5674		− const lc = options.length || naiveLength
5675		− this[LENGTH_CALCULATOR] = (typeof lc !== 'function') ? naiveLength : lc
5676		− this[ALLOW_STALE] = options.stale || false
5677		− if (options.maxAge && typeof options.maxAge !== 'number')
5678		− throw new TypeError('maxAge must be a number')
5679		− this[MAX_AGE] = options.maxAge || 0
5680		− this[DISPOSE] = options.dispose
5681		− this[NO_DISPOSE_ON_SET] = options.noDisposeOnSet || false
5682		− this[UPDATE_AGE_ON_GET] = options.updateAgeOnGet || false
5683		− this.reset()
	5645	+const ANY = Symbol('SemVer ANY')
	5646	+// hoisted class for cyclic dependency
	5647	+class Comparator {
	5648	+ static get ANY () {
	5649	+ return ANY
5684	5650	}
5685	5651
5686		− // resize the cache when the max changes.
5687		− set max (mL) {
5688		− if (typeof mL !== 'number' || mL < 0)
5689		− throw new TypeError('max must be a non-negative number')
	5652	+ constructor (comp, options) {
	5653	+ options = parseOptions(options)
5690	5654
5691		− this[MAX] = mL || Infinity
5692		− trim(this)
5693		− }
5694		− get max () {
5695		− return this[MAX]
5696		− }
	5655	+ if (comp instanceof Comparator) {
	5656	+ if (comp.loose === !!options.loose) {
	5657	+ return comp
	5658	+ } else {
	5659	+ comp = comp.value
	5660	+ }
	5661	+ }
5697	5662
5698		− set allowStale (allowStale) {
5699		− this[ALLOW_STALE] = !!allowStale
5700		− }
5701		− get allowStale () {
5702		− return this[ALLOW_STALE]
5703		− }
	5663	+ comp = comp.trim().split(/\s+/).join(' ')
	5664	+ debug('comparator', comp, options)
	5665	+ this.options = options
	5666	+ this.loose = !!options.loose
	5667	+ this.parse(comp)
5704	5668
5705		− set maxAge (mA) {
5706		− if (typeof mA !== 'number')
5707		− throw new TypeError('maxAge must be a non-negative number')
	5669	+ if (this.semver === ANY) {
	5670	+ this.value = ''
	5671	+ } else {
	5672	+ this.value = this.operator + this.semver.version
	5673	+ }
5708	5674
5709		− this[MAX_AGE] = mA
5710		− trim(this)
5711		− }
5712		− get maxAge () {
5713		− return this[MAX_AGE]
	5675	+ debug('comp', this)
5714	5676	}
5715	5677
5716		− // resize the cache when the lengthCalculator changes.
5717		− set lengthCalculator (lC) {
5718		− if (typeof lC !== 'function')
5719		− lC = naiveLength
	5678	+ parse (comp) {
	5679	+ const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR]
	5680	+ const m = comp.match(r)
5720	5681
5721		− if (lC !== this[LENGTH_CALCULATOR]) {
5722		− this[LENGTH_CALCULATOR] = lC
5723		− this[LENGTH] = 0
5724		− this[LRU_LIST].forEach(hit => {
5725		− hit.length = this[LENGTH_CALCULATOR](hit.value, hit.key)
5726		− this[LENGTH] += hit.length
5727		− })
	5682	+ if (!m) {
	5683	+ throw new TypeError(`Invalid comparator: ${comp}`)
5728	5684	}
5729		− trim(this)
5730		− }
5731		− get lengthCalculator () { return this[LENGTH_CALCULATOR] }
5732		−
5733		− get length () { return this[LENGTH] }
5734		− get itemCount () { return this[LRU_LIST].length }
5735	5685
5736		− rforEach (fn, thisp) {
5737		− thisp = thisp || this
5738		− for (let walker = this[LRU_LIST].tail; walker !== null;) {
5739		− const prev = walker.prev
5740		− forEachStep(this, fn, walker, thisp)
5741		− walker = prev
	5686	+ this.operator = m[1] !== undefined ? m[1] : ''
	5687	+ if (this.operator === '=') {
	5688	+ this.operator = ''
5742	5689	}
5743		− }
5744	5690
5745		− forEach (fn, thisp) {
5746		− thisp = thisp || this
5747		− for (let walker = this[LRU_LIST].head; walker !== null;) {
5748		− const next = walker.next
5749		− forEachStep(this, fn, walker, thisp)
5750		− walker = next
	5691	+ // if it literally is just '>' or '' then allow anything.
	5692	+ if (!m[2]) {
	5693	+ this.semver = ANY
	5694	+ } else {
	5695	+ this.semver = new SemVer(m[2], this.options.loose)
5751	5696	}
5752	5697	}
5753	5698
5754		− keys () {
5755		− return this[LRU_LIST].toArray().map(k => k.key)
	5699	+ toString () {
	5700	+ return this.value
5756	5701	}
5757	5702
5758		− values () {
5759		− return this[LRU_LIST].toArray().map(k => k.value)
5760		− }
	5703	+ test (version) {
	5704	+ debug('Comparator.test', version, this.options.loose)
5761	5705
5762		− reset () {
5763		− if (this[DISPOSE] &&
5764		− this[LRU_LIST] &&
5765		− this[LRU_LIST].length) {
5766		− this[LRU_LIST].forEach(hit => this[DISPOSE](hit.key, hit.value))
	5706	+ if (this.semver === ANY || version === ANY) {
	5707	+ return true
5767	5708	}
5768	5709
5769		− this[CACHE] = new Map() // hash of items by key
5770		− this[LRU_LIST] = new Yallist() // list of items in order of use recency
5771		− this[LENGTH] = 0 // length of items in the list
5772		− }
	5710	+ if (typeof version === 'string') {
	5711	+ try {
	5712	+ version = new SemVer(version, this.options)
	5713	+ } catch (er) {
	5714	+ return false
	5715	+ }
	5716	+ }
5773	5717
5774		− dump () {
5775		− return this[LRU_LIST].map(hit =>
5776		− isStale(this, hit) ? false : {
5777		− k: hit.key,
5778		− v: hit.value,
5779		− e: hit.now + (hit.maxAge || 0)
5780		− }).toArray().filter(h => h)
	5718	+ return cmp(version, this.operator, this.semver, this.options)
5781	5719	}
5782	5720
5783		− dumpLru () {
5784		− return this[LRU_LIST]
5785		− }
	5721	+ intersects (comp, options) {
	5722	+ if (!(comp instanceof Comparator)) {
	5723	+ throw new TypeError('a Comparator is required')
	5724	+ }
5786	5725
5787		− set (key, value, maxAge) {
5788		− maxAge = maxAge || this[MAX_AGE]
	5726	+ if (this.operator === '') {
	5727	+ if (this.value === '') {
	5728	+ return true
	5729	+ }
	5730	+ return new Range(comp.value, options).test(this.value)
	5731	+ } else if (comp.operator === '') {
	5732	+ if (comp.value === '') {
	5733	+ return true
	5734	+ }
	5735	+ return new Range(this.value, options).test(comp.semver)
	5736	+ }
5789	5737
5790		− if (maxAge && typeof maxAge !== 'number')
5791		− throw new TypeError('maxAge must be a number')
5792		−
5793		− const now = maxAge ? Date.now() : 0
5794		− const len = this[LENGTH_CALCULATOR](value, key)
5795		−
5796		− if (this[CACHE].has(key)) {
5797		− if (len > this[MAX]) {
5798		− del(this, this[CACHE].get(key))
5799		− return false
5800		− }
5801		−
5802		− const node = this[CACHE].get(key)
5803		− const item = node.value
5804		−
5805		− // dispose of the old one before overwriting
5806		− // split out into 2 ifs for better coverage tracking
5807		− if (this[DISPOSE]) {
5808		− if (!this[NO_DISPOSE_ON_SET])
5809		− this[DISPOSE](key, item.value)
5810		− }
5811		−
5812		− item.now = now
5813		− item.maxAge = maxAge
5814		− item.value = value
5815		− this[LENGTH] += len - item.length
5816		− item.length = len
5817		− this.get(key)
5818		− trim(this)
5819		− return true
5820		− }
5821		−
5822		− const hit = new Entry(key, value, len, now, maxAge)
5823		−
5824		− // oversized objects fall out of cache automatically.
5825		− if (hit.length > this[MAX]) {
5826		− if (this[DISPOSE])
5827		− this[DISPOSE](key, value)
5828		−
5829		− return false
5830		− }
5831		−
5832		− this[LENGTH] += hit.length
5833		− this[LRU_LIST].unshift(hit)
5834		− this[CACHE].set(key, this[LRU_LIST].head)
5835		− trim(this)
5836		− return true
5837		− }
5838		−
5839		− has (key) {
5840		− if (!this[CACHE].has(key)) return false
5841		− const hit = this[CACHE].get(key).value
5842		− return !isStale(this, hit)
5843		− }
5844		−
5845		− get (key) {
5846		− return get(this, key, true)
5847		− }
5848		−
5849		− peek (key) {
5850		− return get(this, key, false)
5851		− }
5852		−
5853		− pop () {
5854		− const node = this[LRU_LIST].tail
5855		− if (!node)
5856		− return null
5857		−
5858		− del(this, node)
5859		− return node.value
5860		− }
5861		−
5862		− del (key) {
5863		− del(this, this[CACHE].get(key))
5864		− }
5865		−
5866		− load (arr) {
5867		− // reset the cache
5868		− this.reset()
5869		−
5870		− const now = Date.now()
5871		− // A previous serialized cache has the most recent items first
5872		− for (let l = arr.length - 1; l >= 0; l--) {
5873		− const hit = arr[l]
5874		− const expiresAt = hit.e || 0
5875		− if (expiresAt === 0)
5876		− // the item was created without expiration in a non aged cache
5877		− this.set(hit.k, hit.v)
5878		− else {
5879		− const maxAge = expiresAt - now
5880		− // dont add already expired items
5881		− if (maxAge > 0) {
5882		− this.set(hit.k, hit.v, maxAge)
5883		− }
5884		− }
5885		− }
5886		− }
5887		−
5888		− prune () {
5889		− this[CACHE].forEach((value, key) => get(this, key, false))
5890		− }
5891		−}
5892		−
5893		−const get = (self, key, doUse) => {
5894		− const node = self[CACHE].get(key)
5895		− if (node) {
5896		− const hit = node.value
5897		− if (isStale(self, hit)) {
5898		− del(self, node)
5899		− if (!self[ALLOW_STALE])
5900		− return undefined
5901		− } else {
5902		− if (doUse) {
5903		− if (self[UPDATE_AGE_ON_GET])
5904		− node.value.now = Date.now()
5905		− self[LRU_LIST].unshiftNode(node)
5906		− }
5907		− }
5908		− return hit.value
5909		− }
5910		−}
5911		−
5912		−const isStale = (self, hit) => {
5913		− if (!hit || (!hit.maxAge && !self[MAX_AGE]))
5914		− return false
5915		−
5916		− const diff = Date.now() - hit.now
5917		− return hit.maxAge ? diff > hit.maxAge
5918		− : self[MAX_AGE] && (diff > self[MAX_AGE])
5919		−}
5920		−
5921		−const trim = self => {
5922		− if (self[LENGTH] > self[MAX]) {
5923		− for (let walker = self[LRU_LIST].tail;
5924		− self[LENGTH] > self[MAX] && walker !== null;) {
5925		− // We know that we're about to delete this one, and also
5926		− // what the next least recently used key will be, so just
5927		− // go ahead and set it now.
5928		− const prev = walker.prev
5929		− del(self, walker)
5930		− walker = prev
5931		− }
5932		− }
5933		−}
5934		−
5935		−const del = (self, node) => {
5936		− if (node) {
5937		− const hit = node.value
5938		− if (self[DISPOSE])
5939		− self[DISPOSE](hit.key, hit.value)
5940		−
5941		− self[LENGTH] -= hit.length
5942		− self[CACHE].delete(hit.key)
5943		− self[LRU_LIST].removeNode(node)
5944		− }
5945		−}
5946		−
5947		−class Entry {
5948		− constructor (key, value, length, now, maxAge) {
5949		− this.key = key
5950		− this.value = value
5951		− this.length = length
5952		− this.now = now
5953		− this.maxAge = maxAge || 0
5954		− }
5955		−}
5956		−
5957		−const forEachStep = (self, fn, node, thisp) => {
5958		− let hit = node.value
5959		− if (isStale(self, hit)) {
5960		− del(self, node)
5961		− if (!self[ALLOW_STALE])
5962		− hit = undefined
5963		− }
5964		− if (hit)
5965		− fn.call(thisp, hit.value, hit.key, self)
5966		−}
5967		−
5968		−module.exports = LRUCache
5969		−
5970		−
5971		−/***/ }),
5972		−
5973		−/***/ 1532:
5974		−/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
5975		−
5976		−const ANY = Symbol('SemVer ANY')
5977		−// hoisted class for cyclic dependency
5978		−class Comparator {
5979		− static get ANY () {
5980		− return ANY
5981		− }
5982		−
5983		− constructor (comp, options) {
5984		− options = parseOptions(options)
5985		−
5986		− if (comp instanceof Comparator) {
5987		− if (comp.loose === !!options.loose) {
5988		− return comp
5989		− } else {
5990		− comp = comp.value
5991		− }
5992		− }
5993		−
5994		− comp = comp.trim().split(/\s+/).join(' ')
5995		− debug('comparator', comp, options)
5996		− this.options = options
5997		− this.loose = !!options.loose
5998		− this.parse(comp)
5999		−
6000		− if (this.semver === ANY) {
6001		− this.value = ''
6002		− } else {
6003		− this.value = this.operator + this.semver.version
6004		− }
6005		−
6006		− debug('comp', this)
6007		− }
6008		−
6009		− parse (comp) {
6010		− const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR]
6011		− const m = comp.match(r)
6012		−
6013		− if (!m) {
6014		− throw new TypeError(`Invalid comparator: ${comp}`)
6015		− }
6016		−
6017		− this.operator = m[1] !== undefined ? m[1] : ''
6018		− if (this.operator === '=') {
6019		− this.operator = ''
6020		− }
6021		−
6022		− // if it literally is just '>' or '' then allow anything.
6023		− if (!m[2]) {
6024		− this.semver = ANY
6025		− } else {
6026		− this.semver = new SemVer(m[2], this.options.loose)
6027		− }
6028		− }
6029		−
6030		− toString () {
6031		− return this.value
6032		− }
6033		−
6034		− test (version) {
6035		− debug('Comparator.test', version, this.options.loose)
6036		−
6037		− if (this.semver === ANY || version === ANY) {
6038		− return true
6039		− }
6040		−
6041		− if (typeof version === 'string') {
6042		− try {
6043		− version = new SemVer(version, this.options)
6044		− } catch (er) {
6045		− return false
6046		− }
6047		− }
6048		−
6049		− return cmp(version, this.operator, this.semver, this.options)
6050		− }
6051		−
6052		− intersects (comp, options) {
6053		− if (!(comp instanceof Comparator)) {
6054		− throw new TypeError('a Comparator is required')
6055		− }
6056		−
6057		− if (this.operator === '') {
6058		− if (this.value === '') {
6059		− return true
6060		− }
6061		− return new Range(comp.value, options).test(this.value)
6062		− } else if (comp.operator === '') {
6063		− if (comp.value === '') {
6064		− return true
6065		− }
6066		− return new Range(this.value, options).test(comp.semver)
6067		− }
6068		−
6069		− options = parseOptions(options)
	5738	+ options = parseOptions(options)
6070	5739
6071	5740	// Special cases where nothing can possibly be lower
6072	5741	if (options.includePrerelease &&

6321	5990
6322	5991	module.exports = Range
6323	5992
6324		−const LRU = __nccwpck_require__(7129)
	5993	+const LRU = __nccwpck_require__(1196)
6325	5994	const cache = new LRU({ max: 1000 })
6326	5995
6327	5996	const parseOptions = __nccwpck_require__(785)

7581	7250	/***/ 2463:
7582	7251	/***/ ((module) => {
7583	7252
7584		−const numeric = /^[0-9]+$/
7585		−const compareIdentifiers = (a, b) => {
7586		− const anum = numeric.test(a)
7587		− const bnum = numeric.test(b)
	7253	+const numeric = /^[0-9]+$/
	7254	+const compareIdentifiers = (a, b) => {
	7255	+ const anum = numeric.test(a)
	7256	+ const bnum = numeric.test(b)
	7257	+
	7258	+ if (anum && bnum) {
	7259	+ a = +a
	7260	+ b = +b
	7261	+ }
	7262	+
	7263	+ return a === b ? 0
	7264	+ : (anum && !bnum) ? -1
	7265	+ : (bnum && !anum) ? 1
	7266	+ : a < b ? -1
	7267	+ : 1
	7268	+}
	7269	+
	7270	+const rcompareIdentifiers = (a, b) => compareIdentifiers(b, a)
	7271	+
	7272	+module.exports = {
	7273	+ compareIdentifiers,
	7274	+ rcompareIdentifiers,
	7275	+}
	7276	+
	7277	+
	7278	+/***/ }),
	7279	+
	7280	+/***/ 785:
	7281	+/***/ ((module) => {
	7282	+
	7283	+// parse out just the options we care about
	7284	+const looseOption = Object.freeze({ loose: true })
	7285	+const emptyOpts = Object.freeze({ })
	7286	+const parseOptions = options => {
	7287	+ if (!options) {
	7288	+ return emptyOpts
	7289	+ }
	7290	+
	7291	+ if (typeof options !== 'object') {
	7292	+ return looseOption
	7293	+ }
	7294	+
	7295	+ return options
	7296	+}
	7297	+module.exports = parseOptions
	7298	+
	7299	+
	7300	+/***/ }),
	7301	+
	7302	+/***/ 9523:
	7303	+/***/ ((module, exports, __nccwpck_require__) => {
	7304	+
	7305	+const {
	7306	+ MAX_SAFE_COMPONENT_LENGTH,
	7307	+ MAX_SAFE_BUILD_LENGTH,
	7308	+ MAX_LENGTH,
	7309	+} = __nccwpck_require__(2293)
	7310	+const debug = __nccwpck_require__(427)
	7311	+exports = module.exports = {}
	7312	+
	7313	+// The actual regexps go on exports.re
	7314	+const re = exports.re = []
	7315	+const safeRe = exports.safeRe = []
	7316	+const src = exports.src = []
	7317	+const t = exports.t = {}
	7318	+let R = 0
	7319	+
	7320	+const LETTERDASHNUMBER = '[a-zA-Z0-9-]'
	7321	+
	7322	+// Replace some greedy regex tokens to prevent regex dos issues. These regex are
	7323	+// used internally via the safeRe object since all inputs in this library get
	7324	+// normalized first to trim and collapse all extra whitespace. The original
	7325	+// regexes are exported for userland consumption and lower level usage. A
	7326	+// future breaking change could export the safer regex only with a note that
	7327	+// all input should have extra whitespace removed.
	7328	+const safeRegexReplacements = [
	7329	+ ['\\s', 1],
	7330	+ ['\\d', MAX_LENGTH],
	7331	+ [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH],
	7332	+]
	7333	+
	7334	+const makeSafeRegex = (value) => {
	7335	+ for (const [token, max] of safeRegexReplacements) {
	7336	+ value = value
	7337	+ .split(`${token}*`).join(`${token}{0,${max}}`)
	7338	+ .split(`${token}+`).join(`${token}{1,${max}}`)
	7339	+ }
	7340	+ return value
	7341	+}
	7342	+
	7343	+const createToken = (name, value, isGlobal) => {
	7344	+ const safe = makeSafeRegex(value)
	7345	+ const index = R++
	7346	+ debug(name, index, value)
	7347	+ t[name] = index
	7348	+ src[index] = value
	7349	+ re[index] = new RegExp(value, isGlobal ? 'g' : undefined)
	7350	+ safeRe[index] = new RegExp(safe, isGlobal ? 'g' : undefined)
	7351	+}
	7352	+
	7353	+// The following Regular Expressions can be used for tokenizing,
	7354	+// validating, and parsing SemVer version strings.
	7355	+
	7356	+// ## Numeric Identifier
	7357	+// A single `0`, or a non-zero digit followed by zero or more digits.
	7358	+
	7359	+createToken('NUMERICIDENTIFIER', '0|[1-9]\\d*')
	7360	+createToken('NUMERICIDENTIFIERLOOSE', '\\d+')
	7361	+
	7362	+// ## Non-numeric Identifier
	7363	+// Zero or more digits, followed by a letter or hyphen, and then zero or
	7364	+// more letters, digits, or hyphens.
	7365	+
	7366	+createToken('NONNUMERICIDENTIFIER', `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`)
	7367	+
	7368	+// ## Main Version
	7369	+// Three dot-separated numeric identifiers.
	7370	+
	7371	+createToken('MAINVERSION', `(${src[t.NUMERICIDENTIFIER]})\\.` +
	7372	+ `(${src[t.NUMERICIDENTIFIER]})\\.` +
	7373	+ `(${src[t.NUMERICIDENTIFIER]})`)
	7374	+
	7375	+createToken('MAINVERSIONLOOSE', `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` +
	7376	+ `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` +
	7377	+ `(${src[t.NUMERICIDENTIFIERLOOSE]})`)
	7378	+
	7379	+// ## Pre-release Version Identifier
	7380	+// A numeric identifier, or a non-numeric identifier.
	7381	+
	7382	+createToken('PRERELEASEIDENTIFIER', `(?:${src[t.NUMERICIDENTIFIER]
	7383	+}|${src[t.NONNUMERICIDENTIFIER]})`)
	7384	+
	7385	+createToken('PRERELEASEIDENTIFIERLOOSE', `(?:${src[t.NUMERICIDENTIFIERLOOSE]
	7386	+}|${src[t.NONNUMERICIDENTIFIER]})`)
	7387	+
	7388	+// ## Pre-release Version
	7389	+// Hyphen, followed by one or more dot-separated pre-release version
	7390	+// identifiers.
	7391	+
	7392	+createToken('PRERELEASE', `(?:-(${src[t.PRERELEASEIDENTIFIER]
	7393	+}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`)
	7394	+
	7395	+createToken('PRERELEASELOOSE', `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]
	7396	+}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`)
	7397	+
	7398	+// ## Build Metadata Identifier
	7399	+// Any combination of digits, letters, or hyphens.
	7400	+
	7401	+createToken('BUILDIDENTIFIER', `${LETTERDASHNUMBER}+`)
	7402	+
	7403	+// ## Build Metadata
	7404	+// Plus sign, followed by one or more period-separated build metadata
	7405	+// identifiers.
	7406	+
	7407	+createToken('BUILD', `(?:\\+(${src[t.BUILDIDENTIFIER]
	7408	+}(?:\\.${src[t.BUILDIDENTIFIER]})*))`)
	7409	+
	7410	+// ## Full Version String
	7411	+// A main version, followed optionally by a pre-release version and
	7412	+// build metadata.
	7413	+
	7414	+// Note that the only major, minor, patch, and pre-release sections of
	7415	+// the version string are capturing groups. The build metadata is not a
	7416	+// capturing group, because it should not ever be used in version
	7417	+// comparison.
	7418	+
	7419	+createToken('FULLPLAIN', `v?${src[t.MAINVERSION]
	7420	+}${src[t.PRERELEASE]}?${
	7421	+ src[t.BUILD]}?`)
	7422	+
	7423	+createToken('FULL', `^${src[t.FULLPLAIN]}$`)
	7424	+
	7425	+// like full, but allows v1.2.3 and =1.2.3, which people do sometimes.
	7426	+// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty
	7427	+// common in the npm registry.
	7428	+createToken('LOOSEPLAIN', `[v=\\s]*${src[t.MAINVERSIONLOOSE]
	7429	+}${src[t.PRERELEASELOOSE]}?${
	7430	+ src[t.BUILD]}?`)
	7431	+
	7432	+createToken('LOOSE', `^${src[t.LOOSEPLAIN]}$`)
	7433	+
	7434	+createToken('GTLT', '((?:<|>)?=?)')
	7435	+
	7436	+// Something like "2.*" or "1.2.x".
	7437	+// Note that "x.x" is a valid xRange identifer, meaning "any version"
	7438	+// Only the first item is strictly required.
	7439	+createToken('XRANGEIDENTIFIERLOOSE', `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`)
	7440	+createToken('XRANGEIDENTIFIER', `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`)
	7441	+
	7442	+createToken('XRANGEPLAIN', `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})` +
	7443	+ `(?:\\.(${src[t.XRANGEIDENTIFIER]})` +
	7444	+ `(?:\\.(${src[t.XRANGEIDENTIFIER]})` +
	7445	+ `(?:${src[t.PRERELEASE]})?${
	7446	+ src[t.BUILD]}?` +
	7447	+ `)?)?`)
	7448	+
	7449	+createToken('XRANGEPLAINLOOSE', `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})` +
	7450	+ `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` +
	7451	+ `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` +
	7452	+ `(?:${src[t.PRERELEASELOOSE]})?${
	7453	+ src[t.BUILD]}?` +
	7454	+ `)?)?`)
	7455	+
	7456	+createToken('XRANGE', `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`)
	7457	+createToken('XRANGELOOSE', `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`)
	7458	+
	7459	+// Coercion.
	7460	+// Extract anything that could conceivably be a part of a valid semver
	7461	+createToken('COERCE', `${'(^|[^\\d])' +
	7462	+ '(\\d{1,'}${MAX_SAFE_COMPONENT_LENGTH}})` +
	7463	+ `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` +
	7464	+ `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` +
	7465	+ `(?:$|[^\\d])`)
	7466	+createToken('COERCERTL', src[t.COERCE], true)
	7467	+
	7468	+// Tilde ranges.
	7469	+// Meaning is "reasonably at or greater than"
	7470	+createToken('LONETILDE', '(?:~>?)')
	7471	+
	7472	+createToken('TILDETRIM', `(\\s*)${src[t.LONETILDE]}\\s+`, true)
	7473	+exports.tildeTrimReplace = '$1~'
	7474	+
	7475	+createToken('TILDE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`)
	7476	+createToken('TILDELOOSE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`)
	7477	+
	7478	+// Caret ranges.
	7479	+// Meaning is "at least and backwards compatible with"
	7480	+createToken('LONECARET', '(?:\\^)')
	7481	+
	7482	+createToken('CARETTRIM', `(\\s*)${src[t.LONECARET]}\\s+`, true)
	7483	+exports.caretTrimReplace = '$1^'
	7484	+
	7485	+createToken('CARET', `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`)
	7486	+createToken('CARETLOOSE', `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`)
	7487	+
	7488	+// A simple gt/lt/eq thing, or just "" to indicate "any version"
	7489	+createToken('COMPARATORLOOSE', `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`)
	7490	+createToken('COMPARATOR', `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`)
7588	7491
7589		− if (anum && bnum) {
7590		− a = +a
7591		− b = +b
7592		− }
	7492	+// An expression to strip any whitespace between the gtlt and the thing
	7493	+// it modifies, so that `> 1.2.3` ==> `>1.2.3`
	7494	+createToken('COMPARATORTRIM', `(\\s*)${src[t.GTLT]
	7495	+}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true)
	7496	+exports.comparatorTrimReplace = '$1$2$3'
7593	7497
7594		− return a === b ? 0
7595		− : (anum && !bnum) ? -1
7596		− : (bnum && !anum) ? 1
7597		− : a < b ? -1
7598		− : 1
7599		−}
	7498	+// Something like `1.2.3 - 1.2.4`
	7499	+// Note that these all use the loose form, because they'll be
	7500	+// checked against either the strict or loose comparator form
	7501	+// later.
	7502	+createToken('HYPHENRANGE', `^\\s*(${src[t.XRANGEPLAIN]})` +
	7503	+ `\\s+-\\s+` +
	7504	+ `(${src[t.XRANGEPLAIN]})` +
	7505	+ `\\s*$`)
7600	7506
7601		−const rcompareIdentifiers = (a, b) => compareIdentifiers(b, a)
	7507	+createToken('HYPHENRANGELOOSE', `^\\s*(${src[t.XRANGEPLAINLOOSE]})` +
	7508	+ `\\s+-\\s+` +
	7509	+ `(${src[t.XRANGEPLAINLOOSE]})` +
	7510	+ `\\s*$`)
7602	7511
7603		−module.exports = {
7604		− compareIdentifiers,
7605		− rcompareIdentifiers,
7606		−}
	7512	+// Star ranges basically just allow anything at all.
	7513	+createToken('STAR', '(<|>)?=?\\s*\\*')
	7514	+// >=0.0.0 is like a star
	7515	+createToken('GTE0', '^\\s*>=\\s*0\\.0\\.0\\s*$')
	7516	+createToken('GTE0PRE', '^\\s*>=\\s*0\\.0\\.0-0\\s*$')
7607	7517
7608	7518
7609	7519	/***/ }),
7610	7520
7611		−/***/ 785:
7612		−/***/ ((module) => {
	7521	+/***/ 1196:
	7522	+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
7613	7523
7614		−// parse out just the options we care about
7615		−const looseOption = Object.freeze({ loose: true })
7616		−const emptyOpts = Object.freeze({ })
7617		−const parseOptions = options => {
7618		− if (!options) {
7619		− return emptyOpts
7620		− }
	7524	+"use strict";
7621	7525
7622		− if (typeof options !== 'object') {
7623		− return looseOption
7624		− }
7625	7526
7626		− return options
7627		−}
7628		−module.exports = parseOptions
	7527	+// A linked list to keep track of recently-used-ness
	7528	+const Yallist = __nccwpck_require__(665)
7629	7529
	7530	+const MAX = Symbol('max')
	7531	+const LENGTH = Symbol('length')
	7532	+const LENGTH_CALCULATOR = Symbol('lengthCalculator')
	7533	+const ALLOW_STALE = Symbol('allowStale')
	7534	+const MAX_AGE = Symbol('maxAge')
	7535	+const DISPOSE = Symbol('dispose')
	7536	+const NO_DISPOSE_ON_SET = Symbol('noDisposeOnSet')
	7537	+const LRU_LIST = Symbol('lruList')
	7538	+const CACHE = Symbol('cache')
	7539	+const UPDATE_AGE_ON_GET = Symbol('updateAgeOnGet')
7630	7540
7631		−/***/ }),
	7541	+const naiveLength = () => 1
7632	7542
7633		−/***/ 9523:
7634		−/***/ ((module, exports, __nccwpck_require__) => {
	7543	+// lruList is a yallist where the head is the youngest
	7544	+// item, and the tail is the oldest. the list contains the Hit
	7545	+// objects as the entries.
	7546	+// Each Hit object has a reference to its Yallist.Node. This
	7547	+// never changes.
	7548	+//
	7549	+// cache is a Map (or PseudoMap) that matches the keys to
	7550	+// the Yallist.Node object.
	7551	+class LRUCache {
	7552	+ constructor (options) {
	7553	+ if (typeof options === 'number')
	7554	+ options = { max: options }
7635	7555
7636		−const {
7637		− MAX_SAFE_COMPONENT_LENGTH,
7638		− MAX_SAFE_BUILD_LENGTH,
7639		− MAX_LENGTH,
7640		−} = __nccwpck_require__(2293)
7641		−const debug = __nccwpck_require__(427)
7642		−exports = module.exports = {}
	7556	+ if (!options)
	7557	+ options = {}
7643	7558
7644		−// The actual regexps go on exports.re
7645		−const re = exports.re = []
7646		−const safeRe = exports.safeRe = []
7647		−const src = exports.src = []
7648		−const t = exports.t = {}
7649		−let R = 0
	7559	+ if (options.max && (typeof options.max !== 'number' || options.max < 0))
	7560	+ throw new TypeError('max must be a non-negative number')
	7561	+ // Kind of weird to have a default max of Infinity, but oh well.
	7562	+ const max = this[MAX] = options.max || Infinity
7650	7563
7651		−const LETTERDASHNUMBER = '[a-zA-Z0-9-]'
	7564	+ const lc = options.length || naiveLength
	7565	+ this[LENGTH_CALCULATOR] = (typeof lc !== 'function') ? naiveLength : lc
	7566	+ this[ALLOW_STALE] = options.stale || false
	7567	+ if (options.maxAge && typeof options.maxAge !== 'number')
	7568	+ throw new TypeError('maxAge must be a number')
	7569	+ this[MAX_AGE] = options.maxAge || 0
	7570	+ this[DISPOSE] = options.dispose
	7571	+ this[NO_DISPOSE_ON_SET] = options.noDisposeOnSet || false
	7572	+ this[UPDATE_AGE_ON_GET] = options.updateAgeOnGet || false
	7573	+ this.reset()
	7574	+ }
7652	7575
7653		−// Replace some greedy regex tokens to prevent regex dos issues. These regex are
7654		−// used internally via the safeRe object since all inputs in this library get
7655		−// normalized first to trim and collapse all extra whitespace. The original
7656		−// regexes are exported for userland consumption and lower level usage. A
7657		−// future breaking change could export the safer regex only with a note that
7658		−// all input should have extra whitespace removed.
7659		−const safeRegexReplacements = [
7660		− ['\\s', 1],
7661		− ['\\d', MAX_LENGTH],
7662		− [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH],
7663		−]
	7576	+ // resize the cache when the max changes.
	7577	+ set max (mL) {
	7578	+ if (typeof mL !== 'number' || mL < 0)
	7579	+ throw new TypeError('max must be a non-negative number')
7664	7580
7665		−const makeSafeRegex = (value) => {
7666		− for (const [token, max] of safeRegexReplacements) {
7667		− value = value
7668		− .split(`${token}*`).join(`${token}{0,${max}}`)
7669		− .split(`${token}+`).join(`${token}{1,${max}}`)
	7581	+ this[MAX] = mL || Infinity
	7582	+ trim(this)
	7583	+ }
	7584	+ get max () {
	7585	+ return this[MAX]
7670	7586	}
7671		− return value
7672		−}
7673	7587
7674		−const createToken = (name, value, isGlobal) => {
7675		− const safe = makeSafeRegex(value)
7676		− const index = R++
7677		− debug(name, index, value)
7678		− t[name] = index
7679		− src[index] = value
7680		− re[index] = new RegExp(value, isGlobal ? 'g' : undefined)
7681		− safeRe[index] = new RegExp(safe, isGlobal ? 'g' : undefined)
7682		−}
	7588	+ set allowStale (allowStale) {
	7589	+ this[ALLOW_STALE] = !!allowStale
	7590	+ }
	7591	+ get allowStale () {
	7592	+ return this[ALLOW_STALE]
	7593	+ }
7683	7594
7684		−// The following Regular Expressions can be used for tokenizing,
7685		−// validating, and parsing SemVer version strings.
	7595	+ set maxAge (mA) {
	7596	+ if (typeof mA !== 'number')
	7597	+ throw new TypeError('maxAge must be a non-negative number')
7686	7598
7687		−// ## Numeric Identifier
7688		−// A single `0`, or a non-zero digit followed by zero or more digits.
	7599	+ this[MAX_AGE] = mA
	7600	+ trim(this)
	7601	+ }
	7602	+ get maxAge () {
	7603	+ return this[MAX_AGE]
	7604	+ }
7689	7605
7690		−createToken('NUMERICIDENTIFIER', '0|[1-9]\\d*')
7691		−createToken('NUMERICIDENTIFIERLOOSE', '\\d+')
	7606	+ // resize the cache when the lengthCalculator changes.
	7607	+ set lengthCalculator (lC) {
	7608	+ if (typeof lC !== 'function')
	7609	+ lC = naiveLength
7692	7610
7693		−// ## Non-numeric Identifier
7694		−// Zero or more digits, followed by a letter or hyphen, and then zero or
7695		−// more letters, digits, or hyphens.
	7611	+ if (lC !== this[LENGTH_CALCULATOR]) {
	7612	+ this[LENGTH_CALCULATOR] = lC
	7613	+ this[LENGTH] = 0
	7614	+ this[LRU_LIST].forEach(hit => {
	7615	+ hit.length = this[LENGTH_CALCULATOR](hit.value, hit.key)
	7616	+ this[LENGTH] += hit.length
	7617	+ })
	7618	+ }
	7619	+ trim(this)
	7620	+ }
	7621	+ get lengthCalculator () { return this[LENGTH_CALCULATOR] }
7696	7622
7697		−createToken('NONNUMERICIDENTIFIER', `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`)
	7623	+ get length () { return this[LENGTH] }
	7624	+ get itemCount () { return this[LRU_LIST].length }
7698	7625
7699		−// ## Main Version
7700		−// Three dot-separated numeric identifiers.
	7626	+ rforEach (fn, thisp) {
	7627	+ thisp = thisp || this
	7628	+ for (let walker = this[LRU_LIST].tail; walker !== null;) {
	7629	+ const prev = walker.prev
	7630	+ forEachStep(this, fn, walker, thisp)
	7631	+ walker = prev
	7632	+ }
	7633	+ }
7701	7634
7702		−createToken('MAINVERSION', `(${src[t.NUMERICIDENTIFIER]})\\.` +
7703		− `(${src[t.NUMERICIDENTIFIER]})\\.` +
7704		− `(${src[t.NUMERICIDENTIFIER]})`)
	7635	+ forEach (fn, thisp) {
	7636	+ thisp = thisp || this
	7637	+ for (let walker = this[LRU_LIST].head; walker !== null;) {
	7638	+ const next = walker.next
	7639	+ forEachStep(this, fn, walker, thisp)
	7640	+ walker = next
	7641	+ }
	7642	+ }
7705	7643
7706		−createToken('MAINVERSIONLOOSE', `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` +
7707		− `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` +
7708		− `(${src[t.NUMERICIDENTIFIERLOOSE]})`)
	7644	+ keys () {
	7645	+ return this[LRU_LIST].toArray().map(k => k.key)
	7646	+ }
7709	7647
7710		−// ## Pre-release Version Identifier
7711		−// A numeric identifier, or a non-numeric identifier.
	7648	+ values () {
	7649	+ return this[LRU_LIST].toArray().map(k => k.value)
	7650	+ }
7712	7651
7713		−createToken('PRERELEASEIDENTIFIER', `(?:${src[t.NUMERICIDENTIFIER]
7714		−}|${src[t.NONNUMERICIDENTIFIER]})`)
	7652	+ reset () {
	7653	+ if (this[DISPOSE] &&
	7654	+ this[LRU_LIST] &&
	7655	+ this[LRU_LIST].length) {
	7656	+ this[LRU_LIST].forEach(hit => this[DISPOSE](hit.key, hit.value))
	7657	+ }
7715	7658
7716		−createToken('PRERELEASEIDENTIFIERLOOSE', `(?:${src[t.NUMERICIDENTIFIERLOOSE]
7717		−}|${src[t.NONNUMERICIDENTIFIER]})`)
	7659	+ this[CACHE] = new Map() // hash of items by key
	7660	+ this[LRU_LIST] = new Yallist() // list of items in order of use recency
	7661	+ this[LENGTH] = 0 // length of items in the list
	7662	+ }
7718	7663
7719		−// ## Pre-release Version
7720		−// Hyphen, followed by one or more dot-separated pre-release version
7721		−// identifiers.
	7664	+ dump () {
	7665	+ return this[LRU_LIST].map(hit =>
	7666	+ isStale(this, hit) ? false : {
	7667	+ k: hit.key,
	7668	+ v: hit.value,
	7669	+ e: hit.now + (hit.maxAge || 0)
	7670	+ }).toArray().filter(h => h)
	7671	+ }
	7672	+
	7673	+ dumpLru () {
	7674	+ return this[LRU_LIST]
	7675	+ }
7722	7676
7723		−createToken('PRERELEASE', `(?:-(${src[t.PRERELEASEIDENTIFIER]
7724		−}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`)
	7677	+ set (key, value, maxAge) {
	7678	+ maxAge = maxAge || this[MAX_AGE]
7725	7679
7726		−createToken('PRERELEASELOOSE', `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]
7727		−}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`)
	7680	+ if (maxAge && typeof maxAge !== 'number')
	7681	+ throw new TypeError('maxAge must be a number')
7728	7682
7729		−// ## Build Metadata Identifier
7730		−// Any combination of digits, letters, or hyphens.
	7683	+ const now = maxAge ? Date.now() : 0
	7684	+ const len = this[LENGTH_CALCULATOR](value, key)
7731	7685
7732		−createToken('BUILDIDENTIFIER', `${LETTERDASHNUMBER}+`)
	7686	+ if (this[CACHE].has(key)) {
	7687	+ if (len > this[MAX]) {
	7688	+ del(this, this[CACHE].get(key))
	7689	+ return false
	7690	+ }
7733	7691
7734		−// ## Build Metadata
7735		−// Plus sign, followed by one or more period-separated build metadata
7736		−// identifiers.
	7692	+ const node = this[CACHE].get(key)
	7693	+ const item = node.value
7737	7694
7738		−createToken('BUILD', `(?:\\+(${src[t.BUILDIDENTIFIER]
7739		−}(?:\\.${src[t.BUILDIDENTIFIER]})*))`)
	7695	+ // dispose of the old one before overwriting
	7696	+ // split out into 2 ifs for better coverage tracking
	7697	+ if (this[DISPOSE]) {
	7698	+ if (!this[NO_DISPOSE_ON_SET])
	7699	+ this[DISPOSE](key, item.value)
	7700	+ }
7740	7701
7741		−// ## Full Version String
7742		−// A main version, followed optionally by a pre-release version and
7743		−// build metadata.
	7702	+ item.now = now
	7703	+ item.maxAge = maxAge
	7704	+ item.value = value
	7705	+ this[LENGTH] += len - item.length
	7706	+ item.length = len
	7707	+ this.get(key)
	7708	+ trim(this)
	7709	+ return true
	7710	+ }
7744	7711
7745		−// Note that the only major, minor, patch, and pre-release sections of
7746		−// the version string are capturing groups. The build metadata is not a
7747		−// capturing group, because it should not ever be used in version
7748		−// comparison.
	7712	+ const hit = new Entry(key, value, len, now, maxAge)
7749	7713
7750		−createToken('FULLPLAIN', `v?${src[t.MAINVERSION]
7751		−}${src[t.PRERELEASE]}?${
7752		− src[t.BUILD]}?`)
	7714	+ // oversized objects fall out of cache automatically.
	7715	+ if (hit.length > this[MAX]) {
	7716	+ if (this[DISPOSE])
	7717	+ this[DISPOSE](key, value)
7753	7718
7754		−createToken('FULL', `^${src[t.FULLPLAIN]}$`)
	7719	+ return false
	7720	+ }
7755	7721
7756		−// like full, but allows v1.2.3 and =1.2.3, which people do sometimes.
7757		−// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty
7758		−// common in the npm registry.
7759		−createToken('LOOSEPLAIN', `[v=\\s]*${src[t.MAINVERSIONLOOSE]
7760		−}${src[t.PRERELEASELOOSE]}?${
7761		− src[t.BUILD]}?`)
	7722	+ this[LENGTH] += hit.length
	7723	+ this[LRU_LIST].unshift(hit)
	7724	+ this[CACHE].set(key, this[LRU_LIST].head)
	7725	+ trim(this)
	7726	+ return true
	7727	+ }
7762	7728
7763		−createToken('LOOSE', `^${src[t.LOOSEPLAIN]}$`)
	7729	+ has (key) {
	7730	+ if (!this[CACHE].has(key)) return false
	7731	+ const hit = this[CACHE].get(key).value
	7732	+ return !isStale(this, hit)
	7733	+ }
7764	7734
7765		−createToken('GTLT', '((?:<|>)?=?)')
	7735	+ get (key) {
	7736	+ return get(this, key, true)
	7737	+ }
7766	7738
7767		−// Something like "2.*" or "1.2.x".
7768		−// Note that "x.x" is a valid xRange identifer, meaning "any version"
7769		−// Only the first item is strictly required.
7770		−createToken('XRANGEIDENTIFIERLOOSE', `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`)
7771		−createToken('XRANGEIDENTIFIER', `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`)
	7739	+ peek (key) {
	7740	+ return get(this, key, false)
	7741	+ }
7772	7742
7773		−createToken('XRANGEPLAIN', `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})` +
7774		− `(?:\\.(${src[t.XRANGEIDENTIFIER]})` +
7775		− `(?:\\.(${src[t.XRANGEIDENTIFIER]})` +
7776		− `(?:${src[t.PRERELEASE]})?${
7777		− src[t.BUILD]}?` +
7778		− `)?)?`)
	7743	+ pop () {
	7744	+ const node = this[LRU_LIST].tail
	7745	+ if (!node)
	7746	+ return null
7779	7747
7780		−createToken('XRANGEPLAINLOOSE', `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})` +
7781		− `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` +
7782		− `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` +
7783		− `(?:${src[t.PRERELEASELOOSE]})?${
7784		− src[t.BUILD]}?` +
7785		− `)?)?`)
	7748	+ del(this, node)
	7749	+ return node.value
	7750	+ }
7786	7751
7787		−createToken('XRANGE', `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`)
7788		−createToken('XRANGELOOSE', `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`)
	7752	+ del (key) {
	7753	+ del(this, this[CACHE].get(key))
	7754	+ }
7789	7755
7790		−// Coercion.
7791		−// Extract anything that could conceivably be a part of a valid semver
7792		−createToken('COERCE', `${'(^|[^\\d])' +
7793		− '(\\d{1,'}${MAX_SAFE_COMPONENT_LENGTH}})` +
7794		− `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` +
7795		− `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` +
7796		− `(?:$|[^\\d])`)
7797		−createToken('COERCERTL', src[t.COERCE], true)
	7756	+ load (arr) {
	7757	+ // reset the cache
	7758	+ this.reset()
7798	7759
7799		−// Tilde ranges.
7800		−// Meaning is "reasonably at or greater than"
7801		−createToken('LONETILDE', '(?:~>?)')
	7760	+ const now = Date.now()
	7761	+ // A previous serialized cache has the most recent items first
	7762	+ for (let l = arr.length - 1; l >= 0; l--) {
	7763	+ const hit = arr[l]
	7764	+ const expiresAt = hit.e || 0
	7765	+ if (expiresAt === 0)
	7766	+ // the item was created without expiration in a non aged cache
	7767	+ this.set(hit.k, hit.v)
	7768	+ else {
	7769	+ const maxAge = expiresAt - now
	7770	+ // dont add already expired items
	7771	+ if (maxAge > 0) {
	7772	+ this.set(hit.k, hit.v, maxAge)
	7773	+ }
	7774	+ }
	7775	+ }
	7776	+ }
7802	7777
7803		−createToken('TILDETRIM', `(\\s*)${src[t.LONETILDE]}\\s+`, true)
7804		−exports.tildeTrimReplace = '$1~'
	7778	+ prune () {
	7779	+ this[CACHE].forEach((value, key) => get(this, key, false))
	7780	+ }
	7781	+}
7805	7782
7806		−createToken('TILDE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`)
7807		−createToken('TILDELOOSE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`)
	7783	+const get = (self, key, doUse) => {
	7784	+ const node = self[CACHE].get(key)
	7785	+ if (node) {
	7786	+ const hit = node.value
	7787	+ if (isStale(self, hit)) {
	7788	+ del(self, node)
	7789	+ if (!self[ALLOW_STALE])
	7790	+ return undefined
	7791	+ } else {
	7792	+ if (doUse) {
	7793	+ if (self[UPDATE_AGE_ON_GET])
	7794	+ node.value.now = Date.now()
	7795	+ self[LRU_LIST].unshiftNode(node)
	7796	+ }
	7797	+ }
	7798	+ return hit.value
	7799	+ }
	7800	+}
7808	7801
7809		−// Caret ranges.
7810		−// Meaning is "at least and backwards compatible with"
7811		−createToken('LONECARET', '(?:\\^)')
	7802	+const isStale = (self, hit) => {
	7803	+ if (!hit || (!hit.maxAge && !self[MAX_AGE]))
	7804	+ return false
7812	7805
7813		−createToken('CARETTRIM', `(\\s*)${src[t.LONECARET]}\\s+`, true)
7814		−exports.caretTrimReplace = '$1^'
	7806	+ const diff = Date.now() - hit.now
	7807	+ return hit.maxAge ? diff > hit.maxAge
	7808	+ : self[MAX_AGE] && (diff > self[MAX_AGE])
	7809	+}
7815	7810
7816		−createToken('CARET', `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`)
7817		−createToken('CARETLOOSE', `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`)
	7811	+const trim = self => {
	7812	+ if (self[LENGTH] > self[MAX]) {
	7813	+ for (let walker = self[LRU_LIST].tail;
	7814	+ self[LENGTH] > self[MAX] && walker !== null;) {
	7815	+ // We know that we're about to delete this one, and also
	7816	+ // what the next least recently used key will be, so just
	7817	+ // go ahead and set it now.
	7818	+ const prev = walker.prev
	7819	+ del(self, walker)
	7820	+ walker = prev
	7821	+ }
	7822	+ }
	7823	+}
7818	7824
7819		−// A simple gt/lt/eq thing, or just "" to indicate "any version"
7820		−createToken('COMPARATORLOOSE', `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`)
7821		−createToken('COMPARATOR', `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`)
	7825	+const del = (self, node) => {
	7826	+ if (node) {
	7827	+ const hit = node.value
	7828	+ if (self[DISPOSE])
	7829	+ self[DISPOSE](hit.key, hit.value)
7822	7830
7823		−// An expression to strip any whitespace between the gtlt and the thing
7824		−// it modifies, so that `> 1.2.3` ==> `>1.2.3`
7825		−createToken('COMPARATORTRIM', `(\\s*)${src[t.GTLT]
7826		−}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true)
7827		−exports.comparatorTrimReplace = '$1$2$3'
	7831	+ self[LENGTH] -= hit.length
	7832	+ self[CACHE].delete(hit.key)
	7833	+ self[LRU_LIST].removeNode(node)
	7834	+ }
	7835	+}
7828	7836
7829		−// Something like `1.2.3 - 1.2.4`
7830		−// Note that these all use the loose form, because they'll be
7831		−// checked against either the strict or loose comparator form
7832		−// later.
7833		−createToken('HYPHENRANGE', `^\\s*(${src[t.XRANGEPLAIN]})` +
7834		− `\\s+-\\s+` +
7835		− `(${src[t.XRANGEPLAIN]})` +
7836		− `\\s*$`)
	7837	+class Entry {
	7838	+ constructor (key, value, length, now, maxAge) {
	7839	+ this.key = key
	7840	+ this.value = value
	7841	+ this.length = length
	7842	+ this.now = now
	7843	+ this.maxAge = maxAge || 0
	7844	+ }
	7845	+}
7837	7846
7838		−createToken('HYPHENRANGELOOSE', `^\\s*(${src[t.XRANGEPLAINLOOSE]})` +
7839		− `\\s+-\\s+` +
7840		− `(${src[t.XRANGEPLAINLOOSE]})` +
7841		− `\\s*$`)
	7847	+const forEachStep = (self, fn, node, thisp) => {
	7848	+ let hit = node.value
	7849	+ if (isStale(self, hit)) {
	7850	+ del(self, node)
	7851	+ if (!self[ALLOW_STALE])
	7852	+ hit = undefined
	7853	+ }
	7854	+ if (hit)
	7855	+ fn.call(thisp, hit.value, hit.key, self)
	7856	+}
7842	7857
7843		−// Star ranges basically just allow anything at all.
7844		−createToken('STAR', '(<|>)?=?\\s*\\*')
7845		−// >=0.0.0 is like a star
7846		−createToken('GTE0', '^\\s*>=\\s*0\\.0\\.0\\s*$')
7847		−createToken('GTE0PRE', '^\\s*>=\\s*0\\.0\\.0-0\\s*$')
	7858	+module.exports = LRUCache
7848	7859
7849	7860
7850	7861	/***/ }),

9955	9966	core.startGroup(`Installing Gleam ${gleamVersion}`)
9956	9967	await install('gleam', { toolVersion: gleamVersion })
9957	9968	core.setOutput('gleam-version', gleamVersion)
9958		− core.addPath(`${process.env.RUNNER_TEMP}/.setup-beam/gleam/bin`)
9959	9969	core.endGroup()
9960	9970
9961	9971	installed = true

9976	9986	core.startGroup(`Installing rebar3 ${rebar3Version}`)
9977	9987	await install('rebar3', { toolVersion: rebar3Version })
9978	9988	core.setOutput('rebar3-version', rebar3Version)
9979		− core.addPath(`${process.env.RUNNER_TEMP}/.setup-beam/rebar3/bin`)
9980	9989	core.endGroup()
9981	9990
9982	9991	installed = true

10774	10783	core.debug(` ... it is, at ${cachePath}`)
10775	10784	}
10776	10785
	10786	+ // This makes sure we run, e.g. in Windows, the installer in the runner
	10787	+ // We're not caching the install, just the downloaded tool
	10788	+ const runnerToolPath = path.join(
	10789	+ process.env.RUNNER_TEMP,
	10790	+ '.setup-beam',
	10791	+ toolName,
	10792	+ )
	10793	+ fs.cpSync(cachePath, runnerToolPath, { recursive: true })
	10794	+
10777	10795	core.debug('Performing post extract operations...')
10778		− await platformOpts.postExtract(cachePath)
	10796	+ await platformOpts.postExtract(runnerToolPath)
10779	10797
10780		− core.debug(`Adding ${cachePath}'s bin to system path`)
10781		− const catchPathBin = path.join(cachePath, 'bin')
10782		− core.addPath(catchPathBin)
	10798	+ core.debug(`Adding ${runnerToolPath}' bin to system path`)
	10799	+ const runnerToolPathBin = path.join(runnerToolPath, 'bin')
	10800	+ core.addPath(runnerToolPathBin)
10783	10801
10784	10802	const installDirForVarName = `INSTALL_DIR_FOR_${toolName}`.toUpperCase()
10785		− core.debug(`Exporting ${installDirForVarName} as ${catchPathBin}`)
10786		− core.exportVariable(installDirForVarName, catchPathBin)
	10803	+ core.debug(`Exporting ${installDirForVarName} as ${runnerToolPath}`)
	10804	+ core.exportVariable(installDirForVarName, runnerToolPath)
10787	10805
10788	10806	core.info(`Installed ${installOpts.tool} version`)
10789	10807	const [cmd, args] = platformOpts.reportVersion()