From b1b4b8f1bb8f7f3555fc14f40bd44ef38c5a8a6a Mon Sep 17 00:00:00 2001 From: nlf Date: Thu, 24 Mar 2022 13:24:01 -0700 Subject: [PATCH 1/2] deps: lru-cache@7.7.1 --- node_modules/lru-cache/index.js | 262 +++++++++++++++++++++++----- node_modules/lru-cache/package.json | 3 +- package-lock.json | 12 +- 3 files changed, 227 insertions(+), 50 deletions(-) diff --git a/node_modules/lru-cache/index.js b/node_modules/lru-cache/index.js index e37f51616452e..978b8f4ee9595 100644 --- a/node_modules/lru-cache/index.js +++ b/node_modules/lru-cache/index.js @@ -1,6 +1,17 @@ const perf = typeof performance === 'object' && performance && typeof performance.now === 'function' ? performance : Date +const hasAbortController = typeof AbortController !== 'undefined' + +/* istanbul ignore next - minimal backwards compatibility polyfill */ +const AC = hasAbortController ? AbortController : Object.assign( + class AbortController { + constructor () { this.signal = new AC.AbortSignal } + abort () { this.signal.aborted = true } + }, + { AbortSignal: class AbortSignal { constructor () { this.aborted = false }}} +) + const warned = new Set() const deprecatedOption = (opt, instead) => { const code = `LRU_CACHE_OPTION_${opt}` @@ -24,12 +35,15 @@ const deprecatedProperty = (field, instead) => { warn(code, `${field} property`, `cache.${instead}`, get) } } -const shouldWarn = (code) => typeof process === 'object' && + +const shouldWarn = code => typeof process === 'object' && process && - !(process.noDeprecation || warned.has(code)) + !warned.has(code) + const warn = (code, what, instead, fn) => { warned.add(code) - process.emitWarning(`The ${what} is deprecated. Please use ${instead} instead.`, 'DeprecationWarning', code, fn) + const msg = `The ${what} is deprecated. Please use ${instead} instead.` + process.emitWarning(msg, 'DeprecationWarning', code, fn) } const isPosInt = n => n && n === Math.floor(n) && n > 0 && isFinite(n) @@ -58,7 +72,7 @@ class ZeroArray extends Array { class Stack { constructor (max) { - const UintArray = getUintArray(max) + const UintArray = max ? getUintArray(max) : Array this.heap = new UintArray(max) this.length = 0 } @@ -73,7 +87,7 @@ class Stack { class LRUCache { constructor (options = {}) { const { - max, + max = 0, ttl, ttlResolution = 1, ttlAutopurge, @@ -83,8 +97,9 @@ class LRUCache { disposeAfter, noDisposeOnSet, noUpdateTTL, - maxSize, + maxSize = 0, sizeCalculation, + fetchMethod, } = options // deprecated options, don't trigger a warning for getting them if @@ -95,17 +110,17 @@ class LRUCache { stale, } = options instanceof LRUCache ? {} : options - if (!isPosInt(max)) { - throw new TypeError('max option must be an integer') + if (max !== 0 && !isPosInt(max)) { + throw new TypeError('max option must be a nonnegative integer') } - const UintArray = getUintArray(max) + const UintArray = max ? getUintArray(max) : Array if (!UintArray) { throw new Error('invalid max value: ' + max) } this.max = max - this.maxSize = maxSize || 0 + this.maxSize = maxSize this.sizeCalculation = sizeCalculation || length if (this.sizeCalculation) { if (!this.maxSize) { @@ -115,6 +130,13 @@ class LRUCache { throw new TypeError('sizeCalculating set to non-function') } } + + this.fetchMethod = fetchMethod || null + if (this.fetchMethod && typeof this.fetchMethod !== 'function') { + throw new TypeError('fetchMethod must be a function if specified') + } + + this.keyMap = new Map() this.keyList = new Array(max).fill(null) this.valList = new Array(max).fill(null) @@ -139,7 +161,7 @@ class LRUCache { this.noDisposeOnSet = !!noDisposeOnSet this.noUpdateTTL = !!noUpdateTTL - if (this.maxSize) { + if (this.maxSize !== 0) { if (!isPosInt(this.maxSize)) { throw new TypeError('maxSize must be a positive integer if specified') } @@ -159,6 +181,20 @@ class LRUCache { this.initializeTTLTracking() } + // do not allow completely unbounded caches + if (this.max === 0 && this.ttl === 0 && this.maxSize === 0) { + throw new TypeError('At least one of max, maxSize, or ttl is required') + } + if (!this.ttlAutopurge && !this.max && !this.maxSize) { + const code = 'LRU_CACHE_UNBOUNDED' + if (shouldWarn(code)) { + warned.add(code) + const msg = 'TTL caching without ttlAutopurge, max, or maxSize can ' + + 'result in unbounded memory consumption.' + process.emitWarning(msg, 'UnboundedCacheWarning', code, LRUCache) + } + } + if (stale) { deprecatedOption('stale', 'allowStale') } @@ -170,9 +206,14 @@ class LRUCache { } } + getRemainingTTL (key) { + return this.has(key) ? Infinity : 0 + } + initializeTTLTracking () { this.ttls = new ZeroArray(this.max) this.starts = new ZeroArray(this.max) + this.setItemTTL = (index, ttl) => { this.starts[index] = ttl !== 0 ? perf.now() : 0 this.ttls[index] = ttl @@ -188,9 +229,11 @@ class LRUCache { } } } + this.updateItemAge = (index) => { this.starts[index] = this.ttls[index] !== 0 ? perf.now() : 0 } + // debounce calls to perf.now() to 1s so we're not hitting // that costly call repeatedly. let cachedNow = 0 @@ -206,6 +249,16 @@ class LRUCache { } return n } + + this.getRemainingTTL = (key) => { + const index = this.keyMap.get(key) + if (index === undefined) { + return 0 + } + return this.ttls[index] === 0 || this.starts[index] === 0 ? Infinity + : ((this.starts[index] + this.ttls[index]) - (cachedNow || getNow())) + } + this.isStale = (index) => { return this.ttls[index] !== 0 && this.starts[index] !== 0 && ((cachedNow || getNow()) - this.starts[index] > this.ttls[index]) @@ -219,9 +272,17 @@ class LRUCache { this.calculatedSize = 0 this.sizes = new ZeroArray(this.max) this.removeItemSize = index => this.calculatedSize -= this.sizes[index] - this.addItemSize = (index, v, k, size, sizeCalculation) => { - const s = size || (sizeCalculation ? sizeCalculation(v, k) : 0) - this.sizes[index] = isPosInt(s) ? s : 0 + this.requireSize = (k, v, size, sizeCalculation) => { + if (sizeCalculation && !size) { + size = sizeCalculation(v, k) + } + if (!isPosInt(size)) { + throw new TypeError('size must be positive integer') + } + return size + } + this.addItemSize = (index, v, k, size) => { + this.sizes[index] = size const maxSize = this.maxSize - this.sizes[index] while (this.calculatedSize > maxSize) { this.evict() @@ -239,15 +300,19 @@ class LRUCache { } } removeItemSize (index) {} - addItemSize (index, v, k, size, sizeCalculation) {} + addItemSize (index, v, k, size) {} + requireSize (k, v, size, sizeCalculation) { + if (size || sizeCalculation) { + throw new TypeError('cannot set size without setting maxSize on cache') + } + } *indexes ({ allowStale = this.allowStale } = {}) { if (this.size) { - for (let i = this.tail, j; true; ) { + for (let i = this.tail; true; ) { if (!this.isValidIndex(i)) { break } - j = i === this.head if (allowStale || !this.isStale(i)) { yield i } @@ -262,14 +327,13 @@ class LRUCache { *rindexes ({ allowStale = this.allowStale } = {}) { if (this.size) { - for (let i = this.head, j; true; ) { + for (let i = this.head; true; ) { if (!this.isValidIndex(i)) { break } if (allowStale || !this.isStale(i)) { yield i } - // either the tail now, or WAS the tail, and deleted if (i === this.tail) { break } else { @@ -389,6 +453,7 @@ class LRUCache { sizeCalculation = this.sizeCalculation, noUpdateTTL = this.noUpdateTTL, } = {}) { + size = this.requireSize(k, v, size, sizeCalculation) let index = this.size === 0 ? undefined : this.keyMap.get(k) if (index === undefined) { // addition @@ -400,21 +465,25 @@ class LRUCache { this.prev[index] = this.tail this.tail = index this.size ++ - this.addItemSize(index, v, k, size, sizeCalculation) + this.addItemSize(index, v, k, size) noUpdateTTL = false } else { // update const oldVal = this.valList[index] if (v !== oldVal) { - if (!noDisposeOnSet) { - this.dispose(oldVal, k, 'set') - if (this.disposeAfter) { - this.disposed.push([oldVal, k, 'set']) + if (this.isBackgroundFetch(oldVal)) { + oldVal.__abortController.abort() + } else { + if (!noDisposeOnSet) { + this.dispose(oldVal, k, 'set') + if (this.disposeAfter) { + this.disposed.push([oldVal, k, 'set']) + } } } this.removeItemSize(index) this.valList[index] = v - this.addItemSize(index, v, k, size, sizeCalculation) + this.addItemSize(index, v, k, size) } this.moveToTail(index) } @@ -458,9 +527,13 @@ class LRUCache { const head = this.head const k = this.keyList[head] const v = this.valList[head] - this.dispose(v, k, 'evict') - if (this.disposeAfter) { - this.disposed.push([v, k, 'evict']) + if (this.isBackgroundFetch(v)) { + v.__abortController.abort() + } else { + this.dispose(v, k, 'evict') + if (this.disposeAfter) { + this.disposed.push([v, k, 'evict']) + } } this.removeItemSize(head) this.head = this.next[head] @@ -481,22 +554,117 @@ class LRUCache { } } + backgroundFetch (k, index, options) { + const v = index === undefined ? undefined : this.valList[index] + if (this.isBackgroundFetch(v)) { + return v + } + const ac = new AbortController() + const fetchOpts = { + signal: ac.signal, + options, + } + const p = Promise.resolve(this.fetchMethod(k, v, fetchOpts)).then(v => { + if (!ac.signal.aborted) { + this.set(k, v, fetchOpts.options) + } + return v + }) + p.__abortController = ac + p.__staleWhileFetching = v + if (index === undefined) { + this.set(k, p, fetchOpts.options) + index = this.keyMap.get(k) + } else { + this.valList[index] = p + } + return p + } + + isBackgroundFetch (p) { + return p && typeof p === 'object' && typeof p.then === 'function' && + Object.prototype.hasOwnProperty.call(p, '__staleWhileFetching') + } + + // this takes the union of get() and set() opts, because it does both + async fetch (k, { + allowStale = this.allowStale, + updateAgeOnGet = this.updateAgeOnGet, + ttl = this.ttl, + noDisposeOnSet = this.noDisposeOnSet, + size = 0, + sizeCalculation = this.sizeCalculation, + noUpdateTTL = this.noUpdateTTL, + } = {}) { + if (!this.fetchMethod) { + return this.get(k, {allowStale, updateAgeOnGet}) + } + + const options = { + allowStale, + updateAgeOnGet, + ttl, + noDisposeOnSet, + size, + sizeCalculation, + noUpdateTTL, + } + + let index = this.keyMap.get(k) + if (index === undefined) { + return this.backgroundFetch(k, index, options) + } else { + // in cache, maybe already fetching + const v = this.valList[index] + if (this.isBackgroundFetch(v)) { + return allowStale && v.__staleWhileFetching !== undefined + ? v.__staleWhileFetching : v + } + + if (!this.isStale(index)) { + this.moveToTail(index) + if (updateAgeOnGet) { + this.updateItemAge(index) + } + return v + } + + // ok, it is stale, and not already fetching + // refresh the cache. + const p = this.backgroundFetch(k, index, options) + return allowStale && p.__staleWhileFetching !== undefined + ? p.__staleWhileFetching : p + } + } + get (k, { allowStale = this.allowStale, updateAgeOnGet = this.updateAgeOnGet, } = {}) { const index = this.keyMap.get(k) if (index !== undefined) { + const value = this.valList[index] + const fetching = this.isBackgroundFetch(value) if (this.isStale(index)) { - const value = allowStale ? this.valList[index] : undefined - this.delete(k) - return value + // delete only if not an in-flight background fetch + if (!fetching) { + this.delete(k) + return allowStale ? value : undefined + } else { + return allowStale ? value.__staleWhileFetching : undefined + } } else { + // if we're currently fetching it, we don't actually have it yet + // it's not stale, which means this isn't a staleWhileRefetching, + // so we just return undefined + if (fetching) { + return undefined + } this.moveToTail(index) if (updateAgeOnGet) { this.updateItemAge(index) } - return this.valList[index] + return value } } } @@ -540,9 +708,14 @@ class LRUCache { this.clear() } else { this.removeItemSize(index) - this.dispose(this.valList[index], k, 'delete') - if (this.disposeAfter) { - this.disposed.push([this.valList[index], k, 'delete']) + const v = this.valList[index] + if (this.isBackgroundFetch(v)) { + v.__abortController.abort() + } else { + this.dispose(v, k, 'delete') + if (this.disposeAfter) { + this.disposed.push([v, k, 'delete']) + } } this.keyMap.delete(k) this.keyList[index] = null @@ -569,16 +742,19 @@ class LRUCache { } clear () { - if (this.dispose !== LRUCache.prototype.dispose) { - for (const index of this.rindexes({ allowStale: true })) { - this.dispose(this.valList[index], this.keyList[index], 'delete') - } - } - if (this.disposeAfter) { - for (const index of this.rindexes({ allowStale: true })) { - this.disposed.push([this.valList[index], this.keyList[index], 'delete']) + for (const index of this.rindexes({ allowStale: true })) { + const v = this.valList[index] + if (this.isBackgroundFetch(v)) { + v.__abortController.abort() + } else { + const k = this.keyList[index] + this.dispose(v, k, 'delete') + if (this.disposeAfter) { + this.disposed.push([v, k, 'delete']) + } } } + this.keyMap.clear() this.valList.fill(null) this.keyList.fill(null) diff --git a/node_modules/lru-cache/package.json b/node_modules/lru-cache/package.json index a62f74c2b648a..84d199c2b21b3 100644 --- a/node_modules/lru-cache/package.json +++ b/node_modules/lru-cache/package.json @@ -1,7 +1,7 @@ { "name": "lru-cache", "description": "A cache object that deletes the least-recently-used items.", - "version": "7.5.1", + "version": "7.7.1", "author": "Isaac Z. Schlueter ", "keywords": [ "mru", @@ -22,6 +22,7 @@ "devDependencies": { "@size-limit/preset-small-lib": "^7.0.8", "benchmark": "^2.1.4", + "clock-mock": "^1.0.3", "size-limit": "^7.0.8", "tap": "^15.1.6" }, diff --git a/package-lock.json b/package-lock.json index 648a7496f8a70..e30bcc2fa8b3e 100644 --- a/package-lock.json +++ b/package-lock.json @@ -4828,9 +4828,9 @@ } }, "node_modules/lru-cache": { - "version": "7.5.1", - "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-7.5.1.tgz", - "integrity": "sha512-q1TS8IqKvcg3aScamKCHpepSrHF537Ww7nHahBOxhDu9D2YoBXAsj/7uFdZFj1xJr9LmyeJ62AdyofCHafUbIA==", + "version": "7.7.1", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-7.7.1.tgz", + "integrity": "sha512-cRffBiTW8s73eH4aTXqBcTLU0xQnwGV3/imttRHGWCrbergmnK4D6JXQd8qin5z43HnDwRI+o7mVW0LEB+tpAw==", "inBundle": true, "engines": { "node": ">=12" @@ -14464,9 +14464,9 @@ "dev": true }, "lru-cache": { - "version": "7.5.1", - "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-7.5.1.tgz", - "integrity": "sha512-q1TS8IqKvcg3aScamKCHpepSrHF537Ww7nHahBOxhDu9D2YoBXAsj/7uFdZFj1xJr9LmyeJ62AdyofCHafUbIA==" + "version": "7.7.1", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-7.7.1.tgz", + "integrity": "sha512-cRffBiTW8s73eH4aTXqBcTLU0xQnwGV3/imttRHGWCrbergmnK4D6JXQd8qin5z43HnDwRI+o7mVW0LEB+tpAw==" }, "make-dir": { "version": "3.1.0", From f6493bb2764cd579530f00c9c09339ae84b5f28e Mon Sep 17 00:00:00 2001 From: nlf Date: Thu, 24 Mar 2022 13:24:36 -0700 Subject: [PATCH 2/2] deps: make-fetch-happen@10.1.0 --- node_modules/make-fetch-happen/lib/agent.js | 5 ++ .../make-fetch-happen/lib/cache/index.js | 4 +- node_modules/make-fetch-happen/lib/dns.js | 49 +++++++++++++++++++ node_modules/make-fetch-happen/lib/options.js | 4 ++ node_modules/make-fetch-happen/package.json | 32 ++++++------ package-lock.json | 24 ++++----- package.json | 2 +- 7 files changed, 91 insertions(+), 29 deletions(-) create mode 100644 node_modules/make-fetch-happen/lib/dns.js diff --git a/node_modules/make-fetch-happen/lib/agent.js b/node_modules/make-fetch-happen/lib/agent.js index d28a31bfbda0c..f64644ff611a5 100644 --- a/node_modules/make-fetch-happen/lib/agent.js +++ b/node_modules/make-fetch-happen/lib/agent.js @@ -2,6 +2,7 @@ const LRU = require('lru-cache') const url = require('url') const isLambda = require('is-lambda') +const dns = require('./dns.js') const AGENT_CACHE = new LRU({ max: 50 }) const HttpAgent = require('agentkeepalive') @@ -77,11 +78,13 @@ function getAgent (uri, opts) { rejectUnauthorized: opts.rejectUnauthorized, timeout: agentTimeout, freeSocketTimeout: 15000, + lookup: dns.getLookup(opts.dns), }) : new HttpAgent({ maxSockets: agentMaxSockets, localAddress: opts.localAddress, timeout: agentTimeout, freeSocketTimeout: 15000, + lookup: dns.getLookup(opts.dns), }) AGENT_CACHE.set(key, agent) return agent @@ -171,6 +174,8 @@ const HttpsProxyAgent = require('https-proxy-agent') const SocksProxyAgent = require('socks-proxy-agent') module.exports.getProxy = getProxy function getProxy (proxyUrl, opts, isHttps) { + // our current proxy agents do not support an overridden dns lookup method, so will not + // benefit from the dns cache const popts = { host: proxyUrl.hostname, port: proxyUrl.port, diff --git a/node_modules/make-fetch-happen/lib/cache/index.js b/node_modules/make-fetch-happen/lib/cache/index.js index 17a6425592bcf..0de49d23fb933 100644 --- a/node_modules/make-fetch-happen/lib/cache/index.js +++ b/node_modules/make-fetch-happen/lib/cache/index.js @@ -14,8 +14,8 @@ const cacheFetch = async (request, options) => { // otherwise, we make a request, store it and return it const response = await remote(request, options) - const entry = new CacheEntry({ request, response, options }) - return entry.store('miss') + const newEntry = new CacheEntry({ request, response, options }) + return newEntry.store('miss') } // we have a cached response that satisfies this request, however if the cache diff --git a/node_modules/make-fetch-happen/lib/dns.js b/node_modules/make-fetch-happen/lib/dns.js new file mode 100644 index 0000000000000..f817c59f7329c --- /dev/null +++ b/node_modules/make-fetch-happen/lib/dns.js @@ -0,0 +1,49 @@ +const LRUCache = require('lru-cache') +const dns = require('dns') + +const defaultOptions = exports.defaultOptions = { + family: undefined, + hints: dns.ADDRCONFIG, + all: false, + verbatim: true, +} + +const lookupCache = exports.lookupCache = new LRUCache({ max: 50 }) + +// this is a factory so that each request can have its own opts (i.e. ttl) +// while still sharing the cache across all requests +exports.getLookup = (dnsOptions) => { + return (hostname, options, callback) => { + if (typeof options === 'function') { + callback = options + options = null + } else if (typeof options === 'number') { + options = { family: options } + } + + options = { ...defaultOptions, ...options } + + const key = JSON.stringify({ + hostname, + family: options.family, + hints: options.hints, + all: options.all, + verbatim: options.verbatim, + }) + + if (lookupCache.has(key)) { + const [address, family] = lookupCache.get(key) + process.nextTick(callback, null, address, family) + return + } + + dnsOptions.lookup(hostname, options, (err, address, family) => { + if (err) { + return callback(err) + } + + lookupCache.set(key, [address, family], { ttl: dnsOptions.ttl }) + return callback(null, address, family) + }) + } +} diff --git a/node_modules/make-fetch-happen/lib/options.js b/node_modules/make-fetch-happen/lib/options.js index a0c8664adf02a..daa9ecd9d5d5f 100644 --- a/node_modules/make-fetch-happen/lib/options.js +++ b/node_modules/make-fetch-happen/lib/options.js @@ -1,3 +1,5 @@ +const dns = require('dns') + const conditionalHeaders = [ 'if-modified-since', 'if-none-match', @@ -26,6 +28,8 @@ const configureOptions = (opts) => { options.retry = { retries: 0, ...options.retry } } + options.dns = { ttl: 5 * 60 * 1000, lookup: dns.lookup, ...options.dns } + options.cache = options.cache || 'default' if (options.cache === 'default') { const hasConditionalHeader = Object.keys(options.headers || {}).some((name) => { diff --git a/node_modules/make-fetch-happen/package.json b/node_modules/make-fetch-happen/package.json index e52131b8a8e01..e4afddba54090 100644 --- a/node_modules/make-fetch-happen/package.json +++ b/node_modules/make-fetch-happen/package.json @@ -1,11 +1,11 @@ { "name": "make-fetch-happen", - "version": "10.0.6", + "version": "10.1.0", "description": "Opinionated, caching, retrying fetch client", "main": "lib/index.js", "files": [ - "bin", - "lib" + "bin/", + "lib/" ], "scripts": { "preversion": "npm test", @@ -14,13 +14,16 @@ "test": "tap", "posttest": "npm run lint", "eslint": "eslint", - "lint": "eslint '**/*.js'", + "lint": "eslint \"**/*.js\"", "lintfix": "npm run lint -- --fix", - "postlint": "npm-template-check", + "postlint": "template-oss-check", "snap": "tap", - "template-copy": "npm-template-copy --force" + "template-oss-apply": "template-oss-apply --force" + }, + "repository": { + "type": "git", + "url": "https://github.com/npm/make-fetch-happen.git" }, - "repository": "https://github.com/npm/make-fetch-happen", "keywords": [ "http", "request", @@ -34,12 +37,12 @@ "license": "ISC", "dependencies": { "agentkeepalive": "^4.2.1", - "cacache": "^16.0.0", + "cacache": "^16.0.2", "http-cache-semantics": "^4.1.0", "http-proxy-agent": "^5.0.0", "https-proxy-agent": "^5.0.0", "is-lambda": "^1.0.1", - "lru-cache": "^7.5.1", + "lru-cache": "^7.7.1", "minipass": "^3.1.6", "minipass-collect": "^1.0.2", "minipass-fetch": "^2.0.3", @@ -51,17 +54,17 @@ "ssri": "^8.0.1" }, "devDependencies": { - "@npmcli/template-oss": "^2.9.2", - "eslint": "^8.11.0", + "@npmcli/eslint-config": "^3.0.1", + "@npmcli/template-oss": "3.1.2", "mkdirp": "^1.0.4", "nock": "^13.2.4", "rimraf": "^3.0.2", "safe-buffer": "^5.2.1", "standard-version": "^9.3.2", - "tap": "^15.1.6" + "tap": "^16.0.0" }, "engines": { - "node": "^12.13.0 || ^14.15.0 || >=16" + "node": "^12.13.0 || ^14.15.0 || >=16.0.0" }, "tap": { "color": 1, @@ -69,6 +72,7 @@ "check-coverage": true }, "templateOSS": { - "version": "2.9.2" + "//@npmcli/template-oss": "This file is partially managed by @npmcli/template-oss. Edits may be overwritten.", + "version": "3.1.2" } } diff --git a/package-lock.json b/package-lock.json index e30bcc2fa8b3e..a1b25d1a920fd 100644 --- a/package-lock.json +++ b/package-lock.json @@ -122,7 +122,7 @@ "libnpmsearch": "^5.0.2", "libnpmteam": "^4.0.2", "libnpmversion": "^3.0.1", - "make-fetch-happen": "^10.0.6", + "make-fetch-happen": "^10.1.0", "minipass": "^3.1.6", "minipass-pipeline": "^1.2.4", "mkdirp": "^1.0.4", @@ -4869,18 +4869,18 @@ "peer": true }, "node_modules/make-fetch-happen": { - "version": "10.0.6", - "resolved": "https://registry.npmjs.org/make-fetch-happen/-/make-fetch-happen-10.0.6.tgz", - "integrity": "sha512-4Gfh6lV3TLXmj7qz79hBFuvVqjYSMW6v2+sxtdX4LFQU0rK3V/txRjE0DoZb7X0IF3t9f8NO3CxPSWlvdckhVA==", + "version": "10.1.0", + "resolved": "https://registry.npmjs.org/make-fetch-happen/-/make-fetch-happen-10.1.0.tgz", + "integrity": "sha512-HeP4QlkadP/Op+hE+Une1070kcyN85FshQObku3/rmzRh4zDcKXA19d2L3AQR6UoaX3uZmhSOpTLH15b1vOFvQ==", "inBundle": true, "dependencies": { "agentkeepalive": "^4.2.1", - "cacache": "^16.0.0", + "cacache": "^16.0.2", "http-cache-semantics": "^4.1.0", "http-proxy-agent": "^5.0.0", "https-proxy-agent": "^5.0.0", "is-lambda": "^1.0.1", - "lru-cache": "^7.5.1", + "lru-cache": "^7.7.1", "minipass": "^3.1.6", "minipass-collect": "^1.0.2", "minipass-fetch": "^2.0.3", @@ -4892,7 +4892,7 @@ "ssri": "^8.0.1" }, "engines": { - "node": "^12.13.0 || ^14.15.0 || >=16" + "node": "^12.13.0 || ^14.15.0 || >=16.0.0" } }, "node_modules/markdown-escapes": { @@ -14494,17 +14494,17 @@ "peer": true }, "make-fetch-happen": { - "version": "10.0.6", - "resolved": "https://registry.npmjs.org/make-fetch-happen/-/make-fetch-happen-10.0.6.tgz", - "integrity": "sha512-4Gfh6lV3TLXmj7qz79hBFuvVqjYSMW6v2+sxtdX4LFQU0rK3V/txRjE0DoZb7X0IF3t9f8NO3CxPSWlvdckhVA==", + "version": "10.1.0", + "resolved": "https://registry.npmjs.org/make-fetch-happen/-/make-fetch-happen-10.1.0.tgz", + "integrity": "sha512-HeP4QlkadP/Op+hE+Une1070kcyN85FshQObku3/rmzRh4zDcKXA19d2L3AQR6UoaX3uZmhSOpTLH15b1vOFvQ==", "requires": { "agentkeepalive": "^4.2.1", - "cacache": "^16.0.0", + "cacache": "^16.0.2", "http-cache-semantics": "^4.1.0", "http-proxy-agent": "^5.0.0", "https-proxy-agent": "^5.0.0", "is-lambda": "^1.0.1", - "lru-cache": "^7.5.1", + "lru-cache": "^7.7.1", "minipass": "^3.1.6", "minipass-collect": "^1.0.2", "minipass-fetch": "^2.0.3", diff --git a/package.json b/package.json index d51ffcd4dc4fb..482582d1faf41 100644 --- a/package.json +++ b/package.json @@ -90,7 +90,7 @@ "libnpmsearch": "^5.0.2", "libnpmteam": "^4.0.2", "libnpmversion": "^3.0.1", - "make-fetch-happen": "^10.0.6", + "make-fetch-happen": "^10.1.0", "minipass": "^3.1.6", "minipass-pipeline": "^1.2.4", "mkdirp": "^1.0.4",