vlt 0.0.0-0.1727821659739 → 0.0.0-0.1728676223960

package/commands/exec.js

@@ -1,14 +1,14 @@
 import process from"node:process"
 import {Buffer} from"node:buffer"
 import {setImmediate, clearImmediate} from"node:timers"
-import {resolve  as resolve_57b2860c9b55} from"node:path"
-import {pathToFileURL  as pathToFileURL_57b2860c9b55} from"node:url"
-import {createRequire  as createRequire_57b2860c9b55} from"node:module"
+import {resolve  as resolve_d37a7373e648} from"node:path"
+import {pathToFileURL  as pathToFileURL_d37a7373e648} from"node:url"
+import {createRequire  as createRequire_d37a7373e648} from"node:module"
 var global = globalThis
-var __bundleDirname_57b2860c9b55 = resolve_57b2860c9b55(import.meta.dirname, "..")
-var __bundleFilename_57b2860c9b55 = resolve_57b2860c9b55(__bundleDirname_57b2860c9b55, "exec.js")
-var __bundleUrl_57b2860c9b55 = pathToFileURL_57b2860c9b55(__bundleFilename_57b2860c9b55).toString()
-var require = createRequire_57b2860c9b55(__bundleFilename_57b2860c9b55)
+var __bundleDirname_d37a7373e648 = resolve_d37a7373e648(import.meta.dirname, "..")
+var __bundleFilename_d37a7373e648 = resolve_d37a7373e648(__bundleDirname_d37a7373e648, "exec.js")
+var __bundleUrl_d37a7373e648 = pathToFileURL_d37a7373e648(__bundleFilename_d37a7373e648).toString()
+var require = createRequire_d37a7373e648(__bundleFilename_d37a7373e648)
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -1899,15 +1899,17 @@ var Comparator = class {
     });
     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[comps.length - 1] += c;
