@socketsecurity/cli-with-sentry 1.0.8 → 1.0.9

package/dist/vendor.js

@@ -6,17 +6,22 @@ var path$2 = require('node:path');
 var fs$1 = require('node:fs');
 var require$$0$6 = require('node:url');
 var os$3 = require('node:os');
+var require$$0$c = require('node:path');
+var require$$0$9 = require('node:fs');
+var require$$0$7 = require('node:constants');
+var require$$1$7 = require('node:stream');
+var require$$0$8 = require('node:util');
+var require$$0$a = require('node:assert');
+var require$$0$b = require('node:events');
+var require$$0$d = require('node:url');
+var require$$1$8 = require('node:http');
+var require$$0$e = require('node:os');
 var fs$2 = require('node:fs/promises');
-var require$$0$7 = require('node:process');
-var require$$0$8 = require('node:buffer');
-var require$$0$9 = require('node:util');
-var require$$0$a = require('node:path');
-var require$$0$b = require('node:fs');
-var require$$0$c = require('node:tty');
+var require$$0$f = require('node:process');
+var require$$0$g = require('node:buffer');
+var require$$0$h = require('node:tty');
 var require$$2$3 = require('node:https');
-var require$$1$7 = require('node:http');
-var require$$0$d = require('node:url');
-var require$$0$e = require('node:events');
+var require$$0$i = require('node:events');
 var require$$2$4 = require('node:http');
 var require$$3$3 = require('node:https');
 var require$$5$2 = require('node:readline');
