14	14	name: Expected local npm actions
15	15	runs-on: ubuntu-latest
16	16	steps:
17		− - uses: actions/checkout@v2
18		− - uses: actions/setup-node@v1
	17	+ - uses: actions/checkout@v3
	18	+ - uses: actions/setup-node@v3
19	19	with:
20	20	node-version: '14'
21	21	- run: npm install -g npm

34	34	name: Unit tests (Ubuntu)
35	35	runs-on: ubuntu-latest
36	36	steps:
37		− - uses: actions/checkout@v2
38		− - uses: actions/setup-node@v1
	37	+ - uses: actions/checkout@v3
	38	+ - uses: actions/setup-node@v3
39	39	with:
40	40	node-version: '14'
41	41	- run: npm ci

45	45	name: Unit tests (Windows)
46	46	runs-on: windows-latest
47	47	steps:
48		− - uses: actions/checkout@v2
49		− - uses: actions/setup-node@v1
	48	+ - uses: actions/checkout@v3
	49	+ - uses: actions/setup-node@v3
50	50	with:
51	51	node-version: '14'
52	52	- run: npm install --production

52	52	- otp-version: '24'
53	53	rebar3-version: 'nightly'
54	54	os: 'ubuntu-latest'
55		− - elixir-version: 'v1.0'
56		− otp-version: '17'
57		− os: 'ubuntu-18.04'
58		− - elixir-version: 'v1.1'
59		− otp-version: '18'
60		− os: 'ubuntu-18.04'
61		− - elixir-version: 'v1.2'
62		− otp-version: '19'
63		− rebar3-version: '3.10'
64		− os: 'ubuntu-18.04'
65	55	- elixir-version: 'v1.4'
66	56	otp-version: '20'
67	57	rebar3-version: '3.6.0'
68		− os: 'ubuntu-18.04'
	58	+ os: 'ubuntu-20.04'
69	59	- elixir-version: 'v1.4'
70	60	otp-version: '20'
71	61	rebar3-version: '3.11'

73	63	- elixir-version: 'v1.6'
74	64	otp-version: '21'
75	65	rebar3-version: '3.12'
76		− os: 'ubuntu-18.04'
	66	+ os: 'ubuntu-20.04'
77	67	- elixir-version: 'v1.6'
78	68	otp-version: '21'
79	69	rebar3-version: '3.12'

81	71	- elixir-version: 'v1.7'
82	72	otp-version: '22'
83	73	rebar3-version: '3.13'
84		− os: 'ubuntu-18.04'
	74	+ os: 'ubuntu-20.04'
85	75	- elixir-version: 'v1.7'
86	76	otp-version: '22'
87	77	rebar3-version: '3.13'

89	79	- elixir-version: 'v1.10'
90	80	otp-version: '23'
91	81	rebar3-version: '3.14'
92		− os: 'ubuntu-18.04'
	82	+ os: 'ubuntu-20.04'
93	83	- elixir-version: 'v1.13.4'
94	84	otp-version: '25.0.2'
95	85	rebar3-version: '3.19'
96		− os: 'ubuntu-18.04'
	86	+ os: 'ubuntu-20.04'
97	87	- elixir-version: 'v1.10'
98	88	otp-version: '23'
99	89	rebar3-version: '3.14'

127	117	- gleam-version: 'nightly'
128	118	otp-version: '24'
129	119	os: 'ubuntu-latest'
	120	+ disable_problem_matchers: true
130	121	- gleam-version: '0.23'
131	122	otp-version: '24'
132	123	os: 'ubuntu-latest'
	124	+ disable_problem_matchers: true
133	125	- gleam-version: '0.23.0-rc1'
134	126	otp-version: '24'
135	127	os: 'ubuntu-latest'
	128	+ disable_problem_matchers: true
136	129	- gleam-version: '0.23.0-rc1'
137	130	otp-version: false
138	131	os: 'ubuntu-latest'
	132	+ disable_problem_matchers: true
139	133	- gleam-version: '0.22.0' # Version with Gleam's old archive naming convention
140	134	otp-version: '24'
141	135	os: 'ubuntu-latest'
	136	+ disable_problem_matchers: true
142	137	steps:
143		− - uses: actions/checkout@v2
	138	+ - uses: actions/checkout@v3
144	139	- name: Use erlef/setup-beam
145	140	id: setup-beam
146	141	uses: ./

202	197	rebar3-version: 'nightly'
203	198	os: 'ubuntu-latest'
204	199	steps:
205		− - uses: actions/checkout@v2
	200	+ - uses: actions/checkout@v3
206	201	- name: Use erlef/setup-beam
207	202	id: setup-beam
208	203	uses: ./

11	11	name: Update 3rd party licenses
12	12	runs-on: ubuntu-latest
13	13	steps:
14		− - uses: actions/checkout@v2
15		− - uses: actions/setup-node@v1
	14	+ - uses: actions/checkout@v3
	15	+ - uses: actions/setup-node@v3
16	16	with:
17	17	node-version: '14'
18	18	- run:

37	37	otp-version: '23'
38	38	rebar3-version: '3.14'
39	39	os: 'windows-latest'
40		− - elixir-version: 'v1.11'
	40	+ - elixir-version: 'v1.13'
41	41	otp-version: '24'
42	42	rebar3-version: '3.15'
43	43	os: 'windows-latest'

46	46	rebar3-version: '3.16'
47	47	os: 'windows-latest'
48	48	steps:
49		− - uses: actions/checkout@v2
	49	+ - uses: actions/checkout@v3
50	50	- name: Use erlef/setup-beam
51	51	id: setup-beam
52	52	uses: ./

95	95	rebar3-version: 'nightly'
96	96	os: 'windows-latest'
97	97	steps:
98		− - uses: actions/checkout@v2
	98	+ - uses: actions/checkout@v3
99	99	- name: Use erlef/setup-beam
100	100	id: setup-beam
101	101	uses: ./

140	140	const utils_1 = __nccwpck_require__(5278);
141	141	const os = __importStar(__nccwpck_require__(2037));
142	142	const path = __importStar(__nccwpck_require__(1017));
143		−const uuid_1 = __nccwpck_require__(5840);
144	143	const oidc_utils_1 = __nccwpck_require__(8041);
145	144	/**
146	145	* The code to exit an action

170	169	process.env[name] = convertedVal;
171	170	const filePath = process.env['GITHUB_ENV'] || '';
172	171	if (filePath) {
173		− const delimiter = `ghadelimiter_${uuid_1.v4()}`;
174		− // These should realistically never happen, but just in case someone finds a way to exploit uuid generation let's not allow keys or values that contain the delimiter.
175		− if (name.includes(delimiter)) {
176		− throw new Error(`Unexpected input: name should not contain the delimiter "${delimiter}"`);
177		− }
178		− if (convertedVal.includes(delimiter)) {
179		− throw new Error(`Unexpected input: value should not contain the delimiter "${delimiter}"`);
180		− }
181		− const commandValue = `${name}<<${delimiter}${os.EOL}${convertedVal}${os.EOL}${delimiter}`;
182		− file_command_1.issueCommand('ENV', commandValue);
183		− }
184		− else {
185		− command_1.issueCommand('set-env', { name }, convertedVal);
	172	+ return file_command_1.issueFileCommand('ENV', file_command_1.prepareKeyValueMessage(name, val));
186	173	}
	174	+ command_1.issueCommand('set-env', { name }, convertedVal);
187	175	}
188	176	exports.exportVariable = exportVariable;
189	177	/**

201	189	function addPath(inputPath) {
202	190	const filePath = process.env['GITHUB_PATH'] || '';
203	191	if (filePath) {
204		− file_command_1.issueCommand('PATH', inputPath);
	192	+ file_command_1.issueFileCommand('PATH', inputPath);
205	193	}
206	194	else {
207	195	command_1.issueCommand('add-path', {}, inputPath);

241	229	const inputs = getInput(name, options)
242	230	.split('\n')
243	231	.filter(x => x !== '');
244		− return inputs;
	232	+ if (options && options.trimWhitespace === false) {
	233	+ return inputs;
	234	+ }
	235	+ return inputs.map(input => input.trim());
245	236	}
246	237	exports.getMultilineInput = getMultilineInput;
247	238	/**

274	265	*/
275	266	// eslint-disable-next-line @typescript-eslint/no-explicit-any
276	267	function setOutput(name, value) {
	268	+ const filePath = process.env['GITHUB_OUTPUT'] || '';
	269	+ if (filePath) {
	270	+ return file_command_1.issueFileCommand('OUTPUT', file_command_1.prepareKeyValueMessage(name, value));
	271	+ }
277	272	process.stdout.write(os.EOL);
278		− command_1.issueCommand('set-output', { name }, value);
	273	+ command_1.issueCommand('set-output', { name }, utils_1.toCommandValue(value));
279	274	}
280	275	exports.setOutput = setOutput;
281	276	/**

404	399	*/
405	400	// eslint-disable-next-line @typescript-eslint/no-explicit-any
406	401	function saveState(name, value) {
407		− command_1.issueCommand('save-state', { name }, value);
	402	+ const filePath = process.env['GITHUB_STATE'] || '';
	403	+ if (filePath) {
	404	+ return file_command_1.issueFileCommand('STATE', file_command_1.prepareKeyValueMessage(name, value));
	405	+ }
	406	+ command_1.issueCommand('save-state', { name }, utils_1.toCommandValue(value));
408	407	}
409	408	exports.saveState = saveState;
410	409	/**

470	469	return result;
471	470	};
472	471	Object.defineProperty(exports, "__esModule", ({ value: true }));
473		−exports.issueCommand = void 0;
	472	+exports.prepareKeyValueMessage = exports.issueFileCommand = void 0;
474	473	// We use any as a valid input type
475	474	/* eslint-disable @typescript-eslint/no-explicit-any */
476	475	const fs = __importStar(__nccwpck_require__(7147));
477	476	const os = __importStar(__nccwpck_require__(2037));
	477	+const uuid_1 = __nccwpck_require__(5840);