+      comps[l - 1] += c;
       followingOperator = false;
     }
     if (hyphen) {
@@ -1940,8 +1942,7 @@ var Comparator = class {
     const [M, m = 0, p = 0, pr = z, build] = this.#parseX(raw);
     return M === void 0 ? this.#getComparatorAny() : [">=", new Version(raw, M, m, p, pr, build)];
   }
-  // exclusive min.
-  // Note, if not a full version, then
+  // exclusive min
   #xExclusiveMin(raw) {
     const parsed = this.#parseX(raw);
     if (isFullVersion(parsed)) {
@@ -1966,22 +1967,13 @@ var Comparator = class {
   }
   #xInclusiveMax(raw) {
     const parsed = this.#parseX(raw);
-    if (isFullVersion(parsed)) {
-      return ["<=", new Version(raw, ...parsed)];
-    }
-    if (isXPatch(parsed)) {
-      return [
-        "<",
-        new Version(raw, parsed[MAJOR], parsed[MINOR] + 1, 0, "0", void 0)
-      ];
-    }
-    if (isXMinor(parsed)) {
-      return [
-        "<",
-        new Version(raw, parsed[MAJOR] + 1, 0, 0, "0", void 0)
-      ];
-    }
-    return this.#getComparatorAny();
+    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;
@@ -1993,85 +1985,80 @@ var Comparator = class {
     }
     return ["<", new Version(raw, M, m, p, 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 [M, m, p] = fastSplit(raw, ".", 3);
-    let prune = 0;
-    while (M && preJunk.has(M.charAt(prune)))
-      prune++;
-    if (M !== void 0 && prune !== 0)
-      M = M.substring(prune);
-    if (isX(M) || !M) {
-      assertMissing(m, raw, "major");
-      assertMissing(p, raw, "major");
-      if (m === "" || p === "") {
-        throw invalidComp(raw, `(Did you mean '*'?)`);
-      }
-      return [];
+  #validXM(raw, m, p) {
+    assertMissing(m, raw, "major");
+    assertMissing(p, raw, "major");
+    if (m === "" || p === "") {
+      throw invalidComp(raw, `(Did you mean '*'?)`);
     }
-    if (isX(m) || !m) {
-      assertMissing(p, raw, "major");
-      if (m === "" || p === "") {
-        throw invalidComp(raw, `(Did you mean '${M}'?)`);
-      }
-      return [assertNumber(M, raw, "major")];
+    return [];
+  }
+  #validXm(raw, M, m, p) {
+    assertMissing(p, raw, "major");
+    if (m === "" || p === "") {
+      throw invalidComp(raw, `(Did you mean '${M}'?)`);
     }
-    if (isX(p) || !p) {
-      if (p === "") {
-        throw invalidComp(raw, `(Did you mean '${M}.${m}'?)`);
-      }
-      return [
-        assertNumber(M, raw, "major"),
-        assertNumber(m, raw, "minor")
-      ];
+    return [assertNumber(M, raw, "major")];
+  }
+  #validXp(raw, M, m, p) {
+    if (p === "") {
+      throw invalidComp(raw, `(Did you mean '${M}.${m}'?)`);
     }
-    const hy = p.indexOf("-");
-    const pl = p.indexOf("+");
-    if (pl === -1 && hy === -1) {
-      return [
-        assertNumber(M, raw, "major"),
-        assertNumber(m, raw, "minor"),
-        assertNumber(p, raw, "patch")
-      ];
+    return [
+      assertNumber(M, raw, "major"),
+      assertNumber(m, raw, "minor")
+    ];
+  }
+  #validTuple(raw, M, m, p) {
+    return [
+      assertNumber(M, raw, "major"),
+      assertNumber(m, raw, "minor"),
+      assertNumber(p, raw, "patch")
+    ];
+  }
+  #validXbuild(raw, M, m, 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 (hy === -1) {
-      const [patch2, build2] = fastSplit(p, "+", 2);
-      if (!patch2) {
-        throw invalidComp(raw, "cannot specify build without patch");
-      }
-      if (!build2) {
-        throw invalidComp(raw, `encountered '+', but no build value`);
-      }
-      return [
-        assertNumber(M, raw, "major"),
-        assertNumber(m, raw, "minor"),
-        assertNumber(patch2, raw, "patch"),
-        void 0,
-        build2
-      ];
+    if (!build) {
+      throw invalidComp(raw, `encountered '+', but no build value`);
     }
-    if (pl === -1) {
-      const [patch2, pr2] = fastSplit(p, "-", 2);
-      if (!patch2) {
+    return [
+      assertNumber(M, raw, "major"),
+      assertNumber(m, raw, "minor"),
+      assertNumber(patch, raw, "patch"),
+      void 0,
+      build
+    ];
+  }
+  #validXpr(raw, M, m, 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 (!pr2) {
+      if (!pr) {
         throw invalidComp(raw, `encountered '-', but no prerelease value`);
       }
       return [
         assertNumber(M, raw, "major"),
         assertNumber(m, raw, "minor"),
-        assertNumber(patch2, raw, "patch"),
-        pr2
+        assertNumber(patch, raw, "patch"),
+        pr,
+        void 0
       ];
     }
-    const [patch, trailers = ""] = fastSplit(p, "-", 2);
+  }
+  #validXprbuild(raw, M, m, 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");
     }
-    const [pr, build] = fastSplit(trailers, "+", 2);
     if (!pr) {
       throw invalidComp(raw, `encountered '-', but no prerelease value`);
     }
@@ -2086,12 +2073,45 @@ var Comparator = class {
       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 [M, m, p] = fastSplit(raw, ".", 3);
+    let prune = 0;
+    while (M && preJunk.has(M.charAt(prune)))
+      prune++;
+    if (M !== void 0 && prune !== 0)
+      M = M.substring(prune);
+    if (!M || isX(M))
+      return this.#validXM(raw, m, p);
+    if (!m || isX(m))
+      return this.#validXm(raw, M, m, p);
+    if (!p || isX(p))
+      return this.#validXp(raw, M, m, p);
+    const hy = p.indexOf("-");
+    const pl = p.indexOf("+");
+    if (pl === -1 && hy === -1)
+      return this.#validTuple(raw, M, m, p);
+    if (pl === -1)
+      return this.#validXpr(raw, M, m, p, hy);
+    if (hy === -1)
+      return this.#validXbuild(raw, M, m, p, pl);
+    return this.#validXprbuild(raw, M, m, p, hy, pl);
+  }
   #parseHyphenRange(min, max) {
     const minv = this.#xInclusiveMin(min);
     const maxv = this.#xInclusiveMax(max);
     const minAny = isAny(minv);
     const maxAny = isAny(maxv);
-    return minAny && maxAny ? this.tuples.push(this.#getComparatorAny()) : maxAny ? this.tuples.push(minv) : minAny ? this.tuples.push(maxv) : this.tuples.push(minv, 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);
@@ -2107,7 +2127,7 @@ var Comparator = class {
         return this.tuples.push(this.#xInclusiveMin(v2));
       case "<=":
         assertVersion(v2, comp);
-        return this.tuples.push(this.#xInclusiveMax(comp.substring(2)));
+        return this.tuples.push(this.#xInclusiveMax(v2));
     }
     switch (first) {
       case "~":
@@ -2118,10 +2138,10 @@ var Comparator = class {
         return this.#parseCaret(v1);
       case ">":
         assertVersion(v1, comp);
-        return this.tuples.push(this.#xExclusiveMin(comp.substring(1)));
+        return this.tuples.push(this.#xExclusiveMin(v1));
       case "<":
         assertVersion(v1, comp);
-        return this.tuples.push(this.#xExclusiveMax(comp.substring(1)));
+        return this.tuples.push(this.#xExclusiveMax(v1));
     }
     return this.#parseEq(comp);
   }
@@ -2175,12 +2195,16 @@ var Comparator = class {
   #parseEq(comp) {
     const parsed = this.#parseX(comp);
     const z = this.includePrerelease ? "0" : void 0;
-    if (isXMajor(parsed)) {
-      this.tuples.push(this.#getComparatorAny());
-    } else if (isFullVersion(parsed)) {
+    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], 0, 0, z, void 0)
+      ]);
+      this.tuples.push([
         "<",
         new Version(comp, parsed[MAJOR] + 1, 0, 0, "0", void 0)
       ]);
@@ -2278,13 +2302,26 @@ var Range = class {
   constructor(range, includePrerelease = false) {
     this.raw = range;
     this.includePrerelease = includePrerelease;
-    fastSplit(range, "||", -1, (part) => this.set.push(new Comparator(part, this.includePrerelease)));
-    this.isAny = this.set.some((c) => c.isAny);
-    const cmp = this.set[0];
-    this.isSingle = this.set.length === 1 && !!cmp && Array.isArray(cmp.tuples) && cmp.tuples.length === 1 && Array.isArray(cmp.tuples[0]) && cmp.tuples[0][0] === "";
-    if (this.isSingle) {
-      this.#toString = String(cmp);
-    }
+    this.isAny = false;
+    let isFirst = true;
+    this.isSingle = false;
+    fastSplit(range, "||", -1, (part) => {
+      if (this.isAny)
+        return;
+      const cmp = new Comparator(part, this.includePrerelease);
+      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;
+    });
   }
   /**
    * test a {@link Version} against the range
@@ -2296,6 +2333,10 @@ var Range = class {
   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;
   }