diff --git a/node_modules/cacache/node_modules/@npmcli/fs/LICENSE.md b/node_modules/cacache/node_modules/@npmcli/fs/LICENSE.md
deleted file mode 100644
index 5fc208ff122e0..0000000000000
--- a/node_modules/cacache/node_modules/@npmcli/fs/LICENSE.md
+++ /dev/null
@@ -1,20 +0,0 @@
-<!-- This file is automatically added by @npmcli/template-oss. Do not edit. -->
-
-ISC License
-
-Copyright npm, Inc.
-
-Permission to use, copy, modify, and/or distribute this
-software for any purpose with or without fee is hereby
-granted, provided that the above copyright notice and this
-permission notice appear in all copies.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND NPM DISCLAIMS ALL
-WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO
-EVENT SHALL NPM BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
-WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
-TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE
-USE OR PERFORMANCE OF THIS SOFTWARE.
diff --git a/node_modules/cacache/node_modules/@npmcli/fs/lib/common/file-url-to-path/index.js b/node_modules/cacache/node_modules/@npmcli/fs/lib/common/file-url-to-path/index.js
deleted file mode 100644
index 7755d1c10e6d0..0000000000000
--- a/node_modules/cacache/node_modules/@npmcli/fs/lib/common/file-url-to-path/index.js
+++ /dev/null
@@ -1,17 +0,0 @@
-const url = require('url')
-
-const node = require('../node.js')
-const polyfill = require('./polyfill.js')
-
-const useNative = node.satisfies('>=10.12.0')
-
-const fileURLToPath = (path) => {
-  // the polyfill is tested separately from this module, no need to hack
-  // process.version to try to trigger it just for coverage
-  // istanbul ignore next
-  return useNative
-    ? url.fileURLToPath(path)
-    : polyfill(path)
-}
-
-module.exports = fileURLToPath
diff --git a/node_modules/cacache/node_modules/@npmcli/fs/lib/common/file-url-to-path/polyfill.js b/node_modules/cacache/node_modules/@npmcli/fs/lib/common/file-url-to-path/polyfill.js
deleted file mode 100644
index 6cc90f0b07d79..0000000000000
--- a/node_modules/cacache/node_modules/@npmcli/fs/lib/common/file-url-to-path/polyfill.js
+++ /dev/null
@@ -1,121 +0,0 @@
-const { URL, domainToUnicode } = require('url')
-
-const CHAR_LOWERCASE_A = 97
-const CHAR_LOWERCASE_Z = 122
-
-const isWindows = process.platform === 'win32'
-
-class ERR_INVALID_FILE_URL_HOST extends TypeError {
-  constructor (platform) {
-    super(`File URL host must be "localhost" or empty on ${platform}`)
-    this.code = 'ERR_INVALID_FILE_URL_HOST'
-  }
-
-  toString () {
-    return `${this.name} [${this.code}]: ${this.message}`
-  }
-}
-
-class ERR_INVALID_FILE_URL_PATH extends TypeError {
-  constructor (msg) {
-    super(`File URL path ${msg}`)
-    this.code = 'ERR_INVALID_FILE_URL_PATH'
-  }
-
-  toString () {
-    return `${this.name} [${this.code}]: ${this.message}`
-  }
-}
-
-class ERR_INVALID_ARG_TYPE extends TypeError {
-  constructor (name, actual) {
-    super(`The "${name}" argument must be one of type string or an instance ` +
-      `of URL. Received type ${typeof actual} ${actual}`)
-    this.code = 'ERR_INVALID_ARG_TYPE'
-  }
-
-  toString () {
-    return `${this.name} [${this.code}]: ${this.message}`
-  }
-}
-
-class ERR_INVALID_URL_SCHEME extends TypeError {
-  constructor (expected) {
-    super(`The URL must be of scheme ${expected}`)
-    this.code = 'ERR_INVALID_URL_SCHEME'
-  }
-
-  toString () {
-    return `${this.name} [${this.code}]: ${this.message}`
-  }
-}
-
-const isURLInstance = (input) => {
-  return input != null && input.href && input.origin
-}
-
-const getPathFromURLWin32 = (url) => {
-  const hostname = url.hostname
-  let pathname = url.pathname
-  for (let n = 0; n < pathname.length; n++) {
-    if (pathname[n] === '%') {
-      const third = pathname.codePointAt(n + 2) | 0x20
-      if ((pathname[n + 1] === '2' && third === 102) ||
-        (pathname[n + 1] === '5' && third === 99)) {
-        throw new ERR_INVALID_FILE_URL_PATH('must not include encoded \\ or / characters')
-      }
-    }
-  }
-
-  pathname = pathname.replace(/\//g, '\\')
-  pathname = decodeURIComponent(pathname)
-  if (hostname !== '') {
-    return `\\\\${domainToUnicode(hostname)}${pathname}`
-  }
-
-  const letter = pathname.codePointAt(1) | 0x20
-  const sep = pathname[2]
-  if (letter < CHAR_LOWERCASE_A || letter > CHAR_LOWERCASE_Z ||
-    (sep !== ':')) {
-    throw new ERR_INVALID_FILE_URL_PATH('must be absolute')
-  }
-
-  return pathname.slice(1)
-}
-
-const getPathFromURLPosix = (url) => {
-  if (url.hostname !== '') {
-    throw new ERR_INVALID_FILE_URL_HOST(process.platform)
-  }
-
-  const pathname = url.pathname
-
-  for (let n = 0; n < pathname.length; n++) {
-    if (pathname[n] === '%') {
-      const third = pathname.codePointAt(n + 2) | 0x20
-      if (pathname[n + 1] === '2' && third === 102) {
-        throw new ERR_INVALID_FILE_URL_PATH('must not include encoded / characters')
-      }
-    }
-  }
-
-  return decodeURIComponent(pathname)
-}
-
-const fileURLToPath = (path) => {
-  if (typeof path === 'string') {
-    path = new URL(path)
-  } else if (!isURLInstance(path)) {
-    throw new ERR_INVALID_ARG_TYPE('path', ['string', 'URL'], path)
-  }
-
-  if (path.protocol !== 'file:') {
-    throw new ERR_INVALID_URL_SCHEME('file')
-  }
-
-  return isWindows
-    ? getPathFromURLWin32(path)
-    : getPathFromURLPosix(path)
-}
-
-module.exports = fileURLToPath
diff --git a/node_modules/cacache/node_modules/@npmcli/fs/lib/common/get-options.js b/node_modules/cacache/node_modules/@npmcli/fs/lib/common/get-options.js
deleted file mode 100644
index cb5982f79077a..0000000000000
--- a/node_modules/cacache/node_modules/@npmcli/fs/lib/common/get-options.js
+++ /dev/null
@@ -1,20 +0,0 @@
-// given an input that may or may not be an object, return an object that has
-// a copy of every defined property listed in 'copy'. if the input is not an
-// object, assign it to the property named by 'wrap'
-const getOptions = (input, { copy, wrap }) => {
-  const result = {}
-
-  if (input && typeof input === 'object') {
-    for (const prop of copy) {
-      if (input[prop] !== undefined) {
-        result[prop] = input[prop]
-      }
-    }
-  } else {
-    result[wrap] = input
-  }
-
-  return result
-}
-
-module.exports = getOptions
diff --git a/node_modules/cacache/node_modules/@npmcli/fs/lib/common/node.js b/node_modules/cacache/node_modules/@npmcli/fs/lib/common/node.js
deleted file mode 100644
index 4d13bc037359d..0000000000000
--- a/node_modules/cacache/node_modules/@npmcli/fs/lib/common/node.js
+++ /dev/null
@@ -1,9 +0,0 @@
-const semver = require('semver')
-
-const satisfies = (range) => {
-  return semver.satisfies(process.version, range, { includePrerelease: true })
-}
-
-module.exports = {
-  satisfies,
-}
diff --git a/node_modules/cacache/node_modules/@npmcli/fs/lib/common/owner.js b/node_modules/cacache/node_modules/@npmcli/fs/lib/common/owner.js
deleted file mode 100644
index e3468b077d00e..0000000000000
--- a/node_modules/cacache/node_modules/@npmcli/fs/lib/common/owner.js
+++ /dev/null
@@ -1,92 +0,0 @@
-const { dirname, resolve } = require('path')
-
-const fileURLToPath = require('./file-url-to-path/index.js')
-const fs = require('../fs.js')
-
-// given a path, find the owner of the nearest parent
-const find = async (path) => {
-  // if we have no getuid, permissions are irrelevant on this platform
-  if (!process.getuid) {
-    return {}
-  }
-
-  // fs methods accept URL objects with a scheme of file: so we need to unwrap
-  // those into an actual path string before we can resolve it
-  const resolved = path != null && path.href && path.origin
-    ? resolve(fileURLToPath(path))
-    : resolve(path)
-
-  let stat
-
-  try {
-    stat = await fs.lstat(resolved)
-  } finally {
-    // if we got a stat, return its contents
-    if (stat) {
-      return { uid: stat.uid, gid: stat.gid }
-    }
-
-    // try the parent directory
-    if (resolved !== dirname(resolved)) {
-      return find(dirname(resolved))
-    }
-
-    // no more parents, never got a stat, just return an empty object
-    return {}
-  }
-}
-
-// given a path, uid, and gid update the ownership of the path if necessary
-const update = async (path, uid, gid) => {
-  // nothing to update, just exit
-  if (uid === undefined && gid === undefined) {
-    return
-  }
-
-  try {
-    // see if the permissions are already the same, if they are we don't
-    // need to do anything, so return early
-    const stat = await fs.stat(path)
-    if (uid === stat.uid && gid === stat.gid) {
-      return
-    }
-  } catch (err) {}
-
-  try {
-    await fs.chown(path, uid, gid)
-  } catch (err) {}
-}
-
-// accepts a `path` and the `owner` property of an options object and normalizes
-// it into an object with numerical `uid` and `gid`
-const validate = async (path, input) => {
-  let uid
-  let gid
-
-  if (typeof input === 'string' || typeof input === 'number') {
-    uid = input
-    gid = input
-  } else if (input && typeof input === 'object') {
-    uid = input.uid
-    gid = input.gid
-  }
-
-  if (uid === 'inherit' || gid === 'inherit') {
-    const owner = await find(path)
-    if (uid === 'inherit') {
-      uid = owner.uid
-    }
-
-    if (gid === 'inherit') {
-      gid = owner.gid
-    }
-  }
-
-  return { uid, gid }
-}
-
-module.exports = {
-  find,
-  update,
-  validate,
-}
diff --git a/node_modules/cacache/node_modules/@npmcli/fs/lib/copy-file.js b/node_modules/cacache/node_modules/@npmcli/fs/lib/copy-file.js
deleted file mode 100644
index d9875aba11f79..0000000000000
--- a/node_modules/cacache/node_modules/@npmcli/fs/lib/copy-file.js
+++ /dev/null
@@ -1,22 +0,0 @@
-const fs = require('./fs.js')
-const getOptions = require('./common/get-options.js')
-const owner = require('./common/owner.js')
-
-const copyFile = async (src, dest, opts) => {
-  const options = getOptions(opts, {
-    copy: ['mode', 'owner'],
-    wrap: 'mode',
-  })
-
-  const { uid, gid } = await owner.validate(dest, options.owner)
-
-  // the node core method as of 16.5.0 does not support the mode being in an
-  // object, so we have to pass the mode value directly
-  const result = await fs.copyFile(src, dest, options.mode)
-
-  await owner.update(dest, uid, gid)
-
-  return result
-}
-
-module.exports = copyFile
diff --git a/node_modules/cacache/node_modules/@npmcli/fs/lib/cp/LICENSE b/node_modules/cacache/node_modules/@npmcli/fs/lib/cp/LICENSE
deleted file mode 100644
index 93546dfb7655b..0000000000000
--- a/node_modules/cacache/node_modules/@npmcli/fs/lib/cp/LICENSE
+++ /dev/null
@@ -1,15 +0,0 @@
-(The MIT License)
-
-Copyright (c) 2011-2017 JP Richardson
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files
-(the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify,
- merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
- furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
-WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS
-OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/node_modules/cacache/node_modules/@npmcli/fs/lib/cp/index.js b/node_modules/cacache/node_modules/@npmcli/fs/lib/cp/index.js
deleted file mode 100644
index 5da4739bdd528..0000000000000
--- a/node_modules/cacache/node_modules/@npmcli/fs/lib/cp/index.js
+++ /dev/null
@@ -1,22 +0,0 @@
-const fs = require('../fs.js')
-const getOptions = require('../common/get-options.js')
-const node = require('../common/node.js')
-const polyfill = require('./polyfill.js')
-
-// node 16.7.0 added fs.cp
-const useNative = node.satisfies('>=16.7.0')
-
-const cp = async (src, dest, opts) => {
-  const options = getOptions(opts, {
-    copy: ['dereference', 'errorOnExist', 'filter', 'force', 'preserveTimestamps', 'recursive'],
-  })
-
-  // the polyfill is tested separately from this module, no need to hack
-  // process.version to try to trigger it just for coverage
-  // istanbul ignore next
-  return useNative
-    ? fs.cp(src, dest, options)
-    : polyfill(src, dest, options)
-}
-
-module.exports = cp
diff --git a/node_modules/cacache/node_modules/@npmcli/fs/lib/cp/polyfill.js b/node_modules/cacache/node_modules/@npmcli/fs/lib/cp/polyfill.js
deleted file mode 100644
index f83ccbf57ecc9..0000000000000
--- a/node_modules/cacache/node_modules/@npmcli/fs/lib/cp/polyfill.js
+++ /dev/null
@@ -1,428 +0,0 @@
-// this file is a modified version of the code in node 17.2.0
-// which is, in turn, a modified version of the fs-extra module on npm
-// node core changes:
-// - Use of the assert module has been replaced with core's error system.
-// - All code related to the glob dependency has been removed.
-// - Bring your own custom fs module is not currently supported.
-// - Some basic code cleanup.
-// changes here:
-// - remove all callback related code
-// - drop sync support
-// - change assertions back to non-internal methods (see options.js)
-// - throws ENOTDIR when rmdir gets an ENOENT for a path that exists in Windows
-'use strict'
-
-const {
-  ERR_FS_CP_DIR_TO_NON_DIR,
-  ERR_FS_CP_EEXIST,
-  ERR_FS_CP_EINVAL,
-  ERR_FS_CP_FIFO_PIPE,
-  ERR_FS_CP_NON_DIR_TO_DIR,
-  ERR_FS_CP_SOCKET,
-  ERR_FS_CP_SYMLINK_TO_SUBDIRECTORY,
-  ERR_FS_CP_UNKNOWN,
-  ERR_FS_EISDIR,
-  ERR_INVALID_ARG_TYPE,
-} = require('../errors.js')
-const {
-  constants: {
-    errno: {
-      EEXIST,
-      EISDIR,
-      EINVAL,
-      ENOTDIR,
-    },
-  },
-} = require('os')
-const {
-  chmod,
-  copyFile,
-  lstat,
-  mkdir,
-  readdir,
-  readlink,
-  stat,
-  symlink,
-  unlink,
-  utimes,
-} = require('../fs.js')
-const {
-  dirname,
-  isAbsolute,
-  join,
-  parse,
-  resolve,
-  sep,
-  toNamespacedPath,
-} = require('path')
-const { fileURLToPath } = require('url')
-
-const defaultOptions = {
-  dereference: false,
-  errorOnExist: false,
-  filter: undefined,
-  force: true,
-  preserveTimestamps: false,
-  recursive: false,
-}
-
-async function cp (src, dest, opts) {
-  if (opts != null && typeof opts !== 'object') {
-    throw new ERR_INVALID_ARG_TYPE('options', ['Object'], opts)
-  }
-  return cpFn(
-    toNamespacedPath(getValidatedPath(src)),
-    toNamespacedPath(getValidatedPath(dest)),
-    { ...defaultOptions, ...opts })
-}
-
-function getValidatedPath (fileURLOrPath) {
-  const path = fileURLOrPath != null && fileURLOrPath.href
-      && fileURLOrPath.origin
-    ? fileURLToPath(fileURLOrPath)
-    : fileURLOrPath
-  return path
-}
-
-async function cpFn (src, dest, opts) {
-  // Warn about using preserveTimestamps on 32-bit node
-  // istanbul ignore next
-  if (opts.preserveTimestamps && process.arch === 'ia32') {
-    const warning = 'Using the preserveTimestamps option in 32-bit ' +
-      'node is not recommended'
-    process.emitWarning(warning, 'TimestampPrecisionWarning')
-  }
-  const stats = await checkPaths(src, dest, opts)
-  const { srcStat, destStat } = stats
-  await checkParentPaths(src, srcStat, dest)
-  if (opts.filter) {
-    return handleFilter(checkParentDir, destStat, src, dest, opts)
-  }
-  return checkParentDir(destStat, src, dest, opts)
-}
-
-async function checkPaths (src, dest, opts) {
-  const { 0: srcStat, 1: destStat } = await getStats(src, dest, opts)
-  if (destStat) {
-    if (areIdentical(srcStat, destStat)) {
-      throw new ERR_FS_CP_EINVAL({
-        message: 'src and dest cannot be the same',
-        path: dest,
-        syscall: 'cp',
-        errno: EINVAL,
-      })
-    }
-    if (srcStat.isDirectory() && !destStat.isDirectory()) {
-      throw new ERR_FS_CP_DIR_TO_NON_DIR({
-        message: `cannot overwrite directory ${src} ` +
-            `with non-directory ${dest}`,
-        path: dest,
-        syscall: 'cp',
-        errno: EISDIR,
-      })
-    }
-    if (!srcStat.isDirectory() && destStat.isDirectory()) {
-      throw new ERR_FS_CP_NON_DIR_TO_DIR({
-        message: `cannot overwrite non-directory ${src} ` +
-            `with directory ${dest}`,
-        path: dest,
-        syscall: 'cp',
-        errno: ENOTDIR,
-      })
-    }
-  }
-
-  if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {
-    throw new ERR_FS_CP_EINVAL({
-      message: `cannot copy ${src} to a subdirectory of self ${dest}`,
-      path: dest,
-      syscall: 'cp',
-      errno: EINVAL,
-    })
-  }
-  return { srcStat, destStat }
-}
-
-function areIdentical (srcStat, destStat) {
-  return destStat.ino && destStat.dev && destStat.ino === srcStat.ino &&
-    destStat.dev === srcStat.dev
-}
-
-function getStats (src, dest, opts) {
-  const statFunc = opts.dereference ?
-    (file) => stat(file, { bigint: true }) :
-    (file) => lstat(file, { bigint: true })
-  return Promise.all([
-    statFunc(src),
-    statFunc(dest).catch((err) => {
-      // istanbul ignore next: unsure how to cover.
-      if (err.code === 'ENOENT') {
-        return null
-      }
-      // istanbul ignore next: unsure how to cover.
-      throw err
-    }),
-  ])
-}
-
-async function checkParentDir (destStat, src, dest, opts) {
-  const destParent = dirname(dest)
-  const dirExists = await pathExists(destParent)
-  if (dirExists) {
-    return getStatsForCopy(destStat, src, dest, opts)
-  }
-  await mkdir(destParent, { recursive: true })
-  return getStatsForCopy(destStat, src, dest, opts)
-}
-
-function pathExists (dest) {
-  return stat(dest).then(
-    () => true,
-    // istanbul ignore next: not sure when this would occur
-    (err) => (err.code === 'ENOENT' ? false : Promise.reject(err)))
-}
-
-// Recursively check if dest parent is a subdirectory of src.
-// It works for all file types including symlinks since it
-// checks the src and dest inodes. It starts from the deepest
-// parent and stops once it reaches the src parent or the root path.
-async function checkParentPaths (src, srcStat, dest) {
-  const srcParent = resolve(dirname(src))
-  const destParent = resolve(dirname(dest))
-  if (destParent === srcParent || destParent === parse(destParent).root) {
-    return
-  }
-  let destStat
-  try {
-    destStat = await stat(destParent, { bigint: true })
-  } catch (err) {
-    // istanbul ignore else: not sure when this would occur
-    if (err.code === 'ENOENT') {
-      return
-    }
-    // istanbul ignore next: not sure when this would occur
-    throw err
-  }
-  if (areIdentical(srcStat, destStat)) {
-    throw new ERR_FS_CP_EINVAL({
-      message: `cannot copy ${src} to a subdirectory of self ${dest}`,
-      path: dest,
-      syscall: 'cp',
-      errno: EINVAL,
-    })
-  }
-  return checkParentPaths(src, srcStat, destParent)
-}
-
-const normalizePathToArray = (path) =>
-  resolve(path).split(sep).filter(Boolean)
-
-// Return true if dest is a subdir of src, otherwise false.
-// It only checks the path strings.
-function isSrcSubdir (src, dest) {
-  const srcArr = normalizePathToArray(src)
-  const destArr = normalizePathToArray(dest)
-  return srcArr.every((cur, i) => destArr[i] === cur)
-}
-
-async function handleFilter (onInclude, destStat, src, dest, opts, cb) {
-  const include = await opts.filter(src, dest)
-  if (include) {
-    return onInclude(destStat, src, dest, opts, cb)
-  }
-}
-
-function startCopy (destStat, src, dest, opts) {
-  if (opts.filter) {
-    return handleFilter(getStatsForCopy, destStat, src, dest, opts)
-  }
-  return getStatsForCopy(destStat, src, dest, opts)
-}
-
-async function getStatsForCopy (destStat, src, dest, opts) {
-  const statFn = opts.dereference ? stat : lstat
-  const srcStat = await statFn(src)
-  // istanbul ignore else: can't portably test FIFO
-  if (srcStat.isDirectory() && opts.recursive) {
-    return onDir(srcStat, destStat, src, dest, opts)
-  } else if (srcStat.isDirectory()) {
-    throw new ERR_FS_EISDIR({
-      message: `${src} is a directory (not copied)`,
-      path: src,
-      syscall: 'cp',
-      errno: EINVAL,
-    })
-  } else if (srcStat.isFile() ||
-            srcStat.isCharacterDevice() ||
-            srcStat.isBlockDevice()) {
-    return onFile(srcStat, destStat, src, dest, opts)
-  } else if (srcStat.isSymbolicLink()) {
-    return onLink(destStat, src, dest)
-  } else if (srcStat.isSocket()) {
-    throw new ERR_FS_CP_SOCKET({
-      message: `cannot copy a socket file: ${dest}`,
-      path: dest,
-      syscall: 'cp',
-      errno: EINVAL,
-    })
-  } else if (srcStat.isFIFO()) {
-    throw new ERR_FS_CP_FIFO_PIPE({
-      message: `cannot copy a FIFO pipe: ${dest}`,
-      path: dest,
-      syscall: 'cp',
-      errno: EINVAL,
-    })
-  }
-  // istanbul ignore next: should be unreachable
-  throw new ERR_FS_CP_UNKNOWN({
-    message: `cannot copy an unknown file type: ${dest}`,
-    path: dest,
-    syscall: 'cp',
-    errno: EINVAL,
-  })
-}
-
-function onFile (srcStat, destStat, src, dest, opts) {
-  if (!destStat) {
-    return _copyFile(srcStat, src, dest, opts)
-  }
-  return mayCopyFile(srcStat, src, dest, opts)
-}
-
-async function mayCopyFile (srcStat, src, dest, opts) {
-  if (opts.force) {
-    await unlink(dest)
-    return _copyFile(srcStat, src, dest, opts)
-  } else if (opts.errorOnExist) {
-    throw new ERR_FS_CP_EEXIST({
-      message: `${dest} already exists`,
-      path: dest,
-      syscall: 'cp',
-      errno: EEXIST,
-    })
-  }
-}
-
-async function _copyFile (srcStat, src, dest, opts) {
-  await copyFile(src, dest)
-  if (opts.preserveTimestamps) {
-    return handleTimestampsAndMode(srcStat.mode, src, dest)
-  }
-  return setDestMode(dest, srcStat.mode)
-}
-
-async function handleTimestampsAndMode (srcMode, src, dest) {
-  // Make sure the file is writable before setting the timestamp
-  // otherwise open fails with EPERM when invoked with 'r+'
-  // (through utimes call)
-  if (fileIsNotWritable(srcMode)) {
-    await makeFileWritable(dest, srcMode)
-    return setDestTimestampsAndMode(srcMode, src, dest)
-  }
-  return setDestTimestampsAndMode(srcMode, src, dest)
-}
-
-function fileIsNotWritable (srcMode) {
-  return (srcMode & 0o200) === 0
-}
-
-function makeFileWritable (dest, srcMode) {
-  return setDestMode(dest, srcMode | 0o200)
-}
-
-async function setDestTimestampsAndMode (srcMode, src, dest) {
-  await setDestTimestamps(src, dest)
-  return setDestMode(dest, srcMode)
-}
-
-function setDestMode (dest, srcMode) {
-  return chmod(dest, srcMode)
-}
-
-async function setDestTimestamps (src, dest) {
-  // The initial srcStat.atime cannot be trusted
-  // because it is modified by the read(2) system call
-  // (See https://nodejs.org/api/fs.html#fs_stat_time_values)
-  const updatedSrcStat = await stat(src)
-  return utimes(dest, updatedSrcStat.atime, updatedSrcStat.mtime)
-}
-
-function onDir (srcStat, destStat, src, dest, opts) {
-  if (!destStat) {
-    return mkDirAndCopy(srcStat.mode, src, dest, opts)
-  }
-  return copyDir(src, dest, opts)
-}
-
-async function mkDirAndCopy (srcMode, src, dest, opts) {
-  await mkdir(dest)
-  await copyDir(src, dest, opts)
-  return setDestMode(dest, srcMode)
-}
-
-async function copyDir (src, dest, opts) {
-  const dir = await readdir(src)
-  for (let i = 0; i < dir.length; i++) {
-    const item = dir[i]
-    const srcItem = join(src, item)
-    const destItem = join(dest, item)
-    const { destStat } = await checkPaths(srcItem, destItem, opts)
-    await startCopy(destStat, srcItem, destItem, opts)
-  }
-}
-
-async function onLink (destStat, src, dest) {
-  let resolvedSrc = await readlink(src)
-  if (!isAbsolute(resolvedSrc)) {
-    resolvedSrc = resolve(dirname(src), resolvedSrc)
-  }
-  if (!destStat) {
-    return symlink(resolvedSrc, dest)
-  }
-  let resolvedDest
-  try {
-    resolvedDest = await readlink(dest)
-  } catch (err) {
-    // Dest exists and is a regular file or directory,
-    // Windows may throw UNKNOWN error. If dest already exists,
-    // fs throws error anyway, so no need to guard against it here.
-    // istanbul ignore next: can only test on windows
-    if (err.code === 'EINVAL' || err.code === 'UNKNOWN') {
-      return symlink(resolvedSrc, dest)
-    }
-    // istanbul ignore next: should not be possible
-    throw err
-  }
-  if (!isAbsolute(resolvedDest)) {
-    resolvedDest = resolve(dirname(dest), resolvedDest)
-  }
-  if (isSrcSubdir(resolvedSrc, resolvedDest)) {
-    throw new ERR_FS_CP_EINVAL({
-      message: `cannot copy ${resolvedSrc} to a subdirectory of self ` +
-            `${resolvedDest}`,
-      path: dest,
-      syscall: 'cp',
-      errno: EINVAL,
-    })
-  }
-  // Do not copy if src is a subdir of dest since unlinking
-  // dest in this case would result in removing src contents
-  // and therefore a broken symlink would be created.
-  const srcStat = await stat(src)
-  if (srcStat.isDirectory() && isSrcSubdir(resolvedDest, resolvedSrc)) {
-    throw new ERR_FS_CP_SYMLINK_TO_SUBDIRECTORY({
-      message: `cannot overwrite ${resolvedDest} with ${resolvedSrc}`,
-      path: dest,
-      syscall: 'cp',
-      errno: EINVAL,
-    })
-  }
-  return copyLink(resolvedSrc, dest)
-}
-
-async function copyLink (resolvedSrc, dest) {
-  await unlink(dest)
-  return symlink(resolvedSrc, dest)
-}
-
-module.exports = cp
diff --git a/node_modules/cacache/node_modules/@npmcli/fs/lib/errors.js b/node_modules/cacache/node_modules/@npmcli/fs/lib/errors.js
deleted file mode 100644
index 1cd1e05d0c533..0000000000000
--- a/node_modules/cacache/node_modules/@npmcli/fs/lib/errors.js
+++ /dev/null
@@ -1,129 +0,0 @@
-'use strict'
-const { inspect } = require('util')
-
-// adapted from node's internal/errors
-// https://github.com/nodejs/node/blob/c8a04049/lib/internal/errors.js
-
-// close copy of node's internal SystemError class.
-class SystemError {
-  constructor (code, prefix, context) {
-    // XXX context.code is undefined in all constructors used in cp/polyfill
-    // that may be a bug copied from node, maybe the constructor should use
-    // `code` not `errno`?  nodejs/node#41104
-    let message = `${prefix}: ${context.syscall} returned ` +
-                  `${context.code} (${context.message})`
-
-    if (context.path !== undefined) {
-      message += ` ${context.path}`
-    }
-    if (context.dest !== undefined) {
-      message += ` => ${context.dest}`
-    }
-
-    this.code = code
-    Object.defineProperties(this, {
-      name: {
-        value: 'SystemError',
-        enumerable: false,
-        writable: true,
-        configurable: true,
-      },
-      message: {
-        value: message,
-        enumerable: false,
-        writable: true,
-        configurable: true,
-      },
-      info: {
-        value: context,
-        enumerable: true,
-        configurable: true,
-        writable: false,
-      },
-      errno: {
-        get () {
-          return context.errno
-        },
-        set (value) {
-          context.errno = value
-        },
-        enumerable: true,
-        configurable: true,
-      },
-      syscall: {
-        get () {
-          return context.syscall
-        },
-        set (value) {
-          context.syscall = value
-        },
-        enumerable: true,
-        configurable: true,
-      },
-    })
-
-    if (context.path !== undefined) {
-      Object.defineProperty(this, 'path', {
-        get () {
-          return context.path
-        },
-        set (value) {
-          context.path = value
-        },
-        enumerable: true,
-        configurable: true,
-      })
-    }
-
-    if (context.dest !== undefined) {
-      Object.defineProperty(this, 'dest', {
-        get () {
-          return context.dest
-        },
-        set (value) {
-          context.dest = value
-        },
-        enumerable: true,
-        configurable: true,
-      })
-    }
-  }
-
-  toString () {
-    return `${this.name} [${this.code}]: ${this.message}`
-  }
-
-  [Symbol.for('nodejs.util.inspect.custom')] (_recurseTimes, ctx) {
-    return inspect(this, {
-      ...ctx,
-      getters: true,
-      customInspect: false,
-    })
-  }
-}
-
-function E (code, message) {
-  module.exports[code] = class NodeError extends SystemError {
-    constructor (ctx) {
-      super(code, message, ctx)
-    }
-  }
-}
-
-E('ERR_FS_CP_DIR_TO_NON_DIR', 'Cannot overwrite directory with non-directory')
-E('ERR_FS_CP_EEXIST', 'Target already exists')
-E('ERR_FS_CP_EINVAL', 'Invalid src or dest')
-E('ERR_FS_CP_FIFO_PIPE', 'Cannot copy a FIFO pipe')
-E('ERR_FS_CP_NON_DIR_TO_DIR', 'Cannot overwrite non-directory with directory')
-E('ERR_FS_CP_SOCKET', 'Cannot copy a socket file')
-E('ERR_FS_CP_SYMLINK_TO_SUBDIRECTORY', 'Cannot overwrite symlink in subdirectory of self')
-E('ERR_FS_CP_UNKNOWN', 'Cannot copy an unknown file type')
-E('ERR_FS_EISDIR', 'Path is a directory')
-
-module.exports.ERR_INVALID_ARG_TYPE = class ERR_INVALID_ARG_TYPE extends Error {
-  constructor (name, expected, actual) {
-    super()
-    this.code = 'ERR_INVALID_ARG_TYPE'
-    this.message = `The ${name} argument must be ${expected}. Received ${typeof actual}`
-  }
-}
diff --git a/node_modules/cacache/node_modules/@npmcli/fs/lib/fs.js b/node_modules/cacache/node_modules/@npmcli/fs/lib/fs.js
deleted file mode 100644
index 29e5fb5735683..0000000000000
--- a/node_modules/cacache/node_modules/@npmcli/fs/lib/fs.js
+++ /dev/null
@@ -1,8 +0,0 @@
-const fs = require('fs')
-const promisify = require('@gar/promisify')
-
-// this module returns the core fs module wrapped in a proxy that promisifies
-// method calls within the getter. we keep it in a separate module so that the
-// overridden methods have a consistent way to get to promisified fs methods
-// without creating a circular dependency
-module.exports = promisify(fs)
diff --git a/node_modules/cacache/node_modules/@npmcli/fs/lib/index.js b/node_modules/cacache/node_modules/@npmcli/fs/lib/index.js
deleted file mode 100644
index e40d748a7da60..0000000000000
--- a/node_modules/cacache/node_modules/@npmcli/fs/lib/index.js
+++ /dev/null
@@ -1,10 +0,0 @@
-module.exports = {
-  ...require('./fs.js'),
-  copyFile: require('./copy-file.js'),
-  cp: require('./cp/index.js'),
-  mkdir: require('./mkdir/index.js'),
-  mkdtemp: require('./mkdtemp.js'),
-  rm: require('./rm/index.js'),
-  withTempDir: require('./with-temp-dir.js'),
-  writeFile: require('./write-file.js'),
-}
diff --git a/node_modules/cacache/node_modules/@npmcli/fs/lib/mkdir/index.js b/node_modules/cacache/node_modules/@npmcli/fs/lib/mkdir/index.js
deleted file mode 100644
index 04ff447903454..0000000000000
--- a/node_modules/cacache/node_modules/@npmcli/fs/lib/mkdir/index.js
+++ /dev/null
@@ -1,32 +0,0 @@
-const fs = require('../fs.js')
-const getOptions = require('../common/get-options.js')
-const node = require('../common/node.js')
-const owner = require('../common/owner.js')
-
-const polyfill = require('./polyfill.js')
-
-// node 10.12.0 added the options parameter, which allows recursive and mode
-// properties to be passed
-const useNative = node.satisfies('>=10.12.0')
-
-// extends mkdir with the ability to specify an owner of the new dir
-const mkdir = async (path, opts) => {
-  const options = getOptions(opts, {
-    copy: ['mode', 'recursive', 'owner'],
-    wrap: 'mode',
-  })
-  const { uid, gid } = await owner.validate(path, options.owner)
-
-  // the polyfill is tested separately from this module, no need to hack
-  // process.version to try to trigger it just for coverage
-  // istanbul ignore next
-  const result = useNative
-    ? await fs.mkdir(path, options)
-    : await polyfill(path, options)
-
-  await owner.update(path, uid, gid)
-
-  return result
-}
-
-module.exports = mkdir
diff --git a/node_modules/cacache/node_modules/@npmcli/fs/lib/mkdir/polyfill.js b/node_modules/cacache/node_modules/@npmcli/fs/lib/mkdir/polyfill.js
deleted file mode 100644
index 4f8e6f006a30e..0000000000000
--- a/node_modules/cacache/node_modules/@npmcli/fs/lib/mkdir/polyfill.js
+++ /dev/null
@@ -1,81 +0,0 @@
-const { dirname } = require('path')
-
-const fileURLToPath = require('../common/file-url-to-path/index.js')
-const fs = require('../fs.js')
-
-const defaultOptions = {
-  mode: 0o777,
-  recursive: false,
-}
-
-const mkdir = async (path, opts) => {
-  const options = { ...defaultOptions, ...opts }
-
-  // if we're not in recursive mode, just call the real mkdir with the path and
-  // the mode option only
-  if (!options.recursive) {
-    return fs.mkdir(path, options.mode)
-  }
-
-  const makeDirectory = async (dir, mode) => {
-    // we can't use dirname directly since these functions support URL
-    // objects with the file: protocol as the path input, so first we get a
-    // string path, then we can call dirname on that
-    const parent = dir != null && dir.href && dir.origin
-      ? dirname(fileURLToPath(dir))
-      : dirname(dir)
-
-    // if the parent is the dir itself, try to create it. anything but EISDIR
-    // should be rethrown
-    if (parent === dir) {
-      try {
-        await fs.mkdir(dir, opts)
-      } catch (err) {
-        if (err.code !== 'EISDIR') {
-          throw err
-        }
-      }
-      return undefined
-    }
-
-    try {
-      await fs.mkdir(dir, mode)
-      return dir
-    } catch (err) {
-      // ENOENT means the parent wasn't there, so create that
-      if (err.code === 'ENOENT') {
-        const made = await makeDirectory(parent, mode)
-        await makeDirectory(dir, mode)
-        // return the shallowest path we created, i.e. the result of creating
-        // the parent
-        return made
-      }
-
-      // an EEXIST means there's already something there
-      // an EROFS means we have a read-only filesystem and can't create a dir
-      // any other error is fatal and we should give up now
-      if (err.code !== 'EEXIST' && err.code !== 'EROFS') {
-        throw err
-      }
-
-      // stat the directory, if the result is a directory, then we successfully
-      // created this one so return its path. otherwise, we reject with the
-      // original error by ignoring the error in the catch
-      try {
-        const stat = await fs.stat(dir)
-        if (stat.isDirectory()) {
-          // if it already existed, we didn't create anything so return
-          // undefined
-          return undefined
-        }
-      } catch (_) {}
-
-      // if the thing that's there isn't a directory, then just re-throw
-      throw err
-    }
-  }
-
-  return makeDirectory(path, options.mode)
-}
-
-module.exports = mkdir
diff --git a/node_modules/cacache/node_modules/@npmcli/fs/lib/mkdtemp.js b/node_modules/cacache/node_modules/@npmcli/fs/lib/mkdtemp.js
deleted file mode 100644
index b7f078029d111..0000000000000
--- a/node_modules/cacache/node_modules/@npmcli/fs/lib/mkdtemp.js
+++ /dev/null
@@ -1,28 +0,0 @@
-const { dirname, sep } = require('path')
-
-const fs = require('./fs.js')
-const getOptions = require('./common/get-options.js')
-const owner = require('./common/owner.js')
-
-const mkdtemp = async (prefix, opts) => {
-  const options = getOptions(opts, {
-    copy: ['encoding', 'owner'],
-    wrap: 'encoding',
-  })
-
-  // mkdtemp relies on the trailing path separator to indicate if it should
-  // create a directory inside of the prefix. if that's the case then the root
-  // we infer ownership from is the prefix itself, otherwise it's the dirname
-  // /tmp -> /tmpABCDEF, infers from /
-  // /tmp/ -> /tmp/ABCDEF, infers from /tmp
-  const root = prefix.endsWith(sep) ? prefix : dirname(prefix)
-  const { uid, gid } = await owner.validate(root, options.owner)
-
-  const result = await fs.mkdtemp(prefix, options)
-
-  await owner.update(result, uid, gid)
-
-  return result
-}
-
-module.exports = mkdtemp
diff --git a/node_modules/cacache/node_modules/@npmcli/fs/lib/rm/index.js b/node_modules/cacache/node_modules/@npmcli/fs/lib/rm/index.js
deleted file mode 100644
index cb81fbdf8cc47..0000000000000
--- a/node_modules/cacache/node_modules/@npmcli/fs/lib/rm/index.js
+++ /dev/null
@@ -1,22 +0,0 @@
-const fs = require('../fs.js')
-const getOptions = require('../common/get-options.js')
-const node = require('../common/node.js')
-const polyfill = require('./polyfill.js')
-
-// node 14.14.0 added fs.rm, which allows both the force and recursive options
-const useNative = node.satisfies('>=14.14.0')
-
-const rm = async (path, opts) => {
-  const options = getOptions(opts, {
-    copy: ['retryDelay', 'maxRetries', 'recursive', 'force'],
-  })
-
-  // the polyfill is tested separately from this module, no need to hack
-  // process.version to try to trigger it just for coverage
-  // istanbul ignore next
-  return useNative
-    ? fs.rm(path, options)
-    : polyfill(path, options)
-}
-
-module.exports = rm
diff --git a/node_modules/cacache/node_modules/@npmcli/fs/lib/rm/polyfill.js b/node_modules/cacache/node_modules/@npmcli/fs/lib/rm/polyfill.js
deleted file mode 100644
index a25c17483b001..0000000000000
--- a/node_modules/cacache/node_modules/@npmcli/fs/lib/rm/polyfill.js
+++ /dev/null
@@ -1,239 +0,0 @@
-// this file is a modified version of the code in node core >=14.14.0
-// which is, in turn, a modified version of the rimraf module on npm
-// node core changes:
-// - Use of the assert module has been replaced with core's error system.
-// - All code related to the glob dependency has been removed.
-// - Bring your own custom fs module is not currently supported.
-// - Some basic code cleanup.
-// changes here:
-// - remove all callback related code
-// - drop sync support
-// - change assertions back to non-internal methods (see options.js)
-// - throws ENOTDIR when rmdir gets an ENOENT for a path that exists in Windows
-const errnos = require('os').constants.errno
-const { join } = require('path')
-const fs = require('../fs.js')
-
-// error codes that mean we need to remove contents
-const notEmptyCodes = new Set([
-  'ENOTEMPTY',
-  'EEXIST',
-  'EPERM',
-])
-
-// error codes we can retry later
-const retryCodes = new Set([
-  'EBUSY',
-  'EMFILE',
-  'ENFILE',
-  'ENOTEMPTY',
-  'EPERM',
-])
-
-const isWindows = process.platform === 'win32'
-
-const defaultOptions = {
-  retryDelay: 100,
-  maxRetries: 0,
-  recursive: false,
-  force: false,
-}
-
-// this is drastically simplified, but should be roughly equivalent to what
-// node core throws
-class ERR_FS_EISDIR extends Error {
-  constructor (path) {
-    super()
-    this.info = {
-      code: 'EISDIR',
-      message: 'is a directory',
-      path,
-      syscall: 'rm',
-      errno: errnos.EISDIR,
-    }
-    this.name = 'SystemError'
-    this.code = 'ERR_FS_EISDIR'
-    this.errno = errnos.EISDIR
-    this.syscall = 'rm'
-    this.path = path
-    this.message = `Path is a directory: ${this.syscall} returned ` +
-      `${this.info.code} (is a directory) ${path}`
-  }
-
-  toString () {
-    return `${this.name} [${this.code}]: ${this.message}`
-  }
-}
-
-class ENOTDIR extends Error {
-  constructor (path) {
-    super()
-    this.name = 'Error'
-    this.code = 'ENOTDIR'
-    this.errno = errnos.ENOTDIR
-    this.syscall = 'rmdir'
-    this.path = path
-    this.message = `not a directory, ${this.syscall} '${this.path}'`
-  }
-
-  toString () {
-    return `${this.name}: ${this.code}: ${this.message}`
-  }
-}
-
-// force is passed separately here because we respect it for the first entry
-// into rimraf only, any further calls that are spawned as a result (i.e. to
-// delete content within the target) will ignore ENOENT errors
-const rimraf = async (path, options, isTop = false) => {
-  const force = isTop ? options.force : true
-  const stat = await fs.lstat(path)
-    .catch((err) => {
-      // we only ignore ENOENT if we're forcing this call
-      if (err.code === 'ENOENT' && force) {
-        return
-      }
-
-      if (isWindows && err.code === 'EPERM') {
-        return fixEPERM(path, options, err, isTop)
-      }
-
-      throw err
-    })
-
-  // no stat object here means either lstat threw an ENOENT, or lstat threw
-  // an EPERM and the fixPERM function took care of things. either way, we're
-  // already done, so return early
-  if (!stat) {
-    return
-  }
-
-  if (stat.isDirectory()) {
-    return rmdir(path, options, null, isTop)
-  }
-
-  return fs.unlink(path)
-    .catch((err) => {
-      if (err.code === 'ENOENT' && force) {
-        return
-      }
-
-      if (err.code === 'EISDIR') {
-        return rmdir(path, options, err, isTop)
-      }
-
-      if (err.code === 'EPERM') {
-        // in windows, we handle this through fixEPERM which will also try to
-        // delete things again. everywhere else since deleting the target as a
-        // file didn't work we go ahead and try to delete it as a directory
-        return isWindows
-          ? fixEPERM(path, options, err, isTop)
-          : rmdir(path, options, err, isTop)
-      }
-
-      throw err
-    })
-}
-
-const fixEPERM = async (path, options, originalErr, isTop) => {
-  const force = isTop ? options.force : true
-  const targetMissing = await fs.chmod(path, 0o666)
-    .catch((err) => {
-      if (err.code === 'ENOENT' && force) {
-        return true
-      }
-
-      throw originalErr
-    })
-
-  // got an ENOENT above, return now. no file = no problem
-  if (targetMissing) {
-    return
-  }
-
-  // this function does its own lstat rather than calling rimraf again to avoid
-  // infinite recursion for a repeating EPERM
-  const stat = await fs.lstat(path)
-    .catch((err) => {
-      if (err.code === 'ENOENT' && force) {
-        return
-      }
-
-      throw originalErr
-    })
-
-  if (!stat) {
-    return
-  }
-
-  if (stat.isDirectory()) {
-    return rmdir(path, options, originalErr, isTop)
-  }
-
-  return fs.unlink(path)
-}
-
-const rmdir = async (path, options, originalErr, isTop) => {
-  if (!options.recursive && isTop) {
-    throw originalErr || new ERR_FS_EISDIR(path)
-  }
-  const force = isTop ? options.force : true
-
-  return fs.rmdir(path)
-    .catch(async (err) => {
-      // in Windows, calling rmdir on a file path will fail with ENOENT rather
-      // than ENOTDIR. to determine if that's what happened, we have to do
-      // another lstat on the path. if the path isn't actually gone, we throw
-      // away the ENOENT and replace it with our own ENOTDIR
-      if (isWindows && err.code === 'ENOENT') {
-        const stillExists = await fs.lstat(path).then(() => true, () => false)
-        if (stillExists) {
-          err = new ENOTDIR(path)
-        }
-      }
-
-      // not there, not a problem
-      if (err.code === 'ENOENT' && force) {
-        return
-      }
-
-      // we may not have originalErr if lstat tells us our target is a
-      // directory but that changes before we actually remove it, so
-      // only throw it here if it's set
-      if (originalErr && err.code === 'ENOTDIR') {
-        throw originalErr
-      }
-
-      // the directory isn't empty, remove the contents and try again
-      if (notEmptyCodes.has(err.code)) {
-        const files = await fs.readdir(path)
-        await Promise.all(files.map((file) => {
-          const target = join(path, file)
-          return rimraf(target, options)
-        }))
-        return fs.rmdir(path)
-      }
-
-      throw err
-    })
-}
-
-const rm = async (path, opts) => {
-  const options = { ...defaultOptions, ...opts }
-  let retries = 0
-
-  const errHandler = async (err) => {
-    if (retryCodes.has(err.code) && ++retries < options.maxRetries) {
-      const delay = retries * options.retryDelay
-      await promiseTimeout(delay)
-      return rimraf(path, options, true).catch(errHandler)
-    }
-
-    throw err
-  }
-
-  return rimraf(path, options, true).catch(errHandler)
-}
-
-const promiseTimeout = (ms) => new Promise((r) => setTimeout(r, ms))
-
-module.exports = rm
diff --git a/node_modules/cacache/node_modules/@npmcli/fs/lib/with-temp-dir.js b/node_modules/cacache/node_modules/@npmcli/fs/lib/with-temp-dir.js
deleted file mode 100644
index 353d5555d10f6..0000000000000
--- a/node_modules/cacache/node_modules/@npmcli/fs/lib/with-temp-dir.js
+++ /dev/null
@@ -1,39 +0,0 @@
-const { join, sep } = require('path')
-
-const getOptions = require('./common/get-options.js')
-const mkdir = require('./mkdir/index.js')
-const mkdtemp = require('./mkdtemp.js')
-const rm = require('./rm/index.js')
-
-// create a temp directory, ensure its permissions match its parent, then call
-// the supplied function passing it the path to the directory. clean up after
-// the function finishes, whether it throws or not
-const withTempDir = async (root, fn, opts) => {
-  const options = getOptions(opts, {
-    copy: ['tmpPrefix'],
-  })
-  // create the directory, and fix its ownership
-  await mkdir(root, { recursive: true, owner: 'inherit' })
-
-  const target = await mkdtemp(join(`${root}${sep}`, options.tmpPrefix || ''), { owner: 'inherit' })
-  let err
-  let result
-
-  try {
-    result = await fn(target)
-  } catch (_err) {
-    err = _err
-  }
-
-  try {
-    await rm(target, { force: true, recursive: true })
-  } catch (err) {}
-
-  if (err) {
-    throw err
-  }
-
-  return result
-}
-
-module.exports = withTempDir
diff --git a/node_modules/cacache/node_modules/@npmcli/fs/lib/write-file.js b/node_modules/cacache/node_modules/@npmcli/fs/lib/write-file.js
deleted file mode 100644
index 01de531d980c4..0000000000000
--- a/node_modules/cacache/node_modules/@npmcli/fs/lib/write-file.js
+++ /dev/null
@@ -1,19 +0,0 @@
-const fs = require('./fs.js')
-const getOptions = require('./common/get-options.js')
-const owner = require('./common/owner.js')
-
-const writeFile = async (file, data, opts) => {
-  const options = getOptions(opts, {
-    copy: ['encoding', 'mode', 'flag', 'signal', 'owner'],
-    wrap: 'encoding',
-  })
-  const { uid, gid } = await owner.validate(file, options.owner)
-
-  const result = await fs.writeFile(file, data, options)
-
-  await owner.update(file, uid, gid)
-
-  return result
-}
-
-module.exports = writeFile
diff --git a/node_modules/cacache/node_modules/@npmcli/fs/package.json b/node_modules/cacache/node_modules/@npmcli/fs/package.json
deleted file mode 100644
index 0296aa7f1e1d5..0000000000000
--- a/node_modules/cacache/node_modules/@npmcli/fs/package.json
+++ /dev/null
@@ -1,38 +0,0 @@
-{
-  "name": "@npmcli/fs",
-  "version": "1.1.1",
-  "description": "filesystem utilities for the npm cli",
-  "main": "lib/index.js",
-  "files": [
-    "bin",
-    "lib"
-  ],
-  "scripts": {
-    "preversion": "npm test",
-    "postversion": "npm publish",
-    "prepublishOnly": "git push origin --follow-tags",
-    "snap": "tap",
-    "test": "tap",
-    "npmclilint": "npmcli-lint",
-    "lint": "eslint '**/*.js'",
-    "lintfix": "npm run lint -- --fix",
-    "posttest": "npm run lint",
-    "postsnap": "npm run lintfix --",
-    "postlint": "npm-template-check"
-  },
-  "keywords": [
-    "npm",
-    "oss"
-  ],
-  "author": "GitHub Inc.",
-  "license": "ISC",
-  "devDependencies": {
-    "@npmcli/template-oss": "^2.3.1",
-    "tap": "^15.0.9"
-  },
-  "dependencies": {
-    "@gar/promisify": "^1.0.1",
-    "semver": "^7.3.5"
-  },
-  "templateVersion": "2.3.1"
-}
diff --git a/node_modules/cacache/package.json b/node_modules/cacache/package.json
index c240fa446df48..edae9a4f995b4 100644
--- a/node_modules/cacache/package.json
+++ b/node_modules/cacache/package.json
@@ -1,6 +1,6 @@
 {
   "name": "cacache",
-  "version": "16.0.2",
+  "version": "16.0.3",
   "cache-version": {
     "content": "2",
     "index": "5"
@@ -8,8 +8,8 @@
   "description": "Fast, fault-tolerant, cross-platform, disk-based, data-agnostic, content-addressable cache.",
   "main": "lib/index.js",
   "files": [
-    "bin",
-    "lib"
+    "bin/",
+    "lib/"
   ],
   "scripts": {
     "benchmarks": "node test/benchmarks",
@@ -20,15 +20,18 @@
     "snap": "tap",
     "coverage": "tap",
     "test-docker": "docker run -it --rm --name pacotest -v \"$PWD\":/tmp -w /tmp node:latest npm test",
-    "lint": "eslint '**/*.js'",
+    "lint": "eslint \"**/*.js\"",
     "npmclilint": "npmcli-lint",
     "lintfix": "npm run lint -- --fix",
     "postsnap": "npm run lintfix --",
-    "postlint": "npm-template-check",
-    "template-copy": "npm-template-copy --force",
-    "posttest": "npm run lint"
+    "postlint": "template-oss-check",
+    "posttest": "npm run lint",
+    "template-oss-apply": "template-oss-apply --force"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/npm/cacache.git"
   },
-  "repository": "https://github.com/npm/cacache",
   "keywords": [
     "cache",
     "caching",
@@ -46,13 +49,13 @@
   ],
   "license": "ISC",
   "dependencies": {
-    "@npmcli/fs": "^1.0.0",
+    "@npmcli/fs": "^2.1.0",
     "@npmcli/move-file": "^1.1.2",
     "chownr": "^2.0.0",
     "fs-minipass": "^2.1.0",
     "glob": "^7.2.0",
     "infer-owner": "^1.0.4",
-    "lru-cache": "^7.5.1",
+    "lru-cache": "^7.7.1",
     "minipass": "^3.1.6",
     "minipass-collect": "^1.0.2",
     "minipass-flush": "^1.0.5",
@@ -66,23 +69,25 @@
     "unique-filename": "^1.1.1"
   },
   "devDependencies": {
-    "@npmcli/template-oss": "^2.9.2",
+    "@npmcli/eslint-config": "^3.0.1",
+    "@npmcli/template-oss": "3.1.2",
     "benchmark": "^2.1.4",
     "chalk": "^4.1.2",
     "require-inject": "^1.4.4",
     "tacks": "^1.3.0",
-    "tap": "^15.0.9"
+    "tap": "^16.0.0"
   },
   "tap": {
     "100": true,
     "test-regex": "test/[^/]*.js"
   },
   "engines": {
-    "node": "^12.13.0 || ^14.15.0 || >=16"
+    "node": "^12.13.0 || ^14.15.0 || >=16.0.0"
   },
   "templateOSS": {
+    "//@npmcli/template-oss": "This file is partially managed by @npmcli/template-oss. Edits may be overwritten.",
     "windowsCI": false,
-    "version": "2.9.2"
+    "version": "3.1.2"
   },
   "author": "GitHub Inc."
 }
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 <i@izs.me>",
   "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 02e7a335fcae0..7ba150ce719f4 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -98,7 +98,7 @@
         "ansicolors": "~0.3.2",
         "ansistyles": "~0.1.3",
         "archy": "~1.0.0",
-        "cacache": "^16.0.2",
+        "cacache": "^16.0.3",
         "chalk": "^4.1.2",
         "chownr": "^2.0.0",
         "cli-columns": "^4.0.0",
@@ -869,6 +869,7 @@
       "version": "2.1.0",
       "resolved": "https://registry.npmjs.org/@npmcli/fs/-/fs-2.1.0.tgz",
       "integrity": "sha512-DmfBvNXGaetMxj9LTp8NAN9vEidXURrf5ZTslQzEAi/6GbW+4yjaLFQc6Tue5cpZ9Frlk4OBo/Snf1Bh/S7qTQ==",
+      "inBundle": true,
       "dependencies": {
         "@gar/promisify": "^1.1.3",
         "semver": "^7.3.5"
@@ -1591,18 +1592,18 @@
       "inBundle": true
     },
     "node_modules/cacache": {
-      "version": "16.0.2",
-      "resolved": "https://registry.npmjs.org/cacache/-/cacache-16.0.2.tgz",
-      "integrity": "sha512-Q17j7s8X81i/QYVrKVQ/qwWGT+pYLfpTcZ+X+p/Qw9FULy9JEfb2FECYTTt6mPV6A/vk92nRZ80ncpKxiGTrIA==",
+      "version": "16.0.3",
+      "resolved": "https://registry.npmjs.org/cacache/-/cacache-16.0.3.tgz",
+      "integrity": "sha512-eC7wYodNCVb97kuHGk5P+xZsvUJHkhSEOyNwkenqQPAsOtrTjvWOE5vSPNBpz9d8X3acIf6w2Ub5s4rvOCTs4g==",
       "inBundle": true,
       "dependencies": {
-        "@npmcli/fs": "^1.0.0",
+        "@npmcli/fs": "^2.1.0",
         "@npmcli/move-file": "^1.1.2",
         "chownr": "^2.0.0",
         "fs-minipass": "^2.1.0",
         "glob": "^7.2.0",
         "infer-owner": "^1.0.4",
-        "lru-cache": "^7.5.1",
+        "lru-cache": "^7.7.1",
         "minipass": "^3.1.6",
         "minipass-collect": "^1.0.2",
         "minipass-flush": "^1.0.5",
@@ -1616,17 +1617,7 @@
         "unique-filename": "^1.1.1"
       },
       "engines": {
-        "node": "^12.13.0 || ^14.15.0 || >=16"
-      }
-    },
-    "node_modules/cacache/node_modules/@npmcli/fs": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/@npmcli/fs/-/fs-1.1.1.tgz",
-      "integrity": "sha512-8KG5RD0GVP4ydEzRn/I4BNDuxDtqVbOdm8675T49OIG/NGhaK0pjPX7ZcDlvKYbA+ulvVK3ztfcF4uBdOxuJbQ==",
-      "inBundle": true,
-      "dependencies": {
-        "@gar/promisify": "^1.0.1",
-        "semver": "^7.3.5"
+        "node": "^12.13.0 || ^14.15.0 || >=16.0.0"
       }
     },
     "node_modules/caching-transform": {
@@ -4825,9 +4816,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"
@@ -11819,17 +11810,17 @@
       "integrity": "sha1-y5T662HIaWRR2zZTThQi+U8K7og="
     },
     "cacache": {
-      "version": "16.0.2",
-      "resolved": "https://registry.npmjs.org/cacache/-/cacache-16.0.2.tgz",
-      "integrity": "sha512-Q17j7s8X81i/QYVrKVQ/qwWGT+pYLfpTcZ+X+p/Qw9FULy9JEfb2FECYTTt6mPV6A/vk92nRZ80ncpKxiGTrIA==",
+      "version": "16.0.3",
+      "resolved": "https://registry.npmjs.org/cacache/-/cacache-16.0.3.tgz",
+      "integrity": "sha512-eC7wYodNCVb97kuHGk5P+xZsvUJHkhSEOyNwkenqQPAsOtrTjvWOE5vSPNBpz9d8X3acIf6w2Ub5s4rvOCTs4g==",
       "requires": {
-        "@npmcli/fs": "^1.0.0",
+        "@npmcli/fs": "^2.1.0",
         "@npmcli/move-file": "^1.1.2",
         "chownr": "^2.0.0",
         "fs-minipass": "^2.1.0",
         "glob": "^7.2.0",
         "infer-owner": "^1.0.4",
-        "lru-cache": "^7.5.1",
+        "lru-cache": "^7.7.1",
         "minipass": "^3.1.6",
         "minipass-collect": "^1.0.2",
         "minipass-flush": "^1.0.5",
@@ -11841,17 +11832,6 @@
         "ssri": "^8.0.1",
         "tar": "^6.1.11",
         "unique-filename": "^1.1.1"
-      },
-      "dependencies": {
-        "@npmcli/fs": {
-          "version": "1.1.1",
-          "resolved": "https://registry.npmjs.org/@npmcli/fs/-/fs-1.1.1.tgz",
-          "integrity": "sha512-8KG5RD0GVP4ydEzRn/I4BNDuxDtqVbOdm8675T49OIG/NGhaK0pjPX7ZcDlvKYbA+ulvVK3ztfcF4uBdOxuJbQ==",
-          "requires": {
-            "@gar/promisify": "^1.0.1",
-            "semver": "^7.3.5"
-          }
-        }
       }
     },
     "caching-transform": {
@@ -14460,9 +14440,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",
diff --git a/package.json b/package.json
index 3b2ca7670d8bf..ac5f5dd0bc9b0 100644
--- a/package.json
+++ b/package.json
@@ -66,7 +66,7 @@
     "ansicolors": "~0.3.2",
     "ansistyles": "~0.1.3",
     "archy": "~1.0.0",
-    "cacache": "^16.0.2",
+    "cacache": "^16.0.3",
     "chalk": "^4.1.2",
     "chownr": "^2.0.0",
     "cli-columns": "^4.0.0",