478	478	const utils_1 = __nccwpck_require__(5278);
479		−function issueCommand(command, message) {
	479	+function issueFileCommand(command, message) {
480	480	const filePath = process.env[`GITHUB_${command}`];
481	481	if (!filePath) {
482	482	throw new Error(`Unable to find environment variable for file command ${command}`);

488	488	encoding: 'utf8'
489	489	});
490	490	}
491		−exports.issueCommand = issueCommand;
	491	+exports.issueFileCommand = issueFileCommand;
	492	+function prepareKeyValueMessage(key, value) {
	493	+ const delimiter = `ghadelimiter_${uuid_1.v4()}`;
	494	+ const convertedValue = utils_1.toCommandValue(value);
	495	+ // These should realistically never happen, but just in case someone finds a
	496	+ // way to exploit uuid generation let's not allow keys or values that contain
	497	+ // the delimiter.
	498	+ if (key.includes(delimiter)) {
	499	+ throw new Error(`Unexpected input: name should not contain the delimiter "${delimiter}"`);
	500	+ }
	501	+ if (convertedValue.includes(delimiter)) {
	502	+ throw new Error(`Unexpected input: value should not contain the delimiter "${delimiter}"`);
	503	+ }
	504	+ return `${key}<<${delimiter}${os.EOL}${convertedValue}${os.EOL}${delimiter}`;
	505	+}
	506	+exports.prepareKeyValueMessage = prepareKeyValueMessage;
492	507	//# sourceMappingURL=file-command.js.map
493	508
494	509	/***/ }),

