@vltpkg/cli-js 1.0.1 → 1.0.2

package/registry-client-src-revalidate.js

@@ -10000,9 +10000,9 @@ var require_socks5_client = __commonJS({
     var { EventEmitter: EventEmitter2 } = __require("node:events");
     var { Buffer: Buffer2 } = __require("node:buffer");
     var { InvalidArgumentError, Socks5ProxyError } = require_errors();
-    var { debuglog } = __require("node:util");
+    var { debuglog: debuglog2 } = __require("node:util");
     var { parseAddress } = require_socks5_utils();
-    var debug = debuglog("undici:socks5");
+    var debug2 = debuglog2("undici:socks5");
     var EMPTY_BUFFER = Buffer2.alloc(0);
     var SOCKS_VERSION = 5;
     var AUTH_METHODS = {
@@ -10068,7 +10068,7 @@ var require_socks5_client = __commonJS({
        * Handle incoming data from the socket
        */
       onData(data) {
-        debug("received data", data.length, "bytes in state", this.state);
+        debug2("received data", data.length, "bytes in state", this.state);
         this.buffer = Buffer2.concat([this.buffer, data]);
         try {
           switch (this.state) {
@@ -10090,7 +10090,7 @@ var require_socks5_client = __commonJS({
        * Handle socket errors
        */
       onError(err) {
-        debug("socket error", err);
+        debug2("socket error", err);
         this.state = STATES.ERROR;
         this.emit("error", err);
         this.destroy();
@@ -10099,7 +10099,7 @@ var require_socks5_client = __commonJS({
        * Handle socket close
        */
       onClose() {
-        debug("socket closed");
+        debug2("socket closed");
         this.state = STATES.CLOSED;
         this.emit("close");
       }
@@ -10122,7 +10122,7 @@ var require_socks5_client = __commonJS({
         if (this.state !== STATES.INITIAL) {
           throw new InvalidArgumentError("Handshake already started");
         }
-        debug("starting handshake with", this.authMethods.length, "auth methods");
+        debug2("starting handshake with", this.authMethods.length, "auth methods");
         this.state = STATES.HANDSHAKING;
         const request2 = Buffer2.alloc(2 + this.authMethods.length);
         request2[0] = SOCKS_VERSION;
@@ -10148,7 +10148,7 @@ var require_socks5_client = __commonJS({
           throw new Socks5ProxyError("No acceptable authentication method", "UND_ERR_SOCKS5_AUTH_REJECTED");
         }
         this.buffer = this.buffer.subarray(2);
-        debug("server selected auth method", method);
+        debug2("server selected auth method", method);
         if (method === AUTH_METHODS.NO_AUTH) {
           this.markAuthenticated();
         } else if (method === AUTH_METHODS.USERNAME_PASSWORD) {
@@ -10166,7 +10166,7 @@ var require_socks5_client = __commonJS({
         if (!username || !password) {
           throw new InvalidArgumentError("Username and password required for authentication");
         }
-        debug("sending username/password auth");
+        debug2("sending username/password auth");
         const usernameBuffer = Buffer2.from(username);
         const passwordBuffer = Buffer2.from(password);
         if (usernameBuffer.length > 255 || passwordBuffer.length > 255) {
@@ -10196,7 +10196,7 @@ var require_socks5_client = __commonJS({
           throw new Socks5ProxyError("Authentication failed", "UND_ERR_SOCKS5_AUTH_FAILED");
         }
         this.buffer = this.buffer.subarray(2);
-        debug("authentication successful");
+        debug2("authentication successful");
         this.markAuthenticated();
       }
       /**
@@ -10211,7 +10211,7 @@ var require_socks5_client = __commonJS({
         if (this.state !== STATES.AUTHENTICATED) {
           throw new InvalidArgumentError("Client must be authenticated before CONNECT");
         }
-        debug("connecting to", address, port);
+        debug2("connecting to", address, port);
         this.state = STATES.CONNECTING;
         const request2 = this.buildConnectRequest(COMMANDS.CONNECT, address, port);
         this.socket.write(request2);
@@ -10286,7 +10286,7 @@ var require_socks5_client = __commonJS({
         this.buffer = EMPTY_BUFFER;
         this.state = STATES.CONNECTED;
         this.socket.removeListener("data", this.onSocketData);
-        debug("connected, bound address:", boundAddress, "port:", boundPort);
+        debug2("connected, bound address:", boundAddress, "port:", boundPort);
         this.emit("connected", { address: boundAddress, port: boundPort });
       }
       /**
@@ -10338,8 +10338,8 @@ var require_socks5_proxy_agent = __commonJS({
     var { kDispatch, kClose, kDestroy } = require_symbols();
     var Pool = require_pool();
     var buildConnector = require_connect();
-    var { debuglog } = __require("node:util");
-    var debug = debuglog("undici:socks5-proxy");
+    var { debuglog: debuglog2 } = __require("node:util");
+    var debug2 = debuglog2("undici:socks5-proxy");
     var kProxyUrl = /* @__PURE__ */ Symbol("proxy url");
     var kProxyHeaders = /* @__PURE__ */ Symbol("proxy headers");
     var kProxyAuth = /* @__PURE__ */ Symbol("proxy auth");
@@ -10385,7 +10385,7 @@ var require_socks5_proxy_agent = __commonJS({
       async createSocks5Connection(targetHost, targetPort) {
         const proxyHost = this[kProxyUrl].hostname;
         const proxyPort = parseInt(this[kProxyUrl].port) || 1080;
-        debug("creating SOCKS5 connection to", proxyHost, proxyPort);
+        debug2("creating SOCKS5 connection to", proxyHost, proxyPort);
         const socket = await new Promise((resolve10, reject) => {
           this[kConnector]({
             hostname: proxyHost,
@@ -10402,7 +10402,7 @@ var require_socks5_proxy_agent = __commonJS({
         });
         const socks5Client = new Socks5Client(socket, this[kProxyAuth]);
         socks5Client.on("error", (err) => {
-          debug("SOCKS5 error:", err);
+          debug2("SOCKS5 error:", err);
           socket.destroy();
         });
         await socks5Client.handshake();
@@ -10434,7 +10434,7 @@ var require_socks5_proxy_agent = __commonJS({
             reject(new Error("SOCKS5 connection timeout"));
           }, 5e3);
           const onConnected = (info) => {
-            debug("SOCKS5 tunnel established to", targetHost, targetPort, "via", info);
+            debug2("SOCKS5 tunnel established to", targetHost, targetPort, "via", info);
             clearTimeout(timeout);
             socks5Client.removeListener("error", onError);
             resolve10();
@@ -10454,7 +10454,7 @@ var require_socks5_proxy_agent = __commonJS({
        */
       [kDispatch](opts, handler) {
         const { origin } = opts;
-        debug("dispatching request to", origin, "via SOCKS5");
+        debug2("dispatching request to", origin, "via SOCKS5");
         try {
           const originKey = String(origin);
           let pool = this[kPools].get(originKey);
@@ -10467,14 +10467,14 @@ var require_socks5_proxy_agent = __commonJS({
                   const url = new URL2(origin);
                   const targetHost = url.hostname;
                   const targetPort = parseInt(url.port) || (url.protocol === "https:" ? 443 : 80);
-                  debug("establishing SOCKS5 connection to", targetHost, targetPort);
+                  debug2("establishing SOCKS5 connection to", targetHost, targetPort);
                   const socket = await this.createSocks5Connection(targetHost, targetPort);
                   let finalSocket = socket;
                   if (url.protocol === "https:") {
                     if (!tls) {
                       tls = __require("node:tls");
                     }
-                    debug("upgrading to TLS");
+                    debug2("upgrading to TLS");
                     finalSocket = tls.connect({
                       ...this[kRequestTls],
                       socket,
@@ -10487,7 +10487,7 @@ var require_socks5_proxy_agent = __commonJS({
                   }
                   callback(null, finalSocket);
                 } catch (err) {
-                  debug("SOCKS5 connection error:", err);
+                  debug2("SOCKS5 connection error:", err);
                   callback(err);
                 }
               }
@@ -10496,7 +10496,7 @@ var require_socks5_proxy_agent = __commonJS({
           }
           return pool[kDispatch](opts, handler);
         } catch (err) {
-          debug("dispatch error:", err);
+          debug2("dispatch error:", err);
           if (typeof handler.onResponseError === "function") {
             handler.onResponseError(null, err);
             return false;
@@ -25257,6 +25257,18 @@ function create(cls, defaultFrom, message, cause, from = defaultFrom) {
 function error(message, cause, from) {
   return create(Error, error, message, cause, from);
 }
+function typeError(message, cause, from) {
+  return create(TypeError, typeError, message, cause, from);
+}
+function syntaxError(message, cause, from) {
+  return create(
+    SyntaxError,
+    syntaxError,
+    message,
+    cause,
+    from
+  );
+}
 
 // ../../src/cache/src/index.ts
 import { createHash, randomBytes } from "node:crypto";
@@ -29972,10 +29984,1654 @@ var handleBeforeExit = () => {
   }
 };
 
+// ../../src/fast-split/src/index.ts
+function fastSplit(str, delim, limit = -1, onPart) {
+  let i2 = 0;
+  let p = 0;
+  const l = delim.length;
+  const parts = [];
+  while (i2 !== -1) {
+    i2 = str.indexOf(delim, p);
+    const part = i2 === -1 || parts.length === limit - 1 ? str.substring(p) : str.substring(p, i2);
+    parts.push(onPart?.(part, parts, i2) ?? part);
+    if (parts.length === limit) {
+      return parts;
+    }
+    p = i2 + l;
+  }
+  return parts;
+}
+
+// ../../src/semver/src/version.ts
+var maybeNumber = (s) => {
+  if (!/^[0-9]+$/.test(s)) return s;
+  const n7 = Number(s);
+  return n7 <= Number.MAX_SAFE_INTEGER ? n7 : s;
+};
+var safeNumber = (s, version2, field) => {
+  const n7 = Number(s);
+  if (n7 > Number.MAX_SAFE_INTEGER) {
+    throw invalidVersion(
+      version2,
+      `invalid ${field}, must be <= ${Number.MAX_SAFE_INTEGER}`
+    );
+  }
+  return n7;
+};
+var re2 = {
+  prefix: /^[ v=]+/,
+  main: /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)/,
+  prerelease: /-([0-9a-zA-Z_.-]+)(?:$|\+)/,
+  build: /\+([0-9a-zA-Z_.-]+)$/,
+  full: /^[ v=]*(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9a-zA-Z_.-]+))?(?:\+([0-9a-zA-Z_.-]+))?$/
+};
+var invalidVersion = (version2, message) => {
+  const er = syntaxError(
+    `invalid version: ${message}`,
+    { version: version2 },
+    Version
+  );
+  return er;
+};
+var Version = class _Version {
+  /** raw string provided to create this Version */
+  raw;
+  /**  major version number */
+  major;
+  /** minor version number */
+  minor;
+  /** patch version number */
+  patch;
+  /**
+   * List of `'.'`-separated strings and numbers indicating that this
+   * version is a prerelease.
+   *
+   * This is undefined if the version does not have a prerelease section.
+   */
+  prerelease;
+  /**
+   * List of `'.'`-separated strings in the `build` section.
+   *
+   * This is undefined if the version does not have a build.
+   */
+  build;
+  /** Canonical strict form of this version */
+  toString() {
+    return `${this.major}.${this.minor}.${this.patch}${this.prerelease ? "-" + this.prerelease.join(".") : ""}${this.build ? "+" + this.build.join(".") : ""}`;
+  }
+  /** Generate a `Version` object from a SemVer string */
+  static parse(version2) {
+    version2 = version2.replace(re2.prefix, "").trim();
+    if (version2.length > 256) {
+      throw invalidVersion(
+        version2,
+        "must be less than 256 characters"
+      );
+    }
+    const parsed = re2.full.exec(version2);
+    if (!parsed) {
+      const main3 = re2.main.exec(version2);
+      if (!main3) {
+        throw invalidVersion(
+          version2,
+          "no Major.minor.patch tuple present"
+        );
+      } else {
+        throw invalidVersion(
+          version2,
+          "invalid build or patch section"
+        );
+      }
+    }
+    const [_3, major_, minor_, patch_, prerelease, build] = parsed;
+    const major2 = safeNumber(major_, version2, "major");
+    const minor2 = safeNumber(minor_, version2, "minor");
+    const patch = safeNumber(patch_, version2, "patch");
+    return new _Version(
+      version2,
+      major2,
+      minor2,
+      patch,
+      prerelease,
+      build
+    );
+  }
+  constructor(version2, major2, minor2, patch, prerelease, build) {
+    this.raw = version2;
+    this.major = major2;
+    this.minor = minor2;
+    this.patch = patch;
+    if (prerelease) {
+      this.prerelease = fastSplit(prerelease, ".", -1, (c) => {
+        if (!c) {
+          throw invalidVersion(
+            version2,
+            "invalid prerelease, empty identifiers not allowed"
+          );
+        }
+        return maybeNumber(c);
+      });
+    }
+    if (build) {
+      this.build = fastSplit(build, ".", -1, (c) => {
+        if (!c) {
+          throw invalidVersion(
+            version2,
+            "invalid build metadata, empty identifiers not allowed"
+          );
+        }
+      });
+    }
+  }
+  /**
+   * Return 1 if this is > the provided version, -1 if we're less, or 0 if
+   * they are equal.
+   *
+   * No special handling for prerelease versions, this is just a precedence
+   * comparison.
+   *
+   * This can be used to sort a list of versions by precedence:
+   *
+   * ```ts
+   * const versions: Version[] = getVersionsSomehow()
+   * const sorted = versions.sort((a, b) => a.compare(b))
+   * ```
+   */
+  compare(v3) {
+    if (this.major > v3.major) return 1;
+    if (this.major < v3.major) return -1;
+    if (this.minor > v3.minor) return 1;
+    if (this.minor < v3.minor) return -1;
+    if (this.patch > v3.patch) return 1;
+    if (this.patch < v3.patch) return -1;
+    if (!v3.prerelease?.length)
+      return !this.prerelease?.length ? 0 : -1;
+    if (!this.prerelease?.length) return 1;
+    const len = Math.max(this.prerelease.length, v3.prerelease.length);
+    const me2 = this.prerelease;
+    const thee = v3.prerelease;
+    for (let i2 = 0; i2 < len; i2++) {
+      const m2 = me2[i2];
+      const t = thee[i2];
+      if (m2 === t) continue;
+      if (t === void 0) return 1;
+      if (m2 === void 0) return -1;
+      if (typeof m2 !== typeof t) {
+        return typeof m2 === "string" ? 1 : -1;
+      }
+      return m2 > t ? 1 : -1;
+    }
+    return 0;
+  }
+  /**
+   * The inverse of compare, for sorting version lists in reverse order
+   */
+  rcompare(v3) {
+    return -1 * this.compare(v3);
+  }
+  /** true if this version is > the argument */
+  greaterThan(v3) {
+    return this.compare(v3) === 1;
+  }
+  /** true if this version is >= the argument */
+  greaterThanEqual(v3) {
+    return this.compare(v3) > -1;
+  }
+  /** true if this version is < the argument */
+  lessThan(v3) {
+    return this.compare(v3) === -1;
+  }
+  /** true if this version is &lt;= the argument */
+  lessThanEqual(v3) {
+    return this.compare(v3) < 1;
+  }
+  /** true if these two versions have equal SemVer precedence */
+  equals(v3) {
+    return this.compare(v3) === 0;
+  }
+  /** just compare the M.m.p parts of the version */
+  tupleEquals(v3) {
+    return this.major === v3.major && this.minor === v3.minor && this.patch === v3.patch;
+  }
+  /** true if this version satisfies the range */
+  satisfies(r) {
+    return r.test(this);
+  }
+  /**
+   * Increment the version in place, in the manner specified.
+   *
+   * Part behaviors:
+   *
+   * - `'major'` If the version is a `M.0.0-...` version with a prerelease, then
+   * simply drop the prerelease. Otherwise, set the minor and patch to 0, and
+   * increment the major. So `1.0.0-beta` becomes `1.0.0`, and `1.2.3` becomes
+   * `2.0.0`
+   *
+   * - `'minor'` If the version is a `M.m.0-...` version with a prerelease, then
+   * simply drop the prerelease. Otherwise, set the patch to 0, and increment the
+   * minor. So `1.2.0-beta` becomes `1.2.0`, and `1.2.3` becomes `1.3.0`.
+   *
+   * - `'patch'` If the version has a prerelease, then simply drop the
+   * prerelease. Otherwise, increment the patch value. So `1.2.3-beta` becomes
+   * `1.2.3` and `1.2.3` becomes `1.2.4`.
+   *
+   * - `'premajor'` Set the patch and minor versions to `0`, increment the major
+   * version, and add a prerelease, using the optional identifier.
+   *
+   * - `'preminor'` Set the patch version to `0`, increment the minor version,
+   * and add a prerelease, using the optional identifier.
+   *
+   * - `'prepatch'` If a prerelease is already present, increment the patch
+   * version, otherwise leave it untouched, and add a prerelease, using the
+   * optional identifier.
+   *
+   * - `'prerelease'` If a prerelease version is present, then behave the same as
+   * `'prepatch'`. Otherwise, add a prerelease, using the optional identifier.
+   *
+   * - `'pre'` This is mostly for use by the other prerelease incrementers.
+   *
+   *     - If a prerelease identifier is provided:
+   *
+   *        Update that named portion of the prerelease. For example,
+   *        `inc('1.2.3-beta.4', 'pre', 'beta')` would result in `1.2.3-beta.5`.
+   *
+   *        If there is no prerelease identifier by that name, then replace the
+   *        prerelease with `[name]`. So `inc('1.2.3-alpha.4', 'pre', 'beta')`
+   *        would result in `1.2.3-beta`.
+   *
+   *        If the prerelease identifer is present, but has no numeric value
+   *        following it, then add `0`. So `inc('1.2.3-beta', 'pre', 'beta')`
+   *        would result in `1.2.3-beta.0`.
+   *
+   *     - If no prerelease identifier is provided:
+   *
+   *       If there is no current prerelease, then set the prerelease to `0`. So,
+   *       `inc('1.2.3', 'pre')` becomes `1.2.3-0`.
+   *
+   *       If the last item in the prerelease is numeric, then increment it. So,
+   *       `inc('1.2.3-beta.3', 'pre')` becomes `1.2.3-beta.4`.
+   */
+  inc(part, prereleaseIdentifier) {
+    switch (part) {
+      case "premajor":
+        this.prerelease = void 0;
+        this.patch = 0;
+        this.minor = 0;
+        this.major++;
+        this.inc("pre", prereleaseIdentifier);
+        break;
+      case "preminor":
+        this.prerelease = void 0;
+        this.patch = 0;
+        this.minor++;
+        this.inc("pre", prereleaseIdentifier);
+        break;
+      case "prepatch":
+        this.prerelease = void 0;
+        this.inc("patch");
+        this.inc("pre", prereleaseIdentifier);
+        break;
+      case "prerelease":
+        if (!this.prerelease?.length)
+          this.inc("patch", prereleaseIdentifier);
+        this.inc("pre", prereleaseIdentifier);
+        break;
+      case "pre": {
+        if (!prereleaseIdentifier) {
+          if (!this.prerelease?.length) {
+            this.prerelease = [0];
+            break;
+          }
+          const last = this.prerelease[this.prerelease.length - 1];
+          if (typeof last === "number") {
+            this.prerelease[this.prerelease.length - 1] = last + 1;
+          } else {
+            this.prerelease.push(0);
+          }
+          break;
+        }
+        if (!this.prerelease?.length) {
+          this.prerelease = [prereleaseIdentifier];
+          break;
+        }
+        const i2 = this.prerelease.indexOf(
+          maybeNumber(prereleaseIdentifier)
+        );
+        if (i2 === -1) {
+          this.prerelease = [prereleaseIdentifier];
+          break;
+        }
+        const baseValue = this.prerelease[i2 + 1];
+        if (typeof baseValue === "number") {
+          this.prerelease[i2 + 1] = baseValue + 1;
+          break;
+        }
+        if (i2 === this.prerelease.length - 1) {
+          this.prerelease.push(0);
+          break;
+        }
+        this.prerelease.splice(i2 + 1, 0, 0);
+        break;
+      }
+      case "major":
+        if (!this.prerelease?.length || this.minor || this.patch)
+          this.major++;
+        this.prerelease = void 0;
+        this.patch = 0;
+        this.minor = 0;
+        break;
+      case "minor":
+        if (!this.prerelease?.length || this.patch) this.minor++;
+        this.prerelease = void 0;
+        this.patch = 0;
+        break;
+      case "patch":
+        if (!this.prerelease?.length) this.patch++;
+        this.prerelease = void 0;
+        break;
+      default:
+        throw typeError(
+          "Invalid increment identifier",
+          {
+            version: this,
+            found: part,
+            validOptions: [
+              "major",
+              "minor",
+              "patch",
+              "premajor",
+              "preminor",
+              "prepatch",
+              "prerelease",
+              "pre"
+            ]
+          },
+          this.inc
+        );
+    }
+    this.raw = this.toString();
+    return this;
+  }
+};
+
 // ../../src/semver/src/comparator.ts
+var isOperator = (o) => !!o && (o === ">" || o === "<" || o === ">=" || o === "<=" || o === "" || o === "~" || o === "^" || o === "~>");
 var preJunk = new Set("=v 	");
+var invalidComp = (c, message) => syntaxError(
+  `invalid comparator: '${c}' ${message}`,
+  { found: c },
+  Comparator
+);
+var assertNumber = (value, c, field) => {
+  const n7 = Number(value);
+  if (n7 !== n7) {
+    throw invalidComp(
+      c,
+      `${field} must be numeric or 'x', got: '${value}'`
+    );
+  }
+  return n7;
+};
+var assertVersion = (v3, comp) => {
+  if (!v3) {
+    throw invalidComp(comp, "no value provided for operator");
+  }
+};
+var assertMissing = (value, c, field) => {
+  if (value && !isX(value)) {
+    throw invalidComp(
+      c,
+      `cannot omit '${field}' and include subsequent fields`
+    );
+  }
+};
+var MAJOR = 0;
+var MINOR = 1;
+var PATCH = 2;
+var isX = (c) => !c || c === "X" || c === "x" || c === "*";
+var isFullVersion = (parsed) => void 0 !== parsed[PATCH];
+var isXPatch = (parsed) => void 0 !== parsed[MINOR] && void 0 === parsed[PATCH];
+var isXMinor = (parsed) => void 0 !== parsed[MAJOR] && void 0 === parsed[MINOR];
+var isXMajor = (parsed) => void 0 === parsed[MAJOR];
+var Comparator = class {
+  /**
+   * does this range include prereleases, even when they do not
+   * match the tuple in the comparator?
+   */
+  includePrerelease;
+  /** raw string used to create this comparator */
+  raw;
+  /** tokens extracted from the raw string input */
+  tokens;
+  /**
+   * Either the `any` comparator, the `none` comparator, or an operator
+   * and a {@link ParsedXRange}
+   */
+  tuples = [];
+  /** true if this comparator can not match anything */
+  isNone = false;
+  /**
+   * true if this comparator is a `'*'` type of range.
+   *
+   * Note that it still will not match versions with a prerelease value,
+   * unless the tuple in the version matches the tuple provided to the
+   * comparator, and the comparator version also has a prerelease value,
+   * unless `includePrerelease` is set.
+   */
+  isAny = false;
+  /** the canonical strict simplified parsed form of this constructor */
+  toString() {
+    return this.isNone ? "<0.0.0-0" : this.isAny ? "*" : (
+      /* c8 ignore next */
+      this.tuples.map((c) => isAny(c) ? "*" : c.join("")).join(" ")
+    );
+  }
+  constructor(comp, includePrerelease = false) {
+    this.includePrerelease = includePrerelease;
+    comp = comp.trim();
+    this.raw = comp;
+    let hyphen = false;
+    const rawComps = fastSplit(comp, " ", -1, (part, parts, i2) => {
+      if (part === "-") {
+        if (hyphen) {
+          throw invalidComp(
+            comp,
+            "multiple hyphen ranges not allowed"
+          );
+        }
+        if (parts.length !== 1 || i2 === -1) {
+          throw invalidComp(
+            comp,
+            "hyphen must be between two versions"
+          );
+        }
+        hyphen = true;
+      } else if (hyphen && parts.length !== 2) {
+        throw invalidComp(comp, "hyphen range must be alone");
+      }
+    });
+    const comps = [];
+    let followingOperator = false;
+    let l = 0;
+    for (const c of rawComps) {
+      if (c === "") continue;
+      if (!followingOperator) {
+        followingOperator = isOperator(c);
+        comps.push(c);
+        l++;
+        continue;
+      }
+      comps[l - 1] += c;
+      followingOperator = false;
+    }
+    if (hyphen) {
+      const [min, _3, max] = comps;
+      if (!min || !max) {
+        throw invalidComp(comp, "hyphen must be between two versions");
+      }
+      this.#parseHyphenRange(min, max);
+    } else if (!comps.length || comps.length === 1 && isX(comps[0])) {
+      this.tuples.push(this.#getComparatorAny());
+    } else {
+      for (const c of comps) {
+        this.#parse(c);
+        if (this.isNone) break;
+      }
+    }
+    this.tokens = comps;
+    this.isAny = true;
+    for (const c of this.tuples) {
+      if (Array.isArray(c) || !c.isAny) {
+        this.isAny = false;
+        break;
+      }
+    }
+  }
+  // inclusive min
+  #xInclusiveMin(raw) {
+    const z = this.includePrerelease ? "0" : void 0;
+    const [M3, m2 = 0, p = 0, pr = z, build] = this.#parseX(raw);
+    return M3 === void 0 ? this.#getComparatorAny() : [">=", new Version(raw, M3, m2, p, pr, build)];
+  }
+  // exclusive min
+  #xExclusiveMin(raw) {
+    const parsed = this.#parseX(raw);
+    if (isFullVersion(parsed)) {
+      return [">", new Version(raw, ...parsed)];
+    }
+    const z = this.includePrerelease ? "0" : void 0;
+    if (isXPatch(parsed)) {
+      return [
+        ">=",
+        new Version(
+          raw,
+          parsed[MAJOR],
+          parsed[MINOR] + 1,
+          0,
+          z,
+          void 0
+        )
+      ];
+    }
+    if (isXMinor(parsed)) {
+      return [
+        ">=",
+        new Version(raw, parsed[MAJOR] + 1, 0, 0, z, void 0)
+      ];
+    }
+    this.isNone = true;
+    this.tuples.length = 0;
+    return comparatorNone;
+  }
+  #xInclusiveMax(raw) {
+    const parsed = this.#parseX(raw);
+    return isFullVersion(parsed) ? ["<=", new Version(raw, ...parsed)] : isXPatch(parsed) ? [
+      "<",
+      new Version(
+        raw,
+        parsed[MAJOR],
+        parsed[MINOR] + 1,
+        0,
+        "0",
+        void 0
+      )
+    ] : isXMinor(parsed) ? [
+      "<",
+      new Version(raw, parsed[MAJOR] + 1, 0, 0, "0", void 0)
+    ] : this.#getComparatorAny();
+  }
+  #xExclusiveMax(raw) {
+    const z = this.includePrerelease ? "0" : void 0;
+    const [M3 = 0, m2 = 0, p = 0, pr = z, build] = this.#parseX(raw);
+    if (M3 === 0 && m2 === 0 && p === 0 && pr === "0") {
+      this.isNone = true;
+      this.tuples.length = 0;
+      return comparatorNone;
+    }
+    return ["<", new Version(raw, M3, m2, p, pr, build)];
+  }
+  #validXM(raw, m2, p) {
+    assertMissing(m2, raw, "major");
+    assertMissing(p, raw, "major");
+    if (m2 === "" || p === "") {
+      throw invalidComp(raw, `(Did you mean '*'?)`);
+    }
+    return [];
+  }
+  #validXm(raw, M3, m2, p) {
+    assertMissing(p, raw, "major");
+    if (m2 === "" || p === "") {
+      throw invalidComp(raw, `(Did you mean '${M3}'?)`);
+    }
+    return [assertNumber(M3, raw, "major")];
+  }
+  #validXp(raw, M3, m2, p) {
+    if (p === "") {
+      throw invalidComp(raw, `(Did you mean '${M3}.${m2}'?)`);
+    }
+    return [
+      assertNumber(M3, raw, "major"),
+      assertNumber(m2, raw, "minor")
+    ];
+  }
+  #validTuple(raw, M3, m2, p) {
+    return [
+      assertNumber(M3, raw, "major"),
+      assertNumber(m2, raw, "minor"),
+      assertNumber(p, raw, "patch")
+    ];
+  }
+  #validXbuild(raw, M3, m2, p, pl) {
+    const patch = p.substring(0, pl);
+    const build = p.substring(pl + 1);
+    if (!patch) {
+      throw invalidComp(raw, "cannot specify build without patch");
+    }
+    if (!build) {
+      throw invalidComp(raw, `encountered '+', but no build value`);
+    }
+    return [
+      assertNumber(M3, raw, "major"),
+      assertNumber(m2, raw, "minor"),
+      assertNumber(patch, raw, "patch"),
+      void 0,
+      build
+    ];
+  }
+  #validXpr(raw, M3, m2, p, hy) {
+    {
+      const patch = p.substring(0, hy);
+      const pr = p.substring(hy + 1);
+      if (!patch) {
+        throw invalidComp(
+          raw,
+          "cannot specify prerelease without patch"
+        );
+      }
+      if (!pr) {
+        throw invalidComp(
+          raw,
+          `encountered '-', but no prerelease value`
+        );
+      }
+      return [
+        assertNumber(M3, raw, "major"),
+        assertNumber(m2, raw, "minor"),
+        assertNumber(patch, raw, "patch"),
+        pr,
+        void 0
+      ];
+    }
+  }
+  #validXprbuild(raw, M3, m2, p, hy, pl) {
+    const patch = p.substring(0, hy);
+    const pr = p.substring(hy + 1, pl);
+    const build = p.substring(pl + 1);
+    if (!patch) {
+      throw invalidComp(
+        raw,
+        "cannot specify prerelease without patch"
+      );
+    }
+    if (!pr) {
+      throw invalidComp(
+        raw,
+        `encountered '-', but no prerelease value`
+      );
+    }
+    if (!build) {
+      throw invalidComp(raw, `encountered '+', but no build value`);
+    }
+    return [
+      assertNumber(M3, raw, "major"),
+      assertNumber(m2, raw, "minor"),
+      assertNumber(patch, raw, "patch"),
+      pr,
+      build
+    ];
+  }
+  // pull the relevant values out of an X-range or version
+  // return the fields for creating a Version object.
+  // only call once operator is stripped off
+  #parseX(raw) {
+    let [M3, m2, p] = fastSplit(raw, ".", 3);
+    let prune = 0;
+    while (M3 && preJunk.has(M3.charAt(prune))) prune++;
+    if (M3 !== void 0 && prune !== 0) M3 = M3.substring(prune);
+    if (!M3 || isX(M3)) return this.#validXM(raw, m2, p);
+    if (!m2 || isX(m2)) return this.#validXm(raw, M3, m2, p);
+    if (!p || isX(p)) return this.#validXp(raw, M3, m2, p);
+    const hy = p.indexOf("-");
+    const pl = p.indexOf("+");
+    if (pl === -1 && hy === -1) return this.#validTuple(raw, M3, m2, p);
+    if (pl === -1) return this.#validXpr(raw, M3, m2, p, hy);
+    if (hy === -1) return this.#validXbuild(raw, M3, m2, p, pl);
+    return this.#validXprbuild(raw, M3, m2, p, hy, pl);
+  }
+  #parseHyphenRange(min, max) {
+    const minv = this.#xInclusiveMin(min);
+    const maxv = this.#xInclusiveMax(max);
+    const minAny = isAny(minv);
+    const maxAny = isAny(maxv);
+    if (minAny && maxAny) this.tuples.push(this.#getComparatorAny());
+    else if (minAny) this.tuples.push(maxv);
+    else if (maxAny) this.tuples.push(minv);
+    else this.tuples.push(minv, maxv);
+  }
+  #parse(comp) {
+    const first = comp.charAt(0);
+    const first2 = comp.substring(0, 2);
+    const v1 = comp.substring(1);
+    const v22 = comp.substring(2);
+    switch (first2) {
+      case "~>":
+        assertVersion(v22, comp);
+        return this.#parseTilde(v22);
+      case ">=":
+        assertVersion(v22, comp);
+        return this.tuples.push(this.#xInclusiveMin(v22));
+      case "<=":
+        assertVersion(v22, comp);
+        return this.tuples.push(this.#xInclusiveMax(v22));
+    }
+    switch (first) {
+      case "~":
+        assertVersion(v1, comp);
+        return this.#parseTilde(v1);
+      case "^":
+        assertVersion(v1, comp);
+        return this.#parseCaret(v1);
+      case ">":
+        assertVersion(v1, comp);
+        return this.tuples.push(this.#xExclusiveMin(v1));
+      case "<":
+        assertVersion(v1, comp);
+        return this.tuples.push(this.#xExclusiveMax(v1));
+    }
+    return this.#parseEq(comp);
+  }
+  #parseTilde(comp) {
+    const parsed = this.#parseX(comp);
+    if (isXMajor(parsed)) {
+      this.tuples.push(this.#getComparatorAny());
+      return;
+    }
+    const z = this.includePrerelease ? "0" : void 0;
+    if (isXMinor(parsed)) {
+      const [M4] = parsed;
+      this.tuples.push(
+        [">=", new Version(comp, M4, 0, 0, z, void 0)],
+        ["<", new Version(comp, M4 + 1, 0, 0, "0", void 0)]
+      );
+      return;
+    }
+    if (isXPatch(parsed)) {
+      const [M4, m3] = parsed;
+      const z2 = this.includePrerelease ? "0" : void 0;
+      this.tuples.push(
+        [">=", new Version(comp, M4, m3, 0, z2, void 0)],
+        ["<", new Version(comp, M4, m3 + 1, 0, "0", void 0)]
+      );
+      return;
+    }
+    const [M3, m2, p, pr = z, build] = parsed;
+    this.tuples.push(
+      [">=", new Version(comp, M3, m2, p, pr, build)],
+      ["<", new Version(comp, M3, m2 + 1, 0, "0", build)]
+    );
+  }
+  #parseCaret(comp) {
+    const min = this.#xInclusiveMin(comp);
+    if (isAny(min)) {
+      this.tuples.push(min);
+      return;
+    }
+    const minv = min[1];
+    if (minv.major !== 0) {
+      this.tuples.push(min, [
+        "<",
+        new Version(comp, minv.major + 1, 0, 0, "0", void 0)
+      ]);
+    } else if (minv.minor !== 0) {
+      this.tuples.push(min, [
+        "<",
+        new Version(
+          comp,
+          minv.major,
+          minv.minor + 1,
+          0,
+          "0",
+          void 0
+        )
+      ]);
+    } else if (!minv.prerelease?.length) {
+      this.tuples.push(["", minv]);
+    } else {
+      this.tuples.push(min, [
+        "<",
+        new Version(
+          comp,
+          minv.major,
+          minv.minor,
+          minv.patch + 1,
+          "0",
+          void 0
+        )
+      ]);
+    }
+  }
+  #parseEq(comp) {
+    const parsed = this.#parseX(comp);
+    const z = this.includePrerelease ? "0" : void 0;
+    if (isFullVersion(parsed)) {
+      this.tuples.push(["", new Version(comp, ...parsed)]);
+    } else if (isXMajor(parsed)) {
+      this.tuples.push(this.#getComparatorAny());
+    } else if (isXMinor(parsed)) {
+      this.tuples.push([
+        ">=",
+        new Version(comp, parsed[MAJOR], 0, 0, z, void 0)
+      ]);
+      this.tuples.push([
+        "<",
+        new Version(comp, parsed[MAJOR] + 1, 0, 0, "0", void 0)
+      ]);
+    } else if (isXPatch(parsed)) {
+      this.tuples.push(
+        [
+          ">=",
+          new Version(
+            comp,
+            parsed[MAJOR],
+            parsed[MINOR],
+            0,
+            z,
+            void 0
+          )
+        ],
+        [
+          "<",
+          new Version(
+            comp,
+            parsed[MAJOR],
+            parsed[MINOR] + 1,
+            0,
+            "0",
+            void 0
+          )
+        ]
+      );
+    }
+  }
+  /** return true if the version is a match for this comparator */
+  test(v3) {
+    if (this.isNone) return false;
+    const ip = this.includePrerelease;
+    const hasPR = !!v3.prerelease?.length;
+    let prOK = ip || !hasPR;
+    for (const c of this.tuples) {
+      if (isAny(c)) {
+        continue;
+      }
+      const [op, cv] = c;
+      prOK ||= !!cv.prerelease?.length && v3.tupleEquals(cv);
+      switch (op) {
+        case "":
+          if (!v3.equals(cv)) return false;
+          continue;
+        case ">":
+          if (!v3.greaterThan(cv)) return false;
+          continue;
+        case ">=":
+          if (!v3.greaterThanEqual(cv)) return false;
+          continue;
+        case "<":
+          if (!v3.lessThan(cv)) return false;
+          continue;
+        case "<=":
+          if (!v3.lessThanEqual(cv)) return false;
+          continue;
+      }
+    }
+    return prOK;
+  }
+  #getComparatorAny() {
+    return this.includePrerelease ? comparatorAnyPR : comparatorAny;
+  }
+};
+var isAny = (c) => c === comparatorAny || c === comparatorAnyPR;
+var comparatorAny = {
+  isAny: true,
+  toString: () => "*",
+  includePrerelease: false,
+  test: (v3) => !v3.prerelease?.length
+};
+var comparatorAnyPR = {
+  isAny: true,
+  toString: () => "*",
+  includePrerelease: true,
+  test: (_3) => true
+};
+var comparatorNone = {
+  isNone: true,
+  toString: () => "<0.0.0-0",
+  includePrerelease: false,
+  test: (_3) => false
+};
+
+// ../../src/semver/src/range.ts
+var Range = class {
+  /** raw string used to create this Range */
+  raw;
+  /** true if the range is `*` */
+  isAny;
+  /** true if the range is a single semver version */
+  isSingle;
+  /** true if the range cannot match anything */
+  /**
+   * set of {@link Comparator} objects representing the `||`-separated sections
+   * of the range. If at least one of these matches, then the version is a
+   * match.
+   */
+  set = [];
+  /** true if all prerelease versions should be included */
+  includePrerelease;
+  /** cached toString */
+  #toString;
+  constructor(range, includePrerelease = false) {
+    this.raw = range;
+    this.includePrerelease = includePrerelease;
+    this.isAny = false;
+    let isFirst = true;
+    this.isSingle = false;
+    const comparatorErrors = [];
+    fastSplit(range, "||", -1, (part) => {
+      if (this.isAny) return;
+      const cmp = this.#maybeComparator(part, this.includePrerelease);
+      if (cmp instanceof Error) {
+        comparatorErrors.push(cmp);
+        return;
+      }
+      if (cmp.isAny) {
+        this.set = [cmp];
+        this.isAny = true;
+        return;
+      }
+      this.set.push(cmp);
+      if (!isFirst) this.isSingle = false;
+      else if (Array.isArray(cmp.tuples) && cmp.tuples.length === 1 && Array.isArray(cmp.tuples[0]) && cmp.tuples[0][0] === "") {
+        this.isSingle = true;
+      }
+      isFirst = false;
+    });
+    if (!this.set.length && comparatorErrors.length) {
+      if (comparatorErrors.length === 1 && comparatorErrors[0]) {
+        throw comparatorErrors[0];
+      }
+      throw new AggregateError(comparatorErrors);
+    }
+  }
+  #maybeComparator(part, includePrerelease) {
+    try {
+      return new Comparator(part, includePrerelease);
+    } catch (er) {
+      return asError(er);
+    }
+  }
+  /**
+   * test a {@link Version} against the range
+   */
+  test(v3) {
+    return this.set.some((c) => c.test(v3));
+  }
+  /** return the simplified canonical form of this range */
+  toString() {
+    if (this.#toString) return this.#toString;
+    if (this.isSingle) {
+      this.#toString = String(this.set[0]);
+      return this.#toString;
+    }
+    this.#toString = this.set.map((c) => String(c)).join(" || ");
+    return this.#toString;
+  }
+};
+
+// ../../src/semver/src/index.ts
+var parseRange = (range, includePrerelease = false) => {
+  if (typeof range === "object") {
+    if (range.includePrerelease === includePrerelease) return range;
+    range = range.raw;
+  }
+  try {
+    return new Range(range, includePrerelease);
+  } catch {
+    return void 0;
+  }
+};
+
+// ../../src/spec/src/valid-name.ts
+var pathSafeName = /^(?!(?:node_modules|\.vlt)$)(?![A-Za-z]:)(?:@(?!\.\.?\/)[^/\\\x00-\x1f\x7f]+\/)?(?!\.\.?$)[^/\\\x00-\x1f\x7f]+$/i;
+var isPathSafeName = (name) => typeof name === "string" && pathSafeName.test(name);
+var assertPathSafeName = (name, from) => {
+  if (isPathSafeName(name)) return;
+  throw error(
+    "Invalid package name: not usable as a path segment",
+    {
+      code: "EINVALIDNAME",
+      found: name,
+      from,
+      wanted: "a single path segment, or a well-formed @scope/name"
+    },
+    assertPathSafeName
+  );
+};
+
+// ../../src/spec/src/browser.ts
+var kCustomInspect = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
+var defaultRegistryName = "npm";
+var defaultRegistries = {
+  gh: "https://npm.pkg.github.com/"
+};
+var defaultJsrRegistries = { jsr: "https://npm.jsr.io/" };
+var defaultGitHosts = {
+  github: "git+ssh://git@github.com:$1/$2.git",
+  bitbucket: "git+ssh://git@bitbucket.org:$1/$2.git",
+  gitlab: "git+ssh://git@gitlab.com:$1/$2.git",
+  gist: "git+ssh://git@gist.github.com/$1.git"
+};
+var defaultGitHostArchives = {
+  github: "https://api.github.com/repos/$1/$2/tarball/$committish",
+  bitbucket: "https://bitbucket.org/$1/$2/get/$committish.tar.gz",
+  gist: "https://codeload.github.com/gist/$1/tar.gz/$committish",
+  gitlab: "https://gitlab.com/$1/$2/repository/archive.tar.gz?ref=$committish"
+};
+var gitHostWebsites = {
+  github: "https://github.com/",
+  bitbucket: "https://bitbucket.org/",
+  gist: "https://gist.github.com/",
+  gitlab: "https://gitlab.com/"
+};
+var getOptions = (options) => ({
+  catalog: {},
+  catalogs: {},
+  ...options,
+  // built-in aliases are user/service-overridable: user config wins
+  "jsr-registries": {
+    ...defaultJsrRegistries,
+    ...options?.["jsr-registries"] ?? {}
+  },
+  registry: options?.registry,
+  "default-registry-alias": options?.["default-registry-alias"] ?? defaultRegistryName,
+  "scoped-registries": options?.["scoped-registries"] ?? {},
+  "git-hosts": options?.["git-hosts"] ? {
+    ...defaultGitHosts,
+    ...options["git-hosts"]
+  } : defaultGitHosts,
+  registries: {
+    ...defaultRegistries,
+    ...options?.registries ?? {}
+  },
+  "git-host-archives": options?.["git-host-archives"] ? {
+    ...defaultGitHostArchives,
+    ...options["git-host-archives"]
+  } : defaultGitHostArchives
+});
+var startsWithSpecIdentifier = (spec, options) => spec.startsWith("/") || spec.startsWith("./") || spec.startsWith("../") || spec.startsWith("file:") || spec.startsWith("http:") || spec.startsWith("https:") || spec.startsWith("workspace:") || spec.startsWith("catalog:") || spec.startsWith("git@") || spec.startsWith("git://") || spec.startsWith("git+ssh://") || spec.startsWith("git+http://") || spec.startsWith("git+https://") || spec.startsWith("git+file://") || spec.startsWith("git@github.com") || spec.startsWith("registry:") || spec.startsWith("npm:") || spec.startsWith("jsr:") || spec.startsWith("gh:") || // anything that starts with a known git host key, or a
+// custom registered registry protocol e.g: `github:`, `custom:`
+[
+  ...Object.keys(options["git-hosts"]),
+  ...Object.keys(options.registries),
+  ...Object.keys(options["jsr-registries"])
+].some((key) => spec.startsWith(`${key}:`));
+var findFirstAt = (spec, hasScope) => spec.indexOf("@", hasScope ? 1 : 0);
+var findGitIdentifier = (spec) => spec.indexOf("#") > 2;
+var findFileIdentifier = (spec) => spec.includes("/");
+var Spec = class _Spec {
+  static parse(spec, bareOrOptions, options) {
+    return typeof spec === "object" ? spec : new this(spec, bareOrOptions, options);
+  }
+  static parseArgs(specOrBareSpec, opts) {
+    const options = getOptions(opts ?? {});
+    if (startsWithSpecIdentifier(specOrBareSpec, options)) {
+      const parsed = this.parse("(unknown)", specOrBareSpec, options);
+      if (parsed.subspec) {
+        const { namedJsrRegistry: jsrHost } = parsed;
+        if (!jsrHost) {
+          parsed.name = parsed.subspec.name;
+        }
+        parsed.spec = `${parsed.name}@${parsed.bareSpec}`;
+        assertPathSafeName(parsed.name, parsed.spec);
+      }
+      return parsed;
+    } else {
+      const hasScope = specOrBareSpec.startsWith("@");
+      const at2 = findFirstAt(specOrBareSpec, hasScope);
+      if (at2 > -1) {
+        return this.parse(
+          specOrBareSpec.substring(0, at2),
+          specOrBareSpec.substring(at2 + 1),
+          options
+        );
+      } else if (findGitIdentifier(specOrBareSpec) || !hasScope && findFileIdentifier(specOrBareSpec)) {
+        return this.parse("(unknown)", specOrBareSpec, options);
+      } else {
+        return this.parse(`${specOrBareSpec}@`, options);
+      }
+    }
+  }
+  static nodejsDependencies;
+  type;
+  spec;
+  options;
+  name;
+  scope;
+  scopeRegistry;
+  bareSpec;
+  gitRemote;
+  gitSelector;
+  gitSelectorParsed;
+  gitCommittish;
+  namedGitHost;
+  namedGitHostPath;
+  workspaceSpec;
+  workspace;
+  namedRegistry;
+  namedJsrRegistry;
+  registry;
+  registrySpec;
+  conventionalRegistryTarball;
+  semver;
+  range;
+  distTag;
+  remoteURL;
+  file;
+  catalog;
+  subspec;
+  overridden = false;
+  #final;
+  #toString;
+  /**
+   * Return the final entry in the chain of subspecs
+   * When deciding which thing to actually fetch, spec.final is the thing
+   * to look at.
+   */
+  get final() {
+    if (this.#final) return this.#final;
+    const final = this.subspec ? this.subspec.final : this;
+    if (final.type === "catalog") {
+      throw error('invalid Spec.final value, type is "catalog"');
+    }
+    return this.#final = final;
+  }
+  /**
+   * Normally, the string value of a Spec is just the string passed in to
+   * be parsed. However, in the case of a chain of subspecs, like
+   * `foo@npm:bar@npm:baz@npm:quux@latest`, this simplifies out the middle
+   * parts of the chain, returning just `foo@npm:quux@latest`
+   */
+  toString() {
+    if (this.#toString !== void 0) return this.#toString;
+    let sub = this;
+    while (sub.subspec?.subspec) sub = sub.subspec;
+    if (sub.subspec && sub.subspec.type !== "registry")
+      sub = sub.subspec;
+    return this.#toString = this.name + "@" + sub.bareSpec;
+  }
+  constructor(spec, bareOrOptions, options = {}) {
+    if (bareOrOptions && typeof bareOrOptions === "object") {
+      options = bareOrOptions;
+      bareOrOptions = void 0;
+    }
+    this.options = getOptions(options);
+    if (typeof bareOrOptions === "string") {
+      this.name = spec;
+      this.#parseScope(spec);
+      this.bareSpec = bareOrOptions;
+      this.spec = `${this.name}@${bareOrOptions}`;
+      assertPathSafeName(this.name, this.spec);
+    } else {
+      this.spec = spec;
+      if (!spec.startsWith("git@") && startsWithSpecIdentifier(spec, this.options) && spec.includes(":") && [
+        ...Object.keys(this.options.registries),
+        ...Object.keys(defaultRegistries)
+      ].some((key) => spec.startsWith(`${key}:`))) {
+        this.name = spec;
+        this.bareSpec = spec;
+      } else {
+        const hasScope = spec.startsWith("@");
+        let at2 = findFirstAt(spec, hasScope);
+        if (at2 === -1) {
+          at2 = spec.length;
+          spec += "@";
+        }
+        this.name = spec.substring(0, at2);
+        assertPathSafeName(this.name, spec);
+        if (hasScope) this.#parseScope(this.name);
+        this.bareSpec = spec.substring(at2 + 1);
+      }
+    }
+    if (this.bareSpec.startsWith("catalog:")) {
+      this.catalog = this.bareSpec.substring("catalog:".length);
+      const catalog = this.catalog ? this.options.catalogs?.[this.catalog] : this.options.catalog;
+      if (!catalog) {
+        throw this.#error("Named catalog not found", {
+          name: this.catalog,
+          validOptions: this.options.catalogs && Object.keys(this.options.catalogs)
+        });
+      }
+      const sub = catalog[this.name];
+      if (!sub) {
+        throw this.#error("Name not found in catalog", {
+          name: this.name,
+          validOptions: Object.keys(catalog)
+        });
+      }
+      this.subspec = _Spec.parse(this.name, sub, this.options);
+      this.type = "catalog";
+      this.registry = this.subspec.final.registry;
+      return;
+    }
+    if (this.bareSpec.startsWith("https://")) {
+      for (const [name, origin] of Object.entries(gitHostWebsites)) {
+        if (this.bareSpec.startsWith(origin)) {
+          const parsed = new URL(this.bareSpec);
+          const [user, project] = parsed.pathname.replace(/\.git$/, "").replace(/\/+/g, " ").trim().split(" ");
+          if (user && project) {
+            this.bareSpec = `${name}:${user}/${project}${parsed.hash}`;
+            this.spec = `${this.name}@${this.bareSpec}`;
+            break;
+          }
+        }
+      }
+    }
+    if (this.bareSpec.startsWith("workspace:")) {
+      this.type = "workspace";
+      const ws2 = this.bareSpec.substring("workspace:".length).trim();
+      const w2 = ws2.lastIndexOf("@");
+      if (w2 === -1) {
+        this.workspace = this.name;
+      } else {
+        const wsName = ws2.substring(0, w2);
+        if (!wsName || wsName === "*" || wsName === "~" || wsName === "^" || (wsName.startsWith("@") ? wsName.split("/").length !== 2 || wsName.substring(1).includes("@") : wsName.includes("@"))) {
+          throw this.#error(
+            "workspace: name must be a path or valid package name",
+            { found: wsName }
+          );
+        }
+        this.workspace = wsName;
+      }
+      const wss = w2 === -1 ? ws2 : ws2.substring(w2 + 1) || "*";
+      const range2 = wss === "*" ? void 0 : parseRange(wss);
+      if (wss !== "*" && wss !== "~" && wss !== "^" && !range2) {
+        throw this.#error(
+          "workspace: spec must be one of *, ~, or ^, or a valid semver range",
+          {
+            found: wss,
+            wanted: `'*'|'~'|'^'|SemverRange`
+          }
+        );
+      }
+      this.workspaceSpec = wss;
+      if (range2) {
+        this.semver = wss;
+        this.range = range2;
+      }
+      return;
+    }
+    if (this.bareSpec.startsWith("git://") || this.bareSpec.startsWith("git+ssh://") || this.bareSpec.startsWith("git+http://") || this.bareSpec.startsWith("git+https://") || this.bareSpec.startsWith("git+file://") || // legacy affordance
+    this.bareSpec.startsWith("git@github.com")) {
+      if (this.bareSpec.startsWith("git@")) {
+        this.bareSpec = `git+ssh://${this.bareSpec}`;
+        this.spec = `${this.name}@${this.bareSpec}`;
+      }
+      this.type = "git";
+      for (const [name, host] of Object.entries(
+        this.options["git-hosts"]
+      )) {
+        const s = host.indexOf("$");
+        if (s > 0 && this.bareSpec.startsWith(host.substring(0, s))) {
+          const p = this.bareSpec.substring(s).replace(/\.git(#.*)?$/, "$1");
+          this.bareSpec = `${name}:${p}`;
+          this.spec = `${this.name}@${this.bareSpec}`;
+          this.#parseHostedGit(name, host);
+          this.type = "git";
+          return;
+        }
+      }
+      this.#parseGitSelector(this.bareSpec);
+      return;
+    }
+    const regs = Object.entries(this.options.registries);
+    if (this.bareSpec.startsWith("registry:")) {
+      const reg = this.bareSpec.substring("registry:".length);
+      const h = reg.indexOf("#");
+      if (h === -1) {
+        throw this.#error("registry: must include name/version");
+      }
+      this.type = "registry";
+      let url = reg.substring(0, h);
+      if (!url.endsWith("/")) url += "/";
+      const regSpec = reg.substring(h + 1);
+      for (let [name, u2] of regs) {
+        if (!u2.endsWith("/")) {
+          u2 += "/";
+          this.options.registries[name] = u2;
+        }
+        if (u2 === url) this.namedRegistry = name;
+      }
+      this.#parseRegistrySpec(regSpec, url);
+      this.#guessRegistryTarball();
+      return;
+    }
+    for (const [host, url] of regs) {
+      const h = `${host}:`;
+      if (this.bareSpec.startsWith(h)) {
+        this.type = "registry";
+        this.namedRegistry = host;
+        this.#parseRegistrySpec(
+          this.bareSpec.substring(h.length),
+          url
+        ).namedRegistry ??= host;
+        if (this.subspec && this.name === this.bareSpec) {
+          this.name = this.subspec.name;
+          this.spec = `${this.name}@${this.bareSpec}`;
+          assertPathSafeName(this.name, this.spec);
+        }
+        this.#guessRegistryTarball();
+        return;
+      }
+    }
+    const ghosts = Object.entries(this.options["git-hosts"]);
+    for (const [name, template] of ghosts) {
+      if (this.#parseHostedGit(name, template)) {
+        this.type = "git";
+        return;
+      }
+    }
+    const jsrs = Object.entries(this.options["jsr-registries"]);
+    for (const [host, url] of jsrs) {
+      const h = `${host}:`;
+      if (this.bareSpec.startsWith(h)) {
+        this.type = "registry";
+        this.namedJsrRegistry = host;
+        this.#parseJsrRegistrySpec(
+          this.bareSpec.substring(h.length),
+          url
+        ).namedJsrRegistry ??= host;
+        return;
+      }
+    }
+    if (this.bareSpec.startsWith("https://") || this.bareSpec.startsWith("http://")) {
+      this.remoteURL = this.bareSpec;
+      this.type = "remote";
+      return;
+    }
+    if (this.bareSpec.startsWith("file:")) {
+      this.type = "file";
+      const [path2, uri] = getNormalizeFile(
+        this.constructor.nodejsDependencies
+      )(this.bareSpec, this);
+      this.file = path2;
+      this.bareSpec = uri.replace(/\/+$/, "");
+      this.spec = `${this.name}@${this.bareSpec}`;
+      return;
+    }
+    if (!this.bareSpec.startsWith("./") && !this.bareSpec.startsWith("../") && this.options["git-hosts"].github) {
+      const hash2 = this.bareSpec.indexOf("#");
+      const up = hash2 === -1 ? this.bareSpec : this.bareSpec.substring(0, hash2);
+      if (up.split("/").length === 2) {
+        this.bareSpec = `github:${this.bareSpec}`;
+        this.spec = `${this.name}@${this.bareSpec}`;
+        this.#parseHostedGit(
+          "github",
+          this.options["git-hosts"].github
+        );
+        this.type = "git";
+        return;
+      }
+    }
+    if (this.bareSpec.includes("/") || this.bareSpec === "." || this.bareSpec === "..") {
+      this.type = "file";
+      const [file, uri] = getNormalizeFile(
+        this.constructor.nodejsDependencies
+      )(`file:${this.bareSpec}`, this);
+      this.bareSpec = uri;
+      this.spec = `${this.name}@${this.bareSpec}`;
+      this.file = file;
+      return;
+    }
+    this.type = "registry";
+    const range = parseRange(this.bareSpec);
+    if (range) {
+      this.semver = this.bareSpec.trim();
+      this.range = range;
+    } else {
+      this.distTag = this.bareSpec;
+    }
+    this.registrySpec = this.bareSpec;
+    const {
+      "scoped-registries": scopeRegs,
+      registry,
+      registries,
+      "default-registry-alias": defaultAlias
+    } = this.options;
+    const scopeReg = this.scope && scopeRegs[this.scope];
+    this.registry = scopeReg ?? registry ?? registries[defaultAlias];
+    for (const r of Object.values(this.options["jsr-registries"])) {
+      if (this.registry === r) return;
+    }
+    this.#guessRegistryTarball();
+  }
+  #parseScope(name) {
+    if (!name.startsWith("@")) return;
+    const s = name.indexOf("/");
+    if (s > 1 && s < name.length - 1) {
+      const scope = name.substring(0, s);
+      this.registry = this.scopeRegistry = this.options["scoped-registries"][scope];
+      this.scope = scope;
+    }
+  }
+  #parseHostedGit(name, template) {
+    if (this.bareSpec.startsWith(`${name}:`)) {
+      const h = this.bareSpec.indexOf("#");
+      const bare = h === -1 ? this.bareSpec : this.bareSpec.substring(0, h);
+      const hash2 = h === -1 ? "" : this.bareSpec.substring(h);
+      const hostPath = bare.substring(name.length + 1);
+      if (!hostPath) {
+        throw this.#error("invalid named git host specifier");
+      }
+      const split = hostPath.split("/");
+      let t = template;
+      for (let i2 = 0; i2 < split.length; i2++) {
+        t = t.split(`$${i2 + 1}`).join(split[i2]);
+      }
+      t += hash2;
+      this.namedGitHost = name;
+      this.namedGitHostPath = hostPath;
+      this.#parseGitSelector(t);
+      if (this.gitCommittish && !this.gitSelectorParsed?.path) {
+        const archiveHost = this.options["git-host-archives"][name];
+        if (name === "github" && this.gitCommittish.startsWith("pull/") && this.gitCommittish.match(/\//g)?.length === 1) {
+          this.gitCommittish += "/head";
+        }
+        if (archiveHost) {
+          this.type = "remote";
+          let t2 = archiveHost;
+          t2 = t2.split("$committish").join(this.gitCommittish);
+          for (let i2 = 0; i2 < split.length; i2++) {
+            t2 = t2.split(`$${i2 + 1}`).join(split[i2]);
+          }
+          this.remoteURL = t2;
+        }
+      }
+      return true;
+    }
+    return false;
+  }
+  /* c8 ignore start */
+  [kCustomInspect]() {
+    return `@vltpkg/spec.Spec ${String(this)}`;
+  }
+  /* c8 ignore stop */
+  #guessRegistryTarball() {
+    const { name, registry, range } = this.final;
+    if (!registry || !range?.isSingle) return;
+    const stripScope = /^@[^/]+\//;
+    const base = registry.endsWith("/") ? registry : registry + "/";
+    this.conventionalRegistryTarball = String(
+      new URL(
+        `${name}/-/${name.replace(stripScope, "")}-${range}.tgz`,
+        base
+      )
+    );
+  }
+  #parseRegistrySpec(s, url) {
+    this.registry = url;
+    this.subspec = this.constructor.parse(s, {
+      ...this.options,
+      registry: url
+    });
+    return this.subspec;
+  }
+  #parseJsrRegistrySpec(s, url) {
+    this.registry = url;
+    if (!s.startsWith("@")) s = `${this.name}@${s}`;
+    const name = s.startsWith("@jsr/") ? s : `@jsr/${s.replace(/^@/, "").replace(/\//, "__")}`;
+    this.subspec = this.constructor.parse(name, {
+      ...this.options,
+      "scoped-registries": {
+        ...this.options["scoped-registries"],
+        "@jsr": url
+      }
+    });
+    if (this.name === "(unknown)") {
+      const nextAt = s.indexOf("@", 1);
+      if (nextAt === -1) {
+        this.name = s;
+      } else {
+        this.name = s.substring(0, s.indexOf("@", 1));
+      }
+      assertPathSafeName(this.name, s);
+    }
+    const reg = `${this.namedJsrRegistry}:`;
+    const n7 = `${reg}${this.name}`;
+    if (this.bareSpec.startsWith(n7 + "@")) {
+      this.bareSpec = reg + this.bareSpec.substring(n7.length + 1);
+    } else if (this.bareSpec === n7) {
+      this.bareSpec = reg;
+    }
+    this.spec = this.name + "@" + this.bareSpec;
+    return this.subspec;
+  }
+  #error(message, extra = {}) {
+    return error(message, { spec: this.spec, ...extra }, this.#error);
+  }
+  #parseGitSelector(s) {
+    const h = s.indexOf("#");
+    if (h === -1) {
+      this.gitRemote = s;
+      return;
+    }
+    this.gitRemote = s.substring(0, h);
+    this.gitSelector = s.substring(h + 1);
+    const [selectorParsed, committish, range] = this.constructor.parseGitSelector(this.gitSelector, this);
+    this.range = range;
+    this.gitCommittish = committish;
+    this.gitSelectorParsed = selectorParsed;
+  }
+  /**
+   * Should only ever be called with the bit that comes AFTER the #
+   * in the git remote url.
+   */
+  static parseGitSelector(selector, spec) {
+    if (!selector) return [{}];
+    const split = selector.split("::");
+    const first = split[0];
+    let committish = void 0;
+    let range = void 0;
+    const parsed = {};
+    if (typeof first !== "string") {
+      throw typeError("impossible", {
+        found: first,
+        wanted: String
+      });
+    }
+    if (!first.includes(":")) {
+      committish = first;
+      split.shift();
+    }
+    for (const kv of split) {
+      const c = kv.indexOf(":");
+      if (c === -1) continue;
+      const k4 = kv.substring(0, c);
+      const v3 = kv.substring(c + 1);
+      if (k4 === "semver") {
+        if (committish) {
+          throw error(
+            "Cannot specify a semver range and committish value",
+            { spec }
+          );
+        }
+        range = parseRange(v3);
+        if (!range) {
+          throw error(`Invalid git tag semver range: ${v3}`, { spec });
+        }
+      }
+      if (k4 === "semver" || k4 === "path") {
+        if (k4 === "path") {
+          if (
+            /* c8 ignore next */
+            this.nodejsDependencies?.isAbsolute(
+              v3
+            ) || /(^|\/|\\)\.\.($|\\|\/)/.test(v3)
+          ) {
+            throw error("Invalid path in git selector", { spec });
+          }
+          parsed.path = (this.nodejsDependencies ? this.nodejsDependencies.join("/", v3).substring(1) : v3).replace(/\\/g, "/");
+        } else {
+          parsed[k4] = v3;
+        }
+      }
+    }
+    return [parsed, committish, range];
+  }
+};
+var getNormalizeFile = (opts) => (bareSpec, spec) => {
+  const slashes = bareSpec.substring(
+    "file:".length,
+    "file://".length
+  );
+  const pref = `file:${slashes === "//" ? slashes : ""}`;
+  const rest = bareSpec.substring(pref.length);
+  const [a2 = "", b = "/", c = "/", d4 = "/"] = rest.split("", 4);
+  if (!a2) {
+    return [".", "file:."];
+  }
+  if (a2 === "/" && b === "~" && c !== "/" || a2 === "~" && b !== "/") {
+    throw error(
+      `invalid file: specifier. '~username' not supported`,
+      { spec }
+    );
+  }
+  if (a2 === "~") {
+    return (
+      /* c8 ignore start */
+      opts ? [
+        opts.resolve(opts.homedir(), rest.substring(2)),
+        `file:${rest}`
+      ] : [rest, `file:${rest}`]
+    );
+  }
+  if (a2 === "/" && b === "~") {
+    return opts ? [
+      opts.resolve(opts.homedir(), rest.substring(3)),
+      `file:${rest.substring(1)}`
+    ] : (
+      /* c8 ignore stop */
+      [rest.substring(1), `file:${rest.substring(1)}`]
+    );
+  }
+  if (a2 === "/" && b === "." && (c === "/" || c === "." && d4 === "/")) {
+    return [rest.substring(1), `file:${rest.substring(1)}`];
+  }
+  if (a2 === "." && (b === "/" || b === "." && c === "/")) {
+    return [rest, `file:${rest}`];
+  }
+  if (slashes === "//") {
+    try {
+      const parsed = new URL(bareSpec);
+      if (parsed.host) {
+        if (parsed.host !== "localhost") {
+          throw error(
+            `invalid file:// specifier. host must be empty or 'localhost'`,
+            {
+              spec,
+              found: parsed.host,
+              validOptions: ["", "localhost"]
+            }
+          );
+        }
+      }
+      return [
+        parsed.pathname.replace(/^\/([a-zA-Z]:\/)/, "$1"),
+        `file://${parsed.pathname}`
+      ];
+    } catch (er) {
+      throw error("invalid file:// specifier", {
+        spec,
+        cause: er
+      });
+    }
+  }
+  if (opts?.winPath.isAbsolute(rest)) {
+    return [rest, `file://${rest}`];
+  }
+  return [`./${rest}`, `file:./${rest}`];
+};
 
 // ../../src/types/src/index.ts
+import { debuglog } from "node:util";
+var debug = debuglog("vlt");
 var asError = (er, fallbackMessage = "Unknown error") => er instanceof Error ? er : new Error(String(er) || fallbackMessage);
 
 // ../../src/output/src/index.ts
@@ -30659,7 +32315,7 @@ var readSize = (buf, offset) => {
   }
   return a2 << 24 | b << 16 | c << 8 | d4;
 };
-var kCustomInspect = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
+var kCustomInspect2 = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
 var CacheEntry = class _CacheEntry {
   #statusCode;
   /** The raw headers as an array of buffers */
@@ -30748,7 +32404,7 @@ var CacheEntry = class _CacheEntry {
       }).filter(([_3, v3]) => v3 !== void 0)
     );
   }
-  [kCustomInspect](depth, options) {
+  [kCustomInspect2](depth, options) {
     const str = inspect2(this.toJSON(), {
       depth,
       ...options