@@ -24,28 +29,24 @@ var require$$6$3 = require('../external/@socketsecurity/registry/lib/constants/a
 var require$$7$5 = require('../external/@socketsecurity/registry/lib/promises');
 var node_buffer = require('node:buffer');
 var childProcess = require('node:child_process');
-var require$$0$f = require('node:fs/promises');
-var require$$0$g = require('node:os');
-var require$$1$8 = require('node:tty');
-var require$$1$9 = require('node:stream');
+var require$$0$j = require('node:fs/promises');
+var require$$1$9 = require('node:tty');
 var require$$1$a = require('node:stream');
 var require$$2$5 = require('node:string_decoder');
-var require$$0$h = require('node:child_process');
+var require$$0$k = require('node:child_process');
 var require$$1$b = require('node:path/win32');
-var require$$0$i = require('node:module');
+var require$$0$l = require('node:module');
 var require$$2$6 = require('node:querystring');
-var require$$0$j = require('node:events');
 var require$$2$7 = require('node:string_decoder');
-var require$$0$k = require('node:crypto');
-var require$$0$m = require('node:assert');
-var require$$0$l = require('node:zlib');
-var require$$0$n = require('node:dns');
-var require$$0$o = require('node:net');
+var require$$0$m = require('node:crypto');
+var require$$0$n = require('node:zlib');
+var require$$0$o = require('node:dns');
+var require$$0$p = require('node:net');
 var require$$1$c = require('node:tls');
 var require$$3$4 = require('node:timers/promises');
 var require$$6$4 = require('node:querystring');
-var require$$0$q = require('node:crypto');
-var require$$0$p = require('node:http2');
+var require$$0$r = require('node:crypto');
+var require$$0$q = require('node:http2');
 var require$$1$d = require('node:v8');
 var Module = require('node:module');
 
@@ -3413,7 +3414,7 @@ commonjs$i.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, '-');
-const defaults$1 = {
+const defaults$2 = {
   sshtemplate: ({
     domain,
     user,
@@ -3777,7 +3778,7 @@ hosts$1.sourcehut = {
   }
 };
 for (const [name, host] of Object.entries(hosts$1)) {
-  hosts$1[name] = Object.assign({}, defaults$1, host);
+  hosts$1[name] = Object.assign({}, defaults$2, host);
 }
 var hosts_1$1 = hosts$1;
 const url$2 = require$$0$6;
@@ -4986,7 +4987,7 @@ const require$$1$5 = {
   invalidLicense: invalidLicense,
   typo: typo
 };
-var util$4 = require$$1$6;
+var util$5 = require$$1$6;
 var messages = require$$1$5;
 var make_warning = function () {
   var args = Array.prototype.slice.call(arguments, 0);
@@ -4996,7 +4997,7 @@ var make_warning = function () {
   } else {
     var msgTemplate = messages[warningName] ? messages[warningName] : warningName + ": '%s'";
     args.unshift(msgTemplate);
-    return util$4.format.apply(null, args);
+    return util$5.format.apply(null, args);
   }
 };
 function makeTypoWarning(providedName, probableName, field) {
@@ -5004,11 +5005,11 @@ function makeTypoWarning(providedName, probableName, field) {
     providedName = field + "['" + providedName + "']";
     probableName = field + "['" + probableName + "']";
   }
-  return util$4.format(messages.typo, providedName, probableName);
+  return util$5.format(messages.typo, providedName, probableName);
 }
-var normalize_1$1 = normalize$2;
+var normalize_1$1 = normalize$3;
 var fixer = fixer$1;
-normalize$2.fixer = fixer;
+normalize$3.fixer = fixer;
 var makeWarning = make_warning;
 var fieldsToFix = ['name', 'version', 'description', 'repository', 'modules', 'scripts', 'files', 'bin', 'man', 'bugs', 'keywords', 'readme', 'homepage', 'license'];
 var otherThingsToFix = ['dependencies', 'people', 'typos'];
@@ -5016,7 +5017,7 @@ var thingsToFix = fieldsToFix.map(function (fieldName) {
   return ucFirst(fieldName) + 'Field';
 });
 thingsToFix = thingsToFix.concat(otherThingsToFix);
-function normalize$2(data, warn, strict) {
+function normalize$3(data, warn, strict) {
   if (warn === true) {
     warn = null;
     strict = true;
@@ -5043,7 +5044,7 @@ function ucFirst(string) {
 }
 const normalizePackageData = getDefaultExportFromCjs(normalize_1$1);
 const toPath$1 = urlOrPath => urlOrPath instanceof URL ? require$$0$6.fileURLToPath(urlOrPath) : urlOrPath;
-function findUpSync(name, {
+function findUpSync$1(name, {
   cwd = process$2.cwd(),
   type = 'file',
   stopAt
@@ -7665,10 +7666,10 @@ function parseJson(string, reviver, fileName) {
   }
   throw jsonError;
 }
-function toPath(urlOrPath) {
+function toPath$2(urlOrPath) {
   return urlOrPath instanceof URL ? require$$0$6.fileURLToPath(urlOrPath) : urlOrPath;
 }
-const getPackagePath = cwd => path$2.resolve(toPath(cwd) ?? '.', 'package.json');
+const getPackagePath = cwd => path$2.resolve(toPath$2(cwd) ?? '.', 'package.json');
 const _readPackage = (file, normalize) => {
   const json = typeof file === 'string' ? parseJson(file) : file;
   if (normalize) {
@@ -7684,7 +7685,7 @@ function readPackageSync({
   return _readPackage(packageFile, normalize);
 }
 function readPackageUpSync(options) {
-  const filePath = findUpSync('package.json', options);
+  const filePath = findUpSync$1('package.json', options);
   if (!filePath) {
     return;
   }
@@ -8556,6 +8557,2667 @@ var helpers$5 = /*#__PURE__*/Object.freeze({
   stackWithCauses: stackWithCauses
 });
 
+function getAugmentedNamespace(n) {
+  if (Object.prototype.hasOwnProperty.call(n, '__esModule')) return n;
+  var f = n.default;
+  var a;
+	if (typeof f == "function") {
+		a = function a () {
+			var isInstance = false;
+      try {
+        isInstance = this instanceof a;
+      } catch {}
+			if (isInstance) {
+        return Reflect.construct(f, arguments, this.constructor);
+			}
+			return f.apply(this, arguments);
+		};
+		a.prototype = f.prototype;
+  } else a = {};
+  Object.defineProperty(a, '__esModule', {value: true});
+	Object.keys(n).forEach(function (k) {
+		var d = Object.getOwnPropertyDescriptor(n, k);
+		Object.defineProperty(a, k, d.get ? d : {
+			enumerable: true,
+			get: function () {
+				return n[k];
+			}
+		});
+	});
+	return a;
+}
+
+var npmConf = {exports: {}};
+
+var dist$j = {};
+
+var caFile = {};
+
+var polyfills;
+var hasRequiredPolyfills;
+function requirePolyfills() {
+  if (hasRequiredPolyfills) return polyfills;
+  hasRequiredPolyfills = 1;
+  var constants = require$$0$7;
+  var origCwd = process.cwd;
+  var cwd = null;
+  var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform;
+  process.cwd = function () {
+    if (!cwd) cwd = origCwd.call(process);
+    return cwd;
+  };
+  try {
+    process.cwd();
+  } catch (er) {}
+
+  // This check is needed until node.js 12 is required
+  if (typeof process.chdir === 'function') {
+    var chdir = process.chdir;
+    process.chdir = function (d) {
+      cwd = null;
+      chdir.call(process, d);
+    };
+    if (Object.setPrototypeOf) Object.setPrototypeOf(process.chdir, chdir);
+  }
+  polyfills = patch;
+  function patch(fs) {
+    // (re-)implement some things that are known busted or missing.
+
+    // lchmod, broken prior to 0.6.2
+    // back-port the fix here.
+    if (constants.hasOwnProperty('O_SYMLINK') && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
+      patchLchmod(fs);
+    }
+
+    // lutimes implementation, or no-op
+    if (!fs.lutimes) {
+      patchLutimes(fs);
+    }
+
+    // https://github.com/isaacs/node-graceful-fs/issues/4
+    // Chown should not fail on einval or eperm if non-root.
+    // It should not fail on enosys ever, as this just indicates
+    // that a fs doesn't support the intended operation.
+
+    fs.chown = chownFix(fs.chown);
+    fs.fchown = chownFix(fs.fchown);
+    fs.lchown = chownFix(fs.lchown);
+    fs.chmod = chmodFix(fs.chmod);
+    fs.fchmod = chmodFix(fs.fchmod);
+    fs.lchmod = chmodFix(fs.lchmod);
+    fs.chownSync = chownFixSync(fs.chownSync);
+    fs.fchownSync = chownFixSync(fs.fchownSync);
+    fs.lchownSync = chownFixSync(fs.lchownSync);
+    fs.chmodSync = chmodFixSync(fs.chmodSync);
+    fs.fchmodSync = chmodFixSync(fs.fchmodSync);
+    fs.lchmodSync = chmodFixSync(fs.lchmodSync);
+    fs.stat = statFix(fs.stat);
+    fs.fstat = statFix(fs.fstat);
+    fs.lstat = statFix(fs.lstat);
+    fs.statSync = statFixSync(fs.statSync);
+    fs.fstatSync = statFixSync(fs.fstatSync);
+    fs.lstatSync = statFixSync(fs.lstatSync);
+
+    // if lchmod/lchown do not exist, then make them no-ops
+    if (fs.chmod && !fs.lchmod) {
+      fs.lchmod = function (path, mode, cb) {
+        if (cb) process.nextTick(cb);
+      };
+      fs.lchmodSync = function () {};
+    }
+    if (fs.chown && !fs.lchown) {
+      fs.lchown = function (path, uid, gid, cb) {
+        if (cb) process.nextTick(cb);
+      };
+      fs.lchownSync = function () {};
+    }
+
+    // on Windows, A/V software can lock the directory, causing this
+    // to fail with an EACCES or EPERM if the directory contains newly
+    // created files.  Try again on failure, for up to 60 seconds.
+
+    // Set the timeout this long because some Windows Anti-Virus, such as Parity
+    // bit9, may lock files for up to a minute, causing npm package install
+    // failures. Also, take care to yield the scheduler. Windows scheduling gives
+    // CPU to a busy looping process, which can cause the program causing the lock
+    // contention to be starved of CPU by node, so the contention doesn't resolve.
+    if (platform === "win32") {
+      fs.rename = typeof fs.rename !== 'function' ? fs.rename : function (fs$rename) {
+        function rename(from, to, cb) {
+          var start = Date.now();
+          var backoff = 0;
+          fs$rename(from, to, function CB(er) {
+            if (er && (er.code === "EACCES" || er.code === "EPERM") && Date.now() - start < 60000) {
+              setTimeout(function () {
+                fs.stat(to, function (stater, st) {
+                  if (stater && stater.code === "ENOENT") fs$rename(from, to, CB);else cb(er);
+                });
+              }, backoff);
+              if (backoff < 100) backoff += 10;
+              return;
+            }
+            if (cb) cb(er);
+          });
+        }
+        if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
+        return rename;
+      }(fs.rename);
+    }
+
+    // if read() returns EAGAIN, then just try it again.
+    fs.read = typeof fs.read !== 'function' ? fs.read : function (fs$read) {
+      function read(fd, buffer, offset, length, position, callback_) {
+        var callback;
+        if (callback_ && typeof callback_ === 'function') {
+          var eagCounter = 0;
+          callback = function (er, _, __) {
+            if (er && er.code === 'EAGAIN' && eagCounter < 10) {
+              eagCounter++;
+              return fs$read.call(fs, fd, buffer, offset, length, position, callback);
+            }
+            callback_.apply(this, arguments);
+          };
+        }
+        return fs$read.call(fs, fd, buffer, offset, length, position, callback);
+      }
+
+      // This ensures `util.promisify` works as it does for native `fs.read`.
+      if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
+      return read;
+    }(fs.read);
+    fs.readSync = typeof fs.readSync !== 'function' ? fs.readSync : function (fs$readSync) {
+      return function (fd, buffer, offset, length, position) {
+        var eagCounter = 0;
+        while (true) {
+          try {
+            return fs$readSync.call(fs, fd, buffer, offset, length, position);
+          } catch (er) {
+            if (er.code === 'EAGAIN' && eagCounter < 10) {
+              eagCounter++;
+              continue;
+            }
+            throw er;
+          }
+        }
+      };
+    }(fs.readSync);
+    function patchLchmod(fs) {
+      fs.lchmod = function (path, mode, callback) {
+        fs.open(path, constants.O_WRONLY | constants.O_SYMLINK, mode, function (err, fd) {
+          if (err) {
+            if (callback) callback(err);
+            return;
+          }
+          // prefer to return the chmod error, if one occurs,
+          // but still try to close, and report closing errors if they occur.
+          fs.fchmod(fd, mode, function (err) {
+            fs.close(fd, function (err2) {
+              if (callback) callback(err || err2);
+            });
+          });
+        });
+      };
+      fs.lchmodSync = function (path, mode) {
+        var fd = fs.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode);
+
+        // prefer to return the chmod error, if one occurs,
+        // but still try to close, and report closing errors if they occur.
+        var threw = true;
+        var ret;
+        try {
+          ret = fs.fchmodSync(fd, mode);
+          threw = false;
+        } finally {
+          if (threw) {
+            try {
+              fs.closeSync(fd);
+            } catch (er) {}
+          } else {
+            fs.closeSync(fd);
+          }
+        }
+        return ret;
+      };
+    }
+    function patchLutimes(fs) {
+      if (constants.hasOwnProperty("O_SYMLINK") && fs.futimes) {
+        fs.lutimes = function (path, at, mt, cb) {
+          fs.open(path, constants.O_SYMLINK, function (er, fd) {
+            if (er) {
+              if (cb) cb(er);
+              return;
+            }
+            fs.futimes(fd, at, mt, function (er) {
+              fs.close(fd, function (er2) {
+                if (cb) cb(er || er2);
+              });
+            });
+          });
+        };
+        fs.lutimesSync = function (path, at, mt) {
+          var fd = fs.openSync(path, constants.O_SYMLINK);
+          var ret;
+          var threw = true;
+          try {
+            ret = fs.futimesSync(fd, at, mt);
+            threw = false;
+          } finally {
+            if (threw) {
+              try {
+                fs.closeSync(fd);
+              } catch (er) {}
+            } else {
+              fs.closeSync(fd);
+            }
+          }
+          return ret;
+        };
+      } else if (fs.futimes) {
+        fs.lutimes = function (_a, _b, _c, cb) {
+          if (cb) process.nextTick(cb);
+        };
+        fs.lutimesSync = function () {};
+      }
+    }
+    function chmodFix(orig) {
+      if (!orig) return orig;
+      return function (target, mode, cb) {
+        return orig.call(fs, target, mode, function (er) {
+          if (chownErOk(er)) er = null;
+          if (cb) cb.apply(this, arguments);
+        });
+      };
+    }
+    function chmodFixSync(orig) {
+      if (!orig) return orig;
+      return function (target, mode) {
+        try {
+          return orig.call(fs, target, mode);
+        } catch (er) {
+          if (!chownErOk(er)) throw er;
+        }
+      };
+    }
+    function chownFix(orig) {
+      if (!orig) return orig;
+      return function (target, uid, gid, cb) {
+        return orig.call(fs, target, uid, gid, function (er) {
+          if (chownErOk(er)) er = null;
+          if (cb) cb.apply(this, arguments);
+        });
+      };
+    }
+    function chownFixSync(orig) {
+      if (!orig) return orig;
+      return function (target, uid, gid) {
+        try {
+          return orig.call(fs, target, uid, gid);
+        } catch (er) {
+          if (!chownErOk(er)) throw er;
+        }
+      };
+    }
+    function statFix(orig) {
+      if (!orig) return orig;
+      // Older versions of Node erroneously returned signed integers for
+      // uid + gid.
+      return function (target, options, cb) {
+        if (typeof options === 'function') {
+          cb = options;
+          options = null;
+        }
+        function callback(er, stats) {
+          if (stats) {
+            if (stats.uid < 0) stats.uid += 0x100000000;
+            if (stats.gid < 0) stats.gid += 0x100000000;
+          }
+          if (cb) cb.apply(this, arguments);
+        }
+        return options ? orig.call(fs, target, options, callback) : orig.call(fs, target, callback);
+      };
+    }
+    function statFixSync(orig) {
+      if (!orig) return orig;
+      // Older versions of Node erroneously returned signed integers for
+      // uid + gid.
+      return function (target, options) {
+        var stats = options ? orig.call(fs, target, options) : orig.call(fs, target);
+        if (stats) {
+          if (stats.uid < 0) stats.uid += 0x100000000;
+          if (stats.gid < 0) stats.gid += 0x100000000;
+        }
+        return stats;
+      };
+    }
+
+    // ENOSYS means that the fs doesn't support the op. Just ignore
+    // that, because it doesn't matter.
+    //
+    // if there's no getuid, or if getuid() is something other
+    // than 0, and the error is EINVAL or EPERM, then just ignore
+    // it.
+    //
+    // This specific case is a silent failure in cp, install, tar,
+    // and most other unix tools that manage permissions.
+    //
+    // When running as root, or if other types of errors are
+    // encountered, then it's strict.
+    function chownErOk(er) {
+      if (!er) return true;
+      if (er.code === "ENOSYS") return true;
+      var nonroot = !process.getuid || process.getuid() !== 0;
+      if (nonroot) {
+        if (er.code === "EINVAL" || er.code === "EPERM") return true;
+      }
+      return false;
+    }
+  }
+  return polyfills;
+}
+
+var legacyStreams;
+var hasRequiredLegacyStreams;
+function requireLegacyStreams() {
+  if (hasRequiredLegacyStreams) return legacyStreams;
+  hasRequiredLegacyStreams = 1;
+  var Stream = require$$1$7.Stream;
+  legacyStreams = legacy;
+  function legacy(fs) {
+    return {
+      ReadStream: ReadStream,
+      WriteStream: WriteStream
+    };
+    function ReadStream(path, options) {
+      if (!(this instanceof ReadStream)) return new ReadStream(path, options);
+      Stream.call(this);
+      var self = this;
+      this.path = path;
+      this.fd = null;
+      this.readable = true;
+      this.paused = false;
+      this.flags = 'r';
+      this.mode = 438; /*=0666*/
+      this.bufferSize = 64 * 1024;
+      options = options || {};
+
+      // Mixin options into this
+      var keys = Object.keys(options);
+      for (var index = 0, length = keys.length; index < length; index++) {
+        var key = keys[index];
+        this[key] = options[key];
+      }
+      if (this.encoding) this.setEncoding(this.encoding);
+      if (this.start !== undefined) {
+        if ('number' !== typeof this.start) {
+          throw TypeError('start must be a Number');
+        }
+        if (this.end === undefined) {
+          this.end = Infinity;
+        } else if ('number' !== typeof this.end) {
+          throw TypeError('end must be a Number');
+        }
+        if (this.start > this.end) {
+          throw new Error('start must be <= end');
+        }
+        this.pos = this.start;
+      }
+      if (this.fd !== null) {
+        process.nextTick(function () {
+          self._read();
+        });
+        return;
+      }
+      fs.open(this.path, this.flags, this.mode, function (err, fd) {
+        if (err) {
+          self.emit('error', err);
+          self.readable = false;
+          return;
+        }
+        self.fd = fd;
+        self.emit('open', fd);
+        self._read();
+      });
+    }
+    function WriteStream(path, options) {
+      if (!(this instanceof WriteStream)) return new WriteStream(path, options);
+      Stream.call(this);
+      this.path = path;
+      this.fd = null;
+      this.writable = true;
+      this.flags = 'w';
+      this.encoding = 'binary';
+      this.mode = 438; /*=0666*/
+      this.bytesWritten = 0;
+      options = options || {};
+
+      // Mixin options into this
+      var keys = Object.keys(options);
+      for (var index = 0, length = keys.length; index < length; index++) {
+        var key = keys[index];
+        this[key] = options[key];
+      }
+      if (this.start !== undefined) {
+        if ('number' !== typeof this.start) {
+          throw TypeError('start must be a Number');
+        }
+        if (this.start < 0) {
+          throw new Error('start must be >= zero');
+        }
+        this.pos = this.start;
+      }
+      this.busy = false;
+      this._queue = [];
+      if (this.fd === null) {
+        this._open = fs.open;
+        this._queue.push([this._open, this.path, this.flags, this.mode, undefined]);
+        this.flush();
+      }
+    }
+  }
+  return legacyStreams;
+}
+
+var clone_1$1;
+var hasRequiredClone$1;
+function requireClone$1() {
+  if (hasRequiredClone$1) return clone_1$1;
+  hasRequiredClone$1 = 1;
+  clone_1$1 = clone;
+  var getPrototypeOf = Object.getPrototypeOf || function (obj) {
+    return obj.__proto__;
+  };
+  function clone(obj) {
+    if (obj === null || typeof obj !== 'object') return obj;
+    if (obj instanceof Object) var copy = {
+      __proto__: getPrototypeOf(obj)
+    };else var copy = Object.create(null);
+    Object.getOwnPropertyNames(obj).forEach(function (key) {
+      Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key));
+    });
+    return copy;
+  }
+  return clone_1$1;
+}
+
+var gracefulFs;
+var hasRequiredGracefulFs;
+function requireGracefulFs() {
+  if (hasRequiredGracefulFs) return gracefulFs;
+  hasRequiredGracefulFs = 1;
+  var fs = require$$0$9;
+  var polyfills = requirePolyfills();
+  var legacy = requireLegacyStreams();
+  var clone = requireClone$1();
+  var util = require$$0$8;
+
+  /* istanbul ignore next - node 0.x polyfill */
+  var gracefulQueue;
+  var previousSymbol;
+
+  /* istanbul ignore else - node 0.x polyfill */
+  if (typeof Symbol === 'function' && typeof Symbol.for === 'function') {
+    gracefulQueue = Symbol.for('graceful-fs.queue');
+    // This is used in testing by future versions
+    previousSymbol = Symbol.for('graceful-fs.previous');
+  } else {
+    gracefulQueue = '___graceful-fs.queue';
+    previousSymbol = '___graceful-fs.previous';
+  }
+  function noop() {}
+  function publishQueue(context, queue) {
+    Object.defineProperty(context, gracefulQueue, {
+      get: function () {
+        return queue;
+      }
+    });
+  }
+  var debug = noop;
+  if (util.debuglog) debug = util.debuglog('gfs4');else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || '')) debug = function () {
+    var m = util.format.apply(util, arguments);
+    m = 'GFS4: ' + m.split(/\n/).join('\nGFS4: ');
+    console.error(m);
+  };
+
+  // Once time initialization
+  if (!fs[gracefulQueue]) {
+    // This queue can be shared by multiple loaded instances
+    var queue = global[gracefulQueue] || [];
+    publishQueue(fs, queue);
+
+    // Patch fs.close/closeSync to shared queue version, because we need
+    // to retry() whenever a close happens *anywhere* in the program.
+    // This is essential when multiple graceful-fs instances are
+    // in play at the same time.
+    fs.close = function (fs$close) {
+      function close(fd, cb) {
+        return fs$close.call(fs, fd, function (err) {
+          // This function uses the graceful-fs shared queue
+          if (!err) {
+            resetQueue();
+          }
+          if (typeof cb === 'function') cb.apply(this, arguments);
+        });
+      }
+      Object.defineProperty(close, previousSymbol, {
+        value: fs$close
+      });
+      return close;
+    }(fs.close);
+    fs.closeSync = function (fs$closeSync) {
+      function closeSync(fd) {
+        // This function uses the graceful-fs shared queue
+        fs$closeSync.apply(fs, arguments);
+        resetQueue();
+      }
+      Object.defineProperty(closeSync, previousSymbol, {
+        value: fs$closeSync
+      });
+      return closeSync;
+    }(fs.closeSync);
+    if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || '')) {
+      process.on('exit', function () {
+        debug(fs[gracefulQueue]);
+        require$$0$a.equal(fs[gracefulQueue].length, 0);
+      });
+    }
+  }
+  if (!global[gracefulQueue]) {
+    publishQueue(global, fs[gracefulQueue]);
+  }
+  gracefulFs = patch(clone(fs));
+  if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs.__patched) {
+    gracefulFs = patch(fs);
+    fs.__patched = true;
+  }
+  function patch(fs) {
+    // Everything that references the open() function needs to be in here
+    polyfills(fs);
+    fs.gracefulify = patch;
+    fs.createReadStream = createReadStream;
+    fs.createWriteStream = createWriteStream;
+    var fs$readFile = fs.readFile;
+    fs.readFile = readFile;
+    function readFile(path, options, cb) {
+      if (typeof options === 'function') cb = options, options = null;
+      return go$readFile(path, options, cb);
+      function go$readFile(path, options, cb, startTime) {
+        return fs$readFile(path, options, function (err) {
+          if (err && (err.code === 'EMFILE' || err.code === 'ENFILE')) enqueue([go$readFile, [path, options, cb], err, startTime || Date.now(), Date.now()]);else {
+            if (typeof cb === 'function') cb.apply(this, arguments);
+          }
+        });
+      }
+    }
+    var fs$writeFile = fs.writeFile;
+    fs.writeFile = writeFile;
+    function writeFile(path, data, options, cb) {
+      if (typeof options === 'function') cb = options, options = null;
+      return go$writeFile(path, data, options, cb);
+      function go$writeFile(path, data, options, cb, startTime) {
+        return fs$writeFile(path, data, options, function (err) {
+          if (err && (err.code === 'EMFILE' || err.code === 'ENFILE')) enqueue([go$writeFile, [path, data, options, cb], err, startTime || Date.now(), Date.now()]);else {
+            if (typeof cb === 'function') cb.apply(this, arguments);
+          }
+        });
+      }
+    }
+    var fs$appendFile = fs.appendFile;
+    if (fs$appendFile) fs.appendFile = appendFile;
+    function appendFile(path, data, options, cb) {
+      if (typeof options === 'function') cb = options, options = null;
+      return go$appendFile(path, data, options, cb);
+      function go$appendFile(path, data, options, cb, startTime) {
+        return fs$appendFile(path, data, options, function (err) {
+          if (err && (err.code === 'EMFILE' || err.code === 'ENFILE')) enqueue([go$appendFile, [path, data, options, cb], err, startTime || Date.now(), Date.now()]);else {
+            if (typeof cb === 'function') cb.apply(this, arguments);
+          }
+        });
+      }
+    }
+    var fs$copyFile = fs.copyFile;
+    if (fs$copyFile) fs.copyFile = copyFile;
+    function copyFile(src, dest, flags, cb) {
+      if (typeof flags === 'function') {
+        cb = flags;
+        flags = 0;
+      }
+      return go$copyFile(src, dest, flags, cb);
+      function go$copyFile(src, dest, flags, cb, startTime) {
+        return fs$copyFile(src, dest, flags, function (err) {
+          if (err && (err.code === 'EMFILE' || err.code === 'ENFILE')) enqueue([go$copyFile, [src, dest, flags, cb], err, startTime || Date.now(), Date.now()]);else {
+            if (typeof cb === 'function') cb.apply(this, arguments);
+          }
+        });
+      }
+    }
+    var fs$readdir = fs.readdir;
+    fs.readdir = readdir;
+    var noReaddirOptionVersions = /^v[0-5]\./;
+    function readdir(path, options, cb) {
+      if (typeof options === 'function') cb = options, options = null;
+      var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir(path, options, cb, startTime) {
+        return fs$readdir(path, fs$readdirCallback(path, options, cb, startTime));
+      } : function go$readdir(path, options, cb, startTime) {
+        return fs$readdir(path, options, fs$readdirCallback(path, options, cb, startTime));
+      };
+      return go$readdir(path, options, cb);
+      function fs$readdirCallback(path, options, cb, startTime) {
+        return function (err, files) {
+          if (err && (err.code === 'EMFILE' || err.code === 'ENFILE')) enqueue([go$readdir, [path, options, cb], err, startTime || Date.now(), Date.now()]);else {
+            if (files && files.sort) files.sort();
+            if (typeof cb === 'function') cb.call(this, err, files);
+          }
+        };
+      }
+    }
+    if (process.version.substr(0, 4) === 'v0.8') {
+      var legStreams = legacy(fs);
+      ReadStream = legStreams.ReadStream;
+      WriteStream = legStreams.WriteStream;
+    }
+    var fs$ReadStream = fs.ReadStream;
+    if (fs$ReadStream) {
+      ReadStream.prototype = Object.create(fs$ReadStream.prototype);
+      ReadStream.prototype.open = ReadStream$open;
+    }
+    var fs$WriteStream = fs.WriteStream;
+    if (fs$WriteStream) {
+      WriteStream.prototype = Object.create(fs$WriteStream.prototype);
+      WriteStream.prototype.open = WriteStream$open;
+    }
+    Object.defineProperty(fs, 'ReadStream', {
+      get: function () {
+        return ReadStream;
+      },
+      set: function (val) {
+        ReadStream = val;
+      },
+      enumerable: true,
+      configurable: true
+    });
+    Object.defineProperty(fs, 'WriteStream', {
+      get: function () {
+        return WriteStream;
+      },
+      set: function (val) {
+        WriteStream = val;
+      },
+      enumerable: true,
+      configurable: true
+    });
+
+    // legacy names
+    var FileReadStream = ReadStream;
+    Object.defineProperty(fs, 'FileReadStream', {
+      get: function () {
+        return FileReadStream;
+      },
+      set: function (val) {
+        FileReadStream = val;
+      },
+      enumerable: true,
+      configurable: true
+    });
+    var FileWriteStream = WriteStream;
+    Object.defineProperty(fs, 'FileWriteStream', {
+      get: function () {
+        return FileWriteStream;
+      },
+      set: function (val) {
+        FileWriteStream = val;
+      },
+      enumerable: true,
+      configurable: true
+    });
+    function ReadStream(path, options) {
+      if (this instanceof ReadStream) return fs$ReadStream.apply(this, arguments), this;else return ReadStream.apply(Object.create(ReadStream.prototype), arguments);
+    }
+    function ReadStream$open() {
+      var that = this;
+      open(that.path, that.flags, that.mode, function (err, fd) {
+        if (err) {
+          if (that.autoClose) that.destroy();
+          that.emit('error', err);
+        } else {
+          that.fd = fd;
+          that.emit('open', fd);
+          that.read();
+        }
+      });
+    }
+    function WriteStream(path, options) {
+      if (this instanceof WriteStream) return fs$WriteStream.apply(this, arguments), this;else return WriteStream.apply(Object.create(WriteStream.prototype), arguments);
+    }
+    function WriteStream$open() {
+      var that = this;
+      open(that.path, that.flags, that.mode, function (err, fd) {
+        if (err) {
+          that.destroy();
+          that.emit('error', err);
+        } else {
+          that.fd = fd;
+          that.emit('open', fd);
+        }
+      });
+    }
+    function createReadStream(path, options) {
+      return new fs.ReadStream(path, options);
+    }
+    function createWriteStream(path, options) {
+      return new fs.WriteStream(path, options);
+    }
+    var fs$open = fs.open;
+    fs.open = open;
+    function open(path, flags, mode, cb) {
+      if (typeof mode === 'function') cb = mode, mode = null;
+      return go$open(path, flags, mode, cb);
+      function go$open(path, flags, mode, cb, startTime) {
+        return fs$open(path, flags, mode, function (err, fd) {
+          if (err && (err.code === 'EMFILE' || err.code === 'ENFILE')) enqueue([go$open, [path, flags, mode, cb], err, startTime || Date.now(), Date.now()]);else {
+            if (typeof cb === 'function') cb.apply(this, arguments);
+          }
+        });
+      }
+    }
+    return fs;
+  }
+  function enqueue(elem) {
+    debug('ENQUEUE', elem[0].name, elem[1]);
+    fs[gracefulQueue].push(elem);
+    retry();
+  }
+
+  // keep track of the timeout between retry() calls
+  var retryTimer;
+
+  // reset the startTime and lastTime to now
+  // this resets the start of the 60 second overall timeout as well as the
+  // delay between attempts so that we'll retry these jobs sooner
+  function resetQueue() {
+    var now = Date.now();
+    for (var i = 0; i < fs[gracefulQueue].length; ++i) {
+      // entries that are only a length of 2 are from an older version, don't
+      // bother modifying those since they'll be retried anyway.
+      if (fs[gracefulQueue][i].length > 2) {
+        fs[gracefulQueue][i][3] = now; // startTime
+        fs[gracefulQueue][i][4] = now; // lastTime
+      }
+    }
+    // call retry to make sure we're actively processing the queue
+    retry();
+  }
+  function retry() {
+    // clear the timer and remove it to help prevent unintended concurrency
+    clearTimeout(retryTimer);
+    retryTimer = undefined;
+    if (fs[gracefulQueue].length === 0) return;
+    var elem = fs[gracefulQueue].shift();
+    var fn = elem[0];
+    var args = elem[1];
+    // these items may be unset if they were added by an older graceful-fs
+    var err = elem[2];
+    var startTime = elem[3];
+    var lastTime = elem[4];
+
+    // if we don't have a startTime we have no way of knowing if we've waited
+    // long enough, so go ahead and retry this item now
+    if (startTime === undefined) {
+      debug('RETRY', fn.name, args);
+      fn.apply(null, args);
+    } else if (Date.now() - startTime >= 60000) {
+      // it's been more than 60 seconds total, bail now
+      debug('TIMEOUT', fn.name, args);
+      var cb = args.pop();
+      if (typeof cb === 'function') cb.call(null, err);
+    } else {
+      // the amount of time between the last attempt and right now
+      var sinceAttempt = Date.now() - lastTime;
+      // the amount of time between when we first tried, and when we last tried
+      // rounded up to at least 1
+      var sinceStart = Math.max(lastTime - startTime, 1);
+      // backoff. wait longer than the total time we've been retrying, but only
+      // up to a maximum of 100ms
+      var desiredDelay = Math.min(sinceStart * 1.2, 100);
+      // it's been long enough since the last retry, do it again
+      if (sinceAttempt >= desiredDelay) {
+        debug('RETRY', fn.name, args);
+        fn.apply(null, args.concat([startTime]));
+      } else {
+        // if we can't do this job yet, push it to the end of the queue
+        // and let the next iteration check again
+        fs[gracefulQueue].push(elem);
+      }
+    }
+
+    // schedule our next run if one isn't already scheduled
+    if (retryTimer === undefined) {
+      retryTimer = setTimeout(retry, 0);
+    }
+  }
+  return gracefulFs;
+}
+
+var hasRequiredCaFile;
+function requireCaFile() {
+  if (hasRequiredCaFile) return caFile;
+  hasRequiredCaFile = 1;
+  var __importDefault = this && this.__importDefault || function (mod) {
+    return mod && mod.__esModule ? mod : {
+      "default": mod
+    };
+  };
+  Object.defineProperty(caFile, "__esModule", {
+    value: true
+  });
+  caFile.readCAFileSync = void 0;
+  const graceful_fs_1 = __importDefault(requireGracefulFs());
+  function readCAFileSync(filePath) {
+    try {
+      const contents = graceful_fs_1.default.readFileSync(filePath, 'utf8');
+      const delim = '-----END CERTIFICATE-----';
+      const output = contents.split(delim).filter(ca => Boolean(ca.trim())).map(ca => `${ca.trimLeft()}${delim}`);
+      return output;
+    } catch (err) {
+      if (err.code === 'ENOENT') return undefined;
+      throw err;
+    }
+  }
+  caFile.readCAFileSync = readCAFileSync;
+  return caFile;
+}
+
+var hasRequiredDist$j;
+function requireDist$j() {
+  if (hasRequiredDist$j) return dist$j;
+  hasRequiredDist$j = 1;
+  (function (exports) {
+
+    var __createBinding = this && this.__createBinding || (Object.create ? function (o, m, k, k2) {
+      if (k2 === undefined) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = {
+          enumerable: true,
+          get: function () {
+            return m[k];
+          }
+        };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function (o, m, k, k2) {
+      if (k2 === undefined) k2 = k;
+      o[k2] = m[k];
+    });
+    var __exportStar = this && this.__exportStar || function (m, exports) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    __exportStar(requireCaFile(), exports);
+  })(dist$j);
+  return dist$j;
+}
+
+var configChain = {exports: {}};
+
+var protoList;
+var hasRequiredProtoList;
+function requireProtoList() {
+  if (hasRequiredProtoList) return protoList;
+  hasRequiredProtoList = 1;
+  protoList = ProtoList;
+  function setProto(obj, proto) {
+    if (typeof Object.setPrototypeOf === "function") return Object.setPrototypeOf(obj, proto);else Object.setPrototypeOf(obj, proto);
+  }
+  function ProtoList() {
+    this.list = [];
+    var root = null;
+    Object.defineProperty(this, 'root', {
+      get: function () {
+        return root;
+      },
+      set: function (r) {
+        root = r;
+        if (this.list.length) {
+          setProto(this.list[this.list.length - 1], r);
+        }
+      },
+      enumerable: true,
+      configurable: true
+    });
+  }
+  ProtoList.prototype = {
+    get length() {
+      return this.list.length;
+    },
+    get keys() {
+      var k = [];
+      for (var i in this.list[0]) k.push(i);
+      return k;
+    },
+    get snapshot() {
+      var o = {};
+      this.keys.forEach(function (k) {
+        o[k] = this.get(k);
+      }, this);
+      return o;
+    },
+    get store() {
+      return this.list[0];
+    },
+    push: function (obj) {
+      if (typeof obj !== "object") obj = {
+        valueOf: obj
+      };
+      if (this.list.length >= 1) {
+        setProto(this.list[this.list.length - 1], obj);
+      }
+      setProto(obj, this.root);
+      return this.list.push(obj);
+    },
+    pop: function () {
+      if (this.list.length >= 2) {
+        setProto(this.list[this.list.length - 2], this.root);
+      }
+      return this.list.pop();
+    },
+    unshift: function (obj) {
+      setProto(obj, this.list[0] || this.root);
+      return this.list.unshift(obj);
+    },
+    shift: function () {
+      if (this.list.length === 1) {
+        setProto(this.list[0], this.root);
+      }
+      return this.list.shift();
+    },
+    get: function (key) {
+      return this.list[0][key];
+    },
+    set: function (key, val, save) {
+      if (!this.length) this.push({});
+      if (save && this.list[0].hasOwnProperty(key)) this.push({});
+      return this.list[0][key] = val;
+    },
+    forEach: function (fn, thisp) {
+      for (var key in this.list[0]) fn.call(thisp, key, this.list[0][key]);
+    },
+    slice: function () {
+      return this.list.slice.apply(this.list, arguments);
+    },
+    splice: function () {
+      // handle injections
+      var ret = this.list.splice.apply(this.list, arguments);
+      for (var i = 0, l = this.list.length; i < l; i++) {
+        setProto(this.list[i], this.list[i + 1] || this.root);
+      }
+      return ret;
+    }
+  };
+  return protoList;
+}
+
+var ini$1 = {};
+
+var hasRequiredIni$1;
+function requireIni$1() {
+  if (hasRequiredIni$1) return ini$1;
+  hasRequiredIni$1 = 1;
+  ini$1.parse = ini$1.decode = decode;
+  ini$1.stringify = ini$1.encode = encode;
+  ini$1.safe = safe;
+  ini$1.unsafe = unsafe;
+  var eol = typeof process !== 'undefined' && process.platform === 'win32' ? '\r\n' : '\n';
+  function encode(obj, opt) {
+    var children = [];
+    var out = '';
+    if (typeof opt === 'string') {
+      opt = {
+        section: opt,
+        whitespace: false
+      };
+    } else {
+      opt = opt || {};
+      opt.whitespace = opt.whitespace === true;
+    }
+    var separator = opt.whitespace ? ' = ' : '=';
+    Object.keys(obj).forEach(function (k, _, __) {
+      var val = obj[k];
+      if (val && Array.isArray(val)) {
+        val.forEach(function (item) {
+          out += safe(k + '[]') + separator + safe(item) + '\n';
+        });
+      } else if (val && typeof val === 'object') children.push(k);else out += safe(k) + separator + safe(val) + eol;
+    });
+    if (opt.section && out.length) out = '[' + safe(opt.section) + ']' + eol + out;
+    children.forEach(function (k, _, __) {
+      var nk = dotSplit(k).join('\\.');
+      var section = (opt.section ? opt.section + '.' : '') + nk;
+      var child = encode(obj[k], {
+        section: section,
+        whitespace: opt.whitespace
+      });
+      if (out.length && child.length) out += eol;
+      out += child;
+    });
+    return out;
+  }
+  function dotSplit(str) {
+    return str.replace(/\1/g, '\u0002LITERAL\\1LITERAL\u0002').replace(/\\\./g, '\u0001').split(/\./).map(function (part) {
+      return part.replace(/\1/g, '\\.').replace(/\2LITERAL\\1LITERAL\2/g, '\u0001');
+    });
+  }
+  function decode(str) {
+    var out = {};
+    var p = out;
+    var section = null;
+    //          section     |key      = value
+    var re = /^\[([^\]]*)\]$|^([^=]+)(=(.*))?$/i;
+    var lines = str.split(/[\r\n]+/g);
+    lines.forEach(function (line, _, __) {
+      if (!line || line.match(/^\s*[;#]/)) return;
+      var match = line.match(re);
+      if (!match) return;
+      if (match[1] !== undefined) {
+        section = unsafe(match[1]);
+        if (section === '__proto__') {
+          // not allowed
+          // keep parsing the section, but don't attach it.
+          p = {};
+          return;
+        }
+        p = out[section] = out[section] || {};
+        return;
+      }
+      var key = unsafe(match[2]);
+      if (key === '__proto__') return;
+      var value = match[3] ? unsafe(match[4]) : true;
+      switch (value) {
+        case 'true':
+        case 'false':
+        case 'null':
+          value = JSON.parse(value);
+      }
+
+      // Convert keys with '[]' suffix to an array
+      if (key.length > 2 && key.slice(-2) === '[]') {
+        key = key.substring(0, key.length - 2);
+        if (key === '__proto__') return;
+        if (!p[key]) p[key] = [];else if (!Array.isArray(p[key])) p[key] = [p[key]];
+      }
+
+      // safeguard against resetting a previously defined
+      // array by accidentally forgetting the brackets
+      if (Array.isArray(p[key])) p[key].push(value);else p[key] = value;
+    });
+
+    // {a:{y:1},"a.b":{x:2}} --> {a:{y:1,b:{x:2}}}
+    // use a filter to return the keys that have to be deleted.
+    Object.keys(out).filter(function (k, _, __) {
+      if (!out[k] || typeof out[k] !== 'object' || Array.isArray(out[k])) return false;
+
+      // see if the parent section is also an object.
+      // if so, add it to that, and mark this one for deletion
+      var parts = dotSplit(k);
+      var p = out;
+      var l = parts.pop();
+      var nl = l.replace(/\\\./g, '.');
+      parts.forEach(function (part, _, __) {
+        if (part === '__proto__') return;
+        if (!p[part] || typeof p[part] !== 'object') p[part] = {};
+        p = p[part];
+      });
+      if (p === out && nl === l) return false;
+      p[nl] = out[k];
+      return true;
+    }).forEach(function (del, _, __) {
+      delete out[del];
+    });
+    return out;
+  }
+  function isQuoted(val) {
+    return val.charAt(0) === '"' && val.slice(-1) === '"' || val.charAt(0) === "'" && val.slice(-1) === "'";
+  }
+  function safe(val) {
+    return typeof val !== 'string' || val.match(/[=\r\n]/) || val.match(/^\[/) || val.length > 1 && isQuoted(val) || val !== val.trim() ? JSON.stringify(val) : val.replace(/;/g, '\\;').replace(/#/g, '\\#');
+  }
+  function unsafe(val, doUnesc) {
+    val = (val || '').trim();
+    if (isQuoted(val)) {
+      // remove the single quotes before calling JSON.parse
+      if (val.charAt(0) === "'") val = val.substr(1, val.length - 2);
+      try {
+        val = JSON.parse(val);
+      } catch (_) {}
+    } else {
+      // walk the val to find the first not-escaped ; character
+      var esc = false;
+      var unesc = '';
+      for (var i = 0, l = val.length; i < l; i++) {
+        var c = val.charAt(i);
+        if (esc) {
+          if ('\\;#'.indexOf(c) !== -1) unesc += c;else unesc += '\\' + c;
+          esc = false;
+        } else if (';#'.indexOf(c) !== -1) break;else if (c === '\\') esc = true;else unesc += c;
+      }
+      if (esc) unesc += '\\';
+      return unesc.trim();
+    }
+    return val;
+  }
+  return ini$1;
+}
+
+var hasRequiredConfigChain;
+function requireConfigChain() {
+  if (hasRequiredConfigChain) return configChain.exports;
+  hasRequiredConfigChain = 1;
+  var ProtoList = requireProtoList(),
+    path = require$$0$c,
+    fs = require$$0$9,
+    ini = requireIni$1(),
+    EE = require$$0$b.EventEmitter,
+    url = require$$0$d,
+    http = require$$1$8;
+  var exports = configChain.exports = function () {
+    var args = [].slice.call(arguments),
+      conf = new ConfigChain();
+    while (args.length) {
+      var a = args.shift();
+      if (a) conf.push('string' === typeof a ? json(a) : a);
+    }
+    return conf;
+  };
+
+  //recursively find a file...
+
+  exports.find = function () {
+    var rel = path.join.apply(null, [].slice.call(arguments));
+    function find(start, rel) {
+      var file = path.join(start, rel);
+      try {
+        fs.statSync(file);
+        return file;
+      } catch (err) {
+        if (path.dirname(start) !== start)
+          // root
+          return find(path.dirname(start), rel);
+      }
+    }
+    return find(__dirname, rel);
+  };
+  var parse = exports.parse = function (content, file, type) {
+    content = '' + content;
+    // if we don't know what it is, try json and fall back to ini
+    // if we know what it is, then it must be that.
+    if (!type) {
+      try {
+        return JSON.parse(content);
+      } catch (er) {
+        return ini.parse(content);
+      }
+    } else if (type === 'json') {
+      if (this.emit) {
+        try {
+          return JSON.parse(content);
+        } catch (er) {
+          this.emit('error', er);
+        }
+      } else {
+        return JSON.parse(content);
+      }
+    } else {
+      return ini.parse(content);
+    }
+  };
+  var json = exports.json = function () {
+    var args = [].slice.call(arguments).filter(function (arg) {
+      return arg != null;
+    });
+    var file = path.join.apply(null, args);
+    var content;
+    try {
+      content = fs.readFileSync(file, 'utf-8');
+    } catch (err) {
+      return;
+    }
+    return parse(content, file, 'json');
+  };
+  exports.env = function (prefix, env) {
+    env = env || process.env;
+    var obj = {};
+    var l = prefix.length;
+    for (var k in env) {
+      if (k.indexOf(prefix) === 0) obj[k.substring(l)] = env[k];
+    }
+    return obj;
+  };
+  exports.ConfigChain = ConfigChain;
+  function ConfigChain() {
+    EE.apply(this);
+    ProtoList.apply(this, arguments);
+    this._awaiting = 0;
+    this._saving = 0;
+    this.sources = {};
+  }
+
+  // multi-inheritance-ish
+  var extras = {
+    constructor: {
+      value: ConfigChain
+    }
+  };
+  Object.keys(EE.prototype).forEach(function (k) {
+    extras[k] = Object.getOwnPropertyDescriptor(EE.prototype, k);
+  });
+  ConfigChain.prototype = Object.create(ProtoList.prototype, extras);
+  ConfigChain.prototype.del = function (key, where) {
+    // if not specified where, then delete from the whole chain, scorched
+    // earth style
+    if (where) {
+      var target = this.sources[where];
+      target = target && target.data;
+      if (!target) {
+        return this.emit('error', new Error('not found ' + where));
+      }
+      delete target[key];
+    } else {
+      for (var i = 0, l = this.list.length; i < l; i++) {
+        delete this.list[i][key];
+      }
+    }
+    return this;
+  };
+  ConfigChain.prototype.set = function (key, value, where) {
+    var target;
+    if (where) {
+      target = this.sources[where];
+      target = target && target.data;
+      if (!target) {
+        return this.emit('error', new Error('not found ' + where));
+      }
+    } else {
+      target = this.list[0];
+      if (!target) {
+        return this.emit('error', new Error('cannot set, no confs!'));
+      }
+    }
+    target[key] = value;
+    return this;
+  };
+  ConfigChain.prototype.get = function (key, where) {
+    if (where) {
+      where = this.sources[where];
+      if (where) where = where.data;
+      if (where && Object.hasOwnProperty.call(where, key)) return where[key];
+      return undefined;
+    }
+    return this.list[0][key];
+  };
+  ConfigChain.prototype.save = function (where, type, cb) {
+    if (typeof type === 'function') cb = type, type = null;
+    var target = this.sources[where];
+    if (!target || !(target.path || target.source) || !target.data) {
+      // TODO: maybe save() to a url target could be a PUT or something?
+      // would be easy to swap out with a reddis type thing, too
+      return this.emit('error', new Error('bad save target: ' + where));
+    }
+    if (target.source) {
+      var pref = target.prefix || '';
+      Object.keys(target.data).forEach(function (k) {
+        target.source[pref + k] = target.data[k];
+      });
+      return this;
+    }
+    var type = type || target.type;
+    var data = target.data;
+    if (target.type === 'json') {
+      data = JSON.stringify(data);
+    } else {
+      data = ini.stringify(data);
+    }
+    this._saving++;
+    fs.writeFile(target.path, data, 'utf8', function (er) {
+      this._saving--;
+      if (er) {
+        if (cb) return cb(er);else return this.emit('error', er);
+      }
+      if (this._saving === 0) {
+        if (cb) cb();
+        this.emit('save');
+      }
+    }.bind(this));
+    return this;
+  };
+  ConfigChain.prototype.addFile = function (file, type, name) {
+    name = name || file;
+    var marker = {
+      __source__: name
+    };
+    this.sources[name] = {
+      path: file,
+      type: type
+    };
+    this.push(marker);
+    this._await();
+    fs.readFile(file, 'utf8', function (er, data) {
+      if (er) this.emit('error', er);
+      this.addString(data, file, type, marker);
+    }.bind(this));
+    return this;
+  };
+  ConfigChain.prototype.addEnv = function (prefix, env, name) {
+    name = name || 'env';
+    var data = exports.env(prefix, env);
+    this.sources[name] = {
+      data: data,
+      source: env,
+      prefix: prefix
+    };
+    return this.add(data, name);
+  };
+  ConfigChain.prototype.addUrl = function (req, type, name) {
+    this._await();
+    var href = url.format(req);
+    name = name || href;
+    var marker = {
+      __source__: name
+    };
+    this.sources[name] = {
+      href: href,
+      type: type
+    };
+    this.push(marker);
+    http.request(req, function (res) {
+      var c = [];
+      var ct = res.headers['content-type'];
+      if (!type) {
+        type = ct.indexOf('json') !== -1 ? 'json' : ct.indexOf('ini') !== -1 ? 'ini' : href.match(/\.json$/) ? 'json' : href.match(/\.ini$/) ? 'ini' : null;
+        marker.type = type;
+      }
+      res.on('data', c.push.bind(c)).on('end', function () {
+        this.addString(Buffer.concat(c), href, type, marker);
+      }.bind(this)).on('error', this.emit.bind(this, 'error'));
+    }.bind(this)).on('error', this.emit.bind(this, 'error')).end();
+    return this;
+  };
+  ConfigChain.prototype.addString = function (data, file, type, marker) {
+    data = this.parse(data, file, type);
+    this.add(data, marker);
+    return this;
+  };
+  ConfigChain.prototype.add = function (data, marker) {
+    if (marker && typeof marker === 'object') {
+      var i = this.list.indexOf(marker);
+      if (i === -1) {
+        return this.emit('error', new Error('bad marker'));
+      }
+      this.splice(i, 1, data);
+      marker = marker.__source__;
+      this.sources[marker] = this.sources[marker] || {};
+      this.sources[marker].data = data;
+      // we were waiting for this.  maybe emit 'load'
+      this._resolve();
+    } else {
+      if (typeof marker === 'string') {
+        this.sources[marker] = this.sources[marker] || {};
+        this.sources[marker].data = data;
+      }
+      // trigger the load event if nothing was already going to do so.
+      this._await();
+      this.push(data);
+      process.nextTick(this._resolve.bind(this));
+    }
+    return this;
+  };
+  ConfigChain.prototype.parse = exports.parse;
+  ConfigChain.prototype._await = function () {
+    this._awaiting++;
+  };
+  ConfigChain.prototype._resolve = function () {
+    this._awaiting--;
+    if (this._awaiting === 0) this.emit('load', this);
+  };
+  return configChain.exports;
+}
+
+var envKeyToSetting;
+var hasRequiredEnvKeyToSetting;
+function requireEnvKeyToSetting() {
+  if (hasRequiredEnvKeyToSetting) return envKeyToSetting;
+  hasRequiredEnvKeyToSetting = 1;
+  envKeyToSetting = function (x) {
+    const colonIndex = x.indexOf(':');
+    if (colonIndex === -1) {
+      return normalize(x);
+    }
+    const firstPart = x.substr(0, colonIndex);
+    const secondPart = x.substr(colonIndex + 1);
+    return `${normalize(firstPart)}:${normalize(secondPart)}`;
+  };
+  function normalize(s) {
+    s = s.toLowerCase();
+    if (s === '_authtoken') return '_authToken';
+    let r = s[0];
+    for (let i = 1; i < s.length; i++) {
+      r += s[i] === '_' ? '-' : s[i];
+    }
+    return r;
+  }
+  return envKeyToSetting;
+}
+
+var util$4 = {};
+
+var dist$i = {};
+
+var envReplace$1 = {};
+
+var hasRequiredEnvReplace$1;
+function requireEnvReplace$1() {
+  if (hasRequiredEnvReplace$1) return envReplace$1;
+  hasRequiredEnvReplace$1 = 1;
+  Object.defineProperty(envReplace$1, "__esModule", {
+    value: true
+  });
+  envReplace$1.envReplace = void 0;
+  const ENV_EXPR = /(?<!\\)(\\*)\$\{([^${}]+)\}/g;
+  function envReplace(settingValue, env) {
+    return settingValue.replace(ENV_EXPR, replaceEnvMatch.bind(null, env));
+  }
+  envReplace$1.envReplace = envReplace;
+  function replaceEnvMatch(env, orig, escape, name) {
+    if (escape.length % 2) {
+      return orig.slice((escape.length + 1) / 2);
+    }
+    const envValue = getEnvValue(env, name);
+    if (envValue === undefined) {
+      throw new Error(`Failed to replace env in config: ${orig}`);
+    }
+    return `${escape.slice(escape.length / 2)}${envValue}`;
+  }
+  const ENV_VALUE = /([^:-]+)(:?)-(.+)/;
+  function getEnvValue(env, name) {
+    const matched = name.match(ENV_VALUE);
+    if (!matched) return env[name];
+    const [, variableName, colon, fallback] = matched;
+    if (Object.prototype.hasOwnProperty.call(env, variableName)) {
+      return !env[variableName] && colon ? fallback : env[variableName];
+    }
+    return fallback;
+  }
+  return envReplace$1;
+}
+
+var hasRequiredDist$i;
+function requireDist$i() {
+  if (hasRequiredDist$i) return dist$i;
+  hasRequiredDist$i = 1;
+  (function (exports) {
+
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.envReplace = void 0;
+    var env_replace_1 = requireEnvReplace$1();
+    Object.defineProperty(exports, "envReplace", {
+      enumerable: true,
+      get: function () {
+        return env_replace_1.envReplace;
+      }
+    });
+  })(dist$i);
+  return dist$i;
+}
+
+var hasRequiredUtil$4;
+function requireUtil$4() {
+  if (hasRequiredUtil$4) return util$4;
+  hasRequiredUtil$4 = 1;
+  const fs = require$$0$9;
+  const path = require$$0$c;
+  const {
+    envReplace
+  } = requireDist$i();
+  const parseKey = key => {
+    if (typeof key !== 'string') {
+      return key;
+    }
+    return envReplace(key, process.env);
+  };
+
+  // https://github.com/npm/cli/blob/latest/lib/config/core.js#L359-L404
+  const parseField = (types, field, key) => {
+    if (typeof field !== 'string') {
+      return field;
+    }
+    const typeList = [].concat(types[key]);
+    const isPath = typeList.indexOf(path) !== -1;
+    const isBool = typeList.indexOf(Boolean) !== -1;
+    const isString = typeList.indexOf(String) !== -1;
+    const isNumber = typeList.indexOf(Number) !== -1;
+    field = `${field}`.trim();
+    if (/^".*"$/.test(field)) {
+      try {
+        field = JSON.parse(field);
+      } catch (error) {
+        throw new Error(`Failed parsing JSON config key ${key}: ${field}`);
+      }
+    }
+    if (isBool && !isString && field === '') {
+      return true;
+    }
+    switch (field) {
+      // eslint-disable-line default-case
+      case 'true':
+        {
+          return true;
+        }
+      case 'false':
+        {
+          return false;
+        }
+      case 'null':
+        {
+          return null;
+        }
+      case 'undefined':
+        {
+          return undefined;
+        }
+    }
+    field = envReplace(field, process.env);
+    if (isPath) {
+      const regex = process.platform === 'win32' ? /^~(\/|\\)/ : /^~\//;
+      if (regex.test(field) && process.env.HOME) {
+        field = path.resolve(process.env.HOME, field.substr(2));
+      }
+      field = path.resolve(field);
+    }
+    if (isNumber && !isNaN(field)) {
+      field = Number(field);
+    }
+    return field;
+  };
+
+  // https://github.com/npm/cli/blob/latest/lib/config/find-prefix.js
+  const findPrefix = name => {
+    name = path.resolve(name);
+    let walkedUp = false;
+    while (path.basename(name) === 'node_modules') {
+      name = path.dirname(name);
+      walkedUp = true;
+    }
+    if (walkedUp) {
+      return name;
+    }
+    const find = (name, original) => {
+      const regex = /^[a-zA-Z]:(\\|\/)?$/;
+      if (name === '/' || process.platform === 'win32' && regex.test(name)) {
+        return original;
+      }
+      try {
+        const files = fs.readdirSync(name);
+        if (files.includes('node_modules') || files.includes('package.json') || files.includes('package.json5') || files.includes('package.yaml') || files.includes('pnpm-workspace.yaml')) {
+          return name;
+        }
+        const dirname = path.dirname(name);
+        if (dirname === name) {
+          return original;
+        }
+        return find(dirname, original);
+      } catch (error) {
+        if (name === original) {
+          if (error.code === 'ENOENT') {
+            return original;
+          }
+          throw error;
+        }
+        return original;
+      }
+    };
+    return find(name, name);
+  };
+  util$4.envReplace = envReplace;
+  util$4.findPrefix = findPrefix;
+  util$4.parseField = parseField;
+  util$4.parseKey = parseKey;
+  return util$4;
+}
+
+var types$4 = {};
+
+var hasRequiredTypes$4;
+function requireTypes$4() {
+  if (hasRequiredTypes$4) return types$4;
+  hasRequiredTypes$4 = 1;
+  const path = require$$0$c;
+  const Stream = require$$1$7.Stream;
+  const url = require$$0$d;
+  const Umask = () => {};
+  const getLocalAddresses = () => [];
+  const semver = () => {};
+  types$4.types = {
+    access: [null, 'restricted', 'public'],
+    'allow-same-version': Boolean,
+    'always-auth': Boolean,
+    also: [null, 'dev', 'development'],
+    audit: Boolean,
+    'auth-type': ['legacy', 'sso', 'saml', 'oauth'],
+    'bin-links': Boolean,
+    browser: [null, String],
+    ca: [null, String, Array],
+    cafile: path,
+    cache: path,
+    'cache-lock-stale': Number,
+    'cache-lock-retries': Number,
+    'cache-lock-wait': Number,
+    'cache-max': Number,
+    'cache-min': Number,
+    cert: [null, String],
+    cidr: [null, String, Array],
+    color: ['always', Boolean],
+    depth: Number,
+    description: Boolean,
+    dev: Boolean,
+    'dry-run': Boolean,
+    editor: String,
+    'engine-strict': Boolean,
+    force: Boolean,
+    'fetch-retries': Number,
+    'fetch-retry-factor': Number,
+    'fetch-retry-mintimeout': Number,
+    'fetch-retry-maxtimeout': Number,
+    git: String,
+    'git-tag-version': Boolean,
+    'commit-hooks': Boolean,
+    global: Boolean,
+    globalconfig: path,
+    'global-style': Boolean,
+    group: [Number, String],
+    'https-proxy': [null, url],
+    'user-agent': String,
+    'ham-it-up': Boolean,
+    'heading': String,
+    'if-present': Boolean,
+    'ignore-prepublish': Boolean,
+    'ignore-scripts': Boolean,
+    'init-module': path,
+    'init-author-name': String,
+    'init-author-email': String,
+    'init-author-url': ['', url],
+    'init-license': String,
+    'init-version': semver,
+    json: Boolean,
+    key: [null, String],
+    'legacy-bundling': Boolean,
+    link: Boolean,
+    // local-address must be listed as an IP for a local network interface
+    // must be IPv4 due to node bug
+    'local-address': getLocalAddresses(),
+    loglevel: ['silent', 'error', 'warn', 'notice', 'http', 'timing', 'info', 'verbose', 'silly'],
+    logstream: Stream,
+    'logs-max': Number,
+    long: Boolean,
+    maxsockets: Number,
+    message: String,
+    'metrics-registry': [null, String],
+    'node-options': [null, String],
+    'node-version': [null, semver],
+    'no-proxy': [null, String, Array],
+    offline: Boolean,
+    'onload-script': [null, String],
+    only: [null, 'dev', 'development', 'prod', 'production'],
+    optional: Boolean,
+    'package-lock': Boolean,
+    otp: [null, String],
+    'package-lock-only': Boolean,
+    parseable: Boolean,
+    'prefer-offline': Boolean,
+    'prefer-online': Boolean,
+    prefix: path,
+    production: Boolean,
+    progress: Boolean,
+    proxy: [null, false, url],
+    provenance: Boolean,
+    // allow proxy to be disabled explicitly
+    'read-only': Boolean,
+    'rebuild-bundle': Boolean,
+    registry: [null, url],
+    rollback: Boolean,
+    save: Boolean,
+    'save-bundle': Boolean,
+    'save-dev': Boolean,
+    'save-exact': Boolean,
+    'save-optional': Boolean,
+    'save-prefix': String,
+    'save-prod': Boolean,
+    scope: String,
+    'script-shell': [null, String],
+    'scripts-prepend-node-path': [false, true, 'auto', 'warn-only'],
+    searchopts: String,
+    searchexclude: [null, String],
+    searchlimit: Number,
+    searchstaleness: Number,
+    'send-metrics': Boolean,
+    shell: String,
+    shrinkwrap: Boolean,
+    'sign-git-tag': Boolean,
+    'sso-poll-frequency': Number,
+    'sso-type': [null, 'oauth', 'saml'],
+    'strict-ssl': Boolean,
+    tag: String,
+    timing: Boolean,
+    tmp: path,
+    unicode: Boolean,
+    'unsafe-perm': Boolean,
+    usage: Boolean,
+    user: [Number, String],
+    userconfig: path,
+    umask: Umask,
+    version: Boolean,
+    'tag-version-prefix': String,
+    versions: Boolean,
+    viewer: String,
+    _exit: Boolean
+  };
+  return types$4;
+}
+
+var conf;
+var hasRequiredConf;
+function requireConf() {
+  if (hasRequiredConf) return conf;
+  hasRequiredConf = 1;
+  const {
+    readCAFileSync
+  } = requireDist$j();
+  const fs = require$$0$9;
+  const path = require$$0$c;
+  const {
+    ConfigChain
+  } = requireConfigChain();
+  const envKeyToSetting = requireEnvKeyToSetting();
+  const util = requireUtil$4();
+  class Conf extends ConfigChain {
+    // https://github.com/npm/cli/blob/latest/lib/config/core.js#L203-L217
+    constructor(base, types) {
+      super(base);
+      this.root = base;
+      this._parseField = util.parseField.bind(null, types || requireTypes$4());
+    }
+
+    // https://github.com/npm/cli/blob/latest/lib/config/core.js#L326-L338
+    add(data, marker) {
+      try {
+        for (const [key, value] of Object.entries(data)) {
+          const substKey = util.parseKey(key);
+          if (substKey !== key) {
+            delete data[key];
+          }
+          data[substKey] = this._parseField(value, substKey);
+        }
+      } catch (error) {
+        throw error;
+      }
+      return super.add(data, marker);
+    }
+
+    // https://github.com/npm/cli/blob/latest/lib/config/core.js#L306-L319
+    addFile(file, name) {
+      name = name || file;
+      const marker = {
+        __source__: name
+      };
+      this.sources[name] = {
+        path: file,
+        type: 'ini'
+      };
+      this.push(marker);
+      this._await();
+      try {
+        const contents = fs.readFileSync(file, 'utf8');
+        this.addString(contents, file, 'ini', marker);
+      } catch (error) {
+        if (error.code === 'ENOENT') {
+          this.add({}, marker);
+        } else if (error.code !== 'EISDIR') {
+          return `Issue while reading "${file}". ${error.message}`;
+        }
+      }
+    }
+
+    // https://github.com/npm/cli/blob/latest/lib/config/core.js#L341-L357
+    addEnv(env) {
+      env = env || process.env;
+      const conf = {};
+      Object.keys(env).filter(x => /^npm_config_/i.test(x)).forEach(x => {
+        if (!env[x]) {
+          return;
+        }
+
+        // PNPM patch.
+        // BEGIN
+        const key = envKeyToSetting(x.substr(11));
+        const rawVal = env[x];
+        conf[key] = deserializeEnvVal(key, rawVal);
+        // END
+      });
+      return super.addEnv('', conf, 'env');
+    }
+
+    // https://github.com/npm/cli/blob/latest/lib/config/load-prefix.js
+    loadPrefix() {
+      const cli = this.list[0];
+      Object.defineProperty(this, 'prefix', {
+        enumerable: true,
+        set: prefix => {
+          const g = this.get('global');
+          this[g ? 'globalPrefix' : 'localPrefix'] = prefix;
+        },
+        get: () => {
+          const g = this.get('global');
+          return g ? this.globalPrefix : this.localPrefix;
+        }
+      });
+      Object.defineProperty(this, 'globalPrefix', {
+        enumerable: true,
+        set: prefix => {
+          this.set('prefix', prefix);
+        },
+        get: () => {
+          return path.resolve(this.get('prefix'));
+        }
+      });
+      let p;
+      Object.defineProperty(this, 'localPrefix', {
+        enumerable: true,
+        set: prefix => {
+          p = prefix;
+        },
+        get: () => {
+          return p;
+        }
+      });
+      if (Object.prototype.hasOwnProperty.call(cli, 'prefix')) {
+        p = path.resolve(cli.prefix);
+      } else {
+        try {
+          const prefix = util.findPrefix(process.cwd());
+          p = prefix;
+        } catch (error) {
+          throw error;
+        }
+      }
+      return p;
+    }
+
+    // https://github.com/npm/cli/blob/latest/lib/config/load-cafile.js
+    loadCAFile(file) {
+      if (!file) {
+        return;
+      }
+      const ca = readCAFileSync(file);
+      if (ca) {
+        this.set('ca', ca);
+      }
+    }
+
+    // https://github.com/npm/cli/blob/latest/lib/config/set-user.js
+    loadUser() {
+      const defConf = this.root;
+      if (this.get('global')) {
+        return;
+      }
+      if (process.env.SUDO_UID) {
+        defConf.user = Number(process.env.SUDO_UID);
+        return;
+      }
+      const prefix = path.resolve(this.get('prefix'));
+      try {
+        const stats = fs.statSync(prefix);
+        defConf.user = stats.uid;
+      } catch (error) {
+        if (error.code === 'ENOENT') {
+          return;
+        }
+        throw error;
+      }
+    }
+  }
+
+  // PNPM patch.
+  // BEGIN
+  function deserializeEnvVal(envKey, envValue) {
+    function deserializeList(envValue) {
+      const npmConfigSep = '\n\n';
+      if (envValue.indexOf(npmConfigSep)) {
+        // Supports NPM config serialization format. See:
+        // https://docs.npmjs.com/cli/v10/using-npm/config#ca
+        // https://github.com/npm/cli/blob/v10.0.0/workspaces/config/lib/set-envs.js#L15
+        return envValue.split(npmConfigSep);
+      }
+      return envValue.split(',');
+    }
+    switch (envKey) {
+      case 'hoist-pattern':
+      case 'public-hoist-pattern':
+        return deserializeList(envValue);
+    }
+    return envValue;
+  }
+  // END
+
+  conf = Conf;
+  return conf;
+}
+
+var defaults$1 = {};
+
+var hasRequiredDefaults$1;
+function requireDefaults$1() {
+  if (hasRequiredDefaults$1) return defaults$1;
+  hasRequiredDefaults$1 = 1;
+  (function (exports) {
+
+    const os = require$$0$e;
+    const path = require$$0$c;
+    const temp = os.tmpdir();
+    const uidOrPid = process.getuid ? process.getuid() : process.pid;
+    const hasUnicode = () => true;
+    const isWindows = process.platform === 'win32';
+    const osenv = {
+      editor: () => process.env.EDITOR || process.env.VISUAL || (isWindows ? 'notepad.exe' : 'vi'),
+      shell: () => isWindows ? process.env.COMSPEC || 'cmd.exe' : process.env.SHELL || '/bin/bash'
+    };
+    const umask = {
+      fromString: () => process.umask()
+    };
+    let home = os.homedir();
+    if (home) {
+      process.env.HOME = home;
+    } else {
+      home = path.resolve(temp, 'npm-' + uidOrPid);
+    }
+    const cacheExtra = process.platform === 'win32' ? 'npm-cache' : '.npm';
+    const cacheRoot = process.platform === 'win32' && process.env.APPDATA || home;
+    const cache = path.resolve(cacheRoot, cacheExtra);
+    let defaults;
+    let globalPrefix;
+    Object.defineProperty(exports, 'defaults', {
+      get: function () {
+        if (defaults) return defaults;
+        if (process.env.PREFIX) {
+          globalPrefix = process.env.PREFIX;
+        } else if (process.platform === 'win32') {
+          // c:\node\node.exe --> prefix=c:\node\
+          globalPrefix = path.dirname(process.execPath);
+        } else {
+          // /usr/local/bin/node --> prefix=/usr/local
+          globalPrefix = path.dirname(path.dirname(process.execPath)); // destdir only is respected on Unix
+
+          if (process.env.DESTDIR) {
+            globalPrefix = path.join(process.env.DESTDIR, globalPrefix);
+          }
+        }
+        defaults = {
+          access: null,
+          'allow-same-version': false,
+          'always-auth': false,
+          also: null,
+          audit: true,
+          'auth-type': 'legacy',
+          'bin-links': true,
+          browser: null,
+          ca: null,
+          cafile: null,
+          cache: cache,
+          'cache-lock-stale': 60000,
+          'cache-lock-retries': 10,
+          'cache-lock-wait': 10000,
+          'cache-max': Infinity,
+          'cache-min': 10,
+          cert: null,
+          cidr: null,
+          color: process.env.NO_COLOR == null,
+          depth: Infinity,
+          description: true,
+          dev: false,
+          'dry-run': false,
+          editor: osenv.editor(),
+          'engine-strict': false,
+          force: false,
+          'fetch-retries': 2,
+          'fetch-retry-factor': 10,
+          'fetch-retry-mintimeout': 10000,
+          'fetch-retry-maxtimeout': 60000,
+          git: 'git',
+          'git-tag-version': true,
+          'commit-hooks': true,
+          global: false,
+          globalconfig: path.resolve(globalPrefix, 'etc', 'npmrc'),
+          'global-style': false,
+          group: process.platform === 'win32' ? 0 : process.env.SUDO_GID || process.getgid && process.getgid(),
+          'ham-it-up': false,
+          heading: 'npm',
+          'if-present': false,
+          'ignore-prepublish': false,
+          'ignore-scripts': false,
+          'init-module': path.resolve(home, '.npm-init.js'),
+          'init-author-name': '',
+          'init-author-email': '',
+          'init-author-url': '',
+          'init-version': '1.0.0',
+          'init-license': 'ISC',
+          json: false,
+          key: null,
+          'legacy-bundling': false,
+          link: false,
+          'local-address': undefined,
+          loglevel: 'notice',
+          logstream: process.stderr,
+          'logs-max': 10,
+          long: false,
+          maxsockets: 50,
+          message: '%s',
+          'metrics-registry': null,
+          'node-options': null,
+          // We remove node-version to fix the issue described here: https://github.com/pnpm/pnpm/issues/4203#issuecomment-1133872769
+          'offline': false,
+          'onload-script': false,
+          only: null,
+          optional: true,
+          otp: null,
+          'package-lock': true,
+          'package-lock-only': false,
+          parseable: false,
+          'prefer-offline': false,
+          'prefer-online': false,
+          prefix: globalPrefix,
+          production: process.env.NODE_ENV === 'production',
+          'progress': !process.env.TRAVIS && !process.env.CI,
+          provenance: false,
+          proxy: null,
+          'https-proxy': null,
+          'no-proxy': null,
+          'user-agent': 'npm/{npm-version} ' + 'node/{node-version} ' + '{platform} ' + '{arch}',
+          'read-only': false,
+          'rebuild-bundle': true,
+          registry: 'https://registry.npmjs.org/',
+          rollback: true,
+          save: true,
+          'save-bundle': false,
+          'save-dev': false,
+          'save-exact': false,
+          'save-optional': false,
+          'save-prefix': '^',
+          'save-prod': false,
+          scope: '',
+          'script-shell': null,
+          'scripts-prepend-node-path': 'warn-only',
+          searchopts: '',
+          searchexclude: null,
+          searchlimit: 20,
+          searchstaleness: 15 * 60,
+          'send-metrics': false,
+          shell: osenv.shell(),
+          shrinkwrap: true,
+          'sign-git-tag': false,
+          'sso-poll-frequency': 500,
+          'sso-type': 'oauth',
+          'strict-ssl': true,
+          tag: 'latest',
+          'tag-version-prefix': 'v',
+          timing: false,
+          tmp: temp,
+          unicode: hasUnicode(),
+          'unsafe-perm': process.platform === 'win32' || process.platform === 'cygwin' || !(process.getuid && process.setuid && process.getgid && process.setgid) || process.getuid() !== 0,
+          usage: false,
+          user: process.platform === 'win32' ? 0 : 'nobody',
+          userconfig: path.resolve(home, '.npmrc'),
+          umask: process.umask ? process.umask() : umask.fromString('022'),
+          version: false,
+          versions: false,
+          viewer: process.platform === 'win32' ? 'browser' : 'man',
+          _exit: true
+        };
+        return defaults;
+      }
+    });
+  })(defaults$1);
+  return defaults$1;
+}
+
+var hasRequiredNpmConf;
+function requireNpmConf() {
+  if (hasRequiredNpmConf) return npmConf.exports;
+  hasRequiredNpmConf = 1;
+  (function (module) {
+
+    const path = require$$0$c;
+    const Conf = requireConf();
+    const _defaults = requireDefaults$1();
+
+    // https://github.com/npm/cli/blob/latest/lib/config/core.js#L101-L200
+    module.exports = (opts, types, defaults) => {
+      const conf = new Conf(Object.assign({}, _defaults.defaults, defaults), types);
+      conf.add(Object.assign({}, opts), 'cli');
+      const warnings = [];
+      let failedToLoadBuiltInConfig = false;
+      if (require.resolve.paths) {
+        const paths = require.resolve.paths('npm');
+        // Assume that last path in resolve paths is builtin modules directory
+        let npmPath;
+        try {
+          npmPath = require.resolve('npm', {
+            paths: paths.slice(-1)
+          });
+        } catch (error) {
+          // Error will be thrown if module cannot be found.
+          // Update the flag while loading builtin config failed.
+          failedToLoadBuiltInConfig = true;
+        }
+        if (npmPath) {
+          /**
+           *  According to https://github.com/npm/cli/blob/86f5bdb91f7a5971953a5171d32d6eeda6a2e972/lib/npm.js#L258
+           *  and https://github.com/npm/cli/blob/86f5bdb91f7a5971953a5171d32d6eeda6a2e972/lib/config/core.js#L92
+           */
+          warnings.push(conf.addFile(path.resolve(path.dirname(npmPath), '..', 'npmrc'), 'builtin'));
+        }
+      }
+      conf.addEnv();
+      conf.loadPrefix();
+      const projectConf = path.resolve(conf.localPrefix, '.npmrc');
+      const userConf = conf.get('userconfig');
+      if (!conf.get('global') && projectConf !== userConf) {
+        warnings.push(conf.addFile(projectConf, 'project'));
+      } else {
+        conf.add({}, 'project');
+      }
+
+      // TODO: cover with tests that configs from workspace .npmrc have bigger priority
+      // than the ones in userconfig
+      if (conf.get('workspace-prefix') && conf.get('workspace-prefix') !== projectConf) {
+        const workspaceConf = path.resolve(conf.get('workspace-prefix'), '.npmrc');
+        warnings.push(conf.addFile(workspaceConf, 'workspace'));
+      }
+      warnings.push(conf.addFile(conf.get('userconfig'), 'user'));
+      if (conf.get('prefix')) {
+        const etc = path.resolve(conf.get('prefix'), 'etc');
+        conf.root.globalconfig = path.resolve(etc, 'npmrc');
+        conf.root.globalignorefile = path.resolve(etc, 'npmignore');
+      }
+      warnings.push(conf.addFile(conf.get('globalconfig'), 'global'));
+      conf.loadUser();
+      const caFile = conf.get('cafile');
+      if (caFile) {
+        conf.loadCAFile(caFile);
+      }
+      return {
+        config: conf,
+        warnings: warnings.filter(Boolean),
+        failedToLoadBuiltInConfig
+      };
+    };
+    Object.defineProperty(module.exports, 'defaults', {
+      get() {
+        return _defaults.defaults;
+      },
+      enumerable: true
+    });
+  })(npmConf);
+  return npmConf.exports;
+}
+
+var registryAuthToken;
+var hasRequiredRegistryAuthToken;
+function requireRegistryAuthToken() {
+  if (hasRequiredRegistryAuthToken) return registryAuthToken;
+  hasRequiredRegistryAuthToken = 1;
+  const npmConf = requireNpmConf();
+  const tokenKey = ':_authToken';
+  const legacyTokenKey = ':_auth';
+  const userKey = ':username';
+  const passwordKey = ':_password';
+  registryAuthToken = function getRegistryAuthToken() {
+    let checkUrl;
+    let options;
+    if (arguments.length >= 2) {
+      checkUrl = arguments[0];
+      options = Object.assign({}, arguments[1]);
+    } else if (typeof arguments[0] === 'string') {
+      checkUrl = arguments[0];
+    } else {
+      options = Object.assign({}, arguments[0]);
+    }
+    options = options || {};
+    const providedNpmrc = options.npmrc;
+    options.npmrc = (options.npmrc ? {
+      config: {
+        get: key => providedNpmrc[key]
+      }
+    } : npmConf()).config;
+    checkUrl = checkUrl || options.npmrc.get('registry') || npmConf.defaults.registry;
+    return getRegistryAuthInfo(checkUrl, options) || getLegacyAuthInfo(options.npmrc);
+  };
+
+  // https://nodejs.org/api/url.html#urlresolvefrom-to
+  function urlResolve(from, to) {
+    const resolvedUrl = new URL(to, new URL(from.startsWith('//') ? `./${from}` : from, 'resolve://'));
+    if (resolvedUrl.protocol === 'resolve:') {
+      // `from` is a relative URL.
+      const {
+        pathname,
+        search,
+        hash
+      } = resolvedUrl;
+      return pathname + search + hash;
+    }
+    return resolvedUrl.toString();
+  }
+  function getRegistryAuthInfo(checkUrl, options) {
+    let parsed = checkUrl instanceof URL ? checkUrl : new URL(checkUrl.startsWith('//') ? `http:${checkUrl}` : checkUrl);
+    let pathname;
+    while (pathname !== '/' && parsed.pathname !== pathname) {
+      pathname = parsed.pathname || '/';
+      const regUrl = '//' + parsed.host + pathname.replace(/\/$/, '');
+      const authInfo = getAuthInfoForUrl(regUrl, options.npmrc);
+      if (authInfo) {
+        return authInfo;
+      }
+
+      // break if not recursive
+      if (!options.recursive) {
+        return /\/$/.test(checkUrl) ? undefined : getRegistryAuthInfo(new URL('./', parsed), options);
+      }
+      parsed.pathname = urlResolve(normalizePath(pathname), '..') || '/';
+    }
+    return undefined;
+  }
+  function getLegacyAuthInfo(npmrc) {
+    if (!npmrc.get('_auth')) {
+      return undefined;
+    }
+    const token = replaceEnvironmentVariable(npmrc.get('_auth'));
+    return {
+      token: token,
+      type: 'Basic'
+    };
+  }
+  function normalizePath(path) {
+    return path[path.length - 1] === '/' ? path : path + '/';
+  }
+  function getAuthInfoForUrl(regUrl, npmrc) {
+    // try to get bearer token
+    const bearerAuth = getBearerToken(npmrc.get(regUrl + tokenKey) || npmrc.get(regUrl + '/' + tokenKey));
+    if (bearerAuth) {
+      return bearerAuth;
+    }
+
+    // try to get basic token
+    const username = npmrc.get(regUrl + userKey) || npmrc.get(regUrl + '/' + userKey);
+    const password = npmrc.get(regUrl + passwordKey) || npmrc.get(regUrl + '/' + passwordKey);
+    const basicAuth = getTokenForUsernameAndPassword(username, password);
+    if (basicAuth) {
+      return basicAuth;
+    }
+    const basicAuthWithToken = getLegacyAuthToken(npmrc.get(regUrl + legacyTokenKey) || npmrc.get(regUrl + '/' + legacyTokenKey));
+    if (basicAuthWithToken) {
+      return basicAuthWithToken;
+    }
+    return undefined;
+  }
+  function replaceEnvironmentVariable(token) {
+    return token.replace(/^\$\{?([^}]*)\}?$/, function (fullMatch, envVar) {
+      return process.env[envVar];
+    });
+  }
+  function getBearerToken(tok) {
+    if (!tok) {
+      return undefined;
+    }
+
+    // check if bearer token is set as environment variable
+    const token = replaceEnvironmentVariable(tok);
+    return {
+      token: token,
+      type: 'Bearer'
+    };
+  }
+  function getTokenForUsernameAndPassword(username, password) {
+    if (!username || !password) {
+      return undefined;
+    }
+
+    // passwords are base64 encoded, so we need to decode it
+    // See https://github.com/npm/npm/blob/v3.10.6/lib/config/set-credentials-by-uri.js#L26
+    const pass = Buffer.from(replaceEnvironmentVariable(password), 'base64').toString('utf8');
+
+    // a basic auth token is base64 encoded 'username:password'
+    // See https://github.com/npm/npm/blob/v3.10.6/lib/config/get-credentials-by-uri.js#L70
+    const token = Buffer.from(username + ':' + pass, 'utf8').toString('base64');
+
+    // we found a basicToken token so let's exit the loop
+    return {
+      token: token,
+      type: 'Basic',
+      password: pass,
+      username: username
+    };
+  }
+  function getLegacyAuthToken(tok) {
+    if (!tok) {
+      return undefined;
+    }
+
+    // check if legacy auth token is set as environment variable
+    const token = replaceEnvironmentVariable(tok);
+    return {
+      token: token,
+      type: 'Basic'
+    };
+  }
+  return registryAuthToken;
+}
+
+var registryAuthTokenExports = requireRegistryAuthToken();
+
+const toPath = urlOrPath => urlOrPath instanceof URL ? require$$0$6.fileURLToPath(urlOrPath) : urlOrPath;
+function findUpSync(name, {
+  cwd = process$2.cwd(),
+  type = 'file',
+  stopAt
+} = {}) {
+  let directory = path$2.resolve(toPath(cwd) ?? '');
+  const {
+    root
+  } = path$2.parse(directory);
+  stopAt = path$2.resolve(directory, toPath(stopAt) ?? root);
+  const isAbsoluteName = path$2.isAbsolute(name);
+  while (directory) {
+    const filePath = isAbsoluteName ? name : path$2.join(directory, name);
+    try {
+      const stats = fs$1.statSync(filePath, {
+        throwIfNoEntry: false
+      });
+      if (type === 'file' && stats?.isFile() || type === 'directory' && stats?.isDirectory()) {
+        return filePath;
+      }
+    } catch {}
+    if (directory === stopAt || directory === root) {
+      break;
+    }
+    directory = path$2.dirname(directory);
+  }
+}
+
+var ini;
+var hasRequiredIni;
+function requireIni() {
+  if (hasRequiredIni) return ini;
+  hasRequiredIni = 1;
+  const {
+    hasOwnProperty
+  } = Object.prototype;
+  const encode = (obj, opt = {}) => {
+    if (typeof opt === 'string') {
+      opt = {
+        section: opt
+      };
+    }
+    opt.align = opt.align === true;
+    opt.newline = opt.newline === true;
+    opt.sort = opt.sort === true;
+    opt.whitespace = opt.whitespace === true || opt.align === true;
+    // The `typeof` check is required because accessing the `process` directly fails on browsers.
+    /* istanbul ignore next */
+    opt.platform = opt.platform || typeof process !== 'undefined' && process.platform;
+    opt.bracketedArray = opt.bracketedArray !== false;
+
+    /* istanbul ignore next */
+    const eol = opt.platform === 'win32' ? '\r\n' : '\n';
+    const separator = opt.whitespace ? ' = ' : '=';
+    const children = [];
+    const keys = opt.sort ? Object.keys(obj).sort() : Object.keys(obj);
+    let padToChars = 0;
+    // If aligning on the separator, then padToChars is determined as follows:
+    // 1. Get the keys
+    // 2. Exclude keys pointing to objects unless the value is null or an array
+    // 3. Add `[]` to array keys
+    // 4. Ensure non empty set of keys
+    // 5. Reduce the set to the longest `safe` key
+    // 6. Get the `safe` length
+    if (opt.align) {
+      padToChars = safe(keys.filter(k => obj[k] === null || Array.isArray(obj[k]) || typeof obj[k] !== 'object').map(k => Array.isArray(obj[k]) ? `${k}[]` : k).concat(['']).reduce((a, b) => safe(a).length >= safe(b).length ? a : b)).length;
+    }
+    let out = '';
+    const arraySuffix = opt.bracketedArray ? '[]' : '';
+    for (const k of keys) {
+      const val = obj[k];
+      if (val && Array.isArray(val)) {
+        for (const item of val) {
+          out += safe(`${k}${arraySuffix}`).padEnd(padToChars, ' ') + separator + safe(item) + eol;
+        }
+      } else if (val && typeof val === 'object') {
+        children.push(k);
+      } else {
+        out += safe(k).padEnd(padToChars, ' ') + separator + safe(val) + eol;
+      }
+    }
+    if (opt.section && out.length) {
+      out = '[' + safe(opt.section) + ']' + (opt.newline ? eol + eol : eol) + out;
+    }
+    for (const k of children) {
+      const nk = splitSections(k, '.').join('\\.');
+      const section = (opt.section ? opt.section + '.' : '') + nk;
+      const child = encode(obj[k], {
+        ...opt,
+        section
+      });
+      if (out.length && child.length) {
+        out += eol;
+      }
+      out += child;
+    }
+    return out;
+  };
+  function splitSections(str, separator) {
+    var lastMatchIndex = 0;
+    var lastSeparatorIndex = 0;
+    var nextIndex = 0;
+    var sections = [];
+    do {
+      nextIndex = str.indexOf(separator, lastMatchIndex);
+      if (nextIndex !== -1) {
+        lastMatchIndex = nextIndex + separator.length;
+        if (nextIndex > 0 && str[nextIndex - 1] === '\\') {
+          continue;
+        }
+        sections.push(str.slice(lastSeparatorIndex, nextIndex));
+        lastSeparatorIndex = nextIndex + separator.length;
+      }
+    } while (nextIndex !== -1);
+    sections.push(str.slice(lastSeparatorIndex));
+    return sections;
+  }
+  const decode = (str, opt = {}) => {
+    opt.bracketedArray = opt.bracketedArray !== false;
+    const out = Object.create(null);
+    let p = out;
+    let section = null;
+    //          section          |key      = value
+    const re = /^\[([^\]]*)\]\s*$|^([^=]+)(=(.*))?$/i;
+    const lines = str.split(/[\r\n]+/g);
+    const duplicates = {};
+    for (const line of lines) {
+      if (!line || line.match(/^\s*[;#]/) || line.match(/^\s*$/)) {
+        continue;
+      }
+      const match = line.match(re);
+      if (!match) {
+        continue;
+      }
+      if (match[1] !== undefined) {
+        section = unsafe(match[1]);
+        if (section === '__proto__') {
+          // not allowed
+          // keep parsing the section, but don't attach it.
+          p = Object.create(null);
+          continue;
+        }
+        p = out[section] = out[section] || Object.create(null);
+        continue;
+      }
+      const keyRaw = unsafe(match[2]);
+      let isArray;
+      if (opt.bracketedArray) {
+        isArray = keyRaw.length > 2 && keyRaw.slice(-2) === '[]';
+      } else {
+        duplicates[keyRaw] = (duplicates?.[keyRaw] || 0) + 1;
+        isArray = duplicates[keyRaw] > 1;
+      }
+      const key = isArray && keyRaw.endsWith('[]') ? keyRaw.slice(0, -2) : keyRaw;
+      if (key === '__proto__') {
+        continue;
+      }
+      const valueRaw = match[3] ? unsafe(match[4]) : true;
+      const value = valueRaw === 'true' || valueRaw === 'false' || valueRaw === 'null' ? JSON.parse(valueRaw) : valueRaw;
+
+      // Convert keys with '[]' suffix to an array
+      if (isArray) {
+        if (!hasOwnProperty.call(p, key)) {
+          p[key] = [];
+        } else if (!Array.isArray(p[key])) {
+          p[key] = [p[key]];
+        }
+      }
+
+      // safeguard against resetting a previously defined
+      // array by accidentally forgetting the brackets
+      if (Array.isArray(p[key])) {
+        p[key].push(value);
+      } else {
+        p[key] = value;
+      }
+    }
+
+    // {a:{y:1},"a.b":{x:2}} --> {a:{y:1,b:{x:2}}}
+    // use a filter to return the keys that have to be deleted.
+    const remove = [];
+    for (const k of Object.keys(out)) {
+      if (!hasOwnProperty.call(out, k) || typeof out[k] !== 'object' || Array.isArray(out[k])) {
+        continue;
+      }
+
+      // see if the parent section is also an object.
+      // if so, add it to that, and mark this one for deletion
+      const parts = splitSections(k, '.');
+      p = out;
+      const l = parts.pop();
+      const nl = l.replace(/\\\./g, '.');
+      for (const part of parts) {
+        if (part === '__proto__') {
+          continue;
+        }
+        if (!hasOwnProperty.call(p, part) || typeof p[part] !== 'object') {
+          p[part] = Object.create(null);
+        }
+        p = p[part];
+      }
+      if (p === out && nl === l) {
+        continue;
+      }
+      p[nl] = out[k];
+      remove.push(k);
+    }
+    for (const del of remove) {
+      delete out[del];
+    }
+    return out;
+  };
+  const isQuoted = val => {
+    return val.startsWith('"') && val.endsWith('"') || val.startsWith("'") && val.endsWith("'");
+  };
+  const safe = val => {
+    if (typeof val !== 'string' || val.match(/[=\r\n]/) || val.match(/^\[/) || val.length > 1 && isQuoted(val) || val !== val.trim()) {
+      return JSON.stringify(val);
+    }
+    return val.split(';').join('\\;').split('#').join('\\#');
+  };
+  const unsafe = val => {
+    val = (val || '').trim();
+    if (isQuoted(val)) {
+      // remove the single quotes before calling JSON.parse
+      if (val.charAt(0) === "'") {
+        val = val.slice(1, -1);
+      }
+      try {
+        val = JSON.parse(val);
+      } catch {
+        // ignore errors
+      }
+    } else {
+      // walk the val to find the first not-escaped ; character
+      let esc = false;
+      let unesc = '';
+      for (let i = 0, l = val.length; i < l; i++) {
+        const c = val.charAt(i);
+        if (esc) {
+          if ('\\;#'.indexOf(c) !== -1) {
+            unesc += c;
+          } else {
+            unesc += '\\' + c;
+          }
+          esc = false;
+        } else if (';#'.indexOf(c) !== -1) {
+          break;
+        } else if (c === '\\') {
+          esc = true;
+        } else {
+          unesc += c;
+        }
+      }
+      if (esc) {
+        unesc += '\\';
+      }
+      return unesc.trim();
+    }
+    return val;
+  };
+  ini = {
+    parse: decode,
+    decode,
+    stringify: encode,
+    encode,
+    safe,
+    unsafe
+  };
+  return ini;
+}
+
+var iniExports = requireIni();
+
+const defaultUrl = 'https://registry.npmjs.org/';
+const normalize$2 = url => url.endsWith('/') ? url : `${url}/`;
+function registryUrl(scope) {
+  // Lowercased one is priority.
+  // Run `NPM_CONFIG_REGISTRY=foo npm_config_registry=bar npm config get registry` to check.
+  const npmConfigRegistry = process$2.env.npm_config_registry || process$2.env.NPM_CONFIG_REGISTRY;
+
+  // Don't find up for performance.
+  if (npmConfigRegistry && !scope) {
+    return normalize$2(npmConfigRegistry);
+  }
+  const npmRcPath = findUpSync('.npmrc');
+  if (!npmRcPath) {
+    return normalize$2(npmConfigRegistry || defaultUrl);
+  }
+  const content = fs$1.readFileSync(npmRcPath, 'utf8');
+  const result = iniExports.parse(content);
+  return normalize$2(result[`${scope}:registry`] || npmConfigRegistry || result.registry || defaultUrl);
+}
+
 /* MAIN */
 const attempt = (fn, fallback) => {
   try {
@@ -8807,9 +11469,22 @@ const compare = (a, b) => {
 /* MAIN */
 const Utils = {
   /* API */
-  fetch: async url => {
+  fetch: async (url, options = {}) => {
+    const {
+      authInfo
+    } = {
+      __proto__: null,
+      ...options
+    };
+    const headers = new Headers({
+      'Accept': 'application/vnd.npm.install-v1+json; q=1.0, application/json; q=0.8, */*'
+    });
+    if (authInfo) {
+      headers.set('Authorization', `${authInfo.type} ${authInfo.token}`);
+    }
     const signal = Utils.getExitSignal();
     const request = await fetch(url, {
+      headers,
       signal
     });
     const json = await request.json();
@@ -8820,10 +11495,20 @@ const Utils = {
     whenExit(() => aborter.abort());
     return aborter.signal;
   },
-  getLatestVersion: async name => {
-    const latestUrl = `https://registry.npmjs.org/${name}/latest`;
-    const latest = await Utils.fetch(latestUrl);
-    return latest.version;
+  getLatestVersion: async (name, options = {}) => {
+    const {
+      authInfo,
+      registryUrl = 'https://registry.npmjs.org/'
+    } = {
+      __proto__: null,
+      ...options
+    };
+    const maybeSlash = registryUrl.endsWith('/') ? '' : '/';
+    const latestUrl = `${registryUrl}${maybeSlash}${name}/latest`;
+    const json = await Utils.fetch(latestUrl, {
+      authInfo
+    });
+    return json.version;
   },
   isNumber: value => {
     return typeof value === 'number';
@@ -8875,15 +11560,24 @@ var Store$1 = new Store();
 /* IMPORT */
 /* MAIN */
 //TODO: Account for non-latest releases
-const updater$1 = async ({
-  name,
-  version,
-  ttl = 0
-}) => {
+const updater$1 = async options => {
+  const {
+    authInfo,
+    name,
+    registryUrl,
+    version,
+    ttl = 0
+  } = {
+    __proto__: null,
+    ...options
+  };
   const record = Store$1.get(name);
   const timestamp = Date.now();
   const isFresh = !record || timestamp - record.timestampFetch >= ttl;
-  const latest = isFresh ? await Utils.getLatestVersion(name).catch(Utils.noop) : record?.version;
+  const latest = isFresh ? await Utils.getLatestVersion(name, {
+    authInfo,
+    registryUrl
+  }).catch(Utils.noop) : record?.version;
   if (!latest) return false;
   if (isFresh) {
     const record = {
@@ -8902,36 +11596,6 @@ const updater$1 = async ({
   return true;
 };
 
-function getAugmentedNamespace(n) {
-  if (Object.prototype.hasOwnProperty.call(n, '__esModule')) return n;
-  var f = n.default;
-  var a;
-	if (typeof f == "function") {
-		a = function a () {
-			var isInstance = false;
-      try {
-        isInstance = this instanceof a;
-      } catch {}
-			if (isInstance) {
-        return Reflect.construct(f, arguments, this.constructor);
-			}
-			return f.apply(this, arguments);
-		};
-		a.prototype = f.prototype;
-  } else a = {};
-  Object.defineProperty(a, '__esModule', {value: true});
-	Object.keys(n).forEach(function (k) {
-		var d = Object.getOwnPropertyDescriptor(n, k);
-		Object.defineProperty(a, k, d.get ? d : {
-			enumerable: true,
-			get: function () {
-				return n[k];
-			}
-		});
-	});
-	return a;
-}
-
 var ajv = {exports: {}};
 
 var core$2 = {};
@@ -18234,7 +20898,7 @@ var hasRequiredLog;
 function requireLog() {
   if (hasRequiredLog) return log;
   hasRequiredLog = 1;
-  var node_process = require$$0$7;
+  var node_process = require$$0$f;
   function debug(logLevel, ...messages) {
     if (logLevel === 'debug') console.log(...messages);
   }
@@ -19158,7 +21822,7 @@ var hasRequiredBinary;
 function requireBinary() {
   if (hasRequiredBinary) return binary$1;
   hasRequiredBinary = 1;
-  var node_buffer = require$$0$8;
+  var node_buffer = require$$0$g;
   var Scalar = requireScalar();
   var stringifyString = requireStringifyString();
   const binary = {
@@ -21738,7 +24402,7 @@ var hasRequiredComposer;
 function requireComposer() {
   if (hasRequiredComposer) return composer;
   hasRequiredComposer = 1;
-  var node_process = require$$0$7;
+  var node_process = require$$0$f;
   var directives = requireDirectives();
   var Document = requireDocument();
   var errors = requireErrors$6();
@@ -23220,7 +25884,7 @@ var hasRequiredParser$1;
 function requireParser$1() {
   if (hasRequiredParser$1) return parser$2;
   hasRequiredParser$1 = 1;
-  var node_process = require$$0$7;
+  var node_process = require$$0$f;
   var cst = requireCst();
   var lexer = requireLexer();
   function includesToken(list, type) {
@@ -25706,7 +28370,7 @@ var hasRequiredFillRange;
 function requireFillRange() {
   if (hasRequiredFillRange) return fillRange;
   hasRequiredFillRange = 1;
-  const util = require$$0$9;
+  const util = require$$0$8;
   const toRegexRange = requireToRegexRange();
   const isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);
   const transform = toNumber => {
@@ -26718,7 +29382,7 @@ var hasRequiredConstants$9;
 function requireConstants$9() {
   if (hasRequiredConstants$9) return constants$9;
   hasRequiredConstants$9 = 1;
-  const path = require$$0$a;
+  const path = require$$0$c;
   const WIN_SLASH = '\\\\/';
   const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
 
@@ -26959,7 +29623,7 @@ function requireUtils$6() {
   hasRequiredUtils$6 = 1;
   (function (exports) {
 
-    const path = require$$0$a;
+    const path = require$$0$c;
     const win32 = process.platform === 'win32';
     const {
       REGEX_BACKSLASH,
@@ -28479,7 +31143,7 @@ var hasRequiredPicomatch$3;
 function requirePicomatch$3() {
   if (hasRequiredPicomatch$3) return picomatch_1$2;
   hasRequiredPicomatch$3 = 1;
-  const path = require$$0$a;
+  const path = require$$0$c;
   const scan = requireScan$2();
   const parse = requireParse$6();
   const utils = requireUtils$6();
@@ -28846,7 +31510,7 @@ var hasRequiredMicromatch;
 function requireMicromatch() {
   if (hasRequiredMicromatch) return micromatch_1;
   hasRequiredMicromatch = 1;
-  const util = require$$0$9;
+  const util = require$$0$8;
   const braces = requireBraces();
   const picomatch = requirePicomatch$2();
   const utils = requireUtils$6();
@@ -29338,7 +32002,7 @@ function requireUtils$5() {
     value: true
   });
   utils$5.normalizePath = utils$5.isRootDirectory = utils$5.convertSlashes = utils$5.cleanPath = void 0;
-  const path_1 = require$$0$a;
+  const path_1 = require$$0$c;
   function cleanPath(path) {
     let normalized = (0, path_1.normalize)(path);
     // we have to remove the last path separator
@@ -29383,7 +32047,7 @@ function requireJoinPath() {
     value: true
   });
   joinPath.build = joinPath.joinDirectoryPath = joinPath.joinPathWithBasePath = void 0;
-  const path_1 = require$$0$a;
+  const path_1 = require$$0$c;
   const utils_1 = requireUtils$5();
   function joinPathWithBasePath(filename, directoryPath) {
     return directoryPath + filename;
@@ -29565,8 +32229,8 @@ function requireResolveSymlink() {
     value: true
   });
   resolveSymlink.build = void 0;
-  const fs_1 = __importDefault(require$$0$b);
-  const path_1 = require$$0$a;
+  const fs_1 = __importDefault(require$$0$9);
+  const path_1 = require$$0$c;
   const resolveSymlinksAsync = function (path, state, callback) {
     const {
       queue,
@@ -29693,7 +32357,7 @@ function requireWalkDirectory() {
     value: true
   });
   walkDirectory.build = void 0;
-  const fs_1 = __importDefault(require$$0$b);
+  const fs_1 = __importDefault(require$$0$9);
   const readdirOpts = {
     withFileTypes: true
   };
@@ -29836,7 +32500,7 @@ function requireWalker$3() {
     value: true
   });
   walker$3.Walker = void 0;
-  const path_1 = require$$0$a;
+  const path_1 = require$$0$c;
   const utils_1 = requireUtils$5();
   const joinPath = __importStar(requireJoinPath());
   const pushDirectory = __importStar(requirePushDirectory());
@@ -32171,7 +34835,7 @@ function requireBuilder() {
     value: true
   });
   builder.Builder = void 0;
-  const path_1 = require$$0$a;
+  const path_1 = require$$0$c;
   const api_builder_1 = requireApiBuilder();
   var pm = null;
   /* c8 ignore next 6 */
@@ -32396,7 +35060,7 @@ function requireDist$f() {
   }) : target, mod));
 
   //#endregion
-  const path = __toESM(require$$0$a);
+  const path = __toESM(require$$0$c);
   const fdir = __toESM(requireDist$g());
   const picomatch = __toESM(/*@__PURE__*/requirePicomatch());
 
@@ -32654,7 +35318,7 @@ var hasRequiredYoctocolorsCjs;
 function requireYoctocolorsCjs() {
   if (hasRequiredYoctocolorsCjs) return yoctocolorsCjs;
   hasRequiredYoctocolorsCjs = 1;
-  const tty = require$$0$c;
+  const tty = require$$0$h;
 
   // eslint-disable-next-line no-warning-comments
   // TODO: Use a better method when it's added to Node.js (https://github.com/nodejs/node/pull/40240)
@@ -32744,7 +35408,7 @@ function requireHpagent() {
   if (hasRequiredHpagent) return hpagent;
   hasRequiredHpagent = 1;
   const https = require$$2$3;
-  const http = require$$1$7;
+  const http = require$$1$8;
   const {
     URL
   } = require$$0$d;
@@ -32888,7 +35552,7 @@ function requireIsInteractive () {
 	  if (_process === undefined) {
 	    // Use non-'node:' prefixed require to avoid Webpack errors.
 	    // eslint-disable-next-line n/prefer-node-protocol
-	    _process = require$$0$7;
+	    _process = require$$0$f;
 	  }
 	  return _process
 	}
@@ -33067,7 +35731,7 @@ function requireDist$e () {
 	Object.defineProperty(dist$e, "__esModule", { value: true });
 	dist$e.SocketSdk = void 0;
 	dist$e.createUserAgentFromPkgJson = createUserAgentFromPkgJson;
-	const node_events_1 = __importDefault(require$$0$e);
+	const node_events_1 = __importDefault(require$$0$i);
 	const node_fs_1 = fs$1;
 	const node_http_1 = __importDefault(require$$2$4);
 	const node_https_1 = __importDefault(require$$3$3);
@@ -38737,8 +41401,8 @@ function requirePosix() {
     value: true
   });
   posix.sync = posix.isexe = void 0;
-  const fs_1 = require$$0$b;
-  const promises_1 = require$$0$f;
+  const fs_1 = require$$0$9;
+  const promises_1 = require$$0$j;
   /**
    * Determine whether a path is executable according to the mode and
    * current (or specified) user and group IDs.
@@ -38810,8 +41474,8 @@ function requireWin32() {
     value: true
   });
   win32.sync = win32.isexe = void 0;
-  const fs_1 = require$$0$b;
-  const promises_1 = require$$0$f;
+  const fs_1 = require$$0$9;
+  const promises_1 = require$$0$j;
   /**
    * Determine whether a path is executable based on the file extension
    * and PATHEXT environment variable (or specified pathExt option)
@@ -38957,7 +41621,7 @@ function requireLib$H() {
     delimiter,
     sep,
     posix
-  } = require$$0$a;
+  } = require$$0$c;
   const isWindows = process.platform === 'win32';
 
   // used to check for slashed in commands passed in. always checks for the posix
@@ -39212,8 +41876,8 @@ var hasRequiredSupportsColor$2;
 function requireSupportsColor$2() {
   if (hasRequiredSupportsColor$2) return supportsColor_1$1;
   hasRequiredSupportsColor$2 = 1;
-  const os = require$$0$g;
-  const tty = require$$1$8;
+  const os = require$$0$e;
+  const tty = require$$1$9;
   const hasFlag = requireHasFlag$1();
   const {
     env
@@ -39451,7 +42115,7 @@ function requireCommonjs$h() {
     value: true
   });
   commonjs$h.walkUp = void 0;
-  const path_1 = require$$0$a;
+  const path_1 = require$$0$c;
   const walkUp = function* (path) {
     for (path = (0, path_1.resolve)(path); path;) {
       yield path;
@@ -39467,250 +42131,6 @@ function requireCommonjs$h() {
   return commonjs$h;
 }
 
-var ini;
-var hasRequiredIni;
-function requireIni() {
-  if (hasRequiredIni) return ini;
-  hasRequiredIni = 1;
-  const {
-    hasOwnProperty
-  } = Object.prototype;
-  const encode = (obj, opt = {}) => {
-    if (typeof opt === 'string') {
-      opt = {
-        section: opt
-      };
-    }
-    opt.align = opt.align === true;
-    opt.newline = opt.newline === true;
-    opt.sort = opt.sort === true;
-    opt.whitespace = opt.whitespace === true || opt.align === true;
-    // The `typeof` check is required because accessing the `process` directly fails on browsers.
-    /* istanbul ignore next */
-    opt.platform = opt.platform || typeof process !== 'undefined' && process.platform;
-    opt.bracketedArray = opt.bracketedArray !== false;
-
-    /* istanbul ignore next */
-    const eol = opt.platform === 'win32' ? '\r\n' : '\n';
-    const separator = opt.whitespace ? ' = ' : '=';
-    const children = [];
-    const keys = opt.sort ? Object.keys(obj).sort() : Object.keys(obj);
-    let padToChars = 0;
-    // If aligning on the separator, then padToChars is determined as follows:
-    // 1. Get the keys
-    // 2. Exclude keys pointing to objects unless the value is null or an array
-    // 3. Add `[]` to array keys
-    // 4. Ensure non empty set of keys
-    // 5. Reduce the set to the longest `safe` key
-    // 6. Get the `safe` length
-    if (opt.align) {
-      padToChars = safe(keys.filter(k => obj[k] === null || Array.isArray(obj[k]) || typeof obj[k] !== 'object').map(k => Array.isArray(obj[k]) ? `${k}[]` : k).concat(['']).reduce((a, b) => safe(a).length >= safe(b).length ? a : b)).length;
-    }
-    let out = '';
-    const arraySuffix = opt.bracketedArray ? '[]' : '';
-    for (const k of keys) {
-      const val = obj[k];
-      if (val && Array.isArray(val)) {
-        for (const item of val) {
-          out += safe(`${k}${arraySuffix}`).padEnd(padToChars, ' ') + separator + safe(item) + eol;
-        }
-      } else if (val && typeof val === 'object') {
-        children.push(k);
-      } else {
-        out += safe(k).padEnd(padToChars, ' ') + separator + safe(val) + eol;
-      }
-    }
-    if (opt.section && out.length) {
-      out = '[' + safe(opt.section) + ']' + (opt.newline ? eol + eol : eol) + out;
-    }
-    for (const k of children) {
-      const nk = splitSections(k, '.').join('\\.');
-      const section = (opt.section ? opt.section + '.' : '') + nk;
-      const child = encode(obj[k], {
-        ...opt,
-        section
-      });
-      if (out.length && child.length) {
-        out += eol;
-      }
-      out += child;
-    }
-    return out;
-  };
-  function splitSections(str, separator) {
-    var lastMatchIndex = 0;
-    var lastSeparatorIndex = 0;
-    var nextIndex = 0;
-    var sections = [];
-    do {
-      nextIndex = str.indexOf(separator, lastMatchIndex);
-      if (nextIndex !== -1) {
-        lastMatchIndex = nextIndex + separator.length;
-        if (nextIndex > 0 && str[nextIndex - 1] === '\\') {
-          continue;
-        }
-        sections.push(str.slice(lastSeparatorIndex, nextIndex));
-        lastSeparatorIndex = nextIndex + separator.length;
-      }
-    } while (nextIndex !== -1);
-    sections.push(str.slice(lastSeparatorIndex));
-    return sections;
-  }
-  const decode = (str, opt = {}) => {
-    opt.bracketedArray = opt.bracketedArray !== false;
-    const out = Object.create(null);
-    let p = out;
-    let section = null;
-    //          section          |key      = value
-    const re = /^\[([^\]]*)\]\s*$|^([^=]+)(=(.*))?$/i;
-    const lines = str.split(/[\r\n]+/g);
-    const duplicates = {};
-    for (const line of lines) {
-      if (!line || line.match(/^\s*[;#]/) || line.match(/^\s*$/)) {
-        continue;
-      }
-      const match = line.match(re);
-      if (!match) {
-        continue;
-      }
-      if (match[1] !== undefined) {
-        section = unsafe(match[1]);
-        if (section === '__proto__') {
-          // not allowed
-          // keep parsing the section, but don't attach it.
-          p = Object.create(null);
-          continue;
-        }
-        p = out[section] = out[section] || Object.create(null);
-        continue;
-      }
-      const keyRaw = unsafe(match[2]);
-      let isArray;
-      if (opt.bracketedArray) {
-        isArray = keyRaw.length > 2 && keyRaw.slice(-2) === '[]';
-      } else {
-        duplicates[keyRaw] = (duplicates?.[keyRaw] || 0) + 1;
-        isArray = duplicates[keyRaw] > 1;
-      }
-      const key = isArray && keyRaw.endsWith('[]') ? keyRaw.slice(0, -2) : keyRaw;
-      if (key === '__proto__') {
-        continue;
-      }
-      const valueRaw = match[3] ? unsafe(match[4]) : true;
-      const value = valueRaw === 'true' || valueRaw === 'false' || valueRaw === 'null' ? JSON.parse(valueRaw) : valueRaw;
-
-      // Convert keys with '[]' suffix to an array
-      if (isArray) {
-        if (!hasOwnProperty.call(p, key)) {
-          p[key] = [];
-        } else if (!Array.isArray(p[key])) {
-          p[key] = [p[key]];
-        }
-      }
-
-      // safeguard against resetting a previously defined
-      // array by accidentally forgetting the brackets
-      if (Array.isArray(p[key])) {
-        p[key].push(value);
-      } else {
-        p[key] = value;
-      }
-    }
-
-    // {a:{y:1},"a.b":{x:2}} --> {a:{y:1,b:{x:2}}}
-    // use a filter to return the keys that have to be deleted.
-    const remove = [];
-    for (const k of Object.keys(out)) {
-      if (!hasOwnProperty.call(out, k) || typeof out[k] !== 'object' || Array.isArray(out[k])) {
-        continue;
-      }
-
-      // see if the parent section is also an object.
-      // if so, add it to that, and mark this one for deletion
-      const parts = splitSections(k, '.');
-      p = out;
-      const l = parts.pop();
-      const nl = l.replace(/\\\./g, '.');
-      for (const part of parts) {
-        if (part === '__proto__') {
-          continue;
-        }
-        if (!hasOwnProperty.call(p, part) || typeof p[part] !== 'object') {
-          p[part] = Object.create(null);
-        }
-        p = p[part];
-      }
-      if (p === out && nl === l) {
-        continue;
-      }
-      p[nl] = out[k];
-      remove.push(k);
-    }
-    for (const del of remove) {
-      delete out[del];
-    }
-    return out;
-  };
-  const isQuoted = val => {
-    return val.startsWith('"') && val.endsWith('"') || val.startsWith("'") && val.endsWith("'");
-  };
-  const safe = val => {
-    if (typeof val !== 'string' || val.match(/[=\r\n]/) || val.match(/^\[/) || val.length > 1 && isQuoted(val) || val !== val.trim()) {
-      return JSON.stringify(val);
-    }
-    return val.split(';').join('\\;').split('#').join('\\#');
-  };
-  const unsafe = val => {
-    val = (val || '').trim();
-    if (isQuoted(val)) {
-      // remove the single quotes before calling JSON.parse
-      if (val.charAt(0) === "'") {
-        val = val.slice(1, -1);
-      }
-      try {
-        val = JSON.parse(val);
-      } catch {
-        // ignore errors
-      }
-    } else {
-      // walk the val to find the first not-escaped ; character
-      let esc = false;
-      let unesc = '';
-      for (let i = 0, l = val.length; i < l; i++) {
-        const c = val.charAt(i);
-        if (esc) {
-          if ('\\;#'.indexOf(c) !== -1) {
-            unesc += c;
-          } else {
-            unesc += '\\' + c;
-          }
-          esc = false;
-        } else if (';#'.indexOf(c) !== -1) {
-          break;
-        } else if (c === '\\') {
-          esc = true;
-        } else {
-          unesc += c;
-        }
-      }
-      if (esc) {
-        unesc += '\\';
-      }
-      return unesc.trim();
-    }
-    return val;
-  };
-  ini = {
-    parse: decode,
-    decode,
-    stringify: encode,
-    encode,
-    safe,
-    unsafe
-  };
-  return ini;
-}
-
 var nopt = {exports: {}};
 
 var lib$G;
@@ -39789,9 +42209,9 @@ function requireTypeDefs$1() {
   if (hasRequiredTypeDefs$1) return typeDefs$1;
   hasRequiredTypeDefs$1 = 1;
   const url = require$$0$d;
-  const path = require$$0$a;
-  const Stream = require$$1$9.Stream;
-  const os = require$$0$g;
+  const path = require$$0$c;
+  const Stream = require$$1$7.Stream;
+  const os = require$$0$e;
   const debug = requireDebug$2();
   function validateString(data, k, val) {
     data[k] = String(val);
@@ -47663,7 +50083,7 @@ function requireCommonjs$d() {
       stdout: null,
       stderr: null
     };
-    const node_events_1 = require$$0$e;
+    const node_events_1 = require$$0$i;
     const node_stream_1 = __importDefault(require$$1$a);
     const node_string_decoder_1 = require$$2$5;
     /**
@@ -48615,7 +51035,7 @@ function requireCommonjs$c() {
   const lru_cache_1 = /*@__PURE__*/requireCommonjs$e();
   const node_path_1 = path$2;
   const node_url_1 = require$$0$6;
-  const fs_1 = require$$0$b;
+  const fs_1 = require$$0$9;
   const actualFS = __importStar(fs$1);
   const realpathSync = fs_1.realpathSync.native;
   // TODO: test perf of fs/promises realpath vs realpathCB,
@@ -51952,8 +54372,8 @@ function requireLib$C() {
   hasRequiredLib$C = 1;
   const {
     spawn
-  } = require$$0$h;
-  const os = require$$0$g;
+  } = require$$0$k;
+  const os = require$$0$e;
   const which = requireLib$H();
   const escape = require_escape();
 
@@ -56117,7 +58537,7 @@ function requireLib$B() {
   hasRequiredLib$B = 1;
   const {
     builtinModules: builtins
-  } = require$$0$i;
+  } = require$$0$l;
   var scopedPackagePattern = new RegExp('^(?:@([^/]+?)[/])?([^/]+?)$');
   var blacklist = ['node_modules', 'favicon.ico'];
   function validate(name) {
@@ -56963,7 +59383,7 @@ function requireLib$z() {
   const {
     join,
     basename
-  } = require$$0$a;
+  } = require$$0$c;
   const normalize = pkg => !pkg.bin ? removeBin(pkg) : typeof pkg.bin === 'string' ? normalizeString(pkg) : Array.isArray(pkg.bin) ? normalizeArray(pkg) : typeof pkg.bin === 'object' ? normalizeObject(pkg) : removeBin(pkg);
   const normalizeString = pkg => {
     if (!pkg.name) {
@@ -57239,14 +59659,14 @@ function requireClone() {
   const {
     parse
   } = require$$0$d; // eslint-disable-line node/no-deprecated-api
-  const path = require$$0$a;
+  const path = require$$0$c;
   const getRevs = requireRevs();
   const spawn = requireSpawn();
   const {
     isWindows
   } = requireUtils$3();
   const pickManifest = requireLib$y();
-  const fs = require$$0$f;
+  const fs = require$$0$j;
   clone_1 = (repo, ref = 'HEAD', target = null, opts = {}) => getRevs(repo, opts).then(revs => clone(repo, revs, ref, resolveRef(revs, ref, opts), target || defaultTarget(repo, opts.cwd), opts));
   const maybeShallow = (repo, opts) => {
     if (opts.gitShallow === false || opts.gitShallow) {
@@ -57363,7 +59783,7 @@ function requireIs() {
   // not an airtight indicator, but a good gut-check to even bother trying
   const {
     stat
-  } = require$$0$f;
+  } = require$$0$j;
   is = ({
     cwd = process.cwd()
   } = {}) => stat(cwd + '/.git').then(() => true, () => false);
@@ -57378,7 +59798,7 @@ function requireFind() {
   const is = requireIs();
   const {
     dirname
-  } = require$$0$a;
+  } = require$$0$c;
   find = async ({
     cwd = process.cwd(),
     root
@@ -59651,7 +62071,7 @@ function requireReadPackage() {
 
   const {
     readFile
-  } = require$$0$f;
+  } = require$$0$j;
   const parseJSON = requireLib$E();
   async function read(filename) {
     try {
@@ -60117,7 +62537,7 @@ function requireLib$v() {
   const {
     basename,
     dirname
-  } = require$$0$a;
+  } = require$$0$c;
   const getName = (parent, base) => parent.charAt(0) === '@' ? `${parent}/${base}` : base;
   lib$v = dir => dir ? getName(basename(dirname(dir)), basename(dir)) : false;
   return lib$v;
@@ -61685,7 +64105,7 @@ function requireCommonjs$8() {
   const lru_cache_1 = /*@__PURE__*/requireCommonjs$9();
   const node_path_1 = path$2;
   const node_url_1 = require$$0$6;
-  const fs_1 = require$$0$b;
+  const fs_1 = require$$0$9;
   const actualFS = __importStar(fs$1);
   const realpathSync = fs_1.realpathSync.native;
   // TODO: test perf of fs/promises realpath vs realpathCB,
@@ -64954,7 +67374,7 @@ var hasRequiredLib$u;
 function requireLib$u() {
   if (hasRequiredLib$u) return lib$u;
   hasRequiredLib$u = 1;
-  const path = require$$0$a;
+  const path = require$$0$c;
   const getName = requireLib$v();
   const {
     minimatch
@@ -70038,7 +72458,7 @@ function requireLib$s() {
     readFile,
     lstat,
     readdir
-  } = require$$0$f;
+  } = require$$0$j;
   const parse = requireLib$E();
   const normalizePackageBin = requireLib$z();
   const {
@@ -70046,7 +72466,7 @@ function requireLib$s() {
     dirname,
     join,
     relative
-  } = require$$0$a;
+  } = require$$0$c;
   const rpj = path => readFile(path, 'utf8').then(data => readBinDir(path, normalize(stripUnderscores(parse(data))))).catch(er => {
     er.path = path;
     throw er;
@@ -70195,7 +72615,7 @@ function requireGetNodeModules() {
   const {
     dirname,
     basename
-  } = require$$0$a;
+  } = require$$0$c;
   // this gets called a lot and can't change, so memoize it
   const memo = new Map();
   getNodeModules = path => {
@@ -70217,7 +72637,7 @@ function requireGetPrefix() {
   hasRequiredGetPrefix = 1;
   const {
     dirname
-  } = require$$0$a;
+  } = require$$0$c;
   const getNodeModules = requireGetNodeModules();
   getPrefix = path => dirname(getNodeModules(path));
   return getPrefix;
@@ -70233,7 +72653,7 @@ function requireBinTarget() {
   const getNodeModules = requireGetNodeModules();
   const {
     dirname
-  } = require$$0$a;
+  } = require$$0$c;
   binTarget = ({
     top,
     path
@@ -70317,11 +72737,11 @@ function requireLib$r() {
     stat,
     unlink,
     writeFile
-  } = require$$0$f;
+  } = require$$0$j;
   const {
     dirname,
     relative
-  } = require$$0$a;
+  } = require$$0$c;
   const toBatchSyntax = requireToBatchSyntax();
   // linting disabled because this regex is really long
   // eslint-disable-next-line max-len
@@ -70465,10 +72885,10 @@ var hasRequiredLib$q;
 function requireLib$q() {
   if (hasRequiredLib$q) return lib$q;
   hasRequiredLib$q = 1;
-  const fs = require$$0$b;
+  const fs = require$$0$9;
   const {
     promisify
-  } = require$$0$9;
+  } = require$$0$8;
   const {
     readFileSync
   } = fs;
@@ -71016,15 +73436,15 @@ function requireLib$p() {
   lib$p.exports.sync = writeFileSync;
   lib$p.exports._getTmpname = getTmpname; // for testing
   lib$p.exports._cleanupOnExit = cleanupOnExit;
-  const fs = require$$0$b;
+  const fs = require$$0$9;
   const MurmurHash3 = requireImurmurhash();
   const {
     onExit
   } = requireCjs();
-  const path = require$$0$a;
+  const path = require$$0$c;
   const {
     promisify
-  } = require$$0$9;
+  } = require$$0$8;
   const activeFiles = {};
 
   // if we run inside of a worker_thread, `process.pid` is not unique
@@ -71270,7 +73690,7 @@ function requireFixBin() {
     chmod,
     open,
     readFile
-  } = require$$0$f;
+  } = require$$0$j;
   const execMode = 0o777 & ~process.umask();
   const writeFileAtomic = requireLib$p();
   const isWindowsHashBang = buf => buf[0] === '#'.charCodeAt(0) && buf[1] === '!'.charCodeAt(0) && /^#![^\n]+\r\n/.test(buf.toString());
@@ -71300,10 +73720,10 @@ function requireShimBin() {
   const {
     resolve,
     dirname
-  } = require$$0$a;
+  } = require$$0$c;
   const {
     lstat
-  } = require$$0$f;
+  } = require$$0$j;
   const throwNonEnoent = er => {
     if (er.code !== 'ENOENT') {
       throw er;
@@ -71403,14 +73823,14 @@ function requireLinkGently() {
   const {
     resolve,
     dirname
-  } = require$$0$a;
+  } = require$$0$c;
   const {
     lstat,
     mkdir,
     readlink,
     rm,
     symlink
-  } = require$$0$f;
+  } = require$$0$j;
   const {
     log
   } = requireLib$F();
@@ -71541,7 +73961,7 @@ function requireLinkBins() {
     dirname,
     resolve,
     relative
-  } = require$$0$a;
+  } = require$$0$c;
   const linkBin = isWindows ? requireShimBin() : requireLinkBin();
   const normalize = requireLib$z();
   const linkBins = ({
@@ -71586,7 +74006,7 @@ function requireManTarget() {
   const getPrefix = requireGetPrefix();
   const {
     dirname
-  } = require$$0$a;
+  } = require$$0$c;
   manTarget = ({
     top,
     path
@@ -71605,7 +74025,7 @@ function requireLinkMans() {
     join,
     resolve,
     basename
-  } = require$$0$a;
+  } = require$$0$c;
   const linkGently = requireLinkGently();
   const manTarget = requireManTarget();
   const linkMans = async ({
@@ -71678,11 +74098,11 @@ function requireCheckBin() {
   const {
     resolve,
     dirname
-  } = require$$0$a;
+  } = require$$0$c;
   const readCmdShim = requireLib$q();
   const {
     readlink
-  } = require$$0$f;
+  } = require$$0$j;
   const checkBin = async ({
     bin,
     path,
@@ -71822,7 +74242,7 @@ function requireGetPaths() {
     resolve,
     basename,
     extname
-  } = require$$0$a;
+  } = require$$0$c;
   const isWindows = requireIsWindows();
   getPaths = ({
     path,
@@ -74024,7 +76444,7 @@ function requireNode$4() {
    * For Node.js, simply re-export the core `util.deprecate` function.
    */
 
-  node$4 = require$$0$9.deprecate;
+  node$4 = require$$0$8.deprecate;
   return node$4;
 }
 
@@ -76844,8 +79264,8 @@ function requireMinipass$5() {
     stdout: null,
     stderr: null
   };
-  const EE = require$$0$j;
-  const Stream = require$$1$9;
+  const EE = require$$0$b;
+  const Stream = require$$1$7;
   const SD = require$$2$7.StringDecoder;
   const EOF = Symbol('EOF');
   const MAYBE_EMIT_END = Symbol('maybeEmitEnd');
@@ -77340,7 +79760,7 @@ function requireMinipassPipeline() {
   if (hasRequiredMinipassPipeline) return minipassPipeline;
   hasRequiredMinipassPipeline = 1;
   const Minipass = requireMinipass$5();
-  const EE = require$$0$j;
+  const EE = require$$0$b;
   const isStream = s => s && s instanceof EE && (typeof s.pipe === 'function' ||
   // readable
   typeof s.write === 'function' && typeof s.end === 'function' // writable
@@ -77456,7 +79876,7 @@ var hasRequiredLib$m;
 function requireLib$m() {
   if (hasRequiredLib$m) return lib$l;
   hasRequiredLib$m = 1;
-  const crypto = require$$0$k;
+  const crypto = require$$0$m;
   const {
     Minipass
   } = requireCommonjs$d();
@@ -77967,7 +80387,7 @@ var hasRequiredLib$k;
 function requireLib$k() {
   if (hasRequiredLib$k) return lib$j;
   hasRequiredLib$k = 1;
-  var path = require$$0$a;
+  var path = require$$0$c;
   var uniqueSlug = requireLib$l();
   lib$j = function (filepath, prefix, uniq) {
     return path.join(filepath, (prefix ? prefix + '-' : '') + uniqueSlug(uniq));
@@ -78001,7 +80421,7 @@ function requirePath() {
   hasRequiredPath = 1;
   const contentVer = require$$8['cache-version'].content;
   const hashToSegments = requireHashToSegments();
-  const path$1 = require$$0$a;
+  const path$1 = require$$0$c;
   const ssri = requireLib$m();
 
   // Current format of content file path:
@@ -78079,7 +80499,7 @@ function requireErrors$3() {
 
     const {
       inspect
-    } = require$$0$9;
+    } = require$$0$8;
 
     // adapted from node's internal/errors
     // https://github.com/nodejs/node/blob/c8a04049/lib/internal/errors.js
@@ -78227,7 +80647,7 @@ function requirePolyfill() {
         ENOTDIR
       }
     }
-  } = require$$0$g;
+  } = require$$0$e;
   const {
     chmod,
     copyFile,
@@ -78239,7 +80659,7 @@ function requirePolyfill() {
     symlink,
     unlink,
     utimes
-  } = require$$0$f;
+  } = require$$0$j;
   const {
     dirname,
     isAbsolute,
@@ -78248,7 +80668,7 @@ function requirePolyfill() {
     resolve,
     sep,
     toNamespacedPath
-  } = require$$0$a;
+  } = require$$0$c;
   const {
     fileURLToPath
   } = require$$0$d;
@@ -78603,7 +81023,7 @@ var hasRequiredCp;
 function requireCp() {
   if (hasRequiredCp) return cp_1;
   hasRequiredCp = 1;
-  const fs = require$$0$f;
+  const fs = require$$0$j;
   const getOptions = requireGetOptions();
   const node = requireNode$3();
   const polyfill = requirePolyfill();
@@ -78632,13 +81052,13 @@ function requireWithTempDir() {
   const {
     join,
     sep
-  } = require$$0$a;
+  } = require$$0$c;
   const getOptions = requireGetOptions();
   const {
     mkdir,
     mkdtemp,
     rm
-  } = require$$0$f;
+  } = require$$0$j;
 
   // create a temp directory, ensure its permissions match its parent, then call
   // the supplied function passing it the path to the directory. clean up after
@@ -78683,10 +81103,10 @@ function requireReaddirScoped() {
   hasRequiredReaddirScoped = 1;
   const {
     readdir
-  } = require$$0$f;
+  } = require$$0$j;
   const {
     join
-  } = require$$0$a;
+  } = require$$0$c;
   const readdirScoped = async dir => {
     const results = [];
     for (const item of await readdir(dir)) {
@@ -78715,8 +81135,8 @@ function requireMoveFile() {
     resolve,
     relative,
     isAbsolute
-  } = require$$0$a;
-  const fs = require$$0$f;
+  } = require$$0$c;
+  const fs = require$$0$j;
   const pathExists = async path => {
     try {
       await fs.access(path);
@@ -78815,7 +81235,7 @@ var hasRequiredEntryIndex;
 function requireEntryIndex() {
   if (hasRequiredEntryIndex) return entryIndex;
   hasRequiredEntryIndex = 1;
-  const crypto = require$$0$k;
+  const crypto = require$$0$m;
   const {
     appendFile,
     mkdir,
@@ -78823,11 +81243,11 @@ function requireEntryIndex() {
     readdir,
     rm,
     writeFile
-  } = require$$0$f;
+  } = require$$0$j;
   const {
     Minipass
   } = requireCommonjs$d();
-  const path = require$$0$a;
+  const path = require$$0$c;
   const ssri = requireLib$m();
   const uniqueFilename = requireLib$k();
   const contentPath = requirePath();
@@ -80733,8 +83153,8 @@ function requireLib$i() {
   const {
     Minipass
   } = requireCommonjs$d();
-  const EE = require$$0$j.EventEmitter;
-  const fs = require$$0$b;
+  const EE = require$$0$b.EventEmitter;
+  const fs = require$$0$9;
   const writev = fs.writev;
   const _autoClose = Symbol('_autoClose');
   const _close = Symbol('_close');
@@ -81117,7 +83537,7 @@ var hasRequiredRead;
 function requireRead() {
   if (hasRequiredRead) return read.exports;
   hasRequiredRead = 1;
-  const fs = require$$0$f;
+  const fs = require$$0$j;
   const fsm = requireLib$i();
   const ssri = requireLib$m();
   const contentPath = requirePath();
@@ -81472,8 +83892,8 @@ function requireMinipass$4() {
     stdout: null,
     stderr: null
   };
-  const EE = require$$0$j;
-  const Stream = require$$1$9;
+  const EE = require$$0$b;
+  const Stream = require$$1$7;
   const SD = require$$2$7.StringDecoder;
   const EOF = Symbol('EOF');
   const MAYBE_EMIT_END = Symbol('maybeEmitEnd');
@@ -82002,9 +84422,9 @@ var hasRequiredWrite;
 function requireWrite() {
   if (hasRequiredWrite) return write.exports;
   hasRequiredWrite = 1;
-  const events = require$$0$j;
+  const events = require$$0$b;
   const contentPath = requirePath();
-  const fs = require$$0$f;
+  const fs = require$$0$j;
   const {
     moveFile
   } = requireLib$j();
@@ -82013,7 +84433,7 @@ function requireWrite() {
   } = requireCommonjs$d();
   const Pipeline = requireMinipassPipeline();
   const Flush = requireMinipassFlush();
-  const path = require$$0$a;
+  const path = require$$0$c;
   const ssri = requireLib$m();
   const uniqueFilename = requireLib$k();
   const fsm = requireLib$i();
@@ -82338,7 +84758,7 @@ function requireCommonjs$5() {
   const lru_cache_1 = /*@__PURE__*/requireCommonjs$6();
   const node_path_1 = path$2;
   const node_url_1 = require$$0$6;
-  const fs_1 = require$$0$b;
+  const fs_1 = require$$0$9;
   const actualFS = __importStar(fs$1);
   const realpathSync = fs_1.realpathSync.native;
   // TODO: test perf of fs/promises realpath vs realpathCB,
@@ -85610,7 +88030,7 @@ function requireGlob() {
   const {
     glob
   } = requireCommonjs$4();
-  const path = require$$0$a;
+  const path = require$$0$c;
   const globify = pattern => pattern.split(path.win32.sep).join(path.posix.sep);
   glob_1 = (path, options) => glob(globify(path), options);
   return glob_1;
@@ -85621,7 +88041,7 @@ var hasRequiredRm$1;
 function requireRm$1() {
   if (hasRequiredRm$1) return rm_1;
   hasRequiredRm$1 = 1;
-  const fs = require$$0$f;
+  const fs = require$$0$j;
   const contentPath = requirePath();
   const {
     hasContent
@@ -85649,11 +88069,11 @@ function requireRm() {
   hasRequiredRm = 1;
   const {
     rm: rm$1
-  } = require$$0$f;
+  } = require$$0$j;
   const glob = requireGlob();
   const index = requireEntryIndex();
   const memo = requireMemoization();
-  const path = require$$0$a;
+  const path = require$$0$c;
   const rmContent = requireRm$1();
   rm.exports = entry;
   rm.exports.entry = entry;
@@ -85694,12 +88114,12 @@ function requireVerify$1() {
     stat,
     truncate,
     writeFile
-  } = require$$0$f;
+  } = require$$0$j;
   const contentPath = requirePath();
   const fsm = requireLib$i();
   const glob = requireGlob();
   const index$1 = requireEntryIndex();
-  const path = require$$0$a;
+  const path = require$$0$c;
   const ssri = requireLib$m();
   const hasOwnProperty = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
   const verifyOpts = opts => ({
@@ -85945,8 +88365,8 @@ function requireTmp() {
   const {
     withTempDir
   } = requireLib$j();
-  const fs = require$$0$f;
-  const path = require$$0$a;
+  const fs = require$$0$j;
+  const path = require$$0$c;
   tmp.mkdir = mktmpdir;
   async function mktmpdir(cache, opts = {}) {
     const {
@@ -86032,9 +88452,9 @@ function requireLib$g() {
   // as the "bundled" argument.  Additionally, packageJsonCache is shared so
   // packlist doesn't have to re-read files already consumed in this pass
 
-  const fs = require$$0$b;
-  const path = require$$0$a;
-  const EE = require$$0$j.EventEmitter;
+  const fs = require$$0$9;
+  const path = require$$0$c;
+  const EE = require$$0$b.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$z();
@@ -86273,12 +88693,12 @@ function requireLib$f() {
     readFile,
     readdir,
     stat
-  } = require$$0$f;
+  } = require$$0$j;
   const {
     resolve,
     basename,
     dirname
-  } = require$$0$a;
+  } = require$$0$c;
   const normalizePackageBin = requireLib$z();
   const readPackage = ({
     path,
@@ -86459,8 +88879,8 @@ function requireMinipass$3() {
     stdout: null,
     stderr: null
   };
-  const EE = require$$0$j;
-  const Stream = require$$1$9;
+  const EE = require$$0$b;
+  const Stream = require$$1$7;
   const stringdecoder = require$$2$7;
   const SD = stringdecoder.StringDecoder;
   const EOF = Symbol('EOF');
@@ -87036,7 +89456,7 @@ function requireConstants$5() {
   // Node v6 didn't export this, so we just hard code the version and rely
   // on all the other hard-coded values from zlib v4736.  When node v6
   // support drops, we can just export the realZlibConstants object.
-  const realZlibConstants = require$$0$l.constants || /* istanbul ignore next */{
+  const realZlibConstants = require$$0$n.constants || /* istanbul ignore next */{
     ZLIB_VERNUM: 4736
   };
   constants$5 = Object.freeze(Object.assign(Object.create(null), {
@@ -87159,8 +89579,8 @@ function requireMinipass$2() {
     stdout: null,
     stderr: null
   };
-  const EE = require$$0$j;
-  const Stream = require$$1$9;
+  const EE = require$$0$b;
+  const Stream = require$$1$7;
   const SD = require$$2$7.StringDecoder;
   const EOF = Symbol('EOF');
   const MAYBE_EMIT_END = Symbol('maybeEmitEnd');
@@ -87653,9 +90073,9 @@ var hasRequiredMinizlib;
 function requireMinizlib() {
   if (hasRequiredMinizlib) return minizlib;
   hasRequiredMinizlib = 1;
-  const assert = require$$0$m;
-  const Buffer = require$$0$8.Buffer;
-  const realZlib = require$$0$l;
+  const assert = require$$0$a;
+  const Buffer = require$$0$g.Buffer;
+  const realZlib = require$$0$n;
   const constants = minizlib.constants = requireConstants$5();
   const Minipass = requireMinipass$2();
   const OriginalBufferConcat = Buffer.concat;
@@ -88224,7 +90644,7 @@ function requireHeader() {
   // (Also, check header.needPax to see if it needs a pax header.)
 
   const types = requireTypes();
-  const pathModule = require$$0$a.posix;
+  const pathModule = require$$0$c.posix;
   const large = requireLargeNumbers();
   const SLURP = Symbol('slurp');
   const TYPE = Symbol('type');
@@ -88467,7 +90887,7 @@ function requirePax() {
   if (hasRequiredPax) return pax;
   hasRequiredPax = 1;
   const Header = requireHeader();
-  const path = require$$0$a;
+  const path = require$$0$c;
   class Pax {
     constructor(obj, global) {
       this.atime = obj.atime || null;
@@ -88656,7 +91076,7 @@ function requireStripAbsolutePath() {
   const {
     isAbsolute,
     parse
-  } = require$$0$a.win32;
+  } = require$$0$c.win32;
 
   // returns [root, stripped]
   // Note that windows will think that //x/y/z/a has a "root" of //x/y, and in
@@ -88724,8 +91144,8 @@ function requireWriteEntry() {
   } = requireMinipass$3();
   const Pax = requirePax();
   const Header = requireHeader();
-  const fs = require$$0$b;
-  const path = require$$0$a;
+  const fs = require$$0$9;
+  const path = require$$0$c;
   const normPath = requireNormalizeWindowsPath();
   const stripSlash = requireStripTrailingSlashes();
   const prefixPath = (path, prefix) => {
@@ -89654,8 +92074,8 @@ function requirePack() {
   const WRITEENTRYCLASS = Symbol('writeEntryClass');
   const WRITE = Symbol('write');
   const ONDRAIN = Symbol('ondrain');
-  const fs = require$$0$b;
-  const path = require$$0$a;
+  const fs = require$$0$9;
+  const path = require$$0$c;
   const warner = requireWarnMixin();
   const normPath = requireNormalizeWindowsPath();
   const Pack = warner(class Pack extends Minipass {
@@ -89998,8 +92418,8 @@ function requireMinipass$1() {
     stdout: null,
     stderr: null
   };
-  const EE = require$$0$j;
-  const Stream = require$$1$9;
+  const EE = require$$0$b;
+  const Stream = require$$1$7;
   const SD = require$$2$7.StringDecoder;
   const EOF = Symbol('EOF');
   const MAYBE_EMIT_END = Symbol('maybeEmitEnd');
@@ -90493,8 +92913,8 @@ function requireFsMinipass() {
   if (hasRequiredFsMinipass) return fsMinipass;
   hasRequiredFsMinipass = 1;
   const MiniPass = requireMinipass$1();
-  const EE = require$$0$j.EventEmitter;
-  const fs = require$$0$b;
+  const EE = require$$0$b.EventEmitter;
+  const fs = require$$0$9;
   let writev = fs.writev;
   /* istanbul ignore next */
   if (!writev) {
@@ -90856,7 +93276,7 @@ function requireParse$2() {
 
   const warner = requireWarnMixin();
   const Header = requireHeader();
-  const EE = require$$0$j;
+  const EE = require$$0$b;
   const Yallist = requireYallist();
   const maxMetaEntrySize = 1024 * 1024;
   const Entry = requireReadEntry();
@@ -90864,7 +93284,7 @@ function requireParse$2() {
   const zlib = requireMinizlib();
   const {
     nextTick
-  } = require$$0$7;
+  } = require$$0$f;
   const gzipHeader = Buffer.from([0x1f, 0x8b]);
   const STATE = Symbol('state');
   const WRITEENTRY = Symbol('writeEntry');
@@ -91350,9 +93770,9 @@ function requireList() {
   // tar -t
   const hlo = requireHighLevelOpt();
   const Parser = requireParse$2();
-  const fs = require$$0$b;
+  const fs = require$$0$9;
   const fsm = requireFsMinipass();
-  const path = require$$0$a;
+  const path = require$$0$c;
   const stripSlash = requireStripTrailingSlashes();
   list_1 = (opt_, files, cb) => {
     if (typeof opt_ === 'function') {
@@ -91471,7 +93891,7 @@ function requireCreate() {
   const Pack = requirePack();
   const fsm = requireFsMinipass();
   const t = requireList();
-  const path = require$$0$a;
+  const path = require$$0$c;
   create_1 = (opt_, files, cb) => {
     if (typeof files === 'function') {
       cb = files;
@@ -91566,10 +93986,10 @@ function requireReplace() {
   // tar -r
   const hlo = requireHighLevelOpt();
   const Pack = requirePack();
-  const fs = require$$0$b;
+  const fs = require$$0$9;
   const fsm = requireFsMinipass();
   const t = requireList();
-  const path = require$$0$a;
+  const path = require$$0$c;
 
   // starting at the head of the file, read a Header
   // If the checksum is invalid, that's our position to start writing
@@ -91818,8 +94238,8 @@ function requireOptsArg() {
   hasRequiredOptsArg = 1;
   const {
     promisify
-  } = require$$0$9;
-  const fs = require$$0$b;
+  } = require$$0$8;
+  const fs = require$$0$9;
   const optsArg = opts => {
     if (!opts) opts = {
       mode: 0o777,
@@ -91856,7 +94276,7 @@ function requirePathArg() {
   const {
     resolve,
     parse
-  } = require$$0$a;
+  } = require$$0$c;
   const pathArg = path => {
     if (/\0/.test(path)) {
       // simulate same failure that node raises
@@ -91891,7 +94311,7 @@ function requireFindMade() {
   hasRequiredFindMade = 1;
   const {
     dirname
-  } = require$$0$a;
+  } = require$$0$c;
   const findMade = (opts, parent, path = undefined) => {
     // we never want the 'made' return value to be a root directory
     if (path === parent) return Promise.resolve();
@@ -91921,7 +94341,7 @@ function requireMkdirpManual() {
   hasRequiredMkdirpManual = 1;
   const {
     dirname
-  } = require$$0$a;
+  } = require$$0$c;
   const mkdirpManual = (path, opts, made) => {
     opts.recursive = false;
     const parent = dirname(path);
@@ -91981,7 +94401,7 @@ function requireMkdirpNative() {
   hasRequiredMkdirpNative = 1;
   const {
     dirname
-  } = require$$0$a;
+  } = require$$0$c;
   const {
     findMade,
     findMadeSync
@@ -92022,7 +94442,7 @@ var hasRequiredUseNative;
 function requireUseNative() {
   if (hasRequiredUseNative) return useNative_1;
   hasRequiredUseNative = 1;
-  const fs = require$$0$b;
+  const fs = require$$0$9;
   const version = process.env.__TESTING_MKDIRP_NODE_VERSION__ || process.version;
   const versArr = version.replace(/^v/, '').split('.');
   const hasNative = +versArr[0] > 10 || +versArr[0] === 10 && +versArr[1] >= 12;
@@ -92078,8 +94498,8 @@ var hasRequiredChownr;
 function requireChownr() {
   if (hasRequiredChownr) return chownr_1;
   hasRequiredChownr = 1;
-  const fs = require$$0$b;
-  const path = require$$0$a;
+  const fs = require$$0$9;
+  const path = require$$0$c;
 
   /* istanbul ignore next */
   const LCHOWN = fs.lchown ? 'lchown' : 'chown';
@@ -92213,8 +94633,8 @@ function requireMkdir() {
   // passing around state in a gazillion args.
 
   const mkdirp = requireMkdirp();
-  const fs = require$$0$b;
-  const path = require$$0$a;
+  const fs = require$$0$9;
+  const path = require$$0$c;
   const chownr = requireChownr();
   const normPath = requireNormalizeWindowsPath();
   class SymlinkError extends Error {
@@ -92442,12 +94862,12 @@ function requirePathReservations() {
   // Used by async unpack to avoid clobbering paths in use,
   // while still allowing maximal safe parallelization.
 
-  const assert = require$$0$m;
+  const assert = require$$0$a;
   const normalize = requireNormalizeUnicode();
   const stripSlashes = requireStripTrailingSlashes();
   const {
     join
-  } = require$$0$a;
+  } = require$$0$c;
   const platform = process.env.TESTING_TAR_FAKE_PLATFORM || process.platform;
   const isWindows = platform === 'win32';
   pathReservations = () => {
@@ -92608,7 +95028,7 @@ function requireGetWriteFlag() {
   // Only supported in Node v12.9.0 and above.
   const platform = process.env.__FAKE_PLATFORM__ || process.platform;
   const isWindows = platform === 'win32';
-  const fs = global.__FAKE_TESTING_FS__ || require$$0$b;
+  const fs = global.__FAKE_TESTING_FS__ || require$$0$9;
 
   /* istanbul ignore next */
   const {
@@ -92636,11 +95056,11 @@ function requireUnpack() {
   // (like a Link depending on its target) or destructive operations (like
   // clobbering an fs object to create one of a different type.)
 
-  const assert = require$$0$m;
+  const assert = require$$0$a;
   const Parser = requireParse$2();
-  const fs = require$$0$b;
+  const fs = require$$0$9;
   const fsm = requireFsMinipass();
-  const path = require$$0$a;
+  const path = require$$0$c;
   const mkdir = requireMkdir();
   const wc = requireWinchars();
   const pathReservations = requirePathReservations();
@@ -92673,7 +95093,7 @@ function requireUnpack() {
   const UID = Symbol('uid');
   const GID = Symbol('gid');
   const CHECKED_CWD = Symbol('checkedCwd');
-  const crypto = require$$0$k;
+  const crypto = require$$0$m;
   const getFlag = requireGetWriteFlag();
   const platform = process.env.TESTING_TAR_FAKE_PLATFORM || process.platform;
   const isWindows = platform === 'win32';
@@ -93449,9 +95869,9 @@ function requireExtract() {
   // tar -x
   const hlo = requireHighLevelOpt();
   const Unpack = requireUnpack();
-  const fs = require$$0$b;
+  const fs = require$$0$9;
   const fsm = requireFsMinipass();
-  const path = require$$0$a;
+  const path = require$$0$c;
   const stripSlash = requireStripTrailingSlashes();
   extract_1 = (opt_, files, cb) => {
     if (typeof opt_ === 'function') {
@@ -93653,9 +96073,9 @@ var hasRequiredLib$e;
 function requireLib$e() {
   if (hasRequiredLib$e) return lib$e;
   hasRequiredLib$e = 1;
-  const fs = require$$0$b;
-  const path = require$$0$a;
-  const EE = require$$0$j.EventEmitter;
+  const fs = require$$0$9;
+  const path = require$$0$c;
+  const EE = require$$0$b.EventEmitter;
   const Minimatch = requireCommonjs$f().Minimatch;
   class Walker extends EE {
     constructor(opts) {
@@ -93959,7 +96379,7 @@ function requireLib$d() {
   const {
     lstatSync: lstat,
     readFileSync: readFile
-  } = require$$0$b;
+  } = require$$0$9;
   const {
     basename,
     dirname,
@@ -93968,7 +96388,7 @@ function requireLib$d() {
     relative,
     resolve,
     sep
-  } = require$$0$a;
+  } = require$$0$c;
 
   // symbols used to represent synthetic rule sets
   const defaultRules = Symbol('npm-packlist.rules.default');
@@ -94359,7 +96779,7 @@ function requireSetPath() {
     resolve,
     dirname,
     delimiter
-  } = require$$0$a;
+  } = require$$0$c;
   // the path here is relative, even though it does not need to be
   // in order to make the posix tests pass in windows
   const nodeGypPath = require('./constants.js').npmNmNodeGypPath;
@@ -94409,7 +96829,7 @@ function requireMakeSpawnArgs() {
   const setPATH = requireSetPath();
   const {
     resolve
-  } = require$$0$a;
+  } = require$$0$c;
   let npm_config_node_gyp;
   const makeSpawnArgs = options => {
     const {
@@ -94500,8 +96920,8 @@ var hasRequiredLib$c;
 function requireLib$c() {
   if (hasRequiredLib$c) return lib$c;
   hasRequiredLib$c = 1;
-  const util = require$$0$9;
-  const fs = require$$0$b;
+  const util = require$$0$8;
+  const fs = require$$0$9;
   const {
     stat
   } = fs.promises || {
@@ -95119,7 +97539,7 @@ function requireConstants$4() {
   // Node v6 didn't export this, so we just hard code the version and rely
   // on all the other hard-coded values from zlib v4736.  When node v6
   // support drops, we can just export the realZlibConstants object.
-  const zlib_1 = __importDefault(require$$0$l);
+  const zlib_1 = __importDefault(require$$0$n);
   /* c8 ignore start */
   const realZlibConstants = zlib_1.default.constants || {
     ZLIB_VERNUM: 4736
@@ -95292,10 +97712,10 @@ function requireCommonjs$3() {
       value: true
     });
     exports.BrotliDecompress = exports.BrotliCompress = exports.Brotli = exports.Unzip = exports.InflateRaw = exports.DeflateRaw = exports.Gunzip = exports.Gzip = exports.Inflate = exports.Deflate = exports.Zlib = exports.ZlibError = exports.constants = void 0;
-    const assert_1 = __importDefault(require$$0$m);
-    const buffer_1 = require$$0$8;
+    const assert_1 = __importDefault(require$$0$a);
+    const buffer_1 = require$$0$g;
     const minipass_1 = requireCommonjs$d();
-    const realZlib = __importStar(require$$0$l);
+    const realZlib = __importStar(require$$0$n);
     const constants_js_1 = requireConstants$4();
     var constants_js_2 = requireConstants$4();
     Object.defineProperty(exports, "constants", {
@@ -95631,8 +98051,8 @@ function requireMinipass() {
     stdout: null,
     stderr: null
   };
-  const EE = require$$0$j;
-  const Stream = require$$1$9;
+  const EE = require$$0$b;
+  const Stream = require$$1$7;
   const SD = require$$2$7.StringDecoder;
   const EOF = Symbol('EOF');
   const MAYBE_EMIT_END = Symbol('maybeEmitEnd');
@@ -96300,7 +98720,7 @@ function requireShared() {
 
   // Use non-'node:' prefixed require to avoid Webpack errors.
   // eslint-disable-next-line n/prefer-node-protocol
-  const builtinBufferExports = require$$0$8;
+  const builtinBufferExports = require$$0$g;
   const builtinBufferExportsDescMap = Object.fromEntries(Object.entries(Object.getOwnPropertyDescriptors(builtinBufferExports)).filter(({
     0: key
   }) => key !== 'Buffer' && key !== 'SlowBuffer'));
@@ -96332,7 +98752,7 @@ function requireSafer() {
       transcode
       // Use non-'node:' prefixed require to avoid Webpack errors.
       // eslint-disable-next-line n/prefer-node-protocol
-    } = require$$0$8;
+    } = require$$0$g;
     const {
       builtinBufferExportsDescMap
     } = /*@__PURE__*/requireShared();
@@ -107907,7 +110327,7 @@ var hasRequiredResponse;
 function requireResponse() {
   if (hasRequiredResponse) return response;
   hasRequiredResponse = 1;
-  const http = require$$1$7;
+  const http = require$$1$8;
   const {
     STATUS_CODES
   } = http;
@@ -108291,7 +110711,7 @@ function requireLib$a() {
   const {
     URL
   } = require$$0$d;
-  const http = require$$1$7;
+  const http = require$$1$8;
   const https = require$$2$3;
   const zlib = requireCommonjs$3();
   const {
@@ -109152,7 +111572,7 @@ var hasRequiredAuth;
 function requireAuth() {
   if (hasRequiredAuth) return auth$1;
   hasRequiredAuth = 1;
-  const fs = require$$0$b;
+  const fs = require$$0$9;
   const npa = requireNpa();
   const {
     URL
@@ -109359,7 +111779,7 @@ var hasRequiredOptions$1;
 function requireOptions$1() {
   if (hasRequiredOptions$1) return options$1;
   hasRequiredOptions$1 = 1;
-  const dns = require$$0$n;
+  const dns = require$$0$o;
   const conditionalHeaders = ['if-modified-since', 'if-none-match', 'if-unmodified-since', 'if-match', 'if-range'];
   const configureOptions = opts => {
     const {
@@ -112601,7 +115021,7 @@ function requireDns() {
   const {
     LRUCache
   } = /*@__PURE__*/requireCommonjs$2();
-  const dns = require$$0$n;
+  const dns = require$$0$o;
 
   // this is a factory so that each request can have its own opts (i.e. ttl)
   // while still sharing the cache across all requests
@@ -113433,8 +115853,8 @@ function requireNode$2() {
   if (hasRequiredNode$2) return node$2.exports;
   hasRequiredNode$2 = 1;
   (function (module, exports) {
-    const tty = require$$1$8;
-    const util = require$$0$9;
+    const tty = require$$1$9;
+    const util = require$$0$8;
 
     /**
      * This is the Node.js implementation of `debug()`.
@@ -113663,7 +116083,7 @@ function requireHelpers$3() {
     value: true
   });
   helpers$3.req = helpers$3.json = helpers$3.toBuffer = void 0;
-  const http = __importStar(require$$1$7);
+  const http = __importStar(require$$1$8);
   const https = __importStar(require$$2$3);
   async function toBuffer(stream) {
     let length = 0;
@@ -113745,8 +116165,8 @@ function requireDist$c() {
       value: true
     });
     exports.Agent = void 0;
-    const net = __importStar(require$$0$o);
-    const http = __importStar(require$$1$7);
+    const net = __importStar(require$$0$p);
+    const http = __importStar(require$$1$8);
     const https_1 = require$$2$3;
     __exportStar(requireHelpers$3(), exports);
     const INTERNAL = Symbol('AgentBaseInternalState');
@@ -113936,10 +116356,10 @@ function requireDist$b() {
     value: true
   });
   dist$c.HttpProxyAgent = void 0;
-  const net = __importStar(require$$0$o);
+  const net = __importStar(require$$0$p);
   const tls = __importStar(require$$1$c);
   const debug_1 = __importDefault(requireSrc$1());
-  const events_1 = require$$0$j;
+  const events_1 = require$$0$b;
   const agent_base_1 = requireDist$c();
   const url_1 = require$$0$d;
   const debug = (0, debug_1.default)('http-proxy-agent');
@@ -114200,9 +116620,9 @@ function requireDist$a() {
     value: true
   });
   dist$a.HttpsProxyAgent = void 0;
-  const net = __importStar(require$$0$o);
+  const net = __importStar(require$$0$p);
   const tls = __importStar(require$$1$c);
-  const assert_1 = __importDefault(require$$0$m);
+  const assert_1 = __importDefault(require$$0$a);
   const debug_1 = __importDefault(requireSrc$1());
   const agent_base_1 = requireDist$c();
   const url_1 = require$$0$d;
@@ -114370,7 +116790,7 @@ function requireUtils$1() {
   Object.defineProperty(utils$1, "__esModule", {
     value: true
   });
-  const buffer_1 = require$$0$8;
+  const buffer_1 = require$$0$g;
   /**
    * Error strings
    */
@@ -119362,9 +121782,9 @@ function requireHelpers$1() {
   helpers$2.ipToBuffer = helpers$2.int32ToIpv4 = helpers$2.ipv4ToInt32 = helpers$2.validateSocksClientChainOptions = helpers$2.validateSocksClientOptions = void 0;
   const util_1 = requireUtil$1();
   const constants_1 = requireConstants$3();
-  const stream = require$$1$9;
+  const stream = require$$1$7;
   const ip_address_1 = requireIpAddress();
-  const net = require$$0$o;
+  const net = require$$0$p;
   /**
    * Validates the provided SocksClientOptions
    * @param options { SocksClientOptions }
@@ -119593,8 +122013,8 @@ function requireSocksclient() {
       value: true
     });
     exports.SocksClientError = exports.SocksClient = void 0;
-    const events_1 = require$$0$j;
-    const net = require$$0$o;
+    const events_1 = require$$0$b;
+    const net = require$$0$p;
     const smart_buffer_1 = requireSmartbuffer();
     const constants_1 = requireConstants$3();
     const helpers_1 = requireHelpers$1();
@@ -120430,8 +122850,8 @@ function requireDist$9() {
   const socks_1 = requireBuild$1();
   const agent_base_1 = requireDist$c();
   const debug_1 = __importDefault(requireSrc$1());
-  const dns = __importStar(require$$0$n);
-  const net = __importStar(require$$0$o);
+  const dns = __importStar(require$$0$o);
+  const net = __importStar(require$$0$p);
   const tls = __importStar(require$$1$c);
   const url_1 = require$$0$d;
   const debug = (0, debug_1.default)('socks-proxy-agent');
@@ -120758,11 +123178,11 @@ var hasRequiredAgents$2;
 function requireAgents$2() {
   if (hasRequiredAgents$2) return agents$2;
   hasRequiredAgents$2 = 1;
-  const net = require$$0$o;
+  const net = require$$0$p;
   const tls = require$$1$c;
   const {
     once
-  } = require$$0$j;
+  } = require$$0$b;
   const timers = require$$3$4;
   const {
     normalizeOptions,
@@ -125975,7 +128395,7 @@ function requireCrypto() {
   See the License for the specific language governing permissions and
   limitations under the License.
   */
-  const crypto_1 = __importDefault(require$$0$k);
+  const crypto_1 = __importDefault(require$$0$m);
   function createPublicKey(key, type = 'spki') {
     if (typeof key === 'string') {
       return crypto_1.default.createPublicKey(key);
@@ -127344,7 +129764,7 @@ function requireUa() {
   See the License for the specific language governing permissions and
   limitations under the License.
   */
-  const os_1 = __importDefault(require$$0$g);
+  const os_1 = __importDefault(require$$0$e);
   // Format User-Agent: <product> / <product-version> (<platform>)
   // source: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/User-Agent
   const getUserAgent = () => {
@@ -127967,7 +130387,7 @@ function requireFetch() {
   See the License for the specific language governing permissions and
   limitations under the License.
   */
-  const http2_1 = require$$0$p;
+  const http2_1 = require$$0$q;
   const make_fetch_happen_1 = __importDefault(requireLib$7());
   const proc_log_1 = requireLib$F();
   const promise_retry_1 = __importDefault(requirePromiseRetry());
@@ -128194,7 +130614,7 @@ function requireEphemeral() {
   See the License for the specific language governing permissions and
   limitations under the License.
   */
-  const crypto_1 = __importDefault(require$$0$k);
+  const crypto_1 = __importDefault(require$$0$m);
   const EC_KEYPAIR_TYPE = 'ec';
   const P256_CURVE = 'P-256';
   // Signer implementation which uses an ephemeral keypair to sign artifacts.
@@ -129060,8 +131480,8 @@ function requireAppdata() {
   See the License for the specific language governing permissions and
   limitations under the License.
   */
-  const os_1 = __importDefault(require$$0$g);
-  const path_1 = __importDefault(require$$0$a);
+  const os_1 = __importDefault(require$$0$e);
+  const path_1 = __importDefault(require$$0$c);
   function appDataPath(name) {
     const homedir = os_1.default.homedir();
     switch (process.platform) {
@@ -129249,7 +131669,7 @@ function requireVerify() {
   });
   verify.verifySignature = void 0;
   const canonical_json_1 = requireLib$5();
-  const crypto_1 = __importDefault(require$$0$k);
+  const crypto_1 = __importDefault(require$$0$m);
   const verifySignature = (metaDataSignedData, key, signature) => {
     const canonicalData = Buffer.from((0, canonical_json_1.canonicalize)(metaDataSignedData));
     return crypto_1.default.verify(undefined, canonicalData, key, Buffer.from(signature, 'hex'));
@@ -129316,7 +131736,7 @@ function requireBase() {
   });
   base.Signed = base.MetadataKind = void 0;
   base.isMetadataKind = isMetadataKind;
-  const util_1 = __importDefault(require$$0$9);
+  const util_1 = __importDefault(require$$0$8);
   const error_1 = requireError$5();
   const utils_1 = requireUtils();
   const SPECIFICATION_VERSION = ['1', '0', '31'];
@@ -129416,8 +131836,8 @@ function requireFile() {
     value: true
   });
   file.TargetFile = file.MetaFile = void 0;
-  const crypto_1 = __importDefault(require$$0$k);
-  const util_1 = __importDefault(require$$0$9);
+  const crypto_1 = __importDefault(require$$0$m);
+  const util_1 = __importDefault(require$$0$8);
   const error_1 = requireError$5();
   const utils_1 = requireUtils();
   // A container with information about a particular metadata file.
@@ -129650,7 +132070,7 @@ function requireKey$2() {
     value: true
   });
   key$1.getPublicKey = getPublicKey;
-  const crypto_1 = __importDefault(require$$0$k);
+  const crypto_1 = __importDefault(require$$0$m);
   const error_1 = requireError$5();
   const oid_1 = requireOid();
   const ASN1_TAG_SEQUENCE = 0x30;
@@ -129771,7 +132191,7 @@ function requireKey$1() {
     value: true
   });
   key$2.Key = void 0;
-  const util_1 = __importDefault(require$$0$9);
+  const util_1 = __importDefault(require$$0$8);
   const error_1 = requireError$5();
   const utils_1 = requireUtils();
   const key_1 = requireKey$2();
@@ -129876,9 +132296,9 @@ function requireRole() {
     value: true
   });
   role.SuccinctRoles = role.DelegatedRole = role.Role = role.TOP_LEVEL_ROLE_NAMES = void 0;
-  const crypto_1 = __importDefault(require$$0$k);
+  const crypto_1 = __importDefault(require$$0$m);
   const minimatch_1 = requireCommonjs$f();
-  const util_1 = __importDefault(require$$0$9);
+  const util_1 = __importDefault(require$$0$8);
   const error_1 = requireError$5();
   const utils_1 = requireUtils();
   role.TOP_LEVEL_ROLE_NAMES = ['root', 'targets', 'snapshot', 'timestamp'];
@@ -130201,7 +132621,7 @@ function requireRoot() {
     value: true
   });
   root.Root = void 0;
-  const util_1 = __importDefault(require$$0$9);
+  const util_1 = __importDefault(require$$0$8);
   const base_1 = requireBase();
   const error_1 = requireError$5();
   const key_1 = requireKey$1();
@@ -130396,7 +132816,7 @@ function requireSnapshot() {
     value: true
   });
   snapshot.Snapshot = void 0;
-  const util_1 = __importDefault(require$$0$9);
+  const util_1 = __importDefault(require$$0$8);
   const base_1 = requireBase();
   const file_1 = requireFile();
   const utils_1 = requireUtils();
@@ -130490,7 +132910,7 @@ function requireDelegations() {
     value: true
   });
   delegations.Delegations = void 0;
-  const util_1 = __importDefault(require$$0$9);
+  const util_1 = __importDefault(require$$0$8);
   const error_1 = requireError$5();
   const key_1 = requireKey$1();
   const role_1 = requireRole();
@@ -130618,7 +133038,7 @@ function requireTargets() {
     value: true
   });
   targets.Targets = void 0;
-  const util_1 = __importDefault(require$$0$9);
+  const util_1 = __importDefault(require$$0$8);
   const base_1 = requireBase();
   const delegations_1 = requireDelegations();
   const file_1 = requireFile();
@@ -130801,7 +133221,7 @@ function requireMetadata() {
   });
   metadata.Metadata = void 0;
   const canonical_json_1 = requireLib$5();
-  const util_1 = __importDefault(require$$0$9);
+  const util_1 = __importDefault(require$$0$8);
   const base_1 = requireBase();
   const error_1 = requireError$5();
   const root_1 = requireRoot();
@@ -131113,9 +133533,9 @@ function requireTmpfile() {
     value: true
   });
   tmpfile.withTempFile = void 0;
-  const promises_1 = __importDefault(require$$0$f);
-  const os_1 = __importDefault(require$$0$g);
-  const path_1 = __importDefault(require$$0$a);
+  const promises_1 = __importDefault(require$$0$j);
+  const os_1 = __importDefault(require$$0$e);
+  const path_1 = __importDefault(require$$0$c);
   // Invokes the given handler with the path to a temporary file. The file
   // is deleted after the handler returns.
   const withTempFile = async handler => withTempDir(async dir => handler(path_1.default.join(dir, 'tempfile')));
@@ -131152,9 +133572,9 @@ function requireFetcher$1() {
   });
   fetcher$1.DefaultFetcher = fetcher$1.BaseFetcher = void 0;
   const debug_1 = __importDefault(requireSrc$1());
-  const fs_1 = __importDefault(require$$0$b);
+  const fs_1 = __importDefault(require$$0$9);
   const make_fetch_happen_1 = __importDefault(requireLib$7());
-  const util_1 = __importDefault(require$$0$9);
+  const util_1 = __importDefault(require$$0$8);
   const error_1 = requireError$4();
   const tmpfile_1 = requireTmpfile();
   const log = (0, debug_1.default)('tuf:fetch');
@@ -131550,8 +133970,8 @@ function requireUpdater() {
   updater.Updater = void 0;
   const models_1 = requireDist$4();
   const debug_1 = __importDefault(requireSrc$1());
-  const fs = __importStar(require$$0$b);
-  const path = __importStar(require$$0$a);
+  const fs = __importStar(require$$0$9);
+  const path = __importStar(require$$0$c);
   const config_1 = requireConfig$1();
   const error_1 = requireError$4();
   const fetcher_1 = requireFetcher$1();
@@ -131964,7 +134384,7 @@ function requireTarget() {
   See the License for the specific language governing permissions and
   limitations under the License.
   */
-  const fs_1 = __importDefault(require$$0$b);
+  const fs_1 = __importDefault(require$$0$9);
   const error_1 = requireError$3();
   // Downloads and returns the specified target from the provided TUF Updater.
   async function readTarget(tuf, targetPath) {
@@ -132057,8 +134477,8 @@ function requireClient$1() {
   See the License for the specific language governing permissions and
   limitations under the License.
   */
-  const fs_1 = __importDefault(require$$0$b);
-  const path_1 = __importDefault(require$$0$a);
+  const fs_1 = __importDefault(require$$0$9);
+  const path_1 = __importDefault(require$$0$c);
   const tuf_js_1 = requireDist$3();
   const _1 = requireDist$2();
   const target_1 = requireTarget();
@@ -133726,7 +136146,7 @@ function requireVerifier() {
   See the License for the specific language governing permissions and
   limitations under the License.
   */
-  const util_1 = require$$0$9;
+  const util_1 = require$$0$8;
   const error_1 = requireError$2();
   const key_1 = requireKey();
   const policy_1 = requirePolicy();
@@ -134283,7 +136703,7 @@ var hasRequiredRegistry;
 function requireRegistry() {
   if (hasRequiredRegistry) return registry;
   hasRequiredRegistry = 1;
-  const crypto = require$$0$q;
+  const crypto = require$$0$r;
   const PackageJson = requireLib$w();
   const pickManifest = requireLib$y();
   const ssri = requireLib$m();
@@ -138142,7 +140562,7 @@ function requireHash() {
   hasRequiredHash = 1;
   const {
     createHash
-  } = require$$0$k;
+  } = require$$0$m;
   hash = ({
     name,
     source
@@ -138583,7 +141003,7 @@ function requireLib$2() {
   const Advisory = requireAdvisory();
   const {
     homedir
-  } = require$$0$g;
+  } = require$$0$e;
   const jsonParse = requireLib$E();
   const _packument = Symbol('packument');
   const _cachePut = Symbol('cachePut');
@@ -140641,7 +143061,7 @@ var hasRequiredClient;
 function requireClient() {
   if (hasRequiredClient) return client;
   hasRequiredClient = 1;
-  const EE = require$$0$j;
+  const EE = require$$0$b;
   const onProgress = Symbol('onProgress');
   const bars = Symbol('bars');
   const listener = Symbol('listener');
@@ -140757,7 +143177,7 @@ function requireTracker$1() {
   hasRequiredTracker$1 = 1;
   // The tracker class is intentionally as naive as possible.  it is just
   // an ergonomic wrapper around process.emit('progress', ...)
-  const EE = require$$0$j;
+  const EE = require$$0$b;
   class Tracker extends EE {
     constructor(name, key, total) {
       super();
@@ -146151,7 +148571,7 @@ function requireCommonAncestorPath() {
     parse,
     sep,
     normalize: norm
-  } = require$$0$a;
+  } = require$$0$c;
   function* commonArrayMembers(a, b) {
     const [l, s] = a.length > b.length ? [a, b] : [b, a];
     for (const x of s) {
@@ -147857,7 +150277,7 @@ var hasRequiredRetirePath;
 function requireRetirePath() {
   if (hasRequiredRetirePath) return retirePath_1;
   hasRequiredRetirePath = 1;
-  const crypto = require$$0$q;
+  const crypto = require$$0$r;
   const {
     dirname,
     basename,
@@ -149464,7 +151884,7 @@ function requireIsolatedReifier() {
   const {
     depth
   } = requireLib$3();
-  const crypto = require$$0$q;
+  const crypto = require$$0$r;
 
   // cache complicated function results
   const memoize = fn => {
@@ -149991,7 +152411,7 @@ function requireArborist() {
   const PackumentCache = requirePackumentCache();
   const mixins = [requireTracker(), requireBuildIdealTree(), requireLoadActual(), requireLoadVirtual(), requireRebuild(), requireReify(), requireIsolatedReifier()];
   const _setWorkspaces = Symbol.for('setWorkspaces');
-  const Base = mixins.reduce((a, b) => b(a), require$$0$e);
+  const Base = mixins.reduce((a, b) => b(a), require$$0$i);
 
   // if it's 1, 2, or 3, set it explicitly that.
   // if undefined or null, set it null
@@ -165016,8 +167436,8 @@ function requireNode() {
   (function (module) {
     var feature = requireFeature().default;
     var region = requireRegion().default;
-    var fs = require$$0$b;
-    var path = require$$0$a;
+    var fs = require$$0$9;
+    var path = require$$0$c;
     var BrowserslistError = requireError();
     var IS_SECTION = /^\s*\[(.+)]\s*$/;
     var CONFIG_PATTERN = /^browserslist-config-/;
@@ -165476,7 +167896,7 @@ function requireBrowserslist() {
   var agents = requireAgents().agents;
   var e2c = requireVersions();
   var jsEOL = require$$3;
-  var path = require$$0$a;
+  var path = require$$0$c;
   var BrowserslistError = requireError();
   var env = requireNode();
   var parseWithoutCache = requireParse(); // Will load browser.js in webpack
@@ -169479,7 +171899,7 @@ var hasRequiredSupportsColor;
 function requireSupportsColor() {
   if (hasRequiredSupportsColor) return supportsColor_1;
   hasRequiredSupportsColor = 1;
-  const os = require$$0$g;
+  const os = require$$0$e;
   const hasFlag = requireHasFlag();
   const env = process.env;
   let forceColor;
@@ -170168,6 +172588,8 @@ exports.open = open;
 exports.overrideSetExports = overrideSetExports;
 exports.packageurlJsExports = packageurlJsExports$1;
 exports.packageurlJsExports$1 = packageurlJsExports;
+exports.registryAuthTokenExports = registryAuthTokenExports;
+exports.registryUrl = registryUrl;
 exports.semverExports = semverExports;
 exports.srcExports = srcExports;
 exports.stackWithCauses = stackWithCauses;
@@ -170175,5 +172597,5 @@ exports.terminalLinkExports = terminalLinkExports;
 exports.updater = updater$1;
 exports.yargsParser = yargsParser;
 exports.yoctocolorsCjsExports = yoctocolorsCjsExports;
-//# debugId=7092173f-4e2e-4cb3-9738-4a6fc3927919
+//# debugId=6199d008-a967-4b64-9966-4aeffaad1d3b
 //# sourceMappingURL=vendor.js.map