3015	3030	/***/ }),
3016	3031
3017	3032	/***/ 7129:
3018		−/***/ ((module) => {
	3033	+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
3019	3034
3020		−const perf = typeof performance === 'object' && performance &&
3021		− typeof performance.now === 'function' ? performance : Date
	3035	+"use strict";
3022	3036
3023		−const hasAbortController = typeof AbortController !== 'undefined'
3024	3037
3025		−// minimal backwards-compatibility polyfill
3026		−const AC = hasAbortController ? AbortController : Object.assign(
3027		− class AbortController {
3028		− constructor () { this.signal = new AC.AbortSignal }
3029		− abort () { this.signal.aborted = true }
3030		− },
3031		− { AbortSignal: class AbortSignal { constructor () { this.aborted = false }}}
3032		−)
	3038	+// A linked list to keep track of recently-used-ness
	3039	+const Yallist = __nccwpck_require__(665)
3033	3040
3034		−const warned = new Set()
3035		−const deprecatedOption = (opt, instead) => {
3036		− const code = `LRU_CACHE_OPTION_${opt}`
3037		− if (shouldWarn(code)) {
3038		− warn(code, `${opt} option`, `options.${instead}`, LRUCache)
3039		− }
3040		−}
3041		−const deprecatedMethod = (method, instead) => {
3042		− const code = `LRU_CACHE_METHOD_${method}`
3043		− if (shouldWarn(code)) {
3044		− const { prototype } = LRUCache
3045		− const { get } = Object.getOwnPropertyDescriptor(prototype, method)
3046		− warn(code, `${method} method`, `cache.${instead}()`, get)
3047		− }
3048		−}
3049		−const deprecatedProperty = (field, instead) => {
3050		− const code = `LRU_CACHE_PROPERTY_${field}`
3051		− if (shouldWarn(code)) {
3052		− const { prototype } = LRUCache
3053		− const { get } = Object.getOwnPropertyDescriptor(prototype, field)
3054		− warn(code, `${field} property`, `cache.${instead}`, get)
3055		− }
3056		−}
	3041	+const MAX = Symbol('max')
	3042	+const LENGTH = Symbol('length')
	3043	+const LENGTH_CALCULATOR = Symbol('lengthCalculator')
	3044	+const ALLOW_STALE = Symbol('allowStale')
	3045	+const MAX_AGE = Symbol('maxAge')
	3046	+const DISPOSE = Symbol('dispose')
	3047	+const NO_DISPOSE_ON_SET = Symbol('noDisposeOnSet')
	3048	+const LRU_LIST = Symbol('lruList')
	3049	+const CACHE = Symbol('cache')
	3050	+const UPDATE_AGE_ON_GET = Symbol('updateAgeOnGet')
3057	3051
3058		−const emitWarning = (...a) => {
3059		− typeof process === 'object' &&
3060		− process &&
3061		− typeof process.emitWarning === 'function'
3062		− ? process.emitWarning(...a)
3063		− : console.error(...a)
3064		−}
3065		−
3066		−const shouldWarn = code => !warned.has(code)
	3052	+const naiveLength = () => 1
3067	3053
3068		−const warn = (code, what, instead, fn) => {
3069		− warned.add(code)
3070		− const msg = `The ${what} is deprecated. Please use ${instead} instead.`
3071		− emitWarning(msg, 'DeprecationWarning', code, fn)
3072		−}
	3054	+// lruList is a yallist where the head is the youngest
	3055	+// item, and the tail is the oldest. the list contains the Hit
	3056	+// objects as the entries.
	3057	+// Each Hit object has a reference to its Yallist.Node. This
	3058	+// never changes.
	3059	+//
	3060	+// cache is a Map (or PseudoMap) that matches the keys to
	3061	+// the Yallist.Node object.
	3062	+class LRUCache {
	3063	+ constructor (options) {
	3064	+ if (typeof options === 'number')
	3065	+ options = { max: options }
3073	3066
3074		−const isPosInt = n => n && n === Math.floor(n) && n > 0 && isFinite(n)
	3067	+ if (!options)
	3068	+ options = {}
3075	3069
3076		−/* istanbul ignore next - This is a little bit ridiculous, tbh.
3077		− * The maximum array length is 2^32-1 or thereabouts on most JS impls.
3078		− * And well before that point, you're caching the entire world, I mean,
3079		− * that's ~32GB of just integers for the next/prev links, plus whatever
3080		− * else to hold that many keys and values. Just filling the memory with
3081		− * zeroes at init time is brutal when you get that big.
3082		− * But why not be complete?
3083		− * Maybe in the future, these limits will have expanded. */
3084		−const getUintArray = max => !isPosInt(max) ? null
3085		−: max <= Math.pow(2, 8) ? Uint8Array
3086		−: max <= Math.pow(2, 16) ? Uint16Array
3087		−: max <= Math.pow(2, 32) ? Uint32Array
3088		−: max <= Number.MAX_SAFE_INTEGER ? ZeroArray
3089		−: null
	3070	+ if (options.max && (typeof options.max !== 'number' || options.max < 0))
	3071	+ throw new TypeError('max must be a non-negative number')
	3072	+ // Kind of weird to have a default max of Infinity, but oh well.
	3073	+ const max = this[MAX] = options.max || Infinity
3090	3074
3091		−class ZeroArray extends Array {
3092		− constructor (size) {
3093		− super(size)
3094		− this.fill(0)
	3075	+ const lc = options.length || naiveLength
	3076	+ this[LENGTH_CALCULATOR] = (typeof lc !== 'function') ? naiveLength : lc
	3077	+ this[ALLOW_STALE] = options.stale || false
	3078	+ if (options.maxAge && typeof options.maxAge !== 'number')
	3079	+ throw new TypeError('maxAge must be a number')
	3080	+ this[MAX_AGE] = options.maxAge || 0
	3081	+ this[DISPOSE] = options.dispose
	3082	+ this[NO_DISPOSE_ON_SET] = options.noDisposeOnSet || false
	3083	+ this[UPDATE_AGE_ON_GET] = options.updateAgeOnGet || false
	3084	+ this.reset()
3095	3085	}
3096		−}
3097	3086
3098		−class Stack {
3099		− constructor (max) {
3100		− if (max === 0) {
3101		− return []
3102		− }
3103		− const UintArray = getUintArray(max)
3104		− this.heap = new UintArray(max)
3105		− this.length = 0
3106		− }
3107		− push (n) {
3108		− this.heap[this.length++] = n
	3087	+ // resize the cache when the max changes.
	3088	+ set max (mL) {
	3089	+ if (typeof mL !== 'number' || mL < 0)
	3090	+ throw new TypeError('max must be a non-negative number')
	3091	+
	3092	+ this[MAX] = mL || Infinity
	3093	+ trim(this)
3109	3094	}
3110		− pop () {
3111		− return this.heap[--this.length]
	3095	+ get max () {
	3096	+ return this[MAX]
3112	3097	}
3113		−}
3114		−
3115		−class LRUCache {
3116		− constructor (options = {}) {
3117		− const {
3118		− max = 0,
3119		− ttl,
3120		− ttlResolution = 1,
3121		− ttlAutopurge,
3122		− updateAgeOnGet,
3123		− updateAgeOnHas,
3124		− allowStale,
3125		− dispose,
3126		− disposeAfter,
3127		− noDisposeOnSet,
3128		− noUpdateTTL,
3129		− maxSize = 0,
3130		− sizeCalculation,
3131		− fetchMethod,
3132		− } = options
3133		−
3134		− // deprecated options, don't trigger a warning for getting them if
3135		− // the thing being passed in is another LRUCache we're copying.
3136		− const {
3137		− length,
3138		− maxAge,
3139		− stale,
3140		− } = options instanceof LRUCache ? {} : options
3141		−
3142		− if (max !== 0 && !isPosInt(max)) {
3143		− throw new TypeError('max option must be a nonnegative integer')
3144		− }
3145		−
3146		− const UintArray = max ? getUintArray(max) : Array
3147		− if (!UintArray) {
3148		− throw new Error('invalid max value: ' + max)
3149		− }
3150		−
3151		− this.max = max
3152		− this.maxSize = maxSize
3153		− this.sizeCalculation = sizeCalculation || length
3154		− if (this.sizeCalculation) {
3155		− if (!this.maxSize) {
3156		− throw new TypeError('cannot set sizeCalculation without setting maxSize')
3157		− }
3158		− if (typeof this.sizeCalculation !== 'function') {
3159		− throw new TypeError('sizeCalculation set to non-function')
3160		− }
3161		− }
3162		−
3163		− this.fetchMethod = fetchMethod || null
3164		− if (this.fetchMethod && typeof this.fetchMethod !== 'function') {
3165		− throw new TypeError('fetchMethod must be a function if specified')
3166		− }
3167		−
3168		− this.keyMap = new Map()
3169		− this.keyList = new Array(max).fill(null)
3170		− this.valList = new Array(max).fill(null)
3171		− this.next = new UintArray(max)
3172		− this.prev = new UintArray(max)
3173		− this.head = 0
3174		− this.tail = 0
3175		− this.free = new Stack(max)
3176		− this.initialFill = 1
3177		− this.size = 0
3178		−
3179		− if (typeof dispose === 'function') {
3180		− this.dispose = dispose
3181		− }
3182		− if (typeof disposeAfter === 'function') {
3183		− this.disposeAfter = disposeAfter
3184		− this.disposed = []
3185		− } else {
3186		− this.disposeAfter = null
3187		− this.disposed = null
3188		− }
3189		− this.noDisposeOnSet = !!noDisposeOnSet
3190		− this.noUpdateTTL = !!noUpdateTTL
3191		−
3192		− if (this.maxSize !== 0) {
3193		− if (!isPosInt(this.maxSize)) {
3194		− throw new TypeError('maxSize must be a positive integer if specified')
3195		− }
3196		− this.initializeSizeTracking()
3197		− }
3198		−
3199		− this.allowStale = !!allowStale || !!stale
3200		− this.updateAgeOnGet = !!updateAgeOnGet
3201		− this.updateAgeOnHas = !!updateAgeOnHas
3202		− this.ttlResolution = isPosInt(ttlResolution) || ttlResolution === 0
3203		− ? ttlResolution : 1
3204		− this.ttlAutopurge = !!ttlAutopurge
3205		− this.ttl = ttl || maxAge || 0
3206		− if (this.ttl) {
3207		− if (!isPosInt(this.ttl)) {
3208		− throw new TypeError('ttl must be a positive integer if specified')
3209		− }
3210		− this.initializeTTLTracking()
3211		− }
3212	3098
3213		− // do not allow completely unbounded caches
3214		− if (this.max === 0 && this.ttl === 0 && this.maxSize === 0) {
3215		− throw new TypeError('At least one of max, maxSize, or ttl is required')
3216		− }
3217		− if (!this.ttlAutopurge && !this.max && !this.maxSize) {
3218		− const code = 'LRU_CACHE_UNBOUNDED'
3219		− if (shouldWarn(code)) {
3220		− warned.add(code)
3221		− const msg = 'TTL caching without ttlAutopurge, max, or maxSize can ' +
3222		− 'result in unbounded memory consumption.'
3223		− emitWarning(msg, 'UnboundedCacheWarning', code, LRUCache)
3224		− }
3225		− }
3226		−
3227		− if (stale) {
3228		− deprecatedOption('stale', 'allowStale')
3229		− }
3230		− if (maxAge) {
3231		− deprecatedOption('maxAge', 'ttl')
3232		− }
3233		− if (length) {
3234		− deprecatedOption('length', 'sizeCalculation')
3235		− }
	3099	+ set allowStale (allowStale) {
	3100	+ this[ALLOW_STALE] = !!allowStale
3236	3101	}
3237		−
3238		− getRemainingTTL (key) {
3239		− return this.has(key, { updateAgeOnHas: false }) ? Infinity : 0
	3102	+ get allowStale () {
	3103	+ return this[ALLOW_STALE]
3240	3104	}
3241	3105
3242		− initializeTTLTracking () {
3243		− this.ttls = new ZeroArray(this.max)
3244		− this.starts = new ZeroArray(this.max)
3245		−
3246		− this.setItemTTL = (index, ttl) => {
3247		− this.starts[index] = ttl !== 0 ? perf.now() : 0
3248		− this.ttls[index] = ttl
3249		− if (ttl !== 0 && this.ttlAutopurge) {
3250		− const t = setTimeout(() => {
3251		− if (this.isStale(index)) {
3252		− this.delete(this.keyList[index])
3253		− }
3254		− }, ttl + 1)
3255		− /* istanbul ignore else - unref() not supported on all platforms */
3256		− if (t.unref) {
3257		− t.unref()
3258		− }
3259		− }
3260		− }
3261		−
3262		− this.updateItemAge = (index) => {
3263		− this.starts[index] = this.ttls[index] !== 0 ? perf.now() : 0
3264		− }
	3106	+ set maxAge (mA) {
	3107	+ if (typeof mA !== 'number')
	3108	+ throw new TypeError('maxAge must be a non-negative number')
3265	3109
3266		− // debounce calls to perf.now() to 1s so we're not hitting
3267		− // that costly call repeatedly.
3268		− let cachedNow = 0
3269		− const getNow = () => {
3270		− const n = perf.now()
3271		− if (this.ttlResolution > 0) {
3272		− cachedNow = n
3273		− const t = setTimeout(() => cachedNow = 0, this.ttlResolution)
3274		− /* istanbul ignore else - not available on all platforms */
3275		− if (t.unref) {
3276		− t.unref()
3277		− }
3278		− }
3279		− return n
3280		− }
	3110	+ this[MAX_AGE] = mA
	3111	+ trim(this)
	3112	+ }
	3113	+ get maxAge () {
	3114	+ return this[MAX_AGE]
	3115	+ }
3281	3116
3282		− this.getRemainingTTL = (key) => {
3283		− const index = this.keyMap.get(key)
3284		− if (index === undefined) {
3285		− return 0
3286		− }
3287		− return this.ttls[index] === 0 || this.starts[index] === 0 ? Infinity
3288		− : ((this.starts[index] + this.ttls[index]) - (cachedNow || getNow()))
3289		− }
	3117	+ // resize the cache when the lengthCalculator changes.
	3118	+ set lengthCalculator (lC) {
	3119	+ if (typeof lC !== 'function')
	3120	+ lC = naiveLength
3290	3121
3291		− this.isStale = (index) => {
3292		− return this.ttls[index] !== 0 && this.starts[index] !== 0 &&
3293		− ((cachedNow || getNow()) - this.starts[index] > this.ttls[index])
	3122	+ if (lC !== this[LENGTH_CALCULATOR]) {
	3123	+ this[LENGTH_CALCULATOR] = lC
	3124	+ this[LENGTH] = 0
	3125	+ this[LRU_LIST].forEach(hit => {
	3126	+ hit.length = this[LENGTH_CALCULATOR](hit.value, hit.key)
	3127	+ this[LENGTH] += hit.length
	3128	+ })
3294	3129	}
	3130	+ trim(this)
3295	3131	}
3296		− updateItemAge (index) {}
3297		− setItemTTL (index, ttl) {}
3298		− isStale (index) { return false }
	3132	+ get lengthCalculator () { return this[LENGTH_CALCULATOR] }
3299	3133
3300		− initializeSizeTracking () {
3301		− this.calculatedSize = 0
3302		− this.sizes = new ZeroArray(this.max)
3303		− this.removeItemSize = index => this.calculatedSize -= this.sizes[index]
3304		− this.requireSize = (k, v, size, sizeCalculation) => {
3305		− if (!isPosInt(size)) {
3306		− if (sizeCalculation) {
3307		− if (typeof sizeCalculation !== 'function') {
3308		− throw new TypeError('sizeCalculation must be a function')
3309		− }
3310		− size = sizeCalculation(v, k)
3311		− if (!isPosInt(size)) {
3312		− throw new TypeError('sizeCalculation return invalid (expect positive integer)')
3313		− }
3314		− } else {
3315		− throw new TypeError('invalid size value (must be positive integer)')
3316		− }
3317		− }
3318		− return size
3319		− }
3320		− this.addItemSize = (index, v, k, size) => {
3321		− this.sizes[index] = size
3322		− const maxSize = this.maxSize - this.sizes[index]
3323		− while (this.calculatedSize > maxSize) {
3324		− this.evict(true)
3325		− }
3326		− this.calculatedSize += this.sizes[index]
3327		− }
3328		− this.delete = k => {
3329		− if (this.size !== 0) {
3330		− const index = this.keyMap.get(k)
3331		− if (index !== undefined) {
3332		− this.calculatedSize -= this.sizes[index]
3333		− }
3334		− }
3335		− return LRUCache.prototype.delete.call(this, k)
3336		− }
3337		− }
3338		− removeItemSize (index) {}
3339		− addItemSize (index, v, k, size) {}
3340		− requireSize (k, v, size, sizeCalculation) {
3341		− if (size || sizeCalculation) {
3342		− throw new TypeError('cannot set size without setting maxSize on cache')
3343		− }
3344		− }
	3134	+ get length () { return this[LENGTH] }
	3135	+ get itemCount () { return this[LRU_LIST].length }
3345	3136
3346		− *indexes ({ allowStale = this.allowStale } = {}) {
3347		− if (this.size) {
3348		− for (let i = this.tail; true; ) {
3349		− if (!this.isValidIndex(i)) {
3350		− break
3351		− }
3352		− if (allowStale || !this.isStale(i)) {
3353		− yield i
3354		− }
3355		− if (i === this.head) {
3356		− break
3357		− } else {
3358		− i = this.prev[i]
3359		− }
3360		− }
	3137	+ rforEach (fn, thisp) {
	3138	+ thisp = thisp || this
	3139	+ for (let walker = this[LRU_LIST].tail; walker !== null;) {
	3140	+ const prev = walker.prev
	3141	+ forEachStep(this, fn, walker, thisp)
	3142	+ walker = prev
3361	3143	}
3362	3144	}
3363	3145
3364		− *rindexes ({ allowStale = this.allowStale } = {}) {
3365		− if (this.size) {
3366		− for (let i = this.head; true; ) {
3367		− if (!this.isValidIndex(i)) {
3368		− break
3369		− }
3370		− if (allowStale || !this.isStale(i)) {
3371		− yield i
3372		− }
3373		− if (i === this.tail) {
3374		− break
3375		− } else {
3376		− i = this.next[i]
3377		− }
3378		− }
	3146	+ forEach (fn, thisp) {
	3147	+ thisp = thisp || this
	3148	+ for (let walker = this[LRU_LIST].head; walker !== null;) {
	3149	+ const next = walker.next
	3150	+ forEachStep(this, fn, walker, thisp)
	3151	+ walker = next
3379	3152	}
3380	3153	}
3381	3154
3382		− isValidIndex (index) {
3383		− return this.keyMap.get(this.keyList[index]) === index
	3155	+ keys () {
	3156	+ return this[LRU_LIST].toArray().map(k => k.key)
3384	3157	}
3385	3158
3386		− *entries () {
3387		− for (const i of this.indexes()) {
3388		− yield [this.keyList[i], this.valList[i]]
3389		− }
3390		− }
3391		− *rentries () {
3392		− for (const i of this.rindexes()) {
3393		− yield [this.keyList[i], this.valList[i]]
3394		− }
	3159	+ values () {
	3160	+ return this[LRU_LIST].toArray().map(k => k.value)
3395	3161	}
3396	3162
3397		− *keys () {
3398		− for (const i of this.indexes()) {
3399		− yield this.keyList[i]
	3163	+ reset () {
	3164	+ if (this[DISPOSE] &&
	3165	+ this[LRU_LIST] &&
	3166	+ this[LRU_LIST].length) {
	3167	+ this[LRU_LIST].forEach(hit => this[DISPOSE](hit.key, hit.value))
3400	3168	}
3401		− }
3402		− *rkeys () {
3403		− for (const i of this.rindexes()) {
3404		− yield this.keyList[i]
3405		− }
3406		− }
3407	3169
3408		− *values () {
3409		− for (const i of this.indexes()) {
3410		− yield this.valList[i]
3411		− }
3412		− }
3413		− *rvalues () {
3414		− for (const i of this.rindexes()) {
3415		− yield this.valList[i]
3416		− }
	3170	+ this[CACHE] = new Map() // hash of items by key
	3171	+ this[LRU_LIST] = new Yallist() // list of items in order of use recency
	3172	+ this[LENGTH] = 0 // length of items in the list
3417	3173	}
3418	3174
3419		− [Symbol.iterator] () {
3420		− return this.entries()
	3175	+ dump () {
	3176	+ return this[LRU_LIST].map(hit =>
	3177	+ isStale(this, hit) ? false : {
	3178	+ k: hit.key,
	3179	+ v: hit.value,
	3180	+ e: hit.now + (hit.maxAge || 0)
	3181	+ }).toArray().filter(h => h)
3421	3182	}
3422	3183
3423		− find (fn, getOptions = {}) {
3424		− for (const i of this.indexes()) {
3425		− if (fn(this.valList[i], this.keyList[i], this)) {
3426		− return this.get(this.keyList[i], getOptions)
3427		− }
3428		− }
	3184	+ dumpLru () {
	3185	+ return this[LRU_LIST]
3429	3186	}
3430	3187
3431		− forEach (fn, thisp = this) {
3432		− for (const i of this.indexes()) {
3433		− fn.call(thisp, this.valList[i], this.keyList[i], this)
3434		− }
3435		− }
	3188	+ set (key, value, maxAge) {
	3189	+ maxAge = maxAge || this[MAX_AGE]
3436	3190
3437		− rforEach (fn, thisp = this) {
3438		− for (const i of this.rindexes()) {
3439		− fn.call(thisp, this.valList[i], this.keyList[i], this)
3440		− }
3441		− }
	3191	+ if (maxAge && typeof maxAge !== 'number')
	3192	+ throw new TypeError('maxAge must be a number')
3442	3193
3443		− get prune () {
3444		− deprecatedMethod('prune', 'purgeStale')
3445		− return this.purgeStale
3446		− }
	3194	+ const now = maxAge ? Date.now() : 0
	3195	+ const len = this[LENGTH_CALCULATOR](value, key)
3447	3196
3448		− purgeStale () {
3449		− let deleted = false
3450		− for (const i of this.rindexes({ allowStale: true })) {
3451		− if (this.isStale(i)) {
3452		− this.delete(this.keyList[i])
3453		− deleted = true
	3197	+ if (this[CACHE].has(key)) {
	3198	+ if (len > this[MAX]) {
	3199	+ del(this, this[CACHE].get(key))
	3200	+ return false
3454	3201	}
3455		− }
3456		− return deleted
3457		− }
3458	3202
3459		− dump () {
3460		− const arr = []
3461		− for (const i of this.indexes()) {
3462		− const key = this.keyList[i]
3463		− const value = this.valList[i]
3464		− const entry = { value }
3465		− if (this.ttls) {
3466		− entry.ttl = this.ttls[i]
3467		− }
3468		− if (this.sizes) {
3469		− entry.size = this.sizes[i]
3470		− }
3471		− arr.unshift([key, entry])
3472		− }
3473		− return arr
3474		− }
	3203	+ const node = this[CACHE].get(key)
	3204	+ const item = node.value
3475	3205
3476		− load (arr) {
3477		− this.clear()
3478		− for (const [key, entry] of arr) {
3479		− this.set(key, entry.value, entry)
3480		− }
3481		− }
3482		−
3483		− dispose (v, k, reason) {}
3484		−
3485		− set (k, v, {
3486		− ttl = this.ttl,
3487		− noDisposeOnSet = this.noDisposeOnSet,
3488		− size = 0,
3489		− sizeCalculation = this.sizeCalculation,
3490		− noUpdateTTL = this.noUpdateTTL,
3491		− } = {}) {
3492		− size = this.requireSize(k, v, size, sizeCalculation)
3493		− let index = this.size === 0 ? undefined : this.keyMap.get(k)
3494		− if (index === undefined) {
3495		− // addition
3496		− index = this.newIndex()
3497		− this.keyList[index] = k
3498		− this.valList[index] = v
3499		− this.keyMap.set(k, index)
3500		− this.next[this.tail] = index
3501		− this.prev[index] = this.tail
3502		− this.tail = index
3503		− this.size ++
3504		− this.addItemSize(index, v, k, size)
3505		− noUpdateTTL = false
3506		− } else {
3507		− // update
3508		− const oldVal = this.valList[index]
3509		− if (v !== oldVal) {
3510		− if (this.isBackgroundFetch(oldVal)) {
3511		− oldVal.__abortController.abort()
3512		− } else {
3513		− if (!noDisposeOnSet) {
3514		− this.dispose(oldVal, k, 'set')
3515		− if (this.disposeAfter) {
3516		− this.disposed.push([oldVal, k, 'set'])
3517		− }
3518		− }
3519		− }
3520		− this.removeItemSize(index)
3521		− this.valList[index] = v
3522		− this.addItemSize(index, v, k, size)
3523		− }
3524		− this.moveToTail(index)
3525		− }
3526		− if (ttl !== 0 && this.ttl === 0 && !this.ttls) {
3527		− this.initializeTTLTracking()
3528		− }
3529		− if (!noUpdateTTL) {
3530		− this.setItemTTL(index, ttl)
3531		− }
3532		− if (this.disposeAfter) {
3533		− while (this.disposed.length) {
3534		− this.disposeAfter(...this.disposed.shift())
	3206	+ // dispose of the old one before overwriting
	3207	+ // split out into 2 ifs for better coverage tracking
	3208	+ if (this[DISPOSE]) {
	3209	+ if (!this[NO_DISPOSE_ON_SET])
	3210	+ this[DISPOSE](key, item.value)
3535	3211	}
3536		− }
3537		− return this
3538		− }
3539	3212
3540		− newIndex () {
3541		− if (this.size === 0) {
3542		− return this.tail
3543		− }
3544		− if (this.size === this.max && this.max !== 0) {
3545		− return this.evict(false)
3546		− }
3547		− if (this.free.length !== 0) {
3548		− return this.free.pop()
	3213	+ item.now = now
	3214	+ item.maxAge = maxAge
	3215	+ item.value = value
	3216	+ this[LENGTH] += len - item.length
	3217	+ item.length = len
	3218	+ this.get(key)
	3219	+ trim(this)
	3220	+ return true
3549	3221	}
3550		− // initial fill, just keep writing down the list
3551		− return this.initialFill++
3552		− }
3553	3222
3554		− pop () {
3555		− if (this.size) {
3556		− const val = this.valList[this.head]
3557		− this.evict(true)
3558		− return val
3559		− }
3560		− }
	3223	+ const hit = new Entry(key, value, len, now, maxAge)
3561	3224
3562		− evict (free) {
3563		− const head = this.head
3564		− const k = this.keyList[head]
3565		− const v = this.valList[head]
3566		− if (this.isBackgroundFetch(v)) {
3567		− v.__abortController.abort()
3568		− } else {
3569		− this.dispose(v, k, 'evict')
3570		− if (this.disposeAfter) {
3571		− this.disposed.push([v, k, 'evict'])
3572		− }
3573		− }
3574		− this.removeItemSize(head)
3575		− // if we aren't about to use the index, then null these out
3576		− if (free) {
3577		− this.keyList[head] = null
3578		− this.valList[head] = null
3579		− this.free.push(head)
3580		− }
3581		− this.head = this.next[head]
3582		− this.keyMap.delete(k)
3583		− this.size --
3584		− return head
3585		− }
3586		−
3587		− has (k, { updateAgeOnHas = this.updateAgeOnHas } = {}) {
3588		− const index = this.keyMap.get(k)
3589		− if (index !== undefined) {
3590		− if (!this.isStale(index)) {
3591		− if (updateAgeOnHas) {
3592		− this.updateItemAge(index)
3593		− }
3594		− return true
3595		− }
3596		− }
3597		− return false
3598		− }
	3225	+ // oversized objects fall out of cache automatically.
	3226	+ if (hit.length > this[MAX]) {
	3227	+ if (this[DISPOSE])
	3228	+ this[DISPOSE](key, value)
3599	3229
3600		− // like get(), but without any LRU updating or TTL expiration
3601		− peek (k, { allowStale = this.allowStale } = {}) {
3602		− const index = this.keyMap.get(k)
3603		− if (index !== undefined && (allowStale || !this.isStale(index))) {
3604		− return this.valList[index]
	3230	+ return false
3605	3231	}
	3232	+
	3233	+ this[LENGTH] += hit.length
	3234	+ this[LRU_LIST].unshift(hit)
	3235	+ this[CACHE].set(key, this[LRU_LIST].head)
	3236	+ trim(this)
	3237	+ return true
3606	3238	}
3607	3239
3608		− backgroundFetch (k, index, options) {
3609		− const v = index === undefined ? undefined : this.valList[index]
3610		− if (this.isBackgroundFetch(v)) {
3611		− return v
3612		− }
3613		− const ac = new AC()
3614		− const fetchOpts = {
3615		− signal: ac.signal,
3616		− options,
3617		− }
3618		− const p = Promise.resolve(this.fetchMethod(k, v, fetchOpts)).then(v => {
3619		− if (!ac.signal.aborted) {
3620		− this.set(k, v, fetchOpts.options)
3621		− }
3622		− return v
3623		− })
3624		− p.__abortController = ac
3625		− p.__staleWhileFetching = v
3626		− if (index === undefined) {
3627		− this.set(k, p, fetchOpts.options)
3628		− index = this.keyMap.get(k)
3629		− } else {
3630		− this.valList[index] = p
3631		− }
3632		− return p
	3240	+ has (key) {
	3241	+ if (!this[CACHE].has(key)) return false
	3242	+ const hit = this[CACHE].get(key).value
	3243	+ return !isStale(this, hit)
3633	3244	}
3634	3245
3635		− isBackgroundFetch (p) {
3636		− return p && typeof p === 'object' && typeof p.then === 'function' &&
3637		− Object.prototype.hasOwnProperty.call(p, '__staleWhileFetching')
	3246	+ get (key) {
	3247	+ return get(this, key, true)
3638	3248	}
3639	3249
3640		− // this takes the union of get() and set() opts, because it does both
3641		− async fetch (k, {
3642		− allowStale = this.allowStale,
3643		− updateAgeOnGet = this.updateAgeOnGet,
3644		− ttl = this.ttl,
3645		− noDisposeOnSet = this.noDisposeOnSet,
3646		− size = 0,
3647		− sizeCalculation = this.sizeCalculation,
3648		− noUpdateTTL = this.noUpdateTTL,
3649		− } = {}) {
3650		− if (!this.fetchMethod) {
3651		− return this.get(k, {allowStale, updateAgeOnGet})
3652		− }
	3250	+ peek (key) {
	3251	+ return get(this, key, false)
	3252	+ }
3653	3253
3654		− const options = {
3655		− allowStale,
3656		− updateAgeOnGet,
3657		− ttl,
3658		− noDisposeOnSet,
3659		− size,
3660		− sizeCalculation,
3661		− noUpdateTTL,
3662		− }
	3254	+ pop () {
	3255	+ const node = this[LRU_LIST].tail
	3256	+ if (!node)
	3257	+ return null
3663	3258
3664		− let index = this.keyMap.get(k)
3665		− if (index === undefined) {
3666		− return this.backgroundFetch(k, index, options)
3667		− } else {
3668		− // in cache, maybe already fetching
3669		− const v = this.valList[index]
3670		− if (this.isBackgroundFetch(v)) {
3671		− return allowStale && v.__staleWhileFetching !== undefined
3672		− ? v.__staleWhileFetching : v
3673		− }
	3259	+ del(this, node)
	3260	+ return node.value
	3261	+ }
3674	3262
3675		− if (!this.isStale(index)) {
3676		− this.moveToTail(index)
3677		− if (updateAgeOnGet) {
3678		− this.updateItemAge(index)
3679		− }
3680		− return v
3681		− }
	3263	+ del (key) {
	3264	+ del(this, this[CACHE].get(key))
	3265	+ }
3682	3266
3683		− // ok, it is stale, and not already fetching
3684		− // refresh the cache.
3685		− const p = this.backgroundFetch(k, index, options)
3686		− return allowStale && p.__staleWhileFetching !== undefined
3687		− ? p.__staleWhileFetching : p
3688		− }
3689		− }
3690		−
3691		− get (k, {
3692		− allowStale = this.allowStale,
3693		− updateAgeOnGet = this.updateAgeOnGet,
3694		− } = {}) {
3695		− const index = this.keyMap.get(k)
3696		− if (index !== undefined) {
3697		− const value = this.valList[index]
3698		− const fetching = this.isBackgroundFetch(value)
3699		− if (this.isStale(index)) {
3700		− // delete only if not an in-flight background fetch
3701		− if (!fetching) {
3702		− this.delete(k)
3703		− return allowStale ? value : undefined
3704		− } else {
3705		− return allowStale ? value.__staleWhileFetching : undefined
3706		− }
3707		− } else {
3708		− // if we're currently fetching it, we don't actually have it yet
3709		− // it's not stale, which means this isn't a staleWhileRefetching,
3710		− // so we just return undefined
3711		− if (fetching) {
3712		− return undefined
3713		− }
3714		− this.moveToTail(index)
3715		− if (updateAgeOnGet) {
3716		− this.updateItemAge(index)
	3267	+ load (arr) {
	3268	+ // reset the cache
	3269	+ this.reset()
	3270	+
	3271	+ const now = Date.now()
	3272	+ // A previous serialized cache has the most recent items first
	3273	+ for (let l = arr.length - 1; l >= 0; l--) {
	3274	+ const hit = arr[l]
	3275	+ const expiresAt = hit.e || 0
	3276	+ if (expiresAt === 0)
	3277	+ // the item was created without expiration in a non aged cache
	3278	+ this.set(hit.k, hit.v)
	3279	+ else {
	3280	+ const maxAge = expiresAt - now
	3281	+ // dont add already expired items
	3282	+ if (maxAge > 0) {
	3283	+ this.set(hit.k, hit.v, maxAge)
3717	3284	}
3718		− return value
3719	3285	}
3720	3286	}
3721	3287	}
3722	3288
3723		− connect (p, n) {
3724		− this.prev[n] = p
3725		− this.next[p] = n
	3289	+ prune () {
	3290	+ this[CACHE].forEach((value, key) => get(this, key, false))
3726	3291	}
	3292	+}
3727	3293
3728		− moveToTail (index) {
3729		− // if tail already, nothing to do
3730		− // if head, move head to next[index]
3731		− // else
3732		− // move next[prev[index]] to next[index] (head has no prev)
3733		− // move prev[next[index]] to prev[index]
3734		− // prev[index] = tail
3735		− // next[tail] = index
3736		− // tail = index
3737		− if (index !== this.tail) {
3738		− if (index === this.head) {
3739		− this.head = this.next[index]
3740		− } else {
3741		− this.connect(this.prev[index], this.next[index])
	3294	+const get = (self, key, doUse) => {
	3295	+ const node = self[CACHE].get(key)
	3296	+ if (node) {
	3297	+ const hit = node.value
	3298	+ if (isStale(self, hit)) {
	3299	+ del(self, node)
	3300	+ if (!self[ALLOW_STALE])
	3301	+ return undefined
	3302	+ } else {
	3303	+ if (doUse) {
	3304	+ if (self[UPDATE_AGE_ON_GET])
	3305	+ node.value.now = Date.now()
	3306	+ self[LRU_LIST].unshiftNode(node)
3742	3307	}
3743		− this.connect(this.tail, index)
3744		− this.tail = index
3745	3308	}
	3309	+ return hit.value
3746	3310	}
	3311	+}
3747	3312
3748		− get del () {
3749		− deprecatedMethod('del', 'delete')
3750		− return this.delete
3751		− }
3752		− delete (k) {
3753		− let deleted = false
3754		− if (this.size !== 0) {
3755		− const index = this.keyMap.get(k)
3756		− if (index !== undefined) {
3757		− deleted = true
3758		− if (this.size === 1) {
3759		− this.clear()
3760		− } else {
3761		− this.removeItemSize(index)
3762		− const v = this.valList[index]
3763		− if (this.isBackgroundFetch(v)) {
3764		− v.__abortController.abort()
3765		− } else {
3766		− this.dispose(v, k, 'delete')
3767		− if (this.disposeAfter) {
3768		− this.disposed.push([v, k, 'delete'])
3769		− }
3770		− }
3771		− this.keyMap.delete(k)
3772		− this.keyList[index] = null
3773		− this.valList[index] = null
3774		− if (index === this.tail) {
3775		− this.tail = this.prev[index]
3776		− } else if (index === this.head) {
3777		− this.head = this.next[index]
3778		− } else {
3779		− this.next[this.prev[index]] = this.next[index]
3780		− this.prev[this.next[index]] = this.prev[index]
3781		− }
3782		− this.size --
3783		− this.free.push(index)
3784		− }
3785		− }
3786		− }
3787		− if (this.disposed) {
3788		− while (this.disposed.length) {
3789		− this.disposeAfter(...this.disposed.shift())
3790		− }
	3313	+const isStale = (self, hit) => {
	3314	+ if (!hit || (!hit.maxAge && !self[MAX_AGE]))
	3315	+ return false
	3316	+
	3317	+ const diff = Date.now() - hit.now
	3318	+ return hit.maxAge ? diff > hit.maxAge
	3319	+ : self[MAX_AGE] && (diff > self[MAX_AGE])
	3320	+}
	3321	+
	3322	+const trim = self => {
	3323	+ if (self[LENGTH] > self[MAX]) {
	3324	+ for (let walker = self[LRU_LIST].tail;
	3325	+ self[LENGTH] > self[MAX] && walker !== null;) {
	3326	+ // We know that we're about to delete this one, and also
	3327	+ // what the next least recently used key will be, so just
	3328	+ // go ahead and set it now.
	3329	+ const prev = walker.prev
	3330	+ del(self, walker)
	3331	+ walker = prev
3791	3332	}
3792		− return deleted
3793	3333	}
	3334	+}
3794	3335
3795		− clear () {
3796		− for (const index of this.rindexes({ allowStale: true })) {
3797		− const v = this.valList[index]
3798		− if (this.isBackgroundFetch(v)) {
3799		− v.__abortController.abort()
3800		− } else {
3801		− const k = this.keyList[index]
3802		− this.dispose(v, k, 'delete')
3803		− if (this.disposeAfter) {
3804		− this.disposed.push([v, k, 'delete'])
3805		− }
3806		− }
3807		− }
	3336	+const del = (self, node) => {
	3337	+ if (node) {
	3338	+ const hit = node.value
	3339	+ if (self[DISPOSE])
	3340	+ self[DISPOSE](hit.key, hit.value)
3808	3341
3809		− this.keyMap.clear()
3810		− this.valList.fill(null)
3811		− this.keyList.fill(null)
3812		− if (this.ttls) {
3813		− this.ttls.fill(0)
3814		− this.starts.fill(0)
3815		− }
3816		− if (this.sizes) {
3817		− this.sizes.fill(0)
3818		− }
3819		− this.head = 0
3820		− this.tail = 0
3821		− this.initialFill = 1
3822		− this.free.length = 0
3823		− this.calculatedSize = 0
3824		− this.size = 0
3825		− if (this.disposed) {
3826		− while (this.disposed.length) {
3827		− this.disposeAfter(...this.disposed.shift())
3828		− }
3829		− }
	3342	+ self[LENGTH] -= hit.length
	3343	+ self[CACHE].delete(hit.key)
	3344	+ self[LRU_LIST].removeNode(node)
3830	3345	}
3831		− get reset () {
3832		− deprecatedMethod('reset', 'clear')
3833		− return this.clear
	3346	+}
	3347	+
	3348	+class Entry {
	3349	+ constructor (key, value, length, now, maxAge) {
	3350	+ this.key = key
	3351	+ this.value = value
	3352	+ this.length = length
	3353	+ this.now = now
	3354	+ this.maxAge = maxAge || 0
3834	3355	}
	3356	+}
3835	3357
3836		− get length () {
3837		− deprecatedProperty('length', 'size')
3838		− return this.size
	3358	+const forEachStep = (self, fn, node, thisp) => {
	3359	+ let hit = node.value
	3360	+ if (isStale(self, hit)) {
	3361	+ del(self, node)
	3362	+ if (!self[ALLOW_STALE])
	3363	+ hit = undefined
3839	3364	}
	3365	+ if (hit)
	3366	+ fn.call(thisp, hit.value, hit.key, self)
3840	3367	}
3841	3368
3842	3369	module.exports = LRUCache

4244	3771	// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0-0
4245	3772	// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0-0
4246	3773	// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0-0
	3774	+// ~0.0.1 --> >=0.0.1 <0.1.0-0
4247	3775	const replaceTildes = (comp, options) =>
4248	3776	comp.trim().split(/\s+/).map((c) => {
4249	3777	return replaceTilde(c, options)

4283	3811	// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0-0
4284	3812	// ^1.2.3 --> >=1.2.3 <2.0.0-0
4285	3813	// ^1.2.0 --> >=1.2.0 <2.0.0-0
	3814	+// ^0.0.1 --> >=0.0.1 <0.0.2-0
	3815	+// ^0.1.0 --> >=0.1.0 <0.2.0-0
4286	3816	const replaceCarets = (comp, options) =>
4287	3817	comp.trim().split(/\s+/).map((c) => {
4288	3818	return replaceCaret(c, options)

4783	4313	if (identifier) {
4784	4314	// 1.2.0-beta.1 bumps to 1.2.0-beta.2,
4785	4315	// 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0
4786		− if (this.prerelease[0] === identifier) {
	4316	+ if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
4787	4317	if (isNaN(this.prerelease[1])) {
4788	4318	this.prerelease = [identifier, 0]
4789	4319	}

5046	4576	}
5047	4577
5048	4578	try {
5049		− return new SemVer(version, options).inc(release, identifier).version
	4579	+ return new SemVer(
	4580	+ version instanceof SemVer ? version.version : version,
	4581	+ options
	4582	+ ).inc(release, identifier).version
5050	4583	} catch (er) {
5051	4584	return null
5052	4585	}

5234	4767
5235	4768	// just pre-load all the stuff that index.js lazily exports
5236	4769	const internalRe = __nccwpck_require__(9523)
	4770	+const constants = __nccwpck_require__(2293)
	4771	+const SemVer = __nccwpck_require__(8088)
	4772	+const identifiers = __nccwpck_require__(2463)
	4773	+const parse = __nccwpck_require__(5925)
	4774	+const valid = __nccwpck_require__(9601)
	4775	+const clean = __nccwpck_require__(8848)
	4776	+const inc = __nccwpck_require__(900)
	4777	+const diff = __nccwpck_require__(4297)
	4778	+const major = __nccwpck_require__(6688)
	4779	+const minor = __nccwpck_require__(8447)
	4780	+const patch = __nccwpck_require__(2866)
	4781	+const prerelease = __nccwpck_require__(4016)
	4782	+const compare = __nccwpck_require__(4309)
	4783	+const rcompare = __nccwpck_require__(6417)
	4784	+const compareLoose = __nccwpck_require__(2804)
	4785	+const compareBuild = __nccwpck_require__(2156)
	4786	+const sort = __nccwpck_require__(1426)
	4787	+const rsort = __nccwpck_require__(8701)
	4788	+const gt = __nccwpck_require__(4123)
	4789	+const lt = __nccwpck_require__(194)
	4790	+const eq = __nccwpck_require__(1898)
	4791	+const neq = __nccwpck_require__(6017)
	4792	+const gte = __nccwpck_require__(5522)
	4793	+const lte = __nccwpck_require__(7520)
	4794	+const cmp = __nccwpck_require__(5098)
	4795	+const coerce = __nccwpck_require__(3466)
	4796	+const Comparator = __nccwpck_require__(1532)
	4797	+const Range = __nccwpck_require__(9828)
	4798	+const satisfies = __nccwpck_require__(6055)
	4799	+const toComparators = __nccwpck_require__(2706)
	4800	+const maxSatisfying = __nccwpck_require__(579)
	4801	+const minSatisfying = __nccwpck_require__(832)
	4802	+const minVersion = __nccwpck_require__(4179)
	4803	+const validRange = __nccwpck_require__(2098)
	4804	+const outside = __nccwpck_require__(420)
	4805	+const gtr = __nccwpck_require__(9380)
	4806	+const ltr = __nccwpck_require__(3323)
	4807	+const intersects = __nccwpck_require__(7008)
	4808	+const simplifyRange = __nccwpck_require__(5297)
	4809	+const subset = __nccwpck_require__(7863)
5237	4810	module.exports = {
	4811	+ parse,
	4812	+ valid,
	4813	+ clean,
	4814	+ inc,
	4815	+ diff,
	4816	+ major,
	4817	+ minor,
	4818	+ patch,
	4819	+ prerelease,
	4820	+ compare,
	4821	+ rcompare,
	4822	+ compareLoose,
	4823	+ compareBuild,
	4824	+ sort,
	4825	+ rsort,
	4826	+ gt,
	4827	+ lt,
	4828	+ eq,
	4829	+ neq,
	4830	+ gte,
	4831	+ lte,
	4832	+ cmp,
	4833	+ coerce,
	4834	+ Comparator,
	4835	+ Range,
	4836	+ satisfies,
	4837	+ toComparators,
	4838	+ maxSatisfying,
	4839	+ minSatisfying,
	4840	+ minVersion,
	4841	+ validRange,
	4842	+ outside,
	4843	+ gtr,
	4844	+ ltr,
	4845	+ intersects,
	4846	+ simplifyRange,
	4847	+ subset,
	4848	+ SemVer,
5238	4849	re: internalRe.re,
5239	4850	src: internalRe.src,
5240	4851	tokens: internalRe.t,
5241		− SEMVER_SPEC_VERSION: (__nccwpck_require__(2293).SEMVER_SPEC_VERSION),
5242		− SemVer: __nccwpck_require__(8088),
5243		− compareIdentifiers: (__nccwpck_require__(2463).compareIdentifiers),
5244		− rcompareIdentifiers: (__nccwpck_require__(2463).rcompareIdentifiers),
5245		− parse: __nccwpck_require__(5925),
5246		− valid: __nccwpck_require__(9601),
5247		− clean: __nccwpck_require__(8848),
5248		− inc: __nccwpck_require__(900),
5249		− diff: __nccwpck_require__(4297),
5250		− major: __nccwpck_require__(6688),
5251		− minor: __nccwpck_require__(8447),
5252		− patch: __nccwpck_require__(2866),
5253		− prerelease: __nccwpck_require__(4016),
5254		− compare: __nccwpck_require__(4309),
5255		− rcompare: __nccwpck_require__(6417),
5256		− compareLoose: __nccwpck_require__(2804),
5257		− compareBuild: __nccwpck_require__(2156),
5258		− sort: __nccwpck_require__(1426),
5259		− rsort: __nccwpck_require__(8701),
5260		− gt: __nccwpck_require__(4123),
5261		− lt: __nccwpck_require__(194),
5262		− eq: __nccwpck_require__(1898),
5263		− neq: __nccwpck_require__(6017),
5264		− gte: __nccwpck_require__(5522),
5265		− lte: __nccwpck_require__(7520),
5266		− cmp: __nccwpck_require__(5098),
5267		− coerce: __nccwpck_require__(3466),
5268		− Comparator: __nccwpck_require__(1532),
5269		− Range: __nccwpck_require__(9828),
5270		− satisfies: __nccwpck_require__(6055),
5271		− toComparators: __nccwpck_require__(2706),
5272		− maxSatisfying: __nccwpck_require__(579),
5273		− minSatisfying: __nccwpck_require__(832),
5274		− minVersion: __nccwpck_require__(4179),
5275		− validRange: __nccwpck_require__(2098),
5276		− outside: __nccwpck_require__(420),
5277		− gtr: __nccwpck_require__(9380),
5278		− ltr: __nccwpck_require__(3323),
5279		− intersects: __nccwpck_require__(7008),
5280		− simplifyRange: __nccwpck_require__(5297),
5281		− subset: __nccwpck_require__(7863),
	4852	+ SEMVER_SPEC_VERSION: constants.SEMVER_SPEC_VERSION,
	4853	+ compareIdentifiers: identifiers.compareIdentifiers,
	4854	+ rcompareIdentifiers: identifiers.rcompareIdentifiers,
5282	4855	}
5283	4856
5284	4857

7077	6650	var _default = version;
7078	6651	exports["default"] = _default;
7079	6652
	6653	+/***/ }),
	6654	+
	6655	+/***/ 4091:
	6656	+/***/ ((module) => {
	6657	+
	6658	+"use strict";
	6659	+
	6660	+module.exports = function (Yallist) {
	6661	+ Yallist.prototype[Symbol.iterator] = function* () {
	6662	+ for (let walker = this.head; walker; walker = walker.next) {
	6663	+ yield walker.value
	6664	+ }
	6665	+ }
	6666	+}
	6667	+
	6668	+
	6669	+/***/ }),
	6670	+
	6671	+/***/ 665:
	6672	+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
	6673	+
	6674	+"use strict";
	6675	+
	6676	+module.exports = Yallist
	6677	+
	6678	+Yallist.Node = Node
	6679	+Yallist.create = Yallist
	6680	+
	6681	+function Yallist (list) {
	6682	+ var self = this
	6683	+ if (!(self instanceof Yallist)) {
	6684	+ self = new Yallist()
	6685	+ }
	6686	+
	6687	+ self.tail = null
	6688	+ self.head = null
	6689	+ self.length = 0
	6690	+
	6691	+ if (list && typeof list.forEach === 'function') {
	6692	+ list.forEach(function (item) {
	6693	+ self.push(item)
	6694	+ })
	6695	+ } else if (arguments.length > 0) {
	6696	+ for (var i = 0, l = arguments.length; i < l; i++) {
	6697	+ self.push(arguments[i])
	6698	+ }
	6699	+ }
	6700	+
	6701	+ return self
	6702	+}
	6703	+
	6704	+Yallist.prototype.removeNode = function (node) {
	6705	+ if (node.list !== this) {
	6706	+ throw new Error('removing node which does not belong to this list')
	6707	+ }
	6708	+
	6709	+ var next = node.next
	6710	+ var prev = node.prev
	6711	+
	6712	+ if (next) {
	6713	+ next.prev = prev
	6714	+ }
	6715	+
	6716	+ if (prev) {
	6717	+ prev.next = next
	6718	+ }
	6719	+
	6720	+ if (node === this.head) {
	6721	+ this.head = next
	6722	+ }
	6723	+ if (node === this.tail) {
	6724	+ this.tail = prev
	6725	+ }
	6726	+
	6727	+ node.list.length--
	6728	+ node.next = null
	6729	+ node.prev = null
	6730	+ node.list = null
	6731	+
	6732	+ return next
	6733	+}
	6734	+
	6735	+Yallist.prototype.unshiftNode = function (node) {
	6736	+ if (node === this.head) {
	6737	+ return
	6738	+ }
	6739	+
	6740	+ if (node.list) {
	6741	+ node.list.removeNode(node)
	6742	+ }
	6743	+
	6744	+ var head = this.head
	6745	+ node.list = this
	6746	+ node.next = head
	6747	+ if (head) {
	6748	+ head.prev = node
	6749	+ }
	6750	+
	6751	+ this.head = node
	6752	+ if (!this.tail) {
	6753	+ this.tail = node
	6754	+ }
	6755	+ this.length++
	6756	+}
	6757	+
	6758	+Yallist.prototype.pushNode = function (node) {
	6759	+ if (node === this.tail) {
	6760	+ return
	6761	+ }
	6762	+
	6763	+ if (node.list) {
	6764	+ node.list.removeNode(node)
	6765	+ }
	6766	+
	6767	+ var tail = this.tail
	6768	+ node.list = this
	6769	+ node.prev = tail
	6770	+ if (tail) {
	6771	+ tail.next = node
	6772	+ }
	6773	+
	6774	+ this.tail = node
	6775	+ if (!this.head) {
	6776	+ this.head = node
	6777	+ }
	6778	+ this.length++
	6779	+}
	6780	+
	6781	+Yallist.prototype.push = function () {
	6782	+ for (var i = 0, l = arguments.length; i < l; i++) {
	6783	+ push(this, arguments[i])
	6784	+ }
	6785	+ return this.length
	6786	+}
	6787	+
	6788	+Yallist.prototype.unshift = function () {
	6789	+ for (var i = 0, l = arguments.length; i < l; i++) {
	6790	+ unshift(this, arguments[i])
	6791	+ }
	6792	+ return this.length
	6793	+}
	6794	+
	6795	+Yallist.prototype.pop = function () {
	6796	+ if (!this.tail) {
	6797	+ return undefined
	6798	+ }
	6799	+
	6800	+ var res = this.tail.value
	6801	+ this.tail = this.tail.prev
	6802	+ if (this.tail) {
	6803	+ this.tail.next = null
	6804	+ } else {
	6805	+ this.head = null
	6806	+ }
	6807	+ this.length--
	6808	+ return res
	6809	+}
	6810	+
	6811	+Yallist.prototype.shift = function () {
	6812	+ if (!this.head) {
	6813	+ return undefined
	6814	+ }
	6815	+
	6816	+ var res = this.head.value
	6817	+ this.head = this.head.next
	6818	+ if (this.head) {
	6819	+ this.head.prev = null
	6820	+ } else {
	6821	+ this.tail = null
	6822	+ }
	6823	+ this.length--
	6824	+ return res
	6825	+}
	6826	+
	6827	+Yallist.prototype.forEach = function (fn, thisp) {
	6828	+ thisp = thisp || this
	6829	+ for (var walker = this.head, i = 0; walker !== null; i++) {
	6830	+ fn.call(thisp, walker.value, i, this)
	6831	+ walker = walker.next
	6832	+ }
	6833	+}
	6834	+
	6835	+Yallist.prototype.forEachReverse = function (fn, thisp) {
	6836	+ thisp = thisp || this
	6837	+ for (var walker = this.tail, i = this.length - 1; walker !== null; i--) {
	6838	+ fn.call(thisp, walker.value, i, this)
	6839	+ walker = walker.prev
	6840	+ }
	6841	+}
	6842	+
	6843	+Yallist.prototype.get = function (n) {
	6844	+ for (var i = 0, walker = this.head; walker !== null && i < n; i++) {
	6845	+ // abort out of the list early if we hit a cycle
	6846	+ walker = walker.next
	6847	+ }
	6848	+ if (i === n && walker !== null) {
	6849	+ return walker.value
	6850	+ }
	6851	+}
	6852	+
	6853	+Yallist.prototype.getReverse = function (n) {
	6854	+ for (var i = 0, walker = this.tail; walker !== null && i < n; i++) {
	6855	+ // abort out of the list early if we hit a cycle
	6856	+ walker = walker.prev
	6857	+ }
	6858	+ if (i === n && walker !== null) {
	6859	+ return walker.value
	6860	+ }
	6861	+}
	6862	+
	6863	+Yallist.prototype.map = function (fn, thisp) {
	6864	+ thisp = thisp || this
	6865	+ var res = new Yallist()
	6866	+ for (var walker = this.head; walker !== null;) {
	6867	+ res.push(fn.call(thisp, walker.value, this))
	6868	+ walker = walker.next
	6869	+ }
	6870	+ return res
	6871	+}
	6872	+
	6873	+Yallist.prototype.mapReverse = function (fn, thisp) {
	6874	+ thisp = thisp || this
	6875	+ var res = new Yallist()
	6876	+ for (var walker = this.tail; walker !== null;) {
	6877	+ res.push(fn.call(thisp, walker.value, this))
	6878	+ walker = walker.prev
	6879	+ }
	6880	+ return res
	6881	+}
	6882	+
	6883	+Yallist.prototype.reduce = function (fn, initial) {
	6884	+ var acc
	6885	+ var walker = this.head
	6886	+ if (arguments.length > 1) {
	6887	+ acc = initial
	6888	+ } else if (this.head) {
	6889	+ walker = this.head.next
	6890	+ acc = this.head.value
	6891	+ } else {
	6892	+ throw new TypeError('Reduce of empty list with no initial value')
	6893	+ }
	6894	+
	6895	+ for (var i = 0; walker !== null; i++) {
	6896	+ acc = fn(acc, walker.value, i)
	6897	+ walker = walker.next
	6898	+ }
	6899	+
	6900	+ return acc
	6901	+}
	6902	+
	6903	+Yallist.prototype.reduceReverse = function (fn, initial) {
	6904	+ var acc
	6905	+ var walker = this.tail
	6906	+ if (arguments.length > 1) {
	6907	+ acc = initial
	6908	+ } else if (this.tail) {
	6909	+ walker = this.tail.prev
	6910	+ acc = this.tail.value
	6911	+ } else {
	6912	+ throw new TypeError('Reduce of empty list with no initial value')
	6913	+ }
	6914	+
	6915	+ for (var i = this.length - 1; walker !== null; i--) {
	6916	+ acc = fn(acc, walker.value, i)
	6917	+ walker = walker.prev
	6918	+ }
	6919	+
	6920	+ return acc
	6921	+}
	6922	+
	6923	+Yallist.prototype.toArray = function () {
	6924	+ var arr = new Array(this.length)
	6925	+ for (var i = 0, walker = this.head; walker !== null; i++) {
	6926	+ arr[i] = walker.value
	6927	+ walker = walker.next
	6928	+ }
	6929	+ return arr
	6930	+}
	6931	+
	6932	+Yallist.prototype.toArrayReverse = function () {
	6933	+ var arr = new Array(this.length)
	6934	+ for (var i = 0, walker = this.tail; walker !== null; i++) {
	6935	+ arr[i] = walker.value
	6936	+ walker = walker.prev
	6937	+ }
	6938	+ return arr
	6939	+}
	6940	+
	6941	+Yallist.prototype.slice = function (from, to) {
	6942	+ to = to || this.length
	6943	+ if (to < 0) {
	6944	+ to += this.length
	6945	+ }
	6946	+ from = from || 0
	6947	+ if (from < 0) {
	6948	+ from += this.length
	6949	+ }
	6950	+ var ret = new Yallist()
	6951	+ if (to < from || to < 0) {
	6952	+ return ret
	6953	+ }
	6954	+ if (from < 0) {
	6955	+ from = 0
	6956	+ }
	6957	+ if (to > this.length) {
	6958	+ to = this.length
	6959	+ }
	6960	+ for (var i = 0, walker = this.head; walker !== null && i < from; i++) {
	6961	+ walker = walker.next
	6962	+ }
	6963	+ for (; walker !== null && i < to; i++, walker = walker.next) {
	6964	+ ret.push(walker.value)
	6965	+ }
	6966	+ return ret
	6967	+}
	6968	+
	6969	+Yallist.prototype.sliceReverse = function (from, to) {
	6970	+ to = to || this.length
	6971	+ if (to < 0) {
	6972	+ to += this.length
	6973	+ }
	6974	+ from = from || 0
	6975	+ if (from < 0) {
	6976	+ from += this.length
	6977	+ }
	6978	+ var ret = new Yallist()
	6979	+ if (to < from || to < 0) {
	6980	+ return ret
	6981	+ }
	6982	+ if (from < 0) {
	6983	+ from = 0
	6984	+ }
	6985	+ if (to > this.length) {
	6986	+ to = this.length
	6987	+ }
	6988	+ for (var i = this.length, walker = this.tail; walker !== null && i > to; i--) {
	6989	+ walker = walker.prev
	6990	+ }
	6991	+ for (; walker !== null && i > from; i--, walker = walker.prev) {
	6992	+ ret.push(walker.value)
	6993	+ }
	6994	+ return ret
	6995	+}
	6996	+
	6997	+Yallist.prototype.splice = function (start, deleteCount, ...nodes) {
	6998	+ if (start > this.length) {
	6999	+ start = this.length - 1
	7000	+ }
	7001	+ if (start < 0) {
	7002	+ start = this.length + start;
	7003	+ }
	7004	+
	7005	+ for (var i = 0, walker = this.head; walker !== null && i < start; i++) {
	7006	+ walker = walker.next
	7007	+ }
	7008	+
	7009	+ var ret = []
	7010	+ for (var i = 0; walker && i < deleteCount; i++) {
	7011	+ ret.push(walker.value)
	7012	+ walker = this.removeNode(walker)
	7013	+ }
	7014	+ if (walker === null) {
	7015	+ walker = this.tail
	7016	+ }
	7017	+
	7018	+ if (walker !== this.head && walker !== this.tail) {
	7019	+ walker = walker.prev
	7020	+ }
	7021	+
	7022	+ for (var i = 0; i < nodes.length; i++) {
	7023	+ walker = insert(this, walker, nodes[i])
	7024	+ }
	7025	+ return ret;
	7026	+}
	7027	+
	7028	+Yallist.prototype.reverse = function () {
	7029	+ var head = this.head
	7030	+ var tail = this.tail
	7031	+ for (var walker = head; walker !== null; walker = walker.prev) {
	7032	+ var p = walker.prev
	7033	+ walker.prev = walker.next
	7034	+ walker.next = p
	7035	+ }
	7036	+ this.head = tail
	7037	+ this.tail = head
	7038	+ return this
	7039	+}
	7040	+
	7041	+function insert (self, node, value) {
	7042	+ var inserted = node === self.head ?
	7043	+ new Node(value, null, node, self) :
	7044	+ new Node(value, node, node.next, self)
	7045	+
	7046	+ if (inserted.next === null) {
	7047	+ self.tail = inserted
	7048	+ }
	7049	+ if (inserted.prev === null) {
	7050	+ self.head = inserted
	7051	+ }
	7052	+
	7053	+ self.length++
	7054	+
	7055	+ return inserted
	7056	+}
	7057	+
	7058	+function push (self, item) {
	7059	+ self.tail = new Node(item, self.tail, null, self)
	7060	+ if (!self.head) {
	7061	+ self.head = self.tail
	7062	+ }
	7063	+ self.length++
	7064	+}
	7065	+
	7066	+function unshift (self, item) {
	7067	+ self.head = new Node(item, null, self.head, self)
	7068	+ if (!self.tail) {
	7069	+ self.tail = self.head
	7070	+ }
	7071	+ self.length++
	7072	+}
	7073	+
	7074	+function Node (value, prev, next, list) {
	7075	+ if (!(this instanceof Node)) {
	7076	+ return new Node(value, prev, next, list)
	7077	+ }
	7078	+
	7079	+ this.list = list
	7080	+ this.value = value
	7081	+
	7082	+ if (prev) {
	7083	+ prev.next = this
	7084	+ this.prev = prev
	7085	+ } else {
	7086	+ this.prev = null
	7087	+ }
	7088	+
	7089	+ if (next) {
	7090	+ next.prev = this
	7091	+ this.next = next
	7092	+ } else {
	7093	+ this.next = null
	7094	+ }
	7095	+}
	7096	+
	7097	+try {
	7098	+ // add if support for Symbol.iterator is present
	7099	+ __nccwpck_require__(4091)(Yallist)
	7100	+} catch (er) {}
	7101	+
	7102	+
7080	7103	/***/ }),
7081	7104
7082	7105	/***/ 2127: