@socketsecurity/cli-with-sentry 1.0.69 → 1.0.70

package/dist/vendor.js

@@ -2301,11 +2301,11 @@ var validateNpmPackageLicense$1 = function (argument) {
     };
   }
 };
-var commonjs$i = {};
-Object.defineProperty(commonjs$i, "__esModule", {
+var commonjs$j = {};
+Object.defineProperty(commonjs$j, "__esModule", {
   value: true
 });
-commonjs$i.LRUCache = void 0;
+commonjs$j.LRUCache = void 0;
 const perf = typeof performance === 'object' && performance && typeof performance.now === 'function' ? performance : Date;
 const warned = new Set();
 const PROCESS = typeof process === 'object' && !!process ? process : {};
@@ -3411,7 +3411,7 @@ let LRUCache$1 = class LRUCache {
     }
   }
 };
-commonjs$i.LRUCache = LRUCache$1;
+commonjs$j.LRUCache = LRUCache$1;
 const maybeJoin = (...args) => args.every(arg => arg) ? args.join('') : '';
 const maybeEncode = arg => arg ? encodeURIComponent(arg) : '';
 const formatHashFragment = f => f.toLowerCase().replace(/^\W+|\/|\W+$/g, '').replace(/\W+/g, '-');
@@ -3781,7 +3781,7 @@ hosts$1.sourcehut = {
 for (const [name, host] of Object.entries(hosts$1)) {
   hosts$1[name] = Object.assign({}, defaults$2, host);
 }
-var hosts_1$1 = hosts$1;
+var hosts_1$2 = hosts$1;
 const url$2 = require$$0$7;
 const lastIndexOfBefore = (str, char, beforeChar) => {
   const startPosition = str.indexOf(beforeChar);
@@ -3823,11 +3823,11 @@ const correctUrl = giturl => {
   }
   return giturl;
 };
-var parseUrl$2 = (giturl, protocols) => {
+var parseUrl$2$1 = (giturl, protocols) => {
   const withProtocol = protocols ? correctProtocol(giturl, protocols) : giturl;
   return safeUrl(withProtocol) || safeUrl(correctUrl(withProtocol));
 };
-const parseUrl$1$1 = parseUrl$2;
+const parseUrl$1$1 = parseUrl$2$1;
 const isGitHubShorthand = arg => {
   const firstHash = arg.indexOf('#');
   const firstSlash = arg.indexOf('/');
@@ -3844,7 +3844,7 @@ const isGitHubShorthand = arg => {
   const doesNotStartWithDot = !arg.startsWith('.');
   return spaceOnlyAfterHash && hasSlash && doesNotEndWithSlash && doesNotStartWithDot && atOnlyAfterHash && colonOnlyAfterHash && secondSlashOnlyAfterHash;
 };
-var fromUrl$1 = (giturl, opts, {
+var fromUrl$1$1 = (giturl, opts, {
   gitHosts,
   protocols
 }) => {
@@ -3919,10 +3919,10 @@ var fromUrl$1 = (giturl, opts, {
 };
 const {
   LRUCache
-} = commonjs$i;
-const hosts = hosts_1$1;
-const fromUrl$2 = fromUrl$1;
-const parseUrl$3 = parseUrl$2;
+} = commonjs$j;
+const hosts = hosts_1$2;
+const fromUrl$2 = fromUrl$1$1;
+const parseUrl$3 = parseUrl$2$1;
 const cache$1 = new LRUCache({
   max: 1000
 });
@@ -5084,7 +5084,7 @@ jsTokens.matchToToken = function (match) {
   if (match[1]) token.type = "string", token.closed = !!(match[3] || match[4]);else if (match[5]) token.type = "comment";else if (match[6]) token.type = "comment", token.closed = !!match[7];else if (match[8]) token.type = "regex";else if (match[9]) token.type = "number";else if (match[10]) token.type = "name";else if (match[11]) token.type = "punctuator";else if (match[12]) token.type = "whitespace";
   return token;
 };
-var lib$I = {};
+var lib$J = {};
 var identifier = {};
 Object.defineProperty(identifier, "__esModule", {
   value: true
@@ -5238,7 +5238,7 @@ function isKeyword(word) {
   });
   var _identifier = identifier;
   var _keyword = keyword$1;
-})(lib$I);
+})(lib$J);
 var chalk$1 = {
   exports: {}
 };
@@ -6764,7 +6764,7 @@ Object.defineProperty(lib$1$1, "__esModule", {
 lib$1$1.default = highlight;
 lib$1$1.shouldHighlight = shouldHighlight;
 var _jsTokens = jsTokens;
-var _helperValidatorIdentifier = lib$I;
+var _helperValidatorIdentifier = lib$J;
 var _chalk$1 = _interopRequireWildcard$1(chalkExports$1, true);
 function _getRequireWildcardCache$1(e) {
   if ("function" != typeof WeakMap) return null;
@@ -35519,7 +35519,7 @@ var isInteractiveExports = /*@__PURE__*/ requireIsInteractive();
 var dist$e = {};
 
 var name$2 = "@socketsecurity/sdk";
-var version$5 = "1.4.64";
+var version$5 = "1.4.65";
 var license = "MIT";
 var description = "SDK for the Socket API client";
 var author = {
@@ -35602,7 +35602,7 @@ var scripts = {
 	"update:deps": "npx --yes npm-check-updates"
 };
 var dependencies = {
-	"@socketsecurity/registry": "1.0.244"
+	"@socketsecurity/registry": "1.0.245"
 };
 var devDependencies = {
 	"@biomejs/biome": "2.1.2",
@@ -41646,11 +41646,11 @@ function requireCjs$1() {
   return cjs$1;
 }
 
-var lib$H;
-var hasRequiredLib$H;
-function requireLib$H() {
-  if (hasRequiredLib$H) return lib$H;
-  hasRequiredLib$H = 1;
+var lib$I;
+var hasRequiredLib$I;
+function requireLib$I() {
+  if (hasRequiredLib$I) return lib$I;
+  hasRequiredLib$I = 1;
   const {
     isexe,
     sync: isexeSync
@@ -41768,12 +41768,12 @@ function requireLib$H() {
     }
     throw getNotFoundError(cmd);
   };
-  lib$H = which;
+  lib$I = which;
   which.sync = whichSync;
-  return lib$H;
+  return lib$I;
 }
 
-var libExports$2 = requireLib$H();
+var libExports$2 = requireLib$I();
 
 var error$a;
 var hasRequiredError$a;
@@ -49055,7 +49055,7 @@ function getValues(context, operator, key, modifier) {
   }
   return result;
 }
-function parseUrl$1(template) {
+function parseUrl$2(template) {
   return {
     expand: expand.bind(null, template)
   };
@@ -49104,7 +49104,7 @@ function parse$4(options) {
   let body;
   let parameters = omit(options, ["method", "baseUrl", "url", "headers", "request", "mediaType"]);
   const urlVariableNames = extractUrlVariableNames(url);
-  url = parseUrl$1(url).expand(parameters);
+  url = parseUrl$2(url).expand(parameters);
   if (!/^http/.test(url)) {
     url = options.baseUrl + url;
   }
@@ -51336,19 +51336,19 @@ const Octokit = Octokit$1.plugin(requestLog, legacyRestEndpointMethods, paginate
 
 var npa = {exports: {}};
 
-var commonjs$h = {};
+var commonjs$i = {};
 
-var hasRequiredCommonjs$h;
-function requireCommonjs$h() {
-  if (hasRequiredCommonjs$h) return commonjs$h;
-  hasRequiredCommonjs$h = 1;
+var hasRequiredCommonjs$i;
+function requireCommonjs$i() {
+  if (hasRequiredCommonjs$i) return commonjs$i;
+  hasRequiredCommonjs$i = 1;
   /**
    * @module LRUCache
    */
-  Object.defineProperty(commonjs$h, "__esModule", {
+  Object.defineProperty(commonjs$i, "__esModule", {
     value: true
   });
-  commonjs$h.LRUCache = void 0;
+  commonjs$i.LRUCache = void 0;
   const perf = typeof performance === 'object' && performance && typeof performance.now === 'function' ? performance : Date;
   const warned = new Set();
   /* c8 ignore start */
@@ -51466,6 +51466,7 @@ function requireCommonjs$h() {
     #max;
     #maxSize;
     #dispose;
+    #onInsert;
     #disposeAfter;
     #fetchMethod;
     #memoMethod;
@@ -51547,6 +51548,7 @@ function requireCommonjs$h() {
     #hasDispose;
     #hasFetchMethod;
     #hasDisposeAfter;
+    #hasOnInsert;
     /**
      * Do not call this method unless you need to inspect the
      * inner workings of the cache.  If anything returned by this
@@ -51623,6 +51625,12 @@ function requireCommonjs$h() {
     get dispose() {
       return this.#dispose;
     }
+    /**
+     * {@link LRUCache.OptionsBase.onInsert} (read-only)
+     */
+    get onInsert() {
+      return this.#onInsert;
+    }
     /**
      * {@link LRUCache.OptionsBase.disposeAfter} (read-only)
      */
@@ -51639,6 +51647,7 @@ function requireCommonjs$h() {
         updateAgeOnHas,
         allowStale,
         dispose,
+        onInsert,
         disposeAfter,
         noDisposeOnSet,
         noUpdateTTL,
@@ -51694,6 +51703,9 @@ function requireCommonjs$h() {
       if (typeof dispose === 'function') {
         this.#dispose = dispose;
       }
+      if (typeof onInsert === 'function') {
+        this.#onInsert = onInsert;
+      }
       if (typeof disposeAfter === 'function') {
         this.#disposeAfter = disposeAfter;
         this.#disposed = [];
@@ -51702,6 +51714,7 @@ function requireCommonjs$h() {
         this.#disposed = undefined;
       }
       this.#hasDispose = !!this.#dispose;
+      this.#hasOnInsert = !!this.#onInsert;
       this.#hasDisposeAfter = !!this.#disposeAfter;
       this.noDisposeOnSet = !!noDisposeOnSet;
       this.noUpdateTTL = !!noUpdateTTL;
@@ -52114,7 +52127,7 @@ function requireCommonjs$h() {
     }
     /**
      * Return an array of [key, {@link LRUCache.Entry}] tuples which can be
-     * passed to {@link LRLUCache#load}.
+     * passed to {@link LRUCache#load}.
      *
      * The `start` fields are calculated relative to a portable `Date.now()`
      * timestamp, even if `performance.now()` is available.
@@ -52247,6 +52260,9 @@ function requireCommonjs$h() {
         this.#addItemSize(index, size, status);
         if (status) status.set = 'add';
         noUpdateTTL = false;
+        if (this.#hasOnInsert) {
+          this.#onInsert?.(v, k, 'add');
+        }
       } else {
         // update
         this.#moveToTail(index);
@@ -52284,6 +52300,9 @@ function requireCommonjs$h() {
         } else if (status) {
           status.set = 'update';
         }
+        if (this.#hasOnInsert) {
+          this.onInsert?.(v, k, v === oldVal ? 'update' : 'replace');
+        }
       }
       if (ttl !== 0 && !this.#ttls) {
         this.#initializeTTLTracking();
@@ -52846,16 +52865,16 @@ function requireCommonjs$h() {
       }
     }
   }
-  commonjs$h.LRUCache = LRUCache;
-  return commonjs$h;
+  commonjs$i.LRUCache = LRUCache;
+  return commonjs$i;
 }
 
 /* eslint-disable max-len */
-var hosts_1;
-var hasRequiredHosts;
-function requireHosts() {
-  if (hasRequiredHosts) return hosts_1;
-  hasRequiredHosts = 1;
+var hosts_1$1;
+var hasRequiredHosts$1;
+function requireHosts$1() {
+  if (hasRequiredHosts$1) return hosts_1$1;
+  hasRequiredHosts$1 = 1;
   const maybeJoin = (...args) => args.every(arg => arg) ? args.join('') : '';
   const maybeEncode = arg => arg ? encodeURIComponent(arg) : '';
   const formatHashFragment = f => f.toLowerCase().replace(/^\W+/g, '') // strip leading non-characters
@@ -53230,15 +53249,15 @@ function requireHosts() {
   for (const [name, host] of Object.entries(hosts)) {
     hosts[name] = Object.assign({}, defaults, host);
   }
-  hosts_1 = hosts;
-  return hosts_1;
+  hosts_1$1 = hosts;
+  return hosts_1$1;
 }
 
-var parseUrl;
-var hasRequiredParseUrl;
-function requireParseUrl() {
-  if (hasRequiredParseUrl) return parseUrl;
-  hasRequiredParseUrl = 1;
+var parseUrl$1;
+var hasRequiredParseUrl$1;
+function requireParseUrl$1() {
+  if (hasRequiredParseUrl$1) return parseUrl$1;
+  hasRequiredParseUrl$1 = 1;
   const url = require$$0$e;
   const lastIndexOfBefore = (str, char, beforeChar) => {
     const startPosition = str.indexOf(beforeChar);
@@ -53304,19 +53323,19 @@ function requireParseUrl() {
     }
     return giturl;
   };
-  parseUrl = (giturl, protocols) => {
+  parseUrl$1 = (giturl, protocols) => {
     const withProtocol = protocols ? correctProtocol(giturl, protocols) : giturl;
     return safeUrl(withProtocol) || safeUrl(correctUrl(withProtocol));
   };
-  return parseUrl;
+  return parseUrl$1;
 }
 
-var fromUrl;
-var hasRequiredFromUrl;
-function requireFromUrl() {
-  if (hasRequiredFromUrl) return fromUrl;
-  hasRequiredFromUrl = 1;
-  const parseUrl = requireParseUrl();
+var fromUrl$1;
+var hasRequiredFromUrl$1;
+function requireFromUrl$1() {
+  if (hasRequiredFromUrl$1) return fromUrl$1;
+  hasRequiredFromUrl$1 = 1;
+  const parseUrl = requireParseUrl$1();
 
   // look for github shorthand inputs, such as npm/cli
   const isGitHubShorthand = arg => {
@@ -53344,7 +53363,7 @@ function requireFromUrl() {
     const doesNotStartWithDot = !arg.startsWith('.');
     return spaceOnlyAfterHash && hasSlash && doesNotEndWithSlash && doesNotStartWithDot && atOnlyAfterHash && colonOnlyAfterHash && secondSlashOnlyAfterHash;
   };
-  fromUrl = (giturl, opts, {
+  fromUrl$1 = (giturl, opts, {
     gitHosts,
     protocols
   }) => {
@@ -53420,20 +53439,20 @@ function requireFromUrl() {
     }
     return [gitHostName, user, auth, project, committish, defaultRepresentation, opts];
   };
-  return fromUrl;
+  return fromUrl$1;
 }
 
-var lib$G;
-var hasRequiredLib$G;
-function requireLib$G() {
-  if (hasRequiredLib$G) return lib$G;
-  hasRequiredLib$G = 1;
+var lib$H;
+var hasRequiredLib$H;
+function requireLib$H() {
+  if (hasRequiredLib$H) return lib$H;
+  hasRequiredLib$H = 1;
   const {
     LRUCache
-  } = /*@__PURE__*/requireCommonjs$h();
-  const hosts = requireHosts();
-  const fromUrl = requireFromUrl();
-  const parseUrl = requireParseUrl();
+  } = /*@__PURE__*/requireCommonjs$i();
+  const hosts = requireHosts$1();
+  const fromUrl = requireFromUrl$1();
+  const parseUrl = requireParseUrl$1();
   const cache = new LRUCache({
     max: 1000
   });
@@ -53656,20 +53675,20 @@ function requireLib$G() {
   for (const [name, host] of Object.entries(hosts)) {
     GitHost.addHost(name, host);
   }
-  lib$G = GitHost;
-  return lib$G;
+  lib$H = GitHost;
+  return lib$H;
 }
 
-var lib$F;
-var hasRequiredLib$F;
-function requireLib$F() {
-  if (hasRequiredLib$F) return lib$F;
-  hasRequiredLib$F = 1;
+var lib$G;
+var hasRequiredLib$G;
+function requireLib$G() {
+  if (hasRequiredLib$G) return lib$G;
+  hasRequiredLib$G = 1;
   const {
     builtinModules: builtins
   } = require$$0$l;
   var scopedPackagePattern = new RegExp('^(?:@([^/]+?)[/])?([^/]+?)$');
-  var blacklist = ['node_modules', 'favicon.ico'];
+  var exclusionList = ['node_modules', 'favicon.ico'];
   function validate(name) {
     var warnings = [];
     var errors = [];
@@ -53699,9 +53718,9 @@ function requireLib$F() {
     }
 
     // No funny business
-    blacklist.forEach(function (blacklistedName) {
-      if (name.toLowerCase() === blacklistedName) {
-        errors.push(blacklistedName + ' is a blacklisted name');
+    exclusionList.forEach(function (excludedName) {
+      if (name.toLowerCase() === excludedName) {
+        errors.push(excludedName + ' is not a valid package name');
       }
     });
 
@@ -53754,17 +53773,17 @@ function requireLib$F() {
     }
     return result;
   };
-  lib$F = validate;
-  return lib$F;
+  lib$G = validate;
+  return lib$G;
 }
 
-var lib$E;
-var hasRequiredLib$E;
-function requireLib$E() {
-  if (hasRequiredLib$E) return lib$E;
-  hasRequiredLib$E = 1;
+var lib$F;
+var hasRequiredLib$F;
+function requireLib$F() {
+  if (hasRequiredLib$F) return lib$F;
+  hasRequiredLib$F = 1;
   const META = Symbol('proc-log.meta');
-  lib$E = {
+  lib$F = {
     META: META,
     output: {
       LEVELS: ['standard', 'error', 'buffer', 'flush'],
@@ -53893,7 +53912,7 @@ function requireLib$E() {
       }
     }
   };
-  return lib$E;
+  return lib$F;
 }
 
 var hasRequiredNpa;
@@ -53909,12 +53928,12 @@ function requireNpa() {
   const {
     homedir
   } = os$3;
-  const HostedGit = requireLib$G();
+  const HostedGit = requireLib$H();
   const semver = requireSemver();
-  const validatePackageName = requireLib$F();
+  const validatePackageName = requireLib$G();
   const {
     log
-  } = requireLib$E();
+  } = requireLib$F();
   const hasSlashes = isWindows ? /\\|[/]/ : /[/]/;
   const isURL = /^(?:git[+])?[a-z]+:/i;
   const isGit = /^[^@]+@[^:.]+\.[^:]+:.+$/i;
@@ -54529,7 +54548,7 @@ function requireOverrideSet() {
   const semver = requireSemver();
   const {
     log
-  } = requireLib$E();
+  } = requireLib$F();
   class OverrideSet {
     constructor({
       overrides,
@@ -55037,18 +55056,18 @@ function requireEdge() {
 
 var edgeExports = requireEdge();
 
-var lib$D;
-var hasRequiredLib$D;
-function requireLib$D() {
-  if (hasRequiredLib$D) return lib$D;
-  hasRequiredLib$D = 1;
+var lib$E;
+var hasRequiredLib$E;
+function requireLib$E() {
+  if (hasRequiredLib$E) return lib$E;
+  hasRequiredLib$E = 1;
   const {
     basename,
     dirname
   } = require$$0$d;
   const getName = (parent, base) => parent.charAt(0) === '@' ? `${parent}/${base}` : base;
-  lib$D = dir => dir ? getName(basename(dirname(dir)), basename(dir)) : false;
-  return lib$D;
+  lib$E = dir => dir ? getName(basename(dirname(dir)), basename(dir)) : false;
+  return lib$E;
 }
 
 var debug$1 = {exports: {}};
@@ -55227,11 +55246,11 @@ function requireInventory() {
   return inventory;
 }
 
-var lib$C;
-var hasRequiredLib$C;
-function requireLib$C() {
-  if (hasRequiredLib$C) return lib$C;
-  hasRequiredLib$C = 1;
+var lib$D;
+var hasRequiredLib$D;
+function requireLib$D() {
+  if (hasRequiredLib$D) return lib$D;
+  hasRequiredLib$D = 1;
   const INDENT = Symbol.for('indent');
   const NEWLINE = Symbol.for('newline');
   const DEFAULT_NEWLINE = '\n';
@@ -55331,7 +55350,7 @@ function requireLib$C() {
       throw new JSONParseError(e, txt, context, parseJsonError);
     }
   };
-  lib$C = parseJsonError;
+  lib$D = parseJsonError;
   parseJsonError.JSONParseError = JSONParseError;
   parseJsonError.noExceptions = (raw, reviver) => {
     try {
@@ -55340,14 +55359,14 @@ function requireLib$C() {
       // no exceptions
     }
   };
-  return lib$C;
+  return lib$D;
 }
 
-var lib$B;
-var hasRequiredLib$B;
-function requireLib$B() {
-  if (hasRequiredLib$B) return lib$B;
-  hasRequiredLib$B = 1;
+var lib$C;
+var hasRequiredLib$C;
+function requireLib$C() {
+  if (hasRequiredLib$C) return lib$C;
+  hasRequiredLib$C = 1;
   // pass in a manifest with a 'bin' field here, and it'll turn it
   // into a properly santized bin object
   const {
@@ -55398,22 +55417,22 @@ function requireLib$B() {
     }
     return pkg;
   };
-  lib$B = normalize;
-  return lib$B;
+  lib$C = normalize;
+  return lib$C;
 }
 
-var lib$A;
-var hasRequiredLib$A;
-function requireLib$A() {
-  if (hasRequiredLib$A) return lib$A;
-  hasRequiredLib$A = 1;
+var lib$B;
+var hasRequiredLib$B;
+function requireLib$B() {
+  if (hasRequiredLib$B) return lib$B;
+  hasRequiredLib$B = 1;
   const {
     readFile,
     lstat,
     readdir
   } = require$$0$k;
-  const parse = requireLib$C();
-  const normalizePackageBin = requireLib$B();
+  const parse = requireLib$D();
+  const normalizePackageBin = requireLib$C();
   const {
     resolve,
     dirname,
@@ -55542,8 +55561,8 @@ function requireLib$A() {
     }
     return data;
   };
-  lib$A = rpj;
-  return lib$A;
+  lib$B = rpj;
+  return lib$B;
 }
 
 var isWindows;
@@ -55668,11 +55687,11 @@ function requireToBatchSyntax() {
   return toBatchSyntax;
 }
 
-var lib$z;
-var hasRequiredLib$z;
-function requireLib$z() {
-  if (hasRequiredLib$z) return lib$z;
-  hasRequiredLib$z = 1;
+var lib$A;
+var hasRequiredLib$A;
+function requireLib$A() {
+  if (hasRequiredLib$A) return lib$A;
+  hasRequiredLib$A = 1;
   // On windows, create a .cmd file.
   // Read the #! in the file to see what it uses.  The vast majority
   // of the time, this will be either:
@@ -55828,16 +55847,16 @@ function requireLib$z() {
     return Promise.all([writeFile(to + '.ps1', pwsh, 'utf8'), writeFile(to + '.cmd', cmd, 'utf8'), writeFile(to, sh, 'utf8')]).then(() => chmodShim(to));
   };
   const chmodShim = to => Promise.all([chmod(to, 0o755), chmod(to + '.cmd', 0o755), chmod(to + '.ps1', 0o755)]);
-  lib$z = cmdShim;
+  lib$A = cmdShim;
   cmdShim.ifExists = cmdShimIfExists;
-  return lib$z;
+  return lib$A;
 }
 
-var lib$y;
-var hasRequiredLib$y;
-function requireLib$y() {
-  if (hasRequiredLib$y) return lib$y;
-  hasRequiredLib$y = 1;
+var lib$z;
+var hasRequiredLib$z;
+function requireLib$z() {
+  if (hasRequiredLib$z) return lib$z;
+  hasRequiredLib$z = 1;
   const fs = require$$0$a;
   const {
     promisify
@@ -55906,11 +55925,11 @@ function requireLib$y() {
     return destination;
   };
   readCmdShim.sync = readCmdShimSync;
-  lib$y = readCmdShim;
-  return lib$y;
+  lib$z = readCmdShim;
+  return lib$z;
 }
 
-var lib$x = {exports: {}};
+var lib$y = {exports: {}};
 
 var imurmurhash = {exports: {}};
 
@@ -56381,14 +56400,14 @@ function requireCjs() {
   return cjs;
 }
 
-var hasRequiredLib$x;
-function requireLib$x() {
-  if (hasRequiredLib$x) return lib$x.exports;
-  hasRequiredLib$x = 1;
-  lib$x.exports = writeFile;
-  lib$x.exports.sync = writeFileSync;
-  lib$x.exports._getTmpname = getTmpname; // for testing
-  lib$x.exports._cleanupOnExit = cleanupOnExit;
+var hasRequiredLib$y;
+function requireLib$y() {
+  if (hasRequiredLib$y) return lib$y.exports;
+  hasRequiredLib$y = 1;
+  lib$y.exports = writeFile;
+  lib$y.exports.sync = writeFileSync;
+  lib$y.exports._getTmpname = getTmpname; // for testing
+  lib$y.exports._cleanupOnExit = cleanupOnExit;
   const fs = require$$0$a;
   const MurmurHash3 = requireImurmurhash();
   const {
@@ -56629,7 +56648,7 @@ function requireLib$x() {
       }
     }
   }
-  return lib$x.exports;
+  return lib$y.exports;
 }
 
 var fixBin_1;
@@ -56645,7 +56664,7 @@ function requireFixBin() {
     readFile
   } = require$$0$k;
   const execMode = 0o777 & ~process.umask();
-  const writeFileAtomic = requireLib$x();
+  const writeFileAtomic = requireLib$y();
   const isWindowsHashBang = buf => buf[0] === '#'.charCodeAt(0) && buf[1] === '!'.charCodeAt(0) && /^#![^\n]+\r\n/.test(buf.toString());
   const isWindowsHashbangFile = file => {
     const FALSE = () => false;
@@ -56682,8 +56701,8 @@ function requireShimBin() {
       throw er;
     }
   };
-  const cmdShim = requireLib$z();
-  const readCmdShim = requireLib$y();
+  const cmdShim = requireLib$A();
+  const readCmdShim = requireLib$z();
   const fixBin = requireFixBin();
 
   // even in --force mode, we never create a shim over a shim we've
@@ -56786,7 +56805,7 @@ function requireLinkGently() {
   } = require$$0$k;
   const {
     log
-  } = requireLib$E();
+  } = requireLib$F();
   const throwSignificant = er => {
     if (er.code === 'ENOENT') {
       return;
@@ -56916,7 +56935,7 @@ function requireLinkBins() {
     relative
   } = require$$0$d;
   const linkBin = isWindows ? requireShimBin() : requireLinkBin();
-  const normalize = requireLib$B();
+  const normalize = requireLib$C();
   const linkBins = ({
     path,
     pkg,
@@ -57052,7 +57071,7 @@ function requireCheckBin() {
     resolve,
     dirname
   } = require$$0$d;
-  const readCmdShim = requireLib$y();
+  const readCmdShim = requireLib$z();
   const {
     readlink
   } = require$$0$k;
@@ -57152,7 +57171,7 @@ function requireCheckBins() {
   if (hasRequiredCheckBins) return checkBins_1;
   hasRequiredCheckBins = 1;
   const checkBin = requireCheckBin();
-  const normalize = requireLib$B();
+  const normalize = requireLib$C();
   const checkBins = async ({
     pkg,
     path,
@@ -57241,11 +57260,11 @@ function requireGetPaths() {
   return getPaths;
 }
 
-var lib$w;
-var hasRequiredLib$w;
-function requireLib$w() {
-  if (hasRequiredLib$w) return lib$w;
-  hasRequiredLib$w = 1;
+var lib$x;
+var hasRequiredLib$x;
+function requireLib$x() {
+  if (hasRequiredLib$x) return lib$x;
+  hasRequiredLib$x = 1;
   const linkBins = requireLinkBins();
   const linkMans = requireLinkMans();
   const binLinks = opts => {
@@ -57294,12 +57313,12 @@ function requireLib$w() {
   };
   const checkBins = requireCheckBins();
   const getPaths = requireGetPaths();
-  lib$w = Object.assign(binLinks, {
+  lib$x = Object.assign(binLinks, {
     checkBins,
     resetSeen,
     getPaths
   });
-  return lib$w;
+  return lib$x;
 }
 
 var gatherDepSet_1;
@@ -57499,16 +57518,16 @@ function requireTreeCheck() {
   return treeCheck;
 }
 
-var commonjs$g = {};
+var commonjs$h = {};
 
-var hasRequiredCommonjs$g;
-function requireCommonjs$g() {
-  if (hasRequiredCommonjs$g) return commonjs$g;
-  hasRequiredCommonjs$g = 1;
-  Object.defineProperty(commonjs$g, "__esModule", {
+var hasRequiredCommonjs$h;
+function requireCommonjs$h() {
+  if (hasRequiredCommonjs$h) return commonjs$h;
+  hasRequiredCommonjs$h = 1;
+  Object.defineProperty(commonjs$h, "__esModule", {
     value: true
   });
-  commonjs$g.walkUp = void 0;
+  commonjs$h.walkUp = void 0;
   const path_1 = require$$0$d;
   const walkUp = function* (path) {
     for (path = (0, path_1.resolve)(path); path;) {
@@ -57521,8 +57540,8 @@ function requireCommonjs$g() {
       }
     }
   };
-  commonjs$g.walkUp = walkUp;
-  return commonjs$g;
+  commonjs$h.walkUp = walkUp;
+  return commonjs$h;
 }
 
 var relpath_1;
@@ -61925,11 +61944,11 @@ function requireDist$d() {
   return dist$d.exports;
 }
 
-var lib$v;
-var hasRequiredLib$v;
-function requireLib$v() {
-  if (hasRequiredLib$v) return lib$v;
-  hasRequiredLib$v = 1;
+var lib$w;
+var hasRequiredLib$w;
+function requireLib$w() {
+  if (hasRequiredLib$w) return lib$w;
+  hasRequiredLib$w = 1;
   const parser = requireDist$d();
   const arrayDelimiter = Symbol('arrayDelimiter');
   const escapeSlashes = str => str.replace(/\//g, '\\/');
@@ -62156,14 +62175,14 @@ function requireLib$v() {
       lossless: false
     });
   };
-  lib$v = {
+  lib$w = {
     parser: queryParser,
     arrayDelimiter
   };
-  return lib$v;
+  return lib$w;
 }
 
-var commonjs$f = {};
+var commonjs$g = {};
 
 var balancedMatch;
 var hasRequiredBalancedMatch;
@@ -63149,10 +63168,10 @@ function require_escape$1() {
   return _escape$1;
 }
 
-var hasRequiredCommonjs$f;
-function requireCommonjs$f() {
-  if (hasRequiredCommonjs$f) return commonjs$f;
-  hasRequiredCommonjs$f = 1;
+var hasRequiredCommonjs$g;
+function requireCommonjs$g() {
+  if (hasRequiredCommonjs$g) return commonjs$g;
+  hasRequiredCommonjs$g = 1;
   (function (exports) {
 
     var __importDefault = this && this.__importDefault || function (mod) {
@@ -64052,189 +64071,2513 @@ function requireCommonjs$f() {
             if (options.flipNegate) {
               return true;
             }
-            return !this.negate;
+            return !this.negate;
+          }
+        }
+        // didn't get any hits.  this is success if it's a negative
+        // pattern, failure otherwise.
+        if (options.flipNegate) {
+          return false;
+        }
+        return this.negate;
+      }
+      static defaults(def) {
+        return exports.minimatch.defaults(def).Minimatch;
+      }
+    }
+    exports.Minimatch = Minimatch;
+    /* c8 ignore start */
+    var ast_js_2 = requireAst();
+    Object.defineProperty(exports, "AST", {
+      enumerable: true,
+      get: function () {
+        return ast_js_2.AST;
+      }
+    });
+    var escape_js_2 = require_escape$1();
+    Object.defineProperty(exports, "escape", {
+      enumerable: true,
+      get: function () {
+        return escape_js_2.escape;
+      }
+    });
+    var unescape_js_2 = require_unescape();
+    Object.defineProperty(exports, "unescape", {
+      enumerable: true,
+      get: function () {
+        return unescape_js_2.unescape;
+      }
+    });
+    /* c8 ignore stop */
+    exports.minimatch.AST = ast_js_1.AST;
+    exports.minimatch.Minimatch = Minimatch;
+    exports.minimatch.escape = escape_js_1.escape;
+    exports.minimatch.unescape = unescape_js_1.unescape;
+  })(commonjs$g);
+  return commonjs$g;
+}
+
+var updateDependencies_1;
+var hasRequiredUpdateDependencies;
+function requireUpdateDependencies() {
+  if (hasRequiredUpdateDependencies) return updateDependencies_1;
+  hasRequiredUpdateDependencies = 1;
+  const depTypes = new Set(['dependencies', 'optionalDependencies', 'devDependencies', 'peerDependencies']);
+
+  // sort alphabetically all types of deps for a given package
+  const orderDeps = content => {
+    for (const type of depTypes) {
+      if (content && content[type]) {
+        content[type] = Object.keys(content[type]).sort((a, b) => a.localeCompare(b, 'en')).reduce((res, key) => {
+          res[key] = content[type][key];
+          return res;
+        }, {});
+      }
+    }
+    return content;
+  };
+  const updateDependencies = ({
+    content,
+    originalContent
+  }) => {
+    const pkg = orderDeps({
+      ...content
+    });
+
+    // optionalDependencies don't need to be repeated in two places
+    if (pkg.dependencies) {
+      if (pkg.optionalDependencies) {
+        for (const name of Object.keys(pkg.optionalDependencies)) {
+          delete pkg.dependencies[name];
+        }
+      }
+    }
+    const result = {
+      ...originalContent
+    };
+
+    // loop through all types of dependencies and update package json pkg
+    for (const type of depTypes) {
+      if (pkg[type]) {
+        result[type] = pkg[type];
+      }
+
+      // prune empty type props from resulting object
+      const emptyDepType = pkg[type] && typeof pkg === 'object' && Object.keys(pkg[type]).length === 0;
+      if (emptyDepType) {
+        delete result[type];
+      }
+    }
+
+    // if original package.json had dep in peerDeps AND deps, preserve that.
+    const {
+      dependencies: origProd,
+      peerDependencies: origPeer
+    } = originalContent || {};
+    const {
+      peerDependencies: newPeer
+    } = result;
+    if (origProd && origPeer && newPeer) {
+      // we have original prod/peer deps, and new peer deps
+      // copy over any that were in both in the original
+      for (const name of Object.keys(origPeer)) {
+        if (origProd[name] !== undefined && newPeer[name] !== undefined) {
+          result.dependencies = result.dependencies || {};
+          result.dependencies[name] = newPeer[name];
+        }
+      }
+    }
+    return result;
+  };
+  updateDependencies.knownKeys = depTypes;
+  updateDependencies_1 = updateDependencies;
+  return updateDependencies_1;
+}
+
+var updateScripts_1;
+var hasRequiredUpdateScripts;
+function requireUpdateScripts() {
+  if (hasRequiredUpdateScripts) return updateScripts_1;
+  hasRequiredUpdateScripts = 1;
+  const updateScripts = ({
+    content,
+    originalContent = {}
+  }) => {
+    const newScripts = content.scripts;
+    if (!newScripts) {
+      return originalContent;
+    }
+
+    // validate scripts content being appended
+    const hasInvalidScripts = () => Object.entries(newScripts).some(([key, value]) => typeof key !== 'string' || typeof value !== 'string');
+    if (hasInvalidScripts()) {
+      throw Object.assign(new TypeError('package.json scripts should be a key-value pair of strings.'), {
+        code: 'ESCRIPTSINVALID'
+      });
+    }
+    return {
+      ...originalContent,
+      scripts: {
+        ...newScripts
+      }
+    };
+  };
+  updateScripts_1 = updateScripts;
+  return updateScripts_1;
+}
+
+var updateWorkspaces_1;
+var hasRequiredUpdateWorkspaces;
+function requireUpdateWorkspaces() {
+  if (hasRequiredUpdateWorkspaces) return updateWorkspaces_1;
+  hasRequiredUpdateWorkspaces = 1;
+  const updateWorkspaces = ({
+    content,
+    originalContent = {}
+  }) => {
+    const newWorkspaces = content.workspaces;
+    if (!newWorkspaces) {
+      return originalContent;
+    }
+
+    // validate workspaces content being appended
+    const hasInvalidWorkspaces = () => newWorkspaces.some(w => !(typeof w === 'string'));
+    if (!newWorkspaces.length || hasInvalidWorkspaces()) {
+      throw Object.assign(new TypeError('workspaces should be an array of strings.'), {
+        code: 'EWORKSPACESINVALID'
+      });
+    }
+    return {
+      ...originalContent,
+      workspaces: [...newWorkspaces]
+    };
+  };
+  updateWorkspaces_1 = updateWorkspaces;
+  return updateWorkspaces_1;
+}
+
+var commonjs$f = {};
+
+var hasRequiredCommonjs$f;
+function requireCommonjs$f() {
+  if (hasRequiredCommonjs$f) return commonjs$f;
+  hasRequiredCommonjs$f = 1;
+  /**
+   * @module LRUCache
+   */
+  Object.defineProperty(commonjs$f, "__esModule", {
+    value: true
+  });
+  commonjs$f.LRUCache = void 0;
+  const perf = typeof performance === 'object' && performance && typeof performance.now === 'function' ? performance : Date;
+  const warned = new Set();
+  /* c8 ignore start */
+  const PROCESS = typeof process === 'object' && !!process ? process : {};
+  /* c8 ignore start */
+  const emitWarning = (msg, type, code, fn) => {
+    typeof PROCESS.emitWarning === 'function' ? PROCESS.emitWarning(msg, type, code, fn) : console.error(`[${code}] ${type}: ${msg}`);
+  };
+  let AC = globalThis.AbortController;
+  let AS = globalThis.AbortSignal;
+  /* c8 ignore start */
+  if (typeof AC === 'undefined') {
+    //@ts-ignore
+    AS = class AbortSignal {
+      onabort;
+      _onabort = [];
+      reason;
+      aborted = false;
+      addEventListener(_, fn) {
+        this._onabort.push(fn);
+      }
+    };
+    //@ts-ignore
+    AC = class AbortController {
+      constructor() {
+        warnACPolyfill();
+      }
+      signal = new AS();
+      abort(reason) {
+        if (this.signal.aborted) return;
+        //@ts-ignore
+        this.signal.reason = reason;
+        //@ts-ignore
+        this.signal.aborted = true;
+        //@ts-ignore
+        for (const fn of this.signal._onabort) {
+          fn(reason);
+        }
+        this.signal.onabort?.(reason);
+      }
+    };
+    let printACPolyfillWarning = PROCESS.env?.LRU_CACHE_IGNORE_AC_WARNING !== '1';
+    const warnACPolyfill = () => {
+      if (!printACPolyfillWarning) return;
+      printACPolyfillWarning = false;
+      emitWarning('AbortController is not defined. If using lru-cache in ' + 'node 14, load an AbortController polyfill from the ' + '`node-abort-controller` package. A minimal polyfill is ' + 'provided for use by LRUCache.fetch(), but it should not be ' + 'relied upon in other contexts (eg, passing it to other APIs that ' + 'use AbortController/AbortSignal might have undesirable effects). ' + 'You may disable this with LRU_CACHE_IGNORE_AC_WARNING=1 in the env.', 'NO_ABORT_CONTROLLER', 'ENOTSUP', warnACPolyfill);
+    };
+  }
+  /* c8 ignore stop */
+  const shouldWarn = code => !warned.has(code);
+  const isPosInt = n => n && n === Math.floor(n) && n > 0 && isFinite(n);
+  /* c8 ignore start */
+  // This is a little bit ridiculous, tbh.
+  // The maximum array length is 2^32-1 or thereabouts on most JS impls.
+  // And well before that point, you're caching the entire world, I mean,
+  // that's ~32GB of just integers for the next/prev links, plus whatever
+  // else to hold that many keys and values.  Just filling the memory with
+  // zeroes at init time is brutal when you get that big.
+  // But why not be complete?
+  // Maybe in the future, these limits will have expanded.
+  const getUintArray = max => !isPosInt(max) ? null : max <= Math.pow(2, 8) ? Uint8Array : max <= Math.pow(2, 16) ? Uint16Array : max <= Math.pow(2, 32) ? Uint32Array : max <= Number.MAX_SAFE_INTEGER ? ZeroArray : null;
+  /* c8 ignore stop */
+  class ZeroArray extends Array {
+    constructor(size) {
+      super(size);
+      this.fill(0);
+    }
+  }
+  class Stack {
+    heap;
+    length;
+    // private constructor
+    static #constructing = false;
+    static create(max) {
+      const HeapCls = getUintArray(max);
+      if (!HeapCls) return [];
+      Stack.#constructing = true;
+      const s = new Stack(max, HeapCls);
+      Stack.#constructing = false;
+      return s;
+    }
+    constructor(max, HeapCls) {
+      /* c8 ignore start */
+      if (!Stack.#constructing) {
+        throw new TypeError('instantiate Stack using Stack.create(n)');
+      }
+      /* c8 ignore stop */
+      this.heap = new HeapCls(max);
+      this.length = 0;
+    }
+    push(n) {
+      this.heap[this.length++] = n;
+    }
+    pop() {
+      return this.heap[--this.length];
+    }
+  }
+  /**
+   * Default export, the thing you're using this module to get.
+   *
+   * The `K` and `V` types define the key and value types, respectively. The
+   * optional `FC` type defines the type of the `context` object passed to
+   * `cache.fetch()` and `cache.memo()`.
+   *
+   * Keys and values **must not** be `null` or `undefined`.
+   *
+   * All properties from the options object (with the exception of `max`,
+   * `maxSize`, `fetchMethod`, `memoMethod`, `dispose` and `disposeAfter`) are
+   * added as normal public members. (The listed options are read-only getters.)
+   *
+   * Changing any of these will alter the defaults for subsequent method calls.
+   */
+  class LRUCache {
+    // options that cannot be changed without disaster
+    #max;
+    #maxSize;
+    #dispose;
+    #disposeAfter;
+    #fetchMethod;
+    #memoMethod;
+    /**
+     * {@link LRUCache.OptionsBase.ttl}
+     */
+    ttl;
+    /**
+     * {@link LRUCache.OptionsBase.ttlResolution}
+     */
+    ttlResolution;
+    /**
+     * {@link LRUCache.OptionsBase.ttlAutopurge}
+     */
+    ttlAutopurge;
+    /**
+     * {@link LRUCache.OptionsBase.updateAgeOnGet}
+     */
+    updateAgeOnGet;
+    /**
+     * {@link LRUCache.OptionsBase.updateAgeOnHas}
+     */
+    updateAgeOnHas;
+    /**
+     * {@link LRUCache.OptionsBase.allowStale}
+     */
+    allowStale;
+    /**
+     * {@link LRUCache.OptionsBase.noDisposeOnSet}
+     */
+    noDisposeOnSet;
+    /**
+     * {@link LRUCache.OptionsBase.noUpdateTTL}
+     */
+    noUpdateTTL;
+    /**
+     * {@link LRUCache.OptionsBase.maxEntrySize}
+     */
+    maxEntrySize;
+    /**
+     * {@link LRUCache.OptionsBase.sizeCalculation}
+     */
+    sizeCalculation;
+    /**
+     * {@link LRUCache.OptionsBase.noDeleteOnFetchRejection}
+     */
+    noDeleteOnFetchRejection;
+    /**
+     * {@link LRUCache.OptionsBase.noDeleteOnStaleGet}
+     */
+    noDeleteOnStaleGet;
+    /**
+     * {@link LRUCache.OptionsBase.allowStaleOnFetchAbort}
+     */
+    allowStaleOnFetchAbort;
+    /**
+     * {@link LRUCache.OptionsBase.allowStaleOnFetchRejection}
+     */
+    allowStaleOnFetchRejection;
+    /**
+     * {@link LRUCache.OptionsBase.ignoreFetchAbort}
+     */
+    ignoreFetchAbort;
+    // computed properties
+    #size;
+    #calculatedSize;
+    #keyMap;
+    #keyList;
+    #valList;
+    #next;
+    #prev;
+    #head;
+    #tail;
+    #free;
+    #disposed;
+    #sizes;
+    #starts;
+    #ttls;
+    #hasDispose;
+    #hasFetchMethod;
+    #hasDisposeAfter;
+    /**
+     * Do not call this method unless you need to inspect the
+     * inner workings of the cache.  If anything returned by this
+     * object is modified in any way, strange breakage may occur.
+     *
+     * These fields are private for a reason!
+     *
+     * @internal
+     */
+    static unsafeExposeInternals(c) {
+      return {
+        // properties
+        starts: c.#starts,
+        ttls: c.#ttls,
+        sizes: c.#sizes,
+        keyMap: c.#keyMap,
+        keyList: c.#keyList,
+        valList: c.#valList,
+        next: c.#next,
+        prev: c.#prev,
+        get head() {
+          return c.#head;
+        },
+        get tail() {
+          return c.#tail;
+        },
+        free: c.#free,
+        // methods
+        isBackgroundFetch: p => c.#isBackgroundFetch(p),
+        backgroundFetch: (k, index, options, context) => c.#backgroundFetch(k, index, options, context),
+        moveToTail: index => c.#moveToTail(index),
+        indexes: options => c.#indexes(options),
+        rindexes: options => c.#rindexes(options),
+        isStale: index => c.#isStale(index)
+      };
+    }
+    // Protected read-only members
+    /**
+     * {@link LRUCache.OptionsBase.max} (read-only)
+     */
+    get max() {
+      return this.#max;
+    }
+    /**
+     * {@link LRUCache.OptionsBase.maxSize} (read-only)
+     */
+    get maxSize() {
+      return this.#maxSize;
+    }
+    /**
+     * The total computed size of items in the cache (read-only)
+     */
+    get calculatedSize() {
+      return this.#calculatedSize;
+    }
+    /**
+     * The number of items stored in the cache (read-only)
+     */
+    get size() {
+      return this.#size;
+    }
+    /**
+     * {@link LRUCache.OptionsBase.fetchMethod} (read-only)
+     */
+    get fetchMethod() {
+      return this.#fetchMethod;
+    }
+    get memoMethod() {
+      return this.#memoMethod;
+    }
+    /**
+     * {@link LRUCache.OptionsBase.dispose} (read-only)
+     */
+    get dispose() {
+      return this.#dispose;
+    }
+    /**
+     * {@link LRUCache.OptionsBase.disposeAfter} (read-only)
+     */
+    get disposeAfter() {
+      return this.#disposeAfter;
+    }
+    constructor(options) {
+      const {
+        max = 0,
+        ttl,
+        ttlResolution = 1,
+        ttlAutopurge,
+        updateAgeOnGet,
+        updateAgeOnHas,
+        allowStale,
+        dispose,
+        disposeAfter,
+        noDisposeOnSet,
+        noUpdateTTL,
+        maxSize = 0,
+        maxEntrySize = 0,
+        sizeCalculation,
+        fetchMethod,
+        memoMethod,
+        noDeleteOnFetchRejection,
+        noDeleteOnStaleGet,
+        allowStaleOnFetchRejection,
+        allowStaleOnFetchAbort,
+        ignoreFetchAbort
+      } = options;
+      if (max !== 0 && !isPosInt(max)) {
+        throw new TypeError('max option must be a nonnegative integer');
+      }
+      const UintArray = max ? getUintArray(max) : Array;
+      if (!UintArray) {
+        throw new Error('invalid max value: ' + max);
+      }
+      this.#max = max;
+      this.#maxSize = maxSize;
+      this.maxEntrySize = maxEntrySize || this.#maxSize;
+      this.sizeCalculation = sizeCalculation;
+      if (this.sizeCalculation) {
+        if (!this.#maxSize && !this.maxEntrySize) {
+          throw new TypeError('cannot set sizeCalculation without setting maxSize or maxEntrySize');
+        }
+        if (typeof this.sizeCalculation !== 'function') {
+          throw new TypeError('sizeCalculation set to non-function');
+        }
+      }
+      if (memoMethod !== undefined && typeof memoMethod !== 'function') {
+        throw new TypeError('memoMethod must be a function if defined');
+      }
+      this.#memoMethod = memoMethod;
+      if (fetchMethod !== undefined && typeof fetchMethod !== 'function') {
+        throw new TypeError('fetchMethod must be a function if specified');
+      }
+      this.#fetchMethod = fetchMethod;
+      this.#hasFetchMethod = !!fetchMethod;
+      this.#keyMap = new Map();
+      this.#keyList = new Array(max).fill(undefined);
+      this.#valList = new Array(max).fill(undefined);
+      this.#next = new UintArray(max);
+      this.#prev = new UintArray(max);
+      this.#head = 0;
+      this.#tail = 0;
+      this.#free = Stack.create(max);
+      this.#size = 0;
+      this.#calculatedSize = 0;
+      if (typeof dispose === 'function') {
+        this.#dispose = dispose;
+      }
+      if (typeof disposeAfter === 'function') {
+        this.#disposeAfter = disposeAfter;
+        this.#disposed = [];
+      } else {
+        this.#disposeAfter = undefined;
+        this.#disposed = undefined;
+      }
+      this.#hasDispose = !!this.#dispose;
+      this.#hasDisposeAfter = !!this.#disposeAfter;
+      this.noDisposeOnSet = !!noDisposeOnSet;
+      this.noUpdateTTL = !!noUpdateTTL;
+      this.noDeleteOnFetchRejection = !!noDeleteOnFetchRejection;
+      this.allowStaleOnFetchRejection = !!allowStaleOnFetchRejection;
+      this.allowStaleOnFetchAbort = !!allowStaleOnFetchAbort;
+      this.ignoreFetchAbort = !!ignoreFetchAbort;
+      // NB: maxEntrySize is set to maxSize if it's set
+      if (this.maxEntrySize !== 0) {
+        if (this.#maxSize !== 0) {
+          if (!isPosInt(this.#maxSize)) {
+            throw new TypeError('maxSize must be a positive integer if specified');
+          }
+        }
+        if (!isPosInt(this.maxEntrySize)) {
+          throw new TypeError('maxEntrySize must be a positive integer if specified');
+        }
+        this.#initializeSizeTracking();
+      }
+      this.allowStale = !!allowStale;
+      this.noDeleteOnStaleGet = !!noDeleteOnStaleGet;
+      this.updateAgeOnGet = !!updateAgeOnGet;
+      this.updateAgeOnHas = !!updateAgeOnHas;
+      this.ttlResolution = isPosInt(ttlResolution) || ttlResolution === 0 ? ttlResolution : 1;
+      this.ttlAutopurge = !!ttlAutopurge;
+      this.ttl = ttl || 0;
+      if (this.ttl) {
+        if (!isPosInt(this.ttl)) {
+          throw new TypeError('ttl must be a positive integer if specified');
+        }
+        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.';
+          emitWarning(msg, 'UnboundedCacheWarning', code, LRUCache);
+        }
+      }
+    }
+    /**
+     * Return the number of ms left in the item's TTL. If item is not in cache,
+     * returns `0`. Returns `Infinity` if item is in cache without a defined TTL.
+     */
+    getRemainingTTL(key) {
+      return this.#keyMap.has(key) ? Infinity : 0;
+    }
+    #initializeTTLTracking() {
+      const ttls = new ZeroArray(this.#max);
+      const starts = new ZeroArray(this.#max);
+      this.#ttls = ttls;
+      this.#starts = starts;
+      this.#setItemTTL = (index, ttl, start = perf.now()) => {
+        starts[index] = ttl !== 0 ? start : 0;
+        ttls[index] = ttl;
+        if (ttl !== 0 && this.ttlAutopurge) {
+          const t = setTimeout(() => {
+            if (this.#isStale(index)) {
+              this.#delete(this.#keyList[index], 'expire');
+            }
+          }, ttl + 1);
+          // unref() not supported on all platforms
+          /* c8 ignore start */
+          if (t.unref) {
+            t.unref();
+          }
+          /* c8 ignore stop */
+        }
+      };
+      this.#updateItemAge = index => {
+        starts[index] = ttls[index] !== 0 ? perf.now() : 0;
+      };
+      this.#statusTTL = (status, index) => {
+        if (ttls[index]) {
+          const ttl = ttls[index];
+          const start = starts[index];
+          /* c8 ignore next */
+          if (!ttl || !start) return;
+          status.ttl = ttl;
+          status.start = start;
+          status.now = cachedNow || getNow();
+          const age = status.now - start;
+          status.remainingTTL = ttl - age;
+        }
+      };
+      // debounce calls to perf.now() to 1s so we're not hitting
+      // that costly call repeatedly.
+      let cachedNow = 0;
+      const getNow = () => {
+        const n = perf.now();
+        if (this.ttlResolution > 0) {
+          cachedNow = n;
+          const t = setTimeout(() => cachedNow = 0, this.ttlResolution);
+          // not available on all platforms
+          /* c8 ignore start */
+          if (t.unref) {
+            t.unref();
+          }
+          /* c8 ignore stop */
+        }
+        return n;
+      };
+      this.getRemainingTTL = key => {
+        const index = this.#keyMap.get(key);
+        if (index === undefined) {
+          return 0;
+        }
+        const ttl = ttls[index];
+        const start = starts[index];
+        if (!ttl || !start) {
+          return Infinity;
+        }
+        const age = (cachedNow || getNow()) - start;
+        return ttl - age;
+      };
+      this.#isStale = index => {
+        const s = starts[index];
+        const t = ttls[index];
+        return !!t && !!s && (cachedNow || getNow()) - s > t;
+      };
+    }
+    // conditionally set private methods related to TTL
+    #updateItemAge = () => {};
+    #statusTTL = () => {};
+    #setItemTTL = () => {};
+    /* c8 ignore stop */
+    #isStale = () => false;
+    #initializeSizeTracking() {
+      const sizes = new ZeroArray(this.#max);
+      this.#calculatedSize = 0;
+      this.#sizes = sizes;
+      this.#removeItemSize = index => {
+        this.#calculatedSize -= sizes[index];
+        sizes[index] = 0;
+      };
+      this.#requireSize = (k, v, size, sizeCalculation) => {
+        // provisionally accept background fetches.
+        // actual value size will be checked when they return.
+        if (this.#isBackgroundFetch(v)) {
+          return 0;
+        }
+        if (!isPosInt(size)) {
+          if (sizeCalculation) {
+            if (typeof sizeCalculation !== 'function') {
+              throw new TypeError('sizeCalculation must be a function');
+            }
+            size = sizeCalculation(v, k);
+            if (!isPosInt(size)) {
+              throw new TypeError('sizeCalculation return invalid (expect positive integer)');
+            }
+          } else {
+            throw new TypeError('invalid size value (must be positive integer). ' + 'When maxSize or maxEntrySize is used, sizeCalculation ' + 'or size must be set.');
+          }
+        }
+        return size;
+      };
+      this.#addItemSize = (index, size, status) => {
+        sizes[index] = size;
+        if (this.#maxSize) {
+          const maxSize = this.#maxSize - sizes[index];
+          while (this.#calculatedSize > maxSize) {
+            this.#evict(true);
+          }
+        }
+        this.#calculatedSize += sizes[index];
+        if (status) {
+          status.entrySize = size;
+          status.totalCalculatedSize = this.#calculatedSize;
+        }
+      };
+    }
+    #removeItemSize = _i => {};
+    #addItemSize = (_i, _s, _st) => {};
+    #requireSize = (_k, _v, size, sizeCalculation) => {
+      if (size || sizeCalculation) {
+        throw new TypeError('cannot set size without setting maxSize or maxEntrySize on cache');
+      }
+      return 0;
+    };
+    *#indexes({
+      allowStale = this.allowStale
+    } = {}) {
+      if (this.#size) {
+        for (let i = this.#tail; true;) {
+          if (!this.#isValidIndex(i)) {
+            break;
+          }
+          if (allowStale || !this.#isStale(i)) {
+            yield i;
+          }
+          if (i === this.#head) {
+            break;
+          } else {
+            i = this.#prev[i];
+          }
+        }
+      }
+    }
+    *#rindexes({
+      allowStale = this.allowStale
+    } = {}) {
+      if (this.#size) {
+        for (let i = this.#head; true;) {
+          if (!this.#isValidIndex(i)) {
+            break;
+          }
+          if (allowStale || !this.#isStale(i)) {
+            yield i;
+          }
+          if (i === this.#tail) {
+            break;
+          } else {
+            i = this.#next[i];
+          }
+        }
+      }
+    }
+    #isValidIndex(index) {
+      return index !== undefined && this.#keyMap.get(this.#keyList[index]) === index;
+    }
+    /**
+     * Return a generator yielding `[key, value]` pairs,
+     * in order from most recently used to least recently used.
+     */
+    *entries() {
+      for (const i of this.#indexes()) {
+        if (this.#valList[i] !== undefined && this.#keyList[i] !== undefined && !this.#isBackgroundFetch(this.#valList[i])) {
+          yield [this.#keyList[i], this.#valList[i]];
+        }
+      }
+    }
+    /**
+     * Inverse order version of {@link LRUCache.entries}
+     *
+     * Return a generator yielding `[key, value]` pairs,
+     * in order from least recently used to most recently used.
+     */
+    *rentries() {
+      for (const i of this.#rindexes()) {
+        if (this.#valList[i] !== undefined && this.#keyList[i] !== undefined && !this.#isBackgroundFetch(this.#valList[i])) {
+          yield [this.#keyList[i], this.#valList[i]];
+        }
+      }
+    }
+    /**
+     * Return a generator yielding the keys in the cache,
+     * in order from most recently used to least recently used.
+     */
+    *keys() {
+      for (const i of this.#indexes()) {
+        const k = this.#keyList[i];
+        if (k !== undefined && !this.#isBackgroundFetch(this.#valList[i])) {
+          yield k;
+        }
+      }
+    }
+    /**
+     * Inverse order version of {@link LRUCache.keys}
+     *
+     * Return a generator yielding the keys in the cache,
+     * in order from least recently used to most recently used.
+     */
+    *rkeys() {
+      for (const i of this.#rindexes()) {
+        const k = this.#keyList[i];
+        if (k !== undefined && !this.#isBackgroundFetch(this.#valList[i])) {
+          yield k;
+        }
+      }
+    }
+    /**
+     * Return a generator yielding the values in the cache,
+     * in order from most recently used to least recently used.
+     */
+    *values() {
+      for (const i of this.#indexes()) {
+        const v = this.#valList[i];
+        if (v !== undefined && !this.#isBackgroundFetch(this.#valList[i])) {
+          yield this.#valList[i];
+        }
+      }
+    }
+    /**
+     * Inverse order version of {@link LRUCache.values}
+     *
+     * Return a generator yielding the values in the cache,
+     * in order from least recently used to most recently used.
+     */
+    *rvalues() {
+      for (const i of this.#rindexes()) {
+        const v = this.#valList[i];
+        if (v !== undefined && !this.#isBackgroundFetch(this.#valList[i])) {
+          yield this.#valList[i];
+        }
+      }
+    }
+    /**
+     * Iterating over the cache itself yields the same results as
+     * {@link LRUCache.entries}
+     */
+    [Symbol.iterator]() {
+      return this.entries();
+    }
+    /**
+     * A String value that is used in the creation of the default string
+     * description of an object. Called by the built-in method
+     * `Object.prototype.toString`.
+     */
+    [Symbol.toStringTag] = 'LRUCache';
+    /**
+     * Find a value for which the supplied fn method returns a truthy value,
+     * similar to `Array.find()`. fn is called as `fn(value, key, cache)`.
+     */
+    find(fn, getOptions = {}) {
+      for (const i of this.#indexes()) {
+        const v = this.#valList[i];
+        const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+        if (value === undefined) continue;
+        if (fn(value, this.#keyList[i], this)) {
+          return this.get(this.#keyList[i], getOptions);
+        }
+      }
+    }
+    /**
+     * Call the supplied function on each item in the cache, in order from most
+     * recently used to least recently used.
+     *
+     * `fn` is called as `fn(value, key, cache)`.
+     *
+     * If `thisp` is provided, function will be called in the `this`-context of
+     * the provided object, or the cache if no `thisp` object is provided.
+     *
+     * Does not update age or recenty of use, or iterate over stale values.
+     */
+    forEach(fn, thisp = this) {
+      for (const i of this.#indexes()) {
+        const v = this.#valList[i];
+        const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+        if (value === undefined) continue;
+        fn.call(thisp, value, this.#keyList[i], this);
+      }
+    }
+    /**
+     * The same as {@link LRUCache.forEach} but items are iterated over in
+     * reverse order.  (ie, less recently used items are iterated over first.)
+     */
+    rforEach(fn, thisp = this) {
+      for (const i of this.#rindexes()) {
+        const v = this.#valList[i];
+        const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+        if (value === undefined) continue;
+        fn.call(thisp, value, this.#keyList[i], this);
+      }
+    }
+    /**
+     * Delete any stale entries. Returns true if anything was removed,
+     * false otherwise.
+     */
+    purgeStale() {
+      let deleted = false;
+      for (const i of this.#rindexes({
+        allowStale: true
+      })) {
+        if (this.#isStale(i)) {
+          this.#delete(this.#keyList[i], 'expire');
+          deleted = true;
+        }
+      }
+      return deleted;
+    }
+    /**
+     * Get the extended info about a given entry, to get its value, size, and
+     * TTL info simultaneously. Returns `undefined` if the key is not present.
+     *
+     * Unlike {@link LRUCache#dump}, which is designed to be portable and survive
+     * serialization, the `start` value is always the current timestamp, and the
+     * `ttl` is a calculated remaining time to live (negative if expired).
+     *
+     * Always returns stale values, if their info is found in the cache, so be
+     * sure to check for expirations (ie, a negative {@link LRUCache.Entry#ttl})
+     * if relevant.
+     */
+    info(key) {
+      const i = this.#keyMap.get(key);
+      if (i === undefined) return undefined;
+      const v = this.#valList[i];
+      const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+      if (value === undefined) return undefined;
+      const entry = {
+        value
+      };
+      if (this.#ttls && this.#starts) {
+        const ttl = this.#ttls[i];
+        const start = this.#starts[i];
+        if (ttl && start) {
+          const remain = ttl - (perf.now() - start);
+          entry.ttl = remain;
+          entry.start = Date.now();
+        }
+      }
+      if (this.#sizes) {
+        entry.size = this.#sizes[i];
+      }
+      return entry;
+    }
+    /**
+     * Return an array of [key, {@link LRUCache.Entry}] tuples which can be
+     * passed to {@link LRLUCache#load}.
+     *
+     * The `start` fields are calculated relative to a portable `Date.now()`
+     * timestamp, even if `performance.now()` is available.
+     *
+     * Stale entries are always included in the `dump`, even if
+     * {@link LRUCache.OptionsBase.allowStale} is false.
+     *
+     * Note: this returns an actual array, not a generator, so it can be more
+     * easily passed around.
+     */
+    dump() {
+      const arr = [];
+      for (const i of this.#indexes({
+        allowStale: true
+      })) {
+        const key = this.#keyList[i];
+        const v = this.#valList[i];
+        const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+        if (value === undefined || key === undefined) continue;
+        const entry = {
+          value
+        };
+        if (this.#ttls && this.#starts) {
+          entry.ttl = this.#ttls[i];
+          // always dump the start relative to a portable timestamp
+          // it's ok for this to be a bit slow, it's a rare operation.
+          const age = perf.now() - this.#starts[i];
+          entry.start = Math.floor(Date.now() - age);
+        }
+        if (this.#sizes) {
+          entry.size = this.#sizes[i];
+        }
+        arr.unshift([key, entry]);
+      }
+      return arr;
+    }
+    /**
+     * Reset the cache and load in the items in entries in the order listed.
+     *
+     * The shape of the resulting cache may be different if the same options are
+     * not used in both caches.
+     *
+     * The `start` fields are assumed to be calculated relative to a portable
+     * `Date.now()` timestamp, even if `performance.now()` is available.
+     */
+    load(arr) {
+      this.clear();
+      for (const [key, entry] of arr) {
+        if (entry.start) {
+          // entry.start is a portable timestamp, but we may be using
+          // node's performance.now(), so calculate the offset, so that
+          // we get the intended remaining TTL, no matter how long it's
+          // been on ice.
+          //
+          // it's ok for this to be a bit slow, it's a rare operation.
+          const age = Date.now() - entry.start;
+          entry.start = perf.now() - age;
+        }
+        this.set(key, entry.value, entry);
+      }
+    }
+    /**
+     * Add a value to the cache.
+     *
+     * Note: if `undefined` is specified as a value, this is an alias for
+     * {@link LRUCache#delete}
+     *
+     * Fields on the {@link LRUCache.SetOptions} options param will override
+     * their corresponding values in the constructor options for the scope
+     * of this single `set()` operation.
+     *
+     * If `start` is provided, then that will set the effective start
+     * time for the TTL calculation. Note that this must be a previous
+     * value of `performance.now()` if supported, or a previous value of
+     * `Date.now()` if not.
+     *
+     * Options object may also include `size`, which will prevent
+     * calling the `sizeCalculation` function and just use the specified
+     * number if it is a positive integer, and `noDisposeOnSet` which
+     * will prevent calling a `dispose` function in the case of
+     * overwrites.
+     *
+     * If the `size` (or return value of `sizeCalculation`) for a given
+     * entry is greater than `maxEntrySize`, then the item will not be
+     * added to the cache.
+     *
+     * Will update the recency of the entry.
+     *
+     * If the value is `undefined`, then this is an alias for
+     * `cache.delete(key)`. `undefined` is never stored in the cache.
+     */
+    set(k, v, setOptions = {}) {
+      if (v === undefined) {
+        this.delete(k);
+        return this;
+      }
+      const {
+        ttl = this.ttl,
+        start,
+        noDisposeOnSet = this.noDisposeOnSet,
+        sizeCalculation = this.sizeCalculation,
+        status
+      } = setOptions;
+      let {
+        noUpdateTTL = this.noUpdateTTL
+      } = setOptions;
+      const size = this.#requireSize(k, v, setOptions.size || 0, sizeCalculation);
+      // if the item doesn't fit, don't do anything
+      // NB: maxEntrySize set to maxSize by default
+      if (this.maxEntrySize && size > this.maxEntrySize) {
+        if (status) {
+          status.set = 'miss';
+          status.maxEntrySizeExceeded = true;
+        }
+        // have to delete, in case something is there already.
+        this.#delete(k, 'set');
+        return this;
+      }
+      let index = this.#size === 0 ? undefined : this.#keyMap.get(k);
+      if (index === undefined) {
+        // addition
+        index = this.#size === 0 ? this.#tail : this.#free.length !== 0 ? this.#free.pop() : this.#size === this.#max ? this.#evict(false) : this.#size;
+        this.#keyList[index] = k;
+        this.#valList[index] = v;
+        this.#keyMap.set(k, index);
+        this.#next[this.#tail] = index;
+        this.#prev[index] = this.#tail;
+        this.#tail = index;
+        this.#size++;
+        this.#addItemSize(index, size, status);
+        if (status) status.set = 'add';
+        noUpdateTTL = false;
+      } else {
+        // update
+        this.#moveToTail(index);
+        const oldVal = this.#valList[index];
+        if (v !== oldVal) {
+          if (this.#hasFetchMethod && this.#isBackgroundFetch(oldVal)) {
+            oldVal.__abortController.abort(new Error('replaced'));
+            const {
+              __staleWhileFetching: s
+            } = oldVal;
+            if (s !== undefined && !noDisposeOnSet) {
+              if (this.#hasDispose) {
+                this.#dispose?.(s, k, 'set');
+              }
+              if (this.#hasDisposeAfter) {
+                this.#disposed?.push([s, k, 'set']);
+              }
+            }
+          } else if (!noDisposeOnSet) {
+            if (this.#hasDispose) {
+              this.#dispose?.(oldVal, k, 'set');
+            }
+            if (this.#hasDisposeAfter) {
+              this.#disposed?.push([oldVal, k, 'set']);
+            }
+          }
+          this.#removeItemSize(index);
+          this.#addItemSize(index, size, status);
+          this.#valList[index] = v;
+          if (status) {
+            status.set = 'replace';
+            const oldValue = oldVal && this.#isBackgroundFetch(oldVal) ? oldVal.__staleWhileFetching : oldVal;
+            if (oldValue !== undefined) status.oldValue = oldValue;
+          }
+        } else if (status) {
+          status.set = 'update';
+        }
+      }
+      if (ttl !== 0 && !this.#ttls) {
+        this.#initializeTTLTracking();
+      }
+      if (this.#ttls) {
+        if (!noUpdateTTL) {
+          this.#setItemTTL(index, ttl, start);
+        }
+        if (status) this.#statusTTL(status, index);
+      }
+      if (!noDisposeOnSet && this.#hasDisposeAfter && this.#disposed) {
+        const dt = this.#disposed;
+        let task;
+        while (task = dt?.shift()) {
+          this.#disposeAfter?.(...task);
+        }
+      }
+      return this;
+    }
+    /**
+     * Evict the least recently used item, returning its value or
+     * `undefined` if cache is empty.
+     */
+    pop() {
+      try {
+        while (this.#size) {
+          const val = this.#valList[this.#head];
+          this.#evict(true);
+          if (this.#isBackgroundFetch(val)) {
+            if (val.__staleWhileFetching) {
+              return val.__staleWhileFetching;
+            }
+          } else if (val !== undefined) {
+            return val;
+          }
+        }
+      } finally {
+        if (this.#hasDisposeAfter && this.#disposed) {
+          const dt = this.#disposed;
+          let task;
+          while (task = dt?.shift()) {
+            this.#disposeAfter?.(...task);
+          }
+        }
+      }
+    }
+    #evict(free) {
+      const head = this.#head;
+      const k = this.#keyList[head];
+      const v = this.#valList[head];
+      if (this.#hasFetchMethod && this.#isBackgroundFetch(v)) {
+        v.__abortController.abort(new Error('evicted'));
+      } else if (this.#hasDispose || this.#hasDisposeAfter) {
+        if (this.#hasDispose) {
+          this.#dispose?.(v, k, 'evict');
+        }
+        if (this.#hasDisposeAfter) {
+          this.#disposed?.push([v, k, 'evict']);
+        }
+      }
+      this.#removeItemSize(head);
+      // if we aren't about to use the index, then null these out
+      if (free) {
+        this.#keyList[head] = undefined;
+        this.#valList[head] = undefined;
+        this.#free.push(head);
+      }
+      if (this.#size === 1) {
+        this.#head = this.#tail = 0;
+        this.#free.length = 0;
+      } else {
+        this.#head = this.#next[head];
+      }
+      this.#keyMap.delete(k);
+      this.#size--;
+      return head;
+    }
+    /**
+     * Check if a key is in the cache, without updating the recency of use.
+     * Will return false if the item is stale, even though it is technically
+     * in the cache.
+     *
+     * Check if a key is in the cache, without updating the recency of
+     * use. Age is updated if {@link LRUCache.OptionsBase.updateAgeOnHas} is set
+     * to `true` in either the options or the constructor.
+     *
+     * Will return `false` if the item is stale, even though it is technically in
+     * the cache. The difference can be determined (if it matters) by using a
+     * `status` argument, and inspecting the `has` field.
+     *
+     * Will not update item age unless
+     * {@link LRUCache.OptionsBase.updateAgeOnHas} is set.
+     */
+    has(k, hasOptions = {}) {
+      const {
+        updateAgeOnHas = this.updateAgeOnHas,
+        status
+      } = hasOptions;
+      const index = this.#keyMap.get(k);
+      if (index !== undefined) {
+        const v = this.#valList[index];
+        if (this.#isBackgroundFetch(v) && v.__staleWhileFetching === undefined) {
+          return false;
+        }
+        if (!this.#isStale(index)) {
+          if (updateAgeOnHas) {
+            this.#updateItemAge(index);
+          }
+          if (status) {
+            status.has = 'hit';
+            this.#statusTTL(status, index);
+          }
+          return true;
+        } else if (status) {
+          status.has = 'stale';
+          this.#statusTTL(status, index);
+        }
+      } else if (status) {
+        status.has = 'miss';
+      }
+      return false;
+    }
+    /**
+     * Like {@link LRUCache#get} but doesn't update recency or delete stale
+     * items.
+     *
+     * Returns `undefined` if the item is stale, unless
+     * {@link LRUCache.OptionsBase.allowStale} is set.
+     */
+    peek(k, peekOptions = {}) {
+      const {
+        allowStale = this.allowStale
+      } = peekOptions;
+      const index = this.#keyMap.get(k);
+      if (index === undefined || !allowStale && this.#isStale(index)) {
+        return;
+      }
+      const v = this.#valList[index];
+      // either stale and allowed, or forcing a refresh of non-stale value
+      return this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+    }
+    #backgroundFetch(k, index, options, context) {
+      const v = index === undefined ? undefined : this.#valList[index];
+      if (this.#isBackgroundFetch(v)) {
+        return v;
+      }
+      const ac = new AC();
+      const {
+        signal
+      } = options;
+      // when/if our AC signals, then stop listening to theirs.
+      signal?.addEventListener('abort', () => ac.abort(signal.reason), {
+        signal: ac.signal
+      });
+      const fetchOpts = {
+        signal: ac.signal,
+        options,
+        context
+      };
+      const cb = (v, updateCache = false) => {
+        const {
+          aborted
+        } = ac.signal;
+        const ignoreAbort = options.ignoreFetchAbort && v !== undefined;
+        if (options.status) {
+          if (aborted && !updateCache) {
+            options.status.fetchAborted = true;
+            options.status.fetchError = ac.signal.reason;
+            if (ignoreAbort) options.status.fetchAbortIgnored = true;
+          } else {
+            options.status.fetchResolved = true;
+          }
+        }
+        if (aborted && !ignoreAbort && !updateCache) {
+          return fetchFail(ac.signal.reason);
+        }
+        // either we didn't abort, and are still here, or we did, and ignored
+        const bf = p;
+        if (this.#valList[index] === p) {
+          if (v === undefined) {
+            if (bf.__staleWhileFetching) {
+              this.#valList[index] = bf.__staleWhileFetching;
+            } else {
+              this.#delete(k, 'fetch');
+            }
+          } else {
+            if (options.status) options.status.fetchUpdated = true;
+            this.set(k, v, fetchOpts.options);
+          }
+        }
+        return v;
+      };
+      const eb = er => {
+        if (options.status) {
+          options.status.fetchRejected = true;
+          options.status.fetchError = er;
+        }
+        return fetchFail(er);
+      };
+      const fetchFail = er => {
+        const {
+          aborted
+        } = ac.signal;
+        const allowStaleAborted = aborted && options.allowStaleOnFetchAbort;
+        const allowStale = allowStaleAborted || options.allowStaleOnFetchRejection;
+        const noDelete = allowStale || options.noDeleteOnFetchRejection;
+        const bf = p;
+        if (this.#valList[index] === p) {
+          // if we allow stale on fetch rejections, then we need to ensure that
+          // the stale value is not removed from the cache when the fetch fails.
+          const del = !noDelete || bf.__staleWhileFetching === undefined;
+          if (del) {
+            this.#delete(k, 'fetch');
+          } else if (!allowStaleAborted) {
+            // still replace the *promise* with the stale value,
+            // since we are done with the promise at this point.
+            // leave it untouched if we're still waiting for an
+            // aborted background fetch that hasn't yet returned.
+            this.#valList[index] = bf.__staleWhileFetching;
+          }
+        }
+        if (allowStale) {
+          if (options.status && bf.__staleWhileFetching !== undefined) {
+            options.status.returnedStale = true;
+          }
+          return bf.__staleWhileFetching;
+        } else if (bf.__returned === bf) {
+          throw er;
+        }
+      };
+      const pcall = (res, rej) => {
+        const fmp = this.#fetchMethod?.(k, v, fetchOpts);
+        if (fmp && fmp instanceof Promise) {
+          fmp.then(v => res(v === undefined ? undefined : v), rej);
+        }
+        // ignored, we go until we finish, regardless.
+        // defer check until we are actually aborting,
+        // so fetchMethod can override.
+        ac.signal.addEventListener('abort', () => {
+          if (!options.ignoreFetchAbort || options.allowStaleOnFetchAbort) {
+            res(undefined);
+            // when it eventually resolves, update the cache.
+            if (options.allowStaleOnFetchAbort) {
+              res = v => cb(v, true);
+            }
+          }
+        });
+      };
+      if (options.status) options.status.fetchDispatched = true;
+      const p = new Promise(pcall).then(cb, eb);
+      const bf = Object.assign(p, {
+        __abortController: ac,
+        __staleWhileFetching: v,
+        __returned: undefined
+      });
+      if (index === undefined) {
+        // internal, don't expose status.
+        this.set(k, bf, {
+          ...fetchOpts.options,
+          status: undefined
+        });
+        index = this.#keyMap.get(k);
+      } else {
+        this.#valList[index] = bf;
+      }
+      return bf;
+    }
+    #isBackgroundFetch(p) {
+      if (!this.#hasFetchMethod) return false;
+      const b = p;
+      return !!b && b instanceof Promise && b.hasOwnProperty('__staleWhileFetching') && b.__abortController instanceof AC;
+    }
+    async fetch(k, fetchOptions = {}) {
+      const {
+        // get options
+        allowStale = this.allowStale,
+        updateAgeOnGet = this.updateAgeOnGet,
+        noDeleteOnStaleGet = this.noDeleteOnStaleGet,
+        // set options
+        ttl = this.ttl,
+        noDisposeOnSet = this.noDisposeOnSet,
+        size = 0,
+        sizeCalculation = this.sizeCalculation,
+        noUpdateTTL = this.noUpdateTTL,
+        // fetch exclusive options
+        noDeleteOnFetchRejection = this.noDeleteOnFetchRejection,
+        allowStaleOnFetchRejection = this.allowStaleOnFetchRejection,
+        ignoreFetchAbort = this.ignoreFetchAbort,
+        allowStaleOnFetchAbort = this.allowStaleOnFetchAbort,
+        context,
+        forceRefresh = false,
+        status,
+        signal
+      } = fetchOptions;
+      if (!this.#hasFetchMethod) {
+        if (status) status.fetch = 'get';
+        return this.get(k, {
+          allowStale,
+          updateAgeOnGet,
+          noDeleteOnStaleGet,
+          status
+        });
+      }
+      const options = {
+        allowStale,
+        updateAgeOnGet,
+        noDeleteOnStaleGet,
+        ttl,
+        noDisposeOnSet,
+        size,
+        sizeCalculation,
+        noUpdateTTL,
+        noDeleteOnFetchRejection,
+        allowStaleOnFetchRejection,
+        allowStaleOnFetchAbort,
+        ignoreFetchAbort,
+        status,
+        signal
+      };
+      let index = this.#keyMap.get(k);
+      if (index === undefined) {
+        if (status) status.fetch = 'miss';
+        const p = this.#backgroundFetch(k, index, options, context);
+        return p.__returned = p;
+      } else {
+        // in cache, maybe already fetching
+        const v = this.#valList[index];
+        if (this.#isBackgroundFetch(v)) {
+          const stale = allowStale && v.__staleWhileFetching !== undefined;
+          if (status) {
+            status.fetch = 'inflight';
+            if (stale) status.returnedStale = true;
+          }
+          return stale ? v.__staleWhileFetching : v.__returned = v;
+        }
+        // if we force a refresh, that means do NOT serve the cached value,
+        // unless we are already in the process of refreshing the cache.
+        const isStale = this.#isStale(index);
+        if (!forceRefresh && !isStale) {
+          if (status) status.fetch = 'hit';
+          this.#moveToTail(index);
+          if (updateAgeOnGet) {
+            this.#updateItemAge(index);
+          }
+          if (status) this.#statusTTL(status, index);
+          return v;
+        }
+        // ok, it is stale or a forced refresh, and not already fetching.
+        // refresh the cache.
+        const p = this.#backgroundFetch(k, index, options, context);
+        const hasStale = p.__staleWhileFetching !== undefined;
+        const staleVal = hasStale && allowStale;
+        if (status) {
+          status.fetch = isStale ? 'stale' : 'refresh';
+          if (staleVal && isStale) status.returnedStale = true;
+        }
+        return staleVal ? p.__staleWhileFetching : p.__returned = p;
+      }
+    }
+    async forceFetch(k, fetchOptions = {}) {
+      const v = await this.fetch(k, fetchOptions);
+      if (v === undefined) throw new Error('fetch() returned undefined');
+      return v;
+    }
+    memo(k, memoOptions = {}) {
+      const memoMethod = this.#memoMethod;
+      if (!memoMethod) {
+        throw new Error('no memoMethod provided to constructor');
+      }
+      const {
+        context,
+        forceRefresh,
+        ...options
+      } = memoOptions;
+      const v = this.get(k, options);
+      if (!forceRefresh && v !== undefined) return v;
+      const vv = memoMethod(k, v, {
+        options,
+        context
+      });
+      this.set(k, vv, options);
+      return vv;
+    }
+    /**
+     * Return a value from the cache. Will update the recency of the cache
+     * entry found.
+     *
+     * If the key is not found, get() will return `undefined`.
+     */
+    get(k, getOptions = {}) {
+      const {
+        allowStale = this.allowStale,
+        updateAgeOnGet = this.updateAgeOnGet,
+        noDeleteOnStaleGet = this.noDeleteOnStaleGet,
+        status
+      } = getOptions;
+      const index = this.#keyMap.get(k);
+      if (index !== undefined) {
+        const value = this.#valList[index];
+        const fetching = this.#isBackgroundFetch(value);
+        if (status) this.#statusTTL(status, index);
+        if (this.#isStale(index)) {
+          if (status) status.get = 'stale';
+          // delete only if not an in-flight background fetch
+          if (!fetching) {
+            if (!noDeleteOnStaleGet) {
+              this.#delete(k, 'expire');
+            }
+            if (status && allowStale) status.returnedStale = true;
+            return allowStale ? value : undefined;
+          } else {
+            if (status && allowStale && value.__staleWhileFetching !== undefined) {
+              status.returnedStale = true;
+            }
+            return allowStale ? value.__staleWhileFetching : undefined;
+          }
+        } else {
+          if (status) status.get = 'hit';
+          // if we're currently fetching it, we don't actually have it yet
+          // it's not stale, which means this isn't a staleWhileRefetching.
+          // If it's not stale, and fetching, AND has a __staleWhileFetching
+          // value, then that means the user fetched with {forceRefresh:true},
+          // so it's safe to return that value.
+          if (fetching) {
+            return value.__staleWhileFetching;
+          }
+          this.#moveToTail(index);
+          if (updateAgeOnGet) {
+            this.#updateItemAge(index);
+          }
+          return value;
+        }
+      } else if (status) {
+        status.get = 'miss';
+      }
+    }
+    #connect(p, n) {
+      this.#prev[n] = p;
+      this.#next[p] = n;
+    }
+    #moveToTail(index) {
+      // if tail already, nothing to do
+      // if head, move head to next[index]
+      // else
+      //   move next[prev[index]] to next[index] (head has no prev)
+      //   move prev[next[index]] to prev[index]
+      // prev[index] = tail
+      // next[tail] = index
+      // tail = index
+      if (index !== this.#tail) {
+        if (index === this.#head) {
+          this.#head = this.#next[index];
+        } else {
+          this.#connect(this.#prev[index], this.#next[index]);
+        }
+        this.#connect(this.#tail, index);
+        this.#tail = index;
+      }
+    }
+    /**
+     * Deletes a key out of the cache.
+     *
+     * Returns true if the key was deleted, false otherwise.
+     */
+    delete(k) {
+      return this.#delete(k, 'delete');
+    }
+    #delete(k, reason) {
+      let deleted = false;
+      if (this.#size !== 0) {
+        const index = this.#keyMap.get(k);
+        if (index !== undefined) {
+          deleted = true;
+          if (this.#size === 1) {
+            this.#clear(reason);
+          } else {
+            this.#removeItemSize(index);
+            const v = this.#valList[index];
+            if (this.#isBackgroundFetch(v)) {
+              v.__abortController.abort(new Error('deleted'));
+            } else if (this.#hasDispose || this.#hasDisposeAfter) {
+              if (this.#hasDispose) {
+                this.#dispose?.(v, k, reason);
+              }
+              if (this.#hasDisposeAfter) {
+                this.#disposed?.push([v, k, reason]);
+              }
+            }
+            this.#keyMap.delete(k);
+            this.#keyList[index] = undefined;
+            this.#valList[index] = undefined;
+            if (index === this.#tail) {
+              this.#tail = this.#prev[index];
+            } else if (index === this.#head) {
+              this.#head = this.#next[index];
+            } else {
+              const pi = this.#prev[index];
+              this.#next[pi] = this.#next[index];
+              const ni = this.#next[index];
+              this.#prev[ni] = this.#prev[index];
+            }
+            this.#size--;
+            this.#free.push(index);
           }
         }
-        // didn't get any hits.  this is success if it's a negative
-        // pattern, failure otherwise.
-        if (options.flipNegate) {
-          return false;
-        }
-        return this.negate;
       }
-      static defaults(def) {
-        return exports.minimatch.defaults(def).Minimatch;
+      if (this.#hasDisposeAfter && this.#disposed?.length) {
+        const dt = this.#disposed;
+        let task;
+        while (task = dt?.shift()) {
+          this.#disposeAfter?.(...task);
+        }
       }
+      return deleted;
     }
-    exports.Minimatch = Minimatch;
-    /* c8 ignore start */
-    var ast_js_2 = requireAst();
-    Object.defineProperty(exports, "AST", {
-      enumerable: true,
-      get: function () {
-        return ast_js_2.AST;
+    /**
+     * Clear the cache entirely, throwing away all values.
+     */
+    clear() {
+      return this.#clear('delete');
+    }
+    #clear(reason) {
+      for (const index of this.#rindexes({
+        allowStale: true
+      })) {
+        const v = this.#valList[index];
+        if (this.#isBackgroundFetch(v)) {
+          v.__abortController.abort(new Error('deleted'));
+        } else {
+          const k = this.#keyList[index];
+          if (this.#hasDispose) {
+            this.#dispose?.(v, k, reason);
+          }
+          if (this.#hasDisposeAfter) {
+            this.#disposed?.push([v, k, reason]);
+          }
+        }
       }
-    });
-    var escape_js_2 = require_escape$1();
-    Object.defineProperty(exports, "escape", {
-      enumerable: true,
-      get: function () {
-        return escape_js_2.escape;
+      this.#keyMap.clear();
+      this.#valList.fill(undefined);
+      this.#keyList.fill(undefined);
+      if (this.#ttls && this.#starts) {
+        this.#ttls.fill(0);
+        this.#starts.fill(0);
       }
-    });
-    var unescape_js_2 = require_unescape();
-    Object.defineProperty(exports, "unescape", {
-      enumerable: true,
-      get: function () {
-        return unescape_js_2.unescape;
+      if (this.#sizes) {
+        this.#sizes.fill(0);
       }
-    });
-    /* c8 ignore stop */
-    exports.minimatch.AST = ast_js_1.AST;
-    exports.minimatch.Minimatch = Minimatch;
-    exports.minimatch.escape = escape_js_1.escape;
-    exports.minimatch.unescape = unescape_js_1.unescape;
-  })(commonjs$f);
+      this.#head = 0;
+      this.#tail = 0;
+      this.#free.length = 0;
+      this.#calculatedSize = 0;
+      this.#size = 0;
+      if (this.#hasDisposeAfter && this.#disposed) {
+        const dt = this.#disposed;
+        let task;
+        while (task = dt?.shift()) {
+          this.#disposeAfter?.(...task);
+        }
+      }
+    }
+  }
+  commonjs$f.LRUCache = LRUCache;
   return commonjs$f;
 }
 
-var updateDependencies_1;
-var hasRequiredUpdateDependencies;
-function requireUpdateDependencies() {
-  if (hasRequiredUpdateDependencies) return updateDependencies_1;
-  hasRequiredUpdateDependencies = 1;
-  const depTypes = new Set(['dependencies', 'optionalDependencies', 'devDependencies', 'peerDependencies']);
+/* eslint-disable max-len */
+var hosts_1;
+var hasRequiredHosts;
+function requireHosts() {
+  if (hasRequiredHosts) return hosts_1;
+  hasRequiredHosts = 1;
+  const maybeJoin = (...args) => args.every(arg => arg) ? args.join('') : '';
+  const maybeEncode = arg => arg ? encodeURIComponent(arg) : '';
+  const formatHashFragment = f => f.toLowerCase().replace(/^\W+/g, '') // strip leading non-characters
+  .replace(/(?<!\W)\W+$/, '') // strip trailing non-characters
+  .replace(/\//g, '') // strip all slashes
+  .replace(/\W+/g, '-'); // replace remaining non-characters with '-'
 
-  // sort alphabetically all types of deps for a given package
-  const orderDeps = content => {
-    for (const type of depTypes) {
-      if (content && content[type]) {
-        content[type] = Object.keys(content[type]).sort((a, b) => a.localeCompare(b, 'en')).reduce((res, key) => {
-          res[key] = content[type][key];
-          return res;
-        }, {});
+  const defaults = {
+    sshtemplate: ({
+      domain,
+      user,
+      project,
+      committish
+    }) => `git@${domain}:${user}/${project}.git${maybeJoin('#', committish)}`,
+    sshurltemplate: ({
+      domain,
+      user,
+      project,
+      committish
+    }) => `git+ssh://git@${domain}/${user}/${project}.git${maybeJoin('#', committish)}`,
+    edittemplate: ({
+      domain,
+      user,
+      project,
+      committish,
+      editpath,
+      path
+    }) => `https://${domain}/${user}/${project}${maybeJoin('/', editpath, '/', maybeEncode(committish || 'HEAD'), '/', path)}`,
+    browsetemplate: ({
+      domain,
+      user,
+      project,
+      committish,
+      treepath
+    }) => `https://${domain}/${user}/${project}${maybeJoin('/', treepath, '/', maybeEncode(committish))}`,
+    browsetreetemplate: ({
+      domain,
+      user,
+      project,
+      committish,
+      treepath,
+      path,
+      fragment,
+      hashformat
+    }) => `https://${domain}/${user}/${project}/${treepath}/${maybeEncode(committish || 'HEAD')}/${path}${maybeJoin('#', hashformat(fragment || ''))}`,
+    browseblobtemplate: ({
+      domain,
+      user,
+      project,
+      committish,
+      blobpath,
+      path,
+      fragment,
+      hashformat
+    }) => `https://${domain}/${user}/${project}/${blobpath}/${maybeEncode(committish || 'HEAD')}/${path}${maybeJoin('#', hashformat(fragment || ''))}`,
+    docstemplate: ({
+      domain,
+      user,
+      project,
+      treepath,
+      committish
+    }) => `https://${domain}/${user}/${project}${maybeJoin('/', treepath, '/', maybeEncode(committish))}#readme`,
+    httpstemplate: ({
+      auth,
+      domain,
+      user,
+      project,
+      committish
+    }) => `git+https://${maybeJoin(auth, '@')}${domain}/${user}/${project}.git${maybeJoin('#', committish)}`,
+    filetemplate: ({
+      domain,
+      user,
+      project,
+      committish,
+      path
+    }) => `https://${domain}/${user}/${project}/raw/${maybeEncode(committish || 'HEAD')}/${path}`,
+    shortcuttemplate: ({
+      type,
+      user,
+      project,
+      committish
+    }) => `${type}:${user}/${project}${maybeJoin('#', committish)}`,
+    pathtemplate: ({
+      user,
+      project,
+      committish
+    }) => `${user}/${project}${maybeJoin('#', committish)}`,
+    bugstemplate: ({
+      domain,
+      user,
+      project
+    }) => `https://${domain}/${user}/${project}/issues`,
+    hashformat: formatHashFragment
+  };
+  const hosts = {};
+  hosts.github = {
+    // First two are insecure and generally shouldn't be used any more, but
+    // they are still supported.
+    protocols: ['git:', 'http:', 'git+ssh:', 'git+https:', 'ssh:', 'https:'],
+    domain: 'github.com',
+    treepath: 'tree',
+    blobpath: 'blob',
+    editpath: 'edit',
+    filetemplate: ({
+      auth,
+      user,
+      project,
+      committish,
+      path
+    }) => `https://${maybeJoin(auth, '@')}raw.githubusercontent.com/${user}/${project}/${maybeEncode(committish || 'HEAD')}/${path}`,
+    gittemplate: ({
+      auth,
+      domain,
+      user,
+      project,
+      committish
+    }) => `git://${maybeJoin(auth, '@')}${domain}/${user}/${project}.git${maybeJoin('#', committish)}`,
+    tarballtemplate: ({
+      domain,
+      user,
+      project,
+      committish
+    }) => `https://codeload.${domain}/${user}/${project}/tar.gz/${maybeEncode(committish || 'HEAD')}`,
+    extract: url => {
+      let [, user, project, type, committish] = url.pathname.split('/', 5);
+      if (type && type !== 'tree') {
+        return;
+      }
+      if (!type) {
+        committish = url.hash.slice(1);
+      }
+      if (project && project.endsWith('.git')) {
+        project = project.slice(0, -4);
+      }
+      if (!user || !project) {
+        return;
       }
+      return {
+        user,
+        project,
+        committish
+      };
     }
-    return content;
   };
-  const updateDependencies = ({
-    content,
-    originalContent
-  }) => {
-    const pkg = orderDeps({
-      ...content
-    });
-
-    // optionalDependencies don't need to be repeated in two places
-    if (pkg.dependencies) {
-      if (pkg.optionalDependencies) {
-        for (const name of Object.keys(pkg.optionalDependencies)) {
-          delete pkg.dependencies[name];
+  hosts.bitbucket = {
+    protocols: ['git+ssh:', 'git+https:', 'ssh:', 'https:'],
+    domain: 'bitbucket.org',
+    treepath: 'src',
+    blobpath: 'src',
+    editpath: '?mode=edit',
+    edittemplate: ({
+      domain,
+      user,
+      project,
+      committish,
+      treepath,
+      path,
+      editpath
+    }) => `https://${domain}/${user}/${project}${maybeJoin('/', treepath, '/', maybeEncode(committish || 'HEAD'), '/', path, editpath)}`,
+    tarballtemplate: ({
+      domain,
+      user,
+      project,
+      committish
+    }) => `https://${domain}/${user}/${project}/get/${maybeEncode(committish || 'HEAD')}.tar.gz`,
+    extract: url => {
+      let [, user, project, aux] = url.pathname.split('/', 4);
+      if (['get'].includes(aux)) {
+        return;
+      }
+      if (project && project.endsWith('.git')) {
+        project = project.slice(0, -4);
+      }
+      if (!user || !project) {
+        return;
+      }
+      return {
+        user,
+        project,
+        committish: url.hash.slice(1)
+      };
+    }
+  };
+  hosts.gitlab = {
+    protocols: ['git+ssh:', 'git+https:', 'ssh:', 'https:'],
+    domain: 'gitlab.com',
+    treepath: 'tree',
+    blobpath: 'tree',
+    editpath: '-/edit',
+    httpstemplate: ({
+      auth,
+      domain,
+      user,
+      project,
+      committish
+    }) => `git+https://${maybeJoin(auth, '@')}${domain}/${user}/${project}.git${maybeJoin('#', committish)}`,
+    tarballtemplate: ({
+      domain,
+      user,
+      project,
+      committish
+    }) => `https://${domain}/${user}/${project}/repository/archive.tar.gz?ref=${maybeEncode(committish || 'HEAD')}`,
+    extract: url => {
+      const path = url.pathname.slice(1);
+      if (path.includes('/-/') || path.includes('/archive.tar.gz')) {
+        return;
+      }
+      const segments = path.split('/');
+      let project = segments.pop();
+      if (project.endsWith('.git')) {
+        project = project.slice(0, -4);
+      }
+      const user = segments.join('/');
+      if (!user || !project) {
+        return;
+      }
+      return {
+        user,
+        project,
+        committish: url.hash.slice(1)
+      };
+    }
+  };
+  hosts.gist = {
+    protocols: ['git:', 'git+ssh:', 'git+https:', 'ssh:', 'https:'],
+    domain: 'gist.github.com',
+    editpath: 'edit',
+    sshtemplate: ({
+      domain,
+      project,
+      committish
+    }) => `git@${domain}:${project}.git${maybeJoin('#', committish)}`,
+    sshurltemplate: ({
+      domain,
+      project,
+      committish
+    }) => `git+ssh://git@${domain}/${project}.git${maybeJoin('#', committish)}`,
+    edittemplate: ({
+      domain,
+      user,
+      project,
+      committish,
+      editpath
+    }) => `https://${domain}/${user}/${project}${maybeJoin('/', maybeEncode(committish))}/${editpath}`,
+    browsetemplate: ({
+      domain,
+      project,
+      committish
+    }) => `https://${domain}/${project}${maybeJoin('/', maybeEncode(committish))}`,
+    browsetreetemplate: ({
+      domain,
+      project,
+      committish,
+      path,
+      hashformat
+    }) => `https://${domain}/${project}${maybeJoin('/', maybeEncode(committish))}${maybeJoin('#', hashformat(path))}`,
+    browseblobtemplate: ({
+      domain,
+      project,
+      committish,
+      path,
+      hashformat
+    }) => `https://${domain}/${project}${maybeJoin('/', maybeEncode(committish))}${maybeJoin('#', hashformat(path))}`,
+    docstemplate: ({
+      domain,
+      project,
+      committish
+    }) => `https://${domain}/${project}${maybeJoin('/', maybeEncode(committish))}`,
+    httpstemplate: ({
+      domain,
+      project,
+      committish
+    }) => `git+https://${domain}/${project}.git${maybeJoin('#', committish)}`,
+    filetemplate: ({
+      user,
+      project,
+      committish,
+      path
+    }) => `https://gist.githubusercontent.com/${user}/${project}/raw${maybeJoin('/', maybeEncode(committish))}/${path}`,
+    shortcuttemplate: ({
+      type,
+      project,
+      committish
+    }) => `${type}:${project}${maybeJoin('#', committish)}`,
+    pathtemplate: ({
+      project,
+      committish
+    }) => `${project}${maybeJoin('#', committish)}`,
+    bugstemplate: ({
+      domain,
+      project
+    }) => `https://${domain}/${project}`,
+    gittemplate: ({
+      domain,
+      project,
+      committish
+    }) => `git://${domain}/${project}.git${maybeJoin('#', committish)}`,
+    tarballtemplate: ({
+      project,
+      committish
+    }) => `https://codeload.github.com/gist/${project}/tar.gz/${maybeEncode(committish || 'HEAD')}`,
+    extract: url => {
+      let [, user, project, aux] = url.pathname.split('/', 4);
+      if (aux === 'raw') {
+        return;
+      }
+      if (!project) {
+        if (!user) {
+          return;
         }
+        project = user;
+        user = null;
       }
+      if (project.endsWith('.git')) {
+        project = project.slice(0, -4);
+      }
+      return {
+        user,
+        project,
+        committish: url.hash.slice(1)
+      };
+    },
+    hashformat: function (fragment) {
+      return fragment && 'file-' + formatHashFragment(fragment);
     }
-    const result = {
-      ...originalContent
-    };
+  };
+  hosts.sourcehut = {
+    protocols: ['git+ssh:', 'https:'],
+    domain: 'git.sr.ht',
+    treepath: 'tree',
+    blobpath: 'tree',
+    filetemplate: ({
+      domain,
+      user,
+      project,
+      committish,
+      path
+    }) => `https://${domain}/${user}/${project}/blob/${maybeEncode(committish) || 'HEAD'}/${path}`,
+    httpstemplate: ({
+      domain,
+      user,
+      project,
+      committish
+    }) => `https://${domain}/${user}/${project}.git${maybeJoin('#', committish)}`,
+    tarballtemplate: ({
+      domain,
+      user,
+      project,
+      committish
+    }) => `https://${domain}/${user}/${project}/archive/${maybeEncode(committish) || 'HEAD'}.tar.gz`,
+    bugstemplate: () => null,
+    extract: url => {
+      let [, user, project, aux] = url.pathname.split('/', 4);
 
-    // loop through all types of dependencies and update package json pkg
-    for (const type of depTypes) {
-      if (pkg[type]) {
-        result[type] = pkg[type];
+      // tarball url
+      if (['archive'].includes(aux)) {
+        return;
       }
-
-      // prune empty type props from resulting object
-      const emptyDepType = pkg[type] && typeof pkg === 'object' && Object.keys(pkg[type]).length === 0;
-      if (emptyDepType) {
-        delete result[type];
+      if (project && project.endsWith('.git')) {
+        project = project.slice(0, -4);
       }
+      if (!user || !project) {
+        return;
+      }
+      return {
+        user,
+        project,
+        committish: url.hash.slice(1)
+      };
+    }
+  };
+  for (const [name, host] of Object.entries(hosts)) {
+    hosts[name] = Object.assign({}, defaults, host);
+  }
+  hosts_1 = hosts;
+  return hosts_1;
+}
+
+var parseUrl;
+var hasRequiredParseUrl;
+function requireParseUrl() {
+  if (hasRequiredParseUrl) return parseUrl;
+  hasRequiredParseUrl = 1;
+  const url = require$$0$e;
+  const lastIndexOfBefore = (str, char, beforeChar) => {
+    const startPosition = str.indexOf(beforeChar);
+    return str.lastIndexOf(char, startPosition > -1 ? startPosition : Infinity);
+  };
+  const safeUrl = u => {
+    try {
+      return new url.URL(u);
+    } catch {
+      // this fn should never throw
     }
+  };
 
-    // if original package.json had dep in peerDeps AND deps, preserve that.
-    const {
-      dependencies: origProd,
-      peerDependencies: origPeer
-    } = originalContent || {};
-    const {
-      peerDependencies: newPeer
-    } = result;
-    if (origProd && origPeer && newPeer) {
-      // we have original prod/peer deps, and new peer deps
-      // copy over any that were in both in the original
-      for (const name of Object.keys(origPeer)) {
-        if (origProd[name] !== undefined && newPeer[name] !== undefined) {
-          result.dependencies = result.dependencies || {};
-          result.dependencies[name] = newPeer[name];
-        }
+  // accepts input like git:github.com:user/repo and inserts the // after the first :
+  const correctProtocol = (arg, protocols) => {
+    const firstColon = arg.indexOf(':');
+    const proto = arg.slice(0, firstColon + 1);
+    if (Object.prototype.hasOwnProperty.call(protocols, proto)) {
+      return arg;
+    }
+    const firstAt = arg.indexOf('@');
+    if (firstAt > -1) {
+      if (firstAt > firstColon) {
+        return `git+ssh://${arg}`;
+      } else {
+        return arg;
       }
     }
-    return result;
+    const doubleSlash = arg.indexOf('//');
+    if (doubleSlash === firstColon + 1) {
+      return arg;
+    }
+    return `${arg.slice(0, firstColon + 1)}//${arg.slice(firstColon + 1)}`;
   };
-  updateDependencies.knownKeys = depTypes;
-  updateDependencies_1 = updateDependencies;
-  return updateDependencies_1;
+
+  // attempt to correct an scp style url so that it will parse with `new URL()`
+  const correctUrl = giturl => {
+    // ignore @ that come after the first hash since the denotes the start
+    // of a committish which can contain @ characters
+    const firstAt = lastIndexOfBefore(giturl, '@', '#');
+    // ignore colons that come after the hash since that could include colons such as:
+    // git@github.com:user/package-2#semver:^1.0.0
+    const lastColonBeforeHash = lastIndexOfBefore(giturl, ':', '#');
+    if (lastColonBeforeHash > firstAt) {
+      // the last : comes after the first @ (or there is no @)
+      // like it would in:
+      // proto://hostname.com:user/repo
+      // username@hostname.com:user/repo
+      // :password@hostname.com:user/repo
+      // username:password@hostname.com:user/repo
+      // proto://username@hostname.com:user/repo
+      // proto://:password@hostname.com:user/repo
+      // proto://username:password@hostname.com:user/repo
+      // then we replace the last : with a / to create a valid path
+      giturl = giturl.slice(0, lastColonBeforeHash) + '/' + giturl.slice(lastColonBeforeHash + 1);
+    }
+    if (lastIndexOfBefore(giturl, ':', '#') === -1 && giturl.indexOf('//') === -1) {
+      // we have no : at all
+      // as it would be in:
+      // username@hostname.com/user/repo
+      // then we prepend a protocol
+      giturl = `git+ssh://${giturl}`;
+    }
+    return giturl;
+  };
+  parseUrl = (giturl, protocols) => {
+    const withProtocol = protocols ? correctProtocol(giturl, protocols) : giturl;
+    return safeUrl(withProtocol) || safeUrl(correctUrl(withProtocol));
+  };
+  return parseUrl;
 }
 
-var updateScripts_1;
-var hasRequiredUpdateScripts;
-function requireUpdateScripts() {
-  if (hasRequiredUpdateScripts) return updateScripts_1;
-  hasRequiredUpdateScripts = 1;
-  const updateScripts = ({
-    content,
-    originalContent = {}
+var fromUrl;
+var hasRequiredFromUrl;
+function requireFromUrl() {
+  if (hasRequiredFromUrl) return fromUrl;
+  hasRequiredFromUrl = 1;
+  const parseUrl = requireParseUrl();
+
+  // look for github shorthand inputs, such as npm/cli
+  const isGitHubShorthand = arg => {
+    // it cannot contain whitespace before the first #
+    // it cannot start with a / because that's probably an absolute file path
+    // but it must include a slash since repos are username/repository
+    // it cannot start with a . because that's probably a relative file path
+    // it cannot start with an @ because that's a scoped package if it passes the other tests
+    // it cannot contain a : before a # because that tells us that there's a protocol
+    // a second / may not exist before a #
+    const firstHash = arg.indexOf('#');
+    const firstSlash = arg.indexOf('/');
+    const secondSlash = arg.indexOf('/', firstSlash + 1);
+    const firstColon = arg.indexOf(':');
+    const firstSpace = /\s/.exec(arg);
+    const firstAt = arg.indexOf('@');
+    const spaceOnlyAfterHash = !firstSpace || firstHash > -1 && firstSpace.index > firstHash;
+    const atOnlyAfterHash = firstAt === -1 || firstHash > -1 && firstAt > firstHash;
+    const colonOnlyAfterHash = firstColon === -1 || firstHash > -1 && firstColon > firstHash;
+    const secondSlashOnlyAfterHash = secondSlash === -1 || firstHash > -1 && secondSlash > firstHash;
+    const hasSlash = firstSlash > 0;
+    // if a # is found, what we really want to know is that the character
+    // immediately before # is not a /
+    const doesNotEndWithSlash = firstHash > -1 ? arg[firstHash - 1] !== '/' : !arg.endsWith('/');
+    const doesNotStartWithDot = !arg.startsWith('.');
+    return spaceOnlyAfterHash && hasSlash && doesNotEndWithSlash && doesNotStartWithDot && atOnlyAfterHash && colonOnlyAfterHash && secondSlashOnlyAfterHash;
+  };
+  fromUrl = (giturl, opts, {
+    gitHosts,
+    protocols
   }) => {
-    const newScripts = content.scripts;
-    if (!newScripts) {
-      return originalContent;
+    if (!giturl) {
+      return;
+    }
+    const correctedUrl = isGitHubShorthand(giturl) ? `github:${giturl}` : giturl;
+    const parsed = parseUrl(correctedUrl, protocols);
+    if (!parsed) {
+      return;
+    }
+    const gitHostShortcut = gitHosts.byShortcut[parsed.protocol];
+    const gitHostDomain = gitHosts.byDomain[parsed.hostname.startsWith('www.') ? parsed.hostname.slice(4) : parsed.hostname];
+    const gitHostName = gitHostShortcut || gitHostDomain;
+    if (!gitHostName) {
+      return;
+    }
+    const gitHostInfo = gitHosts[gitHostShortcut || gitHostDomain];
+    let auth = null;
+    if (protocols[parsed.protocol]?.auth && (parsed.username || parsed.password)) {
+      auth = `${parsed.username}${parsed.password ? ':' + parsed.password : ''}`;
+    }
+    let committish = null;
+    let user = null;
+    let project = null;
+    let defaultRepresentation = null;
+    try {
+      if (gitHostShortcut) {
+        let pathname = parsed.pathname.startsWith('/') ? parsed.pathname.slice(1) : parsed.pathname;
+        const firstAt = pathname.indexOf('@');
+        // we ignore auth for shortcuts, so just trim it out
+        if (firstAt > -1) {
+          pathname = pathname.slice(firstAt + 1);
+        }
+        const lastSlash = pathname.lastIndexOf('/');
+        if (lastSlash > -1) {
+          user = decodeURIComponent(pathname.slice(0, lastSlash));
+          // we want nulls only, never empty strings
+          if (!user) {
+            user = null;
+          }
+          project = decodeURIComponent(pathname.slice(lastSlash + 1));
+        } else {
+          project = decodeURIComponent(pathname);
+        }
+        if (project.endsWith('.git')) {
+          project = project.slice(0, -4);
+        }
+        if (parsed.hash) {
+          committish = decodeURIComponent(parsed.hash.slice(1));
+        }
+        defaultRepresentation = 'shortcut';
+      } else {
+        if (!gitHostInfo.protocols.includes(parsed.protocol)) {
+          return;
+        }
+        const segments = gitHostInfo.extract(parsed);
+        if (!segments) {
+          return;
+        }
+        user = segments.user && decodeURIComponent(segments.user);
+        project = decodeURIComponent(segments.project);
+        committish = decodeURIComponent(segments.committish);
+        defaultRepresentation = protocols[parsed.protocol]?.name || parsed.protocol.slice(0, -1);
+      }
+    } catch (err) {
+      /* istanbul ignore else */
+      if (err instanceof URIError) {
+        return;
+      } else {
+        throw err;
+      }
     }
+    return [gitHostName, user, auth, project, committish, defaultRepresentation, opts];
+  };
+  return fromUrl;
+}
 
-    // validate scripts content being appended
-    const hasInvalidScripts = () => Object.entries(newScripts).some(([key, value]) => typeof key !== 'string' || typeof value !== 'string');
-    if (hasInvalidScripts()) {
-      throw Object.assign(new TypeError('package.json scripts should be a key-value pair of strings.'), {
-        code: 'ESCRIPTSINVALID'
+var lib$v;
+var hasRequiredLib$v;
+function requireLib$v() {
+  if (hasRequiredLib$v) return lib$v;
+  hasRequiredLib$v = 1;
+  const {
+    LRUCache
+  } = /*@__PURE__*/requireCommonjs$f();
+  const hosts = requireHosts();
+  const fromUrl = requireFromUrl();
+  const parseUrl = requireParseUrl();
+  const cache = new LRUCache({
+    max: 1000
+  });
+  function unknownHostedUrl(url) {
+    try {
+      const {
+        protocol,
+        hostname,
+        pathname
+      } = new URL(url);
+      if (!hostname) {
+        return null;
+      }
+      const proto = /(?:git\+)http:$/.test(protocol) ? 'http:' : 'https:';
+      const path = pathname.replace(/\.git$/, '');
+      return `${proto}//${hostname}${path}`;
+    } catch {
+      return null;
+    }
+  }
+  class GitHost {
+    constructor(type, user, auth, project, committish, defaultRepresentation, opts = {}) {
+      Object.assign(this, GitHost.#gitHosts[type], {
+        type,
+        user,
+        auth,
+        project,
+        committish,
+        default: defaultRepresentation,
+        opts
       });
     }
-    return {
-      ...originalContent,
-      scripts: {
-        ...newScripts
+    static #gitHosts = {
+      byShortcut: {},
+      byDomain: {}
+    };
+    static #protocols = {
+      'git+ssh:': {
+        name: 'sshurl'
+      },
+      'ssh:': {
+        name: 'sshurl'
+      },
+      'git+https:': {
+        name: 'https',
+        auth: true
+      },
+      'git:': {
+        auth: true
+      },
+      'http:': {
+        auth: true
+      },
+      'https:': {
+        auth: true
+      },
+      'git+http:': {
+        auth: true
       }
     };
-  };
-  updateScripts_1 = updateScripts;
-  return updateScripts_1;
-}
+    static addHost(name, host) {
+      GitHost.#gitHosts[name] = host;
+      GitHost.#gitHosts.byDomain[host.domain] = name;
+      GitHost.#gitHosts.byShortcut[`${name}:`] = name;
+      GitHost.#protocols[`${name}:`] = {
+        name
+      };
+    }
+    static fromUrl(giturl, opts) {
+      if (typeof giturl !== 'string') {
+        return;
+      }
+      const key = giturl + JSON.stringify(opts || {});
+      if (!cache.has(key)) {
+        const hostArgs = fromUrl(giturl, opts, {
+          gitHosts: GitHost.#gitHosts,
+          protocols: GitHost.#protocols
+        });
+        cache.set(key, hostArgs ? new GitHost(...hostArgs) : undefined);
+      }
+      return cache.get(key);
+    }
+    static fromManifest(manifest, opts = {}) {
+      if (!manifest || typeof manifest !== 'object') {
+        return;
+      }
+      const r = manifest.repository;
+      // TODO: look into also checking the `bugs`/`homepage` URLs
 
-var updateWorkspaces_1;
-var hasRequiredUpdateWorkspaces;
-function requireUpdateWorkspaces() {
-  if (hasRequiredUpdateWorkspaces) return updateWorkspaces_1;
-  hasRequiredUpdateWorkspaces = 1;
-  const updateWorkspaces = ({
-    content,
-    originalContent = {}
-  }) => {
-    const newWorkspaces = content.workspaces;
-    if (!newWorkspaces) {
-      return originalContent;
+      const rurl = r && (typeof r === 'string' ? r : typeof r === 'object' && typeof r.url === 'string' ? r.url : null);
+      if (!rurl) {
+        throw new Error('no repository');
+      }
+      const info = rurl && GitHost.fromUrl(rurl.replace(/^git\+/, ''), opts) || null;
+      if (info) {
+        return info;
+      }
+      const unk = unknownHostedUrl(rurl);
+      return GitHost.fromUrl(unk, opts) || unk;
     }
+    static parseUrl(url) {
+      return parseUrl(url);
+    }
+    #fill(template, opts) {
+      if (typeof template !== 'function') {
+        return null;
+      }
+      const options = {
+        ...this,
+        ...this.opts,
+        ...opts
+      };
 
-    // validate workspaces content being appended
-    const hasInvalidWorkspaces = () => newWorkspaces.some(w => !(typeof w === 'string'));
-    if (!newWorkspaces.length || hasInvalidWorkspaces()) {
-      throw Object.assign(new TypeError('workspaces should be an array of strings.'), {
-        code: 'EWORKSPACESINVALID'
+      // the path should always be set so we don't end up with 'undefined' in urls
+      if (!options.path) {
+        options.path = '';
+      }
+
+      // template functions will insert the leading slash themselves
+      if (options.path.startsWith('/')) {
+        options.path = options.path.slice(1);
+      }
+      if (options.noCommittish) {
+        options.committish = null;
+      }
+      const result = template(options);
+      return options.noGitPlus && result.startsWith('git+') ? result.slice(4) : result;
+    }
+    hash() {
+      return this.committish ? `#${this.committish}` : '';
+    }
+    ssh(opts) {
+      return this.#fill(this.sshtemplate, opts);
+    }
+    sshurl(opts) {
+      return this.#fill(this.sshurltemplate, opts);
+    }
+    browse(path, ...args) {
+      // not a string, treat path as opts
+      if (typeof path !== 'string') {
+        return this.#fill(this.browsetemplate, path);
+      }
+      if (typeof args[0] !== 'string') {
+        return this.#fill(this.browsetreetemplate, {
+          ...args[0],
+          path
+        });
+      }
+      return this.#fill(this.browsetreetemplate, {
+        ...args[1],
+        fragment: args[0],
+        path
       });
     }
-    return {
-      ...originalContent,
-      workspaces: [...newWorkspaces]
-    };
-  };
-  updateWorkspaces_1 = updateWorkspaces;
-  return updateWorkspaces_1;
+
+    // If the path is known to be a file, then browseFile should be used. For some hosts
+    // the url is the same as browse, but for others like GitHub a file can use both `/tree/`
+    // and `/blob/` in the path. When using a default committish of `HEAD` then the `/tree/`
+    // path will redirect to a specific commit. Using the `/blob/` path avoids this and
+    // does not redirect to a different commit.
+    browseFile(path, ...args) {
+      if (typeof args[0] !== 'string') {
+        return this.#fill(this.browseblobtemplate, {
+          ...args[0],
+          path
+        });
+      }
+      return this.#fill(this.browseblobtemplate, {
+        ...args[1],
+        fragment: args[0],
+        path
+      });
+    }
+    docs(opts) {
+      return this.#fill(this.docstemplate, opts);
+    }
+    bugs(opts) {
+      return this.#fill(this.bugstemplate, opts);
+    }
+    https(opts) {
+      return this.#fill(this.httpstemplate, opts);
+    }
+    git(opts) {
+      return this.#fill(this.gittemplate, opts);
+    }
+    shortcut(opts) {
+      return this.#fill(this.shortcuttemplate, opts);
+    }
+    path(opts) {
+      return this.#fill(this.pathtemplate, opts);
+    }
+    tarball(opts) {
+      return this.#fill(this.tarballtemplate, {
+        ...opts,
+        noCommittish: false
+      });
+    }
+    file(path, opts) {
+      return this.#fill(this.filetemplate, {
+        ...opts,
+        path
+      });
+    }
+    edit(path, opts) {
+      return this.#fill(this.edittemplate, {
+        ...opts,
+        path
+      });
+    }
+    getDefaultRepresentation() {
+      return this.default;
+    }
+    toString(opts) {
+      if (this.default && typeof this[this.default] === 'function') {
+        return this[this.default](opts);
+      }
+      return this.sshurl(opts);
+    }
+  }
+  for (const [name, host] of Object.entries(hosts)) {
+    GitHost.addHost(name, host);
+  }
+  lib$v = GitHost;
+  return lib$v;
 }
 
 var commonjs$e = {};
@@ -68703,7 +71046,7 @@ function requirePattern$2() {
     value: true
   });
   pattern$2.Pattern = void 0;
-  const minimatch_1 = requireCommonjs$f();
+  const minimatch_1 = requireCommonjs$g();
   const isPatternList = pl => pl.length >= 1;
   const isGlobList = gl => gl.length >= 1;
   /**
@@ -68900,7 +71243,7 @@ function requireIgnore$2() {
     value: true
   });
   ignore$2.Ignore = void 0;
-  const minimatch_1 = requireCommonjs$f();
+  const minimatch_1 = requireCommonjs$g();
   const pattern_js_1 = requirePattern$2();
   const defaultPlatform = typeof process === 'object' && process && typeof process.platform === 'string' ? process.platform : 'linux';
   /**
@@ -69016,7 +71359,7 @@ function requireProcessor$2() {
     value: true
   });
   processor$2.Processor = processor$2.SubWalks = processor$2.MatchRecord = processor$2.HasWalkedCache = void 0;
-  const minimatch_1 = requireCommonjs$f();
+  const minimatch_1 = requireCommonjs$g();
   /**
    * A cache of which patterns have been processed for a given Path
    */
@@ -69633,7 +71976,7 @@ function requireGlob$3() {
     value: true
   });
   glob$2.Glob = void 0;
-  const minimatch_1 = requireCommonjs$f();
+  const minimatch_1 = requireCommonjs$g();
   const node_url_1 = require$$0$7;
   const path_scurry_1 = requireCommonjs$c();
   const pattern_js_1 = requirePattern$2();
@@ -69864,7 +72207,7 @@ function requireHasMagic$2() {
     value: true
   });
   hasMagic$2.hasMagic = void 0;
-  const minimatch_1 = requireCommonjs$f();
+  const minimatch_1 = requireCommonjs$g();
   /**
    * Return true if the patterns provided contain any magic glob characters,
    * given the options provided.
@@ -69904,10 +72247,10 @@ function requireCommonjs$b() {
     exports.globSync = globSync;
     exports.globIterateSync = globIterateSync;
     exports.globIterate = globIterate;
-    const minimatch_1 = requireCommonjs$f();
+    const minimatch_1 = requireCommonjs$g();
     const glob_js_1 = requireGlob$3();
     const has_magic_js_1 = requireHasMagic$2();
-    var minimatch_2 = requireCommonjs$f();
+    var minimatch_2 = requireCommonjs$g();
     Object.defineProperty(exports, "escape", {
       enumerable: true,
       get: function () {
@@ -70069,7 +72412,7 @@ function requireLib$u() {
     spawn
   } = require$$0$m;
   const os = require$$0$f;
-  const which = requireLib$H();
+  const which = requireLib$I();
   const escape = require_escape();
 
   // 'extra' object is for decorating the error a bit more
@@ -70741,7 +73084,7 @@ var hasRequiredWhich;
 function requireWhich() {
   if (hasRequiredWhich) return which_1;
   hasRequiredWhich = 1;
-  const which = requireLib$H();
+  const which = requireLib$I();
   let gitPath;
   try {
     gitPath = which.sync('git');
@@ -70771,7 +73114,7 @@ function requireSpawn() {
   const promiseRetry = requirePromiseRetry();
   const {
     log
-  } = requireLib$E();
+  } = requireLib$F();
   const makeError = requireMakeError();
   const makeOpts = requireOpts();
   spawn_1 = (gitArgs, opts = {}) => {
@@ -72845,7 +75188,7 @@ function requireLib$s() {
   const {
     checkEngine
   } = requireLib$t();
-  const normalizeBin = requireLib$B();
+  const normalizeBin = requireLib$C();
   const engineOk = (manifest, npmVersion, nodeVersion) => {
     try {
       checkEngine(manifest, npmVersion, nodeVersion);
@@ -74612,7 +76955,7 @@ var hasRequiredNormalizeData;
 function requireNormalizeData() {
   if (hasRequiredNormalizeData) return normalizeData_1;
   hasRequiredNormalizeData = 1;
-  const hostedGitInfo = requireLib$G();
+  const hostedGitInfo = requireLib$v();
   const validateLicense = requireValidateNpmPackageLicense();
   const typos = {
     dependancies: 'dependencies',
@@ -74883,7 +77226,7 @@ function requireNormalize() {
   const path = path$2;
   const {
     log
-  } = requireLib$E();
+  } = requireLib$F();
   const moduleBuiltin = require$$5$3;
 
   /**
@@ -74892,7 +77235,7 @@ function requireNormalize() {
   let _hostedGitInfo;
   function lazyHostedGitInfo() {
     if (!_hostedGitInfo) {
-      _hostedGitInfo = requireLib$G();
+      _hostedGitInfo = requireLib$v();
     }
     return _hostedGitInfo;
   }
@@ -75482,7 +77825,7 @@ function requireReadPackage() {
   const {
     readFile
   } = require$$0$k;
-  const parseJSON = requireLib$C();
+  const parseJSON = requireLib$D();
   async function read(filename) {
     try {
       const data = await readFile(filename, 'utf8');
@@ -75716,7 +78059,7 @@ function requireLib$q() {
   const {
     resolve
   } = path$2;
-  const parseJSON = requireLib$C();
+  const parseJSON = requireLib$D();
   const updateDeps = requireUpdateDependencies();
   const updateScripts = requireUpdateScripts();
   const updateWorkspaces = requireUpdateWorkspaces();
@@ -83486,7 +85829,7 @@ function requirePattern$1() {
     value: true
   });
   pattern$1.Pattern = void 0;
-  const minimatch_1 = requireCommonjs$f();
+  const minimatch_1 = requireCommonjs$g();
   const isPatternList = pl => pl.length >= 1;
   const isGlobList = gl => gl.length >= 1;
   /**
@@ -83683,7 +86026,7 @@ function requireIgnore$1() {
     value: true
   });
   ignore$1.Ignore = void 0;
-  const minimatch_1 = requireCommonjs$f();
+  const minimatch_1 = requireCommonjs$g();
   const pattern_js_1 = requirePattern$1();
   const defaultPlatform = typeof process === 'object' && process && typeof process.platform === 'string' ? process.platform : 'linux';
   /**
@@ -83799,7 +86142,7 @@ function requireProcessor$1() {
     value: true
   });
   processor$1.Processor = processor$1.SubWalks = processor$1.MatchRecord = processor$1.HasWalkedCache = void 0;
-  const minimatch_1 = requireCommonjs$f();
+  const minimatch_1 = requireCommonjs$g();
   /**
    * A cache of which patterns have been processed for a given Path
    */
@@ -84416,7 +86759,7 @@ function requireGlob$2() {
     value: true
   });
   glob$1.Glob = void 0;
-  const minimatch_1 = requireCommonjs$f();
+  const minimatch_1 = requireCommonjs$g();
   const node_url_1 = require$$0$7;
   const path_scurry_1 = requireCommonjs$8();
   const pattern_js_1 = requirePattern$1();
@@ -84647,7 +86990,7 @@ function requireHasMagic$1() {
     value: true
   });
   hasMagic$1.hasMagic = void 0;
-  const minimatch_1 = requireCommonjs$f();
+  const minimatch_1 = requireCommonjs$g();
   /**
    * Return true if the patterns provided contain any magic glob characters,
    * given the options provided.
@@ -84687,10 +87030,10 @@ function requireCommonjs$7() {
     exports.globSync = globSync;
     exports.globIterateSync = globIterateSync;
     exports.globIterate = globIterate;
-    const minimatch_1 = requireCommonjs$f();
+    const minimatch_1 = requireCommonjs$g();
     const glob_js_1 = requireGlob$2();
     const has_magic_js_1 = requireHasMagic$1();
-    var minimatch_2 = requireCommonjs$f();
+    var minimatch_2 = requireCommonjs$g();
     Object.defineProperty(exports, "escape", {
       enumerable: true,
       get: function () {
@@ -85212,7 +87555,7 @@ function requireLib$j() {
   const EE = require$$0$c.EventEmitter;
   // we don't care about the package bins, but we share a pj cache
   // with other modules that DO care about it, so keep it nice.
-  const normalizePackageBin = requireLib$B();
+  const normalizePackageBin = requireLib$C();
   class BundleWalker extends EE {
     constructor(opt) {
       opt = opt || {};
@@ -85454,7 +87797,7 @@ function requireLib$i() {
     basename,
     dirname
   } = require$$0$d;
-  const normalizePackageBin = requireLib$B();
+  const normalizePackageBin = requireLib$C();
   const readPackage = ({
     path,
     packageJsonCache
@@ -92831,7 +95174,7 @@ function requireLib$h() {
   const fs = require$$0$a;
   const path = require$$0$d;
   const EE = require$$0$c.EventEmitter;
-  const Minimatch = requireCommonjs$f().Minimatch;
+  const Minimatch = requireCommonjs$g().Minimatch;
   class Walker extends EE {
     constructor(opts) {
       opts = opts || {};
@@ -93831,7 +96174,7 @@ function requireRunScriptPkg() {
       const {
         output,
         input
-      } = requireLib$E();
+      } = requireLib$F();
       output.standard(banner);
       inputEnd = input.start();
     }
@@ -108240,7 +110583,7 @@ function requireCheckResponse() {
   const defaultOpts = requireDefaultOpts();
   const {
     log
-  } = requireLib$E();
+  } = requireLib$F();
   const {
     redact: cleanUrl
   } = requireLib$c();
@@ -120512,7 +122855,7 @@ function requireRemote$1() {
   const ssri = requireLib$p();
   const {
     log
-  } = requireLib$E();
+  } = requireLib$F();
   const CachingMinipassPipeline = requirePipeline();
   const {
     getAgent
@@ -122366,7 +124709,7 @@ function requireGit() {
   } = requireCommonjs$d();
   const {
     log
-  } = requireLib$E();
+  } = requireLib$F();
   const DirFetcher = requireDir();
   const Fetcher = requireFetcher();
   const FileFetcher = requireFile$1();
@@ -127473,7 +129816,7 @@ function requireFetch() {
   */
   const http2_1 = require$$0$r;
   const make_fetch_happen_1 = __importDefault(requireLib$a());
-  const proc_log_1 = requireLib$E();
+  const proc_log_1 = requireLib$F();
   const promise_retry_1 = __importDefault(requirePromiseRetry());
   const util_1 = requireUtil();
   const error_1 = requireError$6();
@@ -129381,7 +131724,7 @@ function requireRole() {
   });
   role.SuccinctRoles = role.DelegatedRole = role.Role = role.TOP_LEVEL_ROLE_NAMES = void 0;
   const crypto_1 = __importDefault(require$$0$n);
-  const minimatch_1 = requireCommonjs$f();
+  const minimatch_1 = requireCommonjs$g();
   const util_1 = __importDefault(require$$0$9);
   const error_1 = requireError$4();
   const utils_1 = requireUtils();
@@ -134175,7 +136518,7 @@ function requireFetcher() {
   } = requireCommonjs$d();
   const {
     log
-  } = requireLib$E();
+  } = requireLib$F();
   const _ = require_protected();
   const cacheDir = requireCacheDir();
   const isPackageBin = requireIsPackageBin();
@@ -134641,14 +136984,14 @@ function requireQuerySelectorAll() {
   const {
     parser,
     arrayDelimiter
-  } = requireLib$v();
+  } = requireLib$w();
   const localeCompare = requireStringLocaleCompare()('en');
   const {
     log
-  } = requireLib$E();
+  } = requireLib$F();
   const {
     minimatch
-  } = requireCommonjs$f();
+  } = requireCommonjs$g();
   const npa = requireNpa();
   const pacote = requireLib$7();
   const semver = requireSemver();
@@ -135590,26 +137933,26 @@ function requireNode$1() {
   // tree.
 
   const semver = requireSemver();
-  const nameFromFolder = requireLib$D();
+  const nameFromFolder = requireLib$E();
   const Edge = requireEdge();
   const Inventory = requireInventory();
   const OverrideSet = requireOverrideSet();
   const {
     normalize
-  } = requireLib$A();
+  } = requireLib$B();
   const {
     getPaths: getBinPaths
-  } = requireLib$w();
+  } = requireLib$x();
   const npa = requireNpa();
   const debug = requireDebug$1();
   const gatherDepSet = requireGatherDepSet();
   const treeCheck = requireTreeCheck();
   const {
     walkUp
-  } = requireCommonjs$g();
+  } = requireCommonjs$h();
   const {
     log
-  } = requireLib$E();
+  } = requireLib$F();
   const {
     resolve,
     relative,
@@ -136029,6 +138372,9 @@ function requireNode$1() {
       }
       return false;
     }
+    shouldOmit(omitSet) {
+      return this.peer && omitSet.has('peer') || this.dev && omitSet.has('dev') || this.optional && omitSet.has('optional') || this.devOptional && omitSet.has('optional') && omitSet.has('dev');
+    }
     getBundler(path = []) {
       // made a cycle, definitely not bundled!
       if (path.includes(this)) {
@@ -140852,7 +143198,7 @@ function requirePattern() {
     value: true
   });
   pattern.Pattern = void 0;
-  const minimatch_1 = requireCommonjs$f();
+  const minimatch_1 = requireCommonjs$g();
   const isPatternList = pl => pl.length >= 1;
   const isGlobList = gl => gl.length >= 1;
   /**
@@ -141049,7 +143395,7 @@ function requireIgnore() {
     value: true
   });
   ignore.Ignore = void 0;
-  const minimatch_1 = requireCommonjs$f();
+  const minimatch_1 = requireCommonjs$g();
   const pattern_js_1 = requirePattern();
   const defaultPlatform = typeof process === 'object' && process && typeof process.platform === 'string' ? process.platform : 'linux';
   /**
@@ -141165,7 +143511,7 @@ function requireProcessor() {
     value: true
   });
   processor.Processor = processor.SubWalks = processor.MatchRecord = processor.HasWalkedCache = void 0;
-  const minimatch_1 = requireCommonjs$f();
+  const minimatch_1 = requireCommonjs$g();
   /**
    * A cache of which patterns have been processed for a given Path
    */
@@ -141782,7 +144128,7 @@ function requireGlob() {
     value: true
   });
   glob.Glob = void 0;
-  const minimatch_1 = requireCommonjs$f();
+  const minimatch_1 = requireCommonjs$g();
   const node_url_1 = require$$0$7;
   const path_scurry_1 = requireCommonjs$3();
   const pattern_js_1 = requirePattern();
@@ -142013,7 +144359,7 @@ function requireHasMagic() {
     value: true
   });
   hasMagic.hasMagic = void 0;
-  const minimatch_1 = requireCommonjs$f();
+  const minimatch_1 = requireCommonjs$g();
   /**
    * Return true if the patterns provided contain any magic glob characters,
    * given the options provided.
@@ -142053,10 +144399,10 @@ function requireCommonjs$2() {
     exports.globSync = globSync;
     exports.globIterateSync = globIterateSync;
     exports.globIterate = globIterate;
-    const minimatch_1 = requireCommonjs$f();
+    const minimatch_1 = requireCommonjs$g();
     const glob_js_1 = requireGlob();
     const has_magic_js_1 = requireHasMagic();
-    var minimatch_2 = requireCommonjs$f();
+    var minimatch_2 = requireCommonjs$g();
     Object.defineProperty(exports, "escape", {
       enumerable: true,
       get: function () {
@@ -142149,10 +144495,10 @@ function requireLib$5() {
   if (hasRequiredLib$5) return lib$5;
   hasRequiredLib$5 = 1;
   const path = require$$0$d;
-  const getName = requireLib$D();
+  const getName = requireLib$E();
   const {
     minimatch
-  } = requireCommonjs$f();
+  } = requireCommonjs$g();
   const pkgJson = requireLib$q();
   const {
     glob
@@ -142376,7 +144722,7 @@ function requireAddRmPkgDeps() {
 
   const {
     log
-  } = requireLib$E();
+  } = requireLib$F();
   const localeCompare = requireStringLocaleCompare()('en');
   const add = ({
     pkg,
@@ -143156,12 +145502,12 @@ function requireLib$4() {
   const cacache = requireLib$k();
   const {
     time
-  } = requireLib$E();
+  } = requireLib$F();
   const Advisory = requireAdvisory();
   const {
     homedir
   } = require$$0$f;
-  const jsonParse = requireLib$C();
+  const jsonParse = requireLib$D();
   const _packument = Symbol('packument');
   const _cachePut = Symbol('cachePut');
   const _cacheGet = Symbol('cacheGet');
@@ -143290,24 +145636,21 @@ function requireAuditReport() {
   if (hasRequiredAuditReport) return auditReport;
   hasRequiredAuditReport = 1;
   // an object representing the set of vulnerabilities in a tree
-  /* eslint camelcase: "off" */
 
   const localeCompare = requireStringLocaleCompare()('en');
   const npa = requireNpa();
   const pickManifest = requireLib$s();
   const Vuln = requireVuln();
   const Calculator = requireLib$4();
-  const _getReport = Symbol('getReport');
-  const _fixAvailable = Symbol('fixAvailable');
-  const _checkTopNode = Symbol('checkTopNode');
-  const _init = Symbol('init');
-  const _omit = Symbol('omit');
   const {
     log,
     time
-  } = requireLib$E();
+  } = requireLib$F();
   const npmFetch = requireLib$9();
   class AuditReport extends Map {
+    #omit;
+    error = null;
+    topVulns = new Map();
     static load(tree, opts) {
       return new AuditReport(tree, opts).run();
     }
@@ -143370,22 +145713,17 @@ function requireAuditReport() {
     }
     constructor(tree, opts = {}) {
       super();
-      const {
-        omit
-      } = opts;
-      this[_omit] = new Set(omit || []);
-      this.topVulns = new Map();
+      this.#omit = new Set(opts.omit || []);
       this.calculator = new Calculator(opts);
-      this.error = null;
       this.options = opts;
       this.tree = tree;
       this.filterSet = opts.filterSet;
     }
     async run() {
-      this.report = await this[_getReport]();
+      this.report = await this.#getReport();
       log.silly('audit report', this.report);
       if (this.report) {
-        await this[_init]();
+        await this.#init();
       }
       return this;
     }
@@ -143393,7 +145731,7 @@ function requireAuditReport() {
       const vuln = this.get(node.packageName);
       return !!(vuln && vuln.isVulnerable(node));
     }
-    async [_init]() {
+    async #init() {
       const timeEnd = time.start('auditReport:init');
       const promises = [];
       for (const [name, advisories] of Object.entries(this.report)) {
@@ -143429,7 +145767,7 @@ function requireAuditReport() {
         if (!seen.has(k)) {
           const p = [];
           for (const node of this.tree.inventory.query('packageName', name)) {
-            if (!shouldAudit(node, this[_omit], this.filterSet)) {
+            if (!this.shouldAudit(node)) {
               continue;
             }
 
@@ -143455,7 +145793,15 @@ function requireAuditReport() {
               spec
             } of node.edgesIn) {
               if (dep.isTop && !vuln.topNodes.has(dep)) {
-                this[_checkTopNode](dep, vuln, spec);
+                vuln.fixAvailable = this.#fixAvailable(vuln, spec);
+                if (vuln.fixAvailable !== true) {
+                  // now we know the top node is vulnerable, and cannot be
+                  // upgraded out of the bad place without --force.  But, there's
+                  // no need to add it to the actual vulns list, because nothing
+                  // depends on root.
+                  this.topVulns.set(vuln.name, vuln);
+                  vuln.topNodes.add(dep);
+                }
               } else {
                 // calculate a metavuln, if necessary
                 const calc = this.calculator.calculate(dep.packageName, advisory);
@@ -143495,31 +145841,15 @@ function requireAuditReport() {
       }
       timeEnd();
     }
-    [_checkTopNode](topNode, vuln, spec) {
-      vuln.fixAvailable = this[_fixAvailable](topNode, vuln, spec);
-      if (vuln.fixAvailable !== true) {
-        // now we know the top node is vulnerable, and cannot be
-        // upgraded out of the bad place without --force.  But, there's
-        // no need to add it to the actual vulns list, because nothing
-        // depends on root.
-        this.topVulns.set(vuln.name, vuln);
-        vuln.topNodes.add(topNode);
-      }
-    }
 
-    // check whether the top node is vulnerable.
-    // check whether we can get out of the bad place with --force, and if
-    // so, whether that update is SemVer Major
-    [_fixAvailable](topNode, vuln, spec) {
-      // this will always be set to at least {name, versions:{}}
-      const paku = vuln.packument;
+    // given the spec, see if there is a fix available at all, and note whether or not it's a semver major fix or not (i.e. will need --force)
+    #fixAvailable(vuln, spec) {
+      // TODO we return true, false, OR an object here. this is probably a bad pattern.
       if (!vuln.testSpec(spec)) {
         return true;
       }
 
-      // similarly, even if we HAVE a packument, but we're looking for it
-      // somewhere other than the registry, and we got something vulnerable,
-      // then we're stuck with it.
+      // even if we HAVE a packument, if we're looking for it somewhere other than the registry and we have something vulnerable then we're stuck with it.
       const specObj = npa(spec);
       if (!specObj.registry) {
         return false;
@@ -143528,15 +145858,13 @@ function requireAuditReport() {
         spec = specObj.subSpec.rawSpec;
       }
 
-      // We don't provide fixes for top nodes other than root, but we
-      // still check to see if the node is fixable with a different version,
-      // and if that is a semver major bump.
+      // we don't provide fixes for top nodes other than root, but we still check to see if the node is fixable with a different version, and note if that is a semver major bump.
       try {
         const {
           _isSemVerMajor: isSemVerMajor,
           version,
           name
-        } = pickManifest(paku, spec, {
+        } = pickManifest(vuln.packument, spec, {
           ...this.options,
           before: null,
           avoid: vuln.range,
@@ -143554,14 +145882,14 @@ function requireAuditReport() {
     set() {
       throw new Error('do not call AuditReport.set() directly');
     }
-    async [_getReport]() {
+    async #getReport() {
       // if we're not auditing, just return false
       if (this.options.audit === false || this.options.offline === true || this.tree.inventory.size === 1) {
         return null;
       }
       const timeEnd = time.start('auditReport:getReport');
       try {
-        const body = prepareBulkData(this.tree, this[_omit], this.filterSet);
+        const body = this.prepareBulkData();
         log.silly('audit', 'bulk request', body);
 
         // no sense asking if we don't have anything to audit,
@@ -143586,28 +145914,34 @@ function requireAuditReport() {
         timeEnd();
       }
     }
-  }
 
-  // return true if we should audit this one
-  const shouldAudit = (node, omit, filterSet) => !node.version ? false : node.isRoot ? false : filterSet && filterSet.size !== 0 && !filterSet.has(node) ? false : omit.size === 0 ? true : !(
-  // otherwise, just ensure we're not omitting this one
-  node.dev && omit.has('dev') || node.optional && omit.has('optional') || node.devOptional && omit.has('dev') && omit.has('optional') || node.peer && omit.has('peer'));
-  const prepareBulkData = (tree, omit, filterSet) => {
-    const payload = {};
-    for (const name of tree.inventory.query('packageName')) {
-      const set = new Set();
-      for (const node of tree.inventory.query('packageName', name)) {
-        if (!shouldAudit(node, omit, filterSet)) {
-          continue;
-        }
-        set.add(node.version);
+    // return true if we should audit this one
+    shouldAudit(node) {
+      if (!node.version || node.isRoot || this.filterSet && this.filterSet?.size !== 0 && !this.filterSet?.has(node)) {
+        return false;
       }
-      if (set.size) {
-        payload[name] = [...set];
+      if (this.#omit.size === 0) {
+        return true;
       }
+      return !node.shouldOmit(this.#omit);
     }
-    return payload;
-  };
+    prepareBulkData() {
+      const payload = {};
+      for (const name of this.tree.inventory.query('packageName')) {
+        const set = new Set();
+        for (const node of this.tree.inventory.query('packageName', name)) {
+          if (!this.shouldAudit(node)) {
+            continue;
+          }
+          set.add(node.version);
+        }
+        if (set.size) {
+          payload[name] = [...set];
+        }
+      }
+      return payload;
+    }
+  }
   auditReport = AuditReport;
   return auditReport;
 }
@@ -145139,7 +147473,7 @@ function requirePackumentCache() {
   } = require$$1$d;
   const {
     log
-  } = requireLib$E();
+  } = requireLib$F();
 
   // This is an in-memory cache that Pacote uses for packuments.
   // Packuments are usually cached on disk.  This allows for rapid re-requests
@@ -146382,7 +148716,7 @@ function requirePlaceDep() {
   const localeCompare = requireStringLocaleCompare()('en');
   const {
     log
-  } = requireLib$E();
+  } = requireLib$F();
   const {
     redact
   } = requireLib$c();
@@ -147879,7 +150213,7 @@ var hasRequiredLib$2;
 function requireLib$2() {
   if (hasRequiredLib$2) return lib$2;
   hasRequiredLib$2 = 1;
-  const parseJSON = requireLib$C();
+  const parseJSON = requireLib$D();
   const {
     diff
   } = requireJustDiff();
@@ -148061,7 +150395,7 @@ function requireShrinkwrap() {
 
   const {
     log
-  } = requireLib$E();
+  } = requireLib$F();
   const YarnLock = requireYarnLock();
   const {
     readFile,
@@ -148081,7 +150415,7 @@ function requireShrinkwrap() {
   const npa = requireNpa();
   const pkgJson = requireLib$q();
   const parseJSON = requireLib$2();
-  const nameFromFolder = requireLib$D();
+  const nameFromFolder = requireLib$E();
   const stringify = requireJsonStringifyNice();
   const swKeyOrder = ['name', 'version', 'lockfileVersion', 'resolved', 'integrity', 'requires', 'packages', 'dependencies'];
 
@@ -149171,7 +151505,7 @@ function requireBuildIdealTree() {
   hasRequiredBuildIdealTree = 1;
   // mixin implementing the buildIdealTree method
   const localeCompare = requireStringLocaleCompare()('en');
-  const rpj = requireLib$A();
+  const rpj = requireLib$B();
   const npa = requireNpa();
   const pacote = requireLib$7();
   const cacache = requireLib$k();
@@ -149181,7 +151515,8 @@ function requireBuildIdealTree() {
   const realpath = requireRealpath();
   const {
     resolve,
-    dirname
+    dirname,
+    sep
   } = path$2;
   const treeCheck = requireTreeCheck();
   const {
@@ -149197,7 +151532,7 @@ function requireBuildIdealTree() {
   const {
     log,
     time
-  } = requireLib$E();
+  } = requireLib$F();
   const {
     redact
   } = requireLib$c();
@@ -149372,10 +151707,12 @@ function requireBuildIdealTree() {
       const {
         engineStrict,
         npmVersion,
-        nodeVersion
+        nodeVersion,
+        omit = []
       } = this.options;
+      const omitSet = new Set(omit);
       for (const node of this.idealTree.inventory.values()) {
-        if (!node.optional) {
+        if (!node.optional && !node.shouldOmit(omitSet)) {
           try {
             // if devEngines is present in the root node we ignore the engines check
             if (!(node.isRoot && node.package.devEngines)) {
@@ -150394,9 +152731,21 @@ This is a one-time fix-up, please be patient...
       } = this;
       const isWorkspace = this.idealTree.workspaces && this.idealTree.workspaces.has(spec.name);
 
-      // spec is a directory, link it unless installLinks is set or it's a workspace
+      // spec is a directory, link it if:
+      // - it's a workspace, OR
+      // - it's a project-internal file: dependency (always linked), OR
+      // - it's external and installLinks is false
       // TODO post arborist refactor, will need to check for installStrategy=linked
-      if (spec.type === 'directory' && (isWorkspace || !installLinks)) {
+      let isProjectInternalFileSpec = false;
+      if (edge?.rawSpec.startsWith('file:../') || edge?.rawSpec.startsWith('file:./')) {
+        const targetPath = resolve(parent.realpath, edge.rawSpec.slice(5));
+        const resolvedProjectRoot = resolve(this.idealTree.realpath);
+        // Check if the target is within the project root
+        isProjectInternalFileSpec = targetPath.startsWith(resolvedProjectRoot + sep) || targetPath === resolvedProjectRoot;
+      }
+      // Decide whether to link or copy the dependency
+      const shouldLink = isWorkspace || isProjectInternalFileSpec || !installLinks;
+      if (spec.type === 'directory' && shouldLink) {
         return this.#linkFromSpec(name, spec, parent, edge);
       }
 
@@ -150648,11 +152997,6 @@ This is a one-time fix-up, please be patient...
       const needPrune = metaFromDisk && (mutateTree || flagsSuspect);
       if (this.#prune && needPrune) {
         this.#idealTreePrune();
-        for (const node of this.idealTree.inventory.values()) {
-          if (node.extraneous) {
-            node.parent = null;
-          }
-        }
       }
       timeEnd();
     }
@@ -150680,7 +153024,12 @@ This is a one-time fix-up, please be patient...
     }
     #idealTreePrune() {
       for (const node of this.idealTree.inventory.values()) {
-        if (node.extraneous) {
+        // optional peer dependencies are meant to be added to the tree
+        // through an explicit required dependency (most commonly in the
+        // root package.json), at which point they won't be optional so
+        // any dependencies still marked as both optional and peer at
+        // this point can be pruned as a special kind of extraneous
+        if (node.extraneous || node.peer && node.optional) {
           node.parent = null;
         }
       }
@@ -150754,13 +153103,13 @@ function requireLoadActual() {
     join,
     normalize
   } = path$2;
-  const rpj = requireLib$A();
+  const rpj = requireLib$B();
   const {
     readdirScoped
   } = requireLib$m();
   const {
     walkUp
-  } = requireCommonjs$g();
+  } = requireCommonjs$h();
   const ancestorPath = requireCommonAncestorPath();
   const treeCheck = requireTreeCheck();
   const Shrinkwrap = requireShrinkwrap();
@@ -151201,14 +153550,14 @@ function requireLoadVirtual() {
   const {
     resolve
   } = path$2;
-  const nameFromFolder = requireLib$D();
+  const nameFromFolder = requireLib$E();
   const consistentResolve = requireConsistentResolve();
   const Shrinkwrap = requireShrinkwrap();
   const Node = requireNode$1();
   const Link = requireLink();
   const relpath = requireRelpath();
   const calcDepFlags = requireCalcDepFlags();
-  const rpj = requireLib$A();
+  const rpj = requireLib$B();
   const treeCheck = requireTreeCheck();
   const flagsSuspect = Symbol.for('flagsSuspect');
   const setWorkspaces = Symbol.for('setWorkspaces');
@@ -151557,8 +153906,8 @@ function requireRebuild() {
     depth: dfwalk
   } = requireLib$6();
   const promiseAllRejectLate = requirePromiseAllRejectLate();
-  const rpj = requireLib$A();
-  const binLinks = requireLib$w();
+  const rpj = requireLib$B();
+  const binLinks = requireLib$x();
   const runScript = requireRunScript();
   const {
     callLimit: promiseCallLimit
@@ -151573,7 +153922,7 @@ function requireRebuild() {
   const {
     log,
     time
-  } = requireLib$E();
+  } = requireLib$F();
   const boolEnv = b => b ? '1' : '';
   const sortNodes = (a, b) => a.depth - b.depth || localeCompare(a.path, b.path);
   const _checkBins = Symbol.for('checkBins');
@@ -152471,13 +154820,13 @@ function requireReify() {
   const debug = requireDebug$1();
   const {
     walkUp
-  } = requireCommonjs$g();
+  } = requireCommonjs$h();
   const {
     log,
     time
-  } = requireLib$E();
-  const rpj = requireLib$A();
-  const hgi = requireLib$G();
+  } = requireLib$F();
+  const rpj = requireLib$B();
+  const hgi = requireLib$v();
   const {
     dirname,
     resolve,
@@ -152566,9 +154915,7 @@ function requireReify() {
     #bundleUnpacked = new Set(); // the nodes we unpack to read their bundles
     #dryRun;
     #nmValidated = new Set();
-    #omitDev;
-    #omitPeer;
-    #omitOptional;
+    #omit;
     #retiredPaths = {};
     #retiredUnchanged = {};
     #savePrefix;
@@ -152588,10 +154935,7 @@ function requireReify() {
         er.code = 'ESHRINKWRAPGLOBAL';
         throw er;
       }
-      const omit = new Set(options.omit || []);
-      this.#omitDev = omit.has('dev');
-      this.#omitOptional = omit.has('optional');
-      this.#omitPeer = omit.has('peer');
+      this.#omit = new Set(options.omit);
 
       // start tracker block
       this.addTracker('reify');
@@ -153021,7 +155365,7 @@ function requireReify() {
     // adding to the trash list will skip reifying, and delete them
     // if they are currently in the tree and otherwise untouched.
     [_addOmitsToTrashList]() {
-      if (!this.#omitDev && !this.#omitOptional && !this.#omitPeer) {
+      if (!this.#omit.size) {
         return;
       }
       const timeEnd = time.start('reify:trashOmits');
@@ -153042,7 +155386,7 @@ function requireReify() {
         }
 
         // omit node if the dep type matches any omit flags that were set
-        if (node.peer && this.#omitPeer || node.dev && this.#omitDev || node.optional && this.#omitOptional || node.devOptional && this.#omitOptional && this.#omitDev) {
+        if (node.shouldOmit(this.#omit)) {
           this[_addNodeToTrashList](node);
         }
       }
@@ -154559,7 +156903,7 @@ function requireArborist() {
   const {
     log,
     time
-  } = requireLib$E();
+  } = requireLib$F();
   const {
     saveTypeMap
   } = requireAddRmPkgDeps();
@@ -159067,13 +161411,13 @@ function requireLib() {
   // TODO: set the scope config from package.json or explicit cli config
   const {
     walkUp
-  } = requireCommonjs$g();
+  } = requireCommonjs$h();
   const ini = requireIni();
   const nopt = requireNopt();
   const {
     log,
     time
-  } = requireLib$E();
+  } = requireLib$F();
   const {
     resolve,
     dirname,
@@ -160898,12 +163242,13 @@ function requireDefinitions$1() {
     }),
     before: new Definition('before', {
       default: null,
+      hint: '<date>',
       type: [null, Date],
       description: `
       If passed to \`npm install\`, will rebuild the npm tree such that only
-      versions that were available **on or before** the \`--before\` time get
-      installed.  If there's no versions available for the current set of
-      direct dependencies, the command will error.
+      versions that were available **on or before** the given date are
+      installed.  If there are no versions available for the current set of
+      dependencies, the command will error.
 
       If the requested version is a \`dist-tag\` and the given tag does not
       pass the \`--before\` filter, the most recent version less than or equal
@@ -160928,7 +163273,7 @@ function requireDefinitions$1() {
     browser: new Definition('browser', {
       default: null,
       defaultDescription: `
-    OS X: \`"open"\`, Windows: \`"start"\`, Others: \`"xdg-open"\`
+    macOS: \`"open"\`, Windows: \`"start"\`, Others: \`"xdg-open"\`
     `,
       type: [null, Boolean, String],
       description: `
@@ -162220,9 +164565,9 @@ function requireDefinitions$1() {
       }
     }),
     progress: new Definition('progress', {
-      default: !ciInfo.isCI,
+      default: !(ciInfo.isCI || !process.stderr.isTTY || !process.stdout.isTTY || process.env.TERM === 'dumb'),
       defaultDescription: `
-      \`true\` unless running in a known CI system
+      \`true\` when not in CI and both stderr and stdout are TTYs and not in a dumb terminal
     `,
       type: Boolean,
       description: `
@@ -162232,11 +164577,8 @@ function requireDefinitions$1() {
       Set to \`false\` to suppress the progress bar.
     `,
       flatten(key, obj, flatOptions) {
-        flatOptions.progress = !obj.progress ? false
-        // progress is only written to stderr but we disable it unless stdout is a tty
-        // also. This prevents the progress from appearing when piping output to another
-        // command which doesn't break anything, but does look very odd to users.
-        : !!process.stderr.isTTY && !!process.stdout.isTTY && process.env.TERM !== 'dumb';
+        // Only show progress if explicitly enabled AND we have proper TTY environment
+        flatOptions.progress = !!obj.progress && !!process.stderr.isTTY && !!process.stdout.isTTY && process.env.TERM !== 'dumb';
       }
     }),
     provenance: new Definition('provenance', {
@@ -171039,7 +173381,7 @@ yargsParser.camelCase = camelCase;
 yargsParser.decamelize = decamelize;
 yargsParser.looksLikeNumber = looksLikeNumber;
 
-var libExports = requireLib$z();
+var libExports = requireLib$A();
 
 var chalk = {exports: {}};
 
@@ -173036,5 +175378,5 @@ exports.terminalLinkExports = terminalLinkExports;
 exports.updater = updater$1;
 exports.yargsParser = yargsParser;
 exports.yoctocolorsCjsExports = yoctocolorsCjsExports;
-//# debugId=be448099-a95b-4fde-9626-d5a33455fa60
+//# debugId=22a026e5-cfb1-461f-b739-122e1b9ab409
 //# sourceMappingURL=vendor.js.map