@vltpkg/cli-js 0.0.0-7

package/chunk-OKDQY2GQ.js

@@ -0,0 +1,1866 @@
+var global = globalThis;
+import {setTimeout,clearTimeout,setImmediate,clearImmediate,setInterval,clearInterval} from "node:timers";
+import {createRequire as _vlt_createRequire} from "node:module";
+var require = _vlt_createRequire(import.meta.filename);
+import {
+  error,
+  syntaxError,
+  typeError
+} from "./chunk-LJEVKV7R.js";
+
+// ../../src/types/src/index.ts
+var integrityRE = /^sha512-[a-zA-Z0-9/+]{86}==$/;
+var isIntegrity = (i) => typeof i === "string" && integrityRE.test(i);
+var isObj = (o) => !!o && typeof o === "object";
+var maybeRecordStringString = (o) => o === void 0 || isRecordStringString(o);
+var isRecordStringString = (o) => isRecordStringT(o, (s) => typeof s === "string");
+var isRecordStringT = (o, check) => isObj(o) && Object.entries(o).every(
+  ([k, v]) => typeof k === "string" && check(v)
+);
+var isRecordStringManifest = (o) => isRecordStringT(o, (v) => isManifest(v));
+var maybePeerDependenciesMetaSet = (o) => o === void 0 || isRecordStringT(
+  o,
+  (v) => isPeerDependenciesMetaValue(v)
+);
+var maybeBoolean = (o) => o === void 0 || typeof o === "boolean";
+var isPeerDependenciesMetaValue = (o) => isObj(o) && maybeBoolean(o.optional);
+var maybeString = (a) => a === void 0 || typeof a === "string";
+var maybeDist = (a) => a === void 0 || isObj(a) && maybeString(a.tarball);
+var isManifest = (m) => isObj(m) && !Array.isArray(m) && maybeString(m.name) && maybeString(m.version) && maybeRecordStringString(m.dependencies) && maybeRecordStringString(m.devDependencies) && maybeRecordStringString(m.optionalDependencies) && maybeRecordStringString(m.peerDependencies) && maybeRecordStringString(m.acceptDependencies) && maybePeerDependenciesMetaSet(m.peerDependenciesMeta) && maybeDist(m.dist);
+var asManifest = (m, from) => {
+  if (!isManifest(m)) {
+    throw error("invalid manifest", { found: m }, from ?? asManifest);
+  }
+  return m;
+};
+var isPackument = (p) => {
+  if (!isObj(p) || typeof p.name !== "string") return false;
+  const { versions, "dist-tags": distTags, time } = p;
+  return isRecordStringString(distTags) && isRecordStringManifest(versions) && maybeRecordStringString(time) && Object.values(distTags).every((v) => versions[v]?.name == p.name);
+};
+var asPackument = (p, from) => {
+  if (!isPackument(p)) {
+    throw error(
+      "invalid packument",
+      { found: p },
+      from ?? asPackument
+    );
+  }
+  return p;
+};
+var longDependencyTypes = /* @__PURE__ */ new Set([
+  "dependencies",
+  "devDependencies",
+  "peerDependencies",
+  "optionalDependencies"
+]);
+var shortDependencyTypes = /* @__PURE__ */ new Set([
+  "prod",
+  "dev",
+  "peer",
+  "optional",
+  "peerOptional"
+]);
+var dependencyTypes = /* @__PURE__ */ new Map([
+  ["dependencies", "prod"],
+  ["devDependencies", "dev"],
+  ["peerDependencies", "peer"],
+  ["optionalDependencies", "optional"]
+]);
+
+// ../../src/package-json/src/index.ts
+import { readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+
+// ../../node_modules/.pnpm/polite-json@5.0.0/node_modules/polite-json/dist/esm/index.js
+var hexify = (s) => Array.from(s).map((c) => "0x" + c.charCodeAt(0).toString(16).toUpperCase().padStart(2, "0")).join("");
+var parseError = (e, txt, context) => {
+  if (!txt) {
+    return {
+      message: e.message + " while parsing empty string",
+      position: 0
+    };
+  }
+  const badToken = e.message.match(/^Unexpected (?:token (.*?))?/i);
+  const atPos = e.message.match(/at positions? (\d+)/);
+  const errIdx = /^Unexpected end of JSON|Unterminated string in JSON/i.test(e.message) ? txt.length - 1 : atPos && atPos[1] ? +atPos[1] : /is not valid JSON$/.test(e.message) ? 0 : null;
+  const msg = badToken && badToken[1] ? e.message.replace(/^Unexpected token ./, `Unexpected token ${JSON.stringify(badToken[1])} (${hexify(badToken[1])})`) : e.message;
+  if (errIdx !== null && errIdx !== void 0) {
+    const start = errIdx <= context ? 0 : errIdx - context;
+    const end = errIdx + context >= txt.length ? txt.length : errIdx + context;
+    const slice = (start === 0 ? "" : "...") + txt.slice(start, end) + (end === txt.length ? "" : "...");
+    const near = txt === slice ? "" : "near ";
+    return {
+      message: msg + ` while parsing ${near}${JSON.stringify(slice)}`,
+      position: errIdx
+    };
+  } else {
+    return {
+      message: msg + ` while parsing '${txt.slice(0, context * 2)}'`,
+      position: 0
+    };
+  }
+};
+var JSONParseError = class extends SyntaxError {
+  code;
+  cause;
+  position;
+  constructor(er, txt, context = 20, caller) {
+    const { message, position } = parseError(er, txt, context);
+    super(message);
+    this.cause = er;
+    this.position = position;
+    this.code = "EJSONPARSE";
+    Error.captureStackTrace(this, caller || this.constructor);
+  }
+  get name() {
+    return this.constructor.name;
+  }
+  set name(_) {
+  }
+  get [Symbol.toStringTag]() {
+    return this.constructor.name;
+  }
+};
+var kIndent = Symbol.for("indent");
+var kNewline = Symbol.for("newline");
+var formatRE = /^\s*[{\[]((?:\r?\n)+)([\s\t]*)/;
+var emptyRE = /^(?:\{\}|\[\])((?:\r?\n)+)?$/;
+var parse = (txt, reviver, context) => {
+  const parseText = stripBOM(String(txt));
+  if (!reviver)
+    reviver = void 0;
+  context = context || 20;
+  try {
+    const [, newline = "\n", indent = "  "] = parseText.match(emptyRE) || parseText.match(formatRE) || [, "", ""];
+    const result = JSON.parse(parseText, reviver);
+    if (result && typeof result === "object") {
+      result[kNewline] = newline;
+      result[kIndent] = indent;
+    }
+    return result;
+  } catch (e) {
+    if (typeof txt !== "string" && !Buffer.isBuffer(txt)) {
+      const isEmptyArray = Array.isArray(txt) && txt.length === 0;
+      throw Object.assign(new TypeError(`Cannot parse ${isEmptyArray ? "an empty array" : String(txt)}`), {
+        code: "EJSONPARSE",
+        systemError: e
+      });
+    }
+    throw new JSONParseError(e, parseText, context, parse);
+  }
+};
+var stripBOM = (txt) => String(txt).replace(/^\uFEFF/, "");
+var stringify = (obj, replacer, indent) => {
+  const space = indent === void 0 ? obj[kIndent] : indent;
+  const res = (
+    /* c8 ignore start */
+    typeof replacer === "function" ? JSON.stringify(obj, replacer, space) : JSON.stringify(obj, replacer, space)
+  );
+  const nl = obj[kNewline] || "\n";
+  return space ? (nl === "\n" ? res : res.split("\n").join(nl)) + nl : res;
+};
+
+// ../../src/package-json/src/index.ts
+var PackageJson = class {
+  /**
+   * cache of `package.json` loads
+   */
+  #cache = /* @__PURE__ */ new Map();
+  /**
+   * cache of `package.json` paths by manifest
+   */
+  #pathCache = /* @__PURE__ */ new Map();
+  /**
+   * cache of load errors
+   */
+  #errCache = /* @__PURE__ */ new Map();
+  /**
+   * Reads and parses contents of a `package.json` file at a directory `dir`.
+   * `reload` will optionally skip reading from the cache when set to `true`.
+   */
+  read(dir, { reload } = {}) {
+    const cachedPackageJson = !reload && this.#cache.get(dir);
+    if (cachedPackageJson) {
+      return cachedPackageJson;
+    }
+    const filename = resolve(dir, "package.json");
+    const fail = (err) => error("Could not read package.json file", err, this.read);
+    const cachedError = !reload && this.#errCache.get(dir);
+    if (cachedError) {
+      throw fail(cachedError);
+    }
+    try {
+      const res = asManifest(
+        parse(readFileSync(filename, { encoding: "utf8" }))
+      );
+      this.#cache.set(dir, res);
+      this.#pathCache.set(res, dir);
+      return res;
+    } catch (err) {
+      const ec = {
+        path: filename,
+        cause: err
+      };
+      this.#errCache.set(dir, ec);
+      throw fail(ec);
+    }
+  }
+  write(dir, manifest, indent) {
+    const filename = resolve(dir, "package.json");
+    this.fix(manifest);
+    try {
+      writeFileSync(filename, stringify(manifest, void 0, indent));
+      this.#cache.set(dir, manifest);
+      this.#pathCache.set(manifest, dir);
+    } catch (err) {
+      this.#cache.delete(dir);
+      this.#pathCache.delete(manifest);
+      throw error(
+        "Could not write package.json file",
+        {
+          path: filename,
+          cause: err
+        },
+        this.write
+      );
+    }
+  }
+  save(manifest) {
+    const dir = this.#pathCache.get(manifest);
+    if (!dir) {
+      throw error(
+        "Could not save manifest",
+        {
+          manifest
+        },
+        this.save
+      );
+    }
+    this.write(dir, manifest);
+  }
+  fix(manifest) {
+    for (const depType of longDependencyTypes) {
+      const deps = manifest[depType];
+      if (deps) {
+        manifest[depType] = Object.fromEntries(
+          Object.entries(deps).sort(
+            ([a], [b]) => a.localeCompare(b, "en")
+          )
+        );
+      }
+    }
+  }
+};
+
+// ../../src/spec/src/index.ts
+import { homedir } from "node:os";
+import {
+  isAbsolute,
+  join,
+  resolve as resolve2,
+  win32 as winPath
+} from "node:path";
+import { inspect } from "node:util";
+
+// ../../src/fast-split/src/index.ts
+function fastSplit(str, delim, limit = -1, onPart) {
+  let i = 0;
+  let p = 0;
+  const l = delim.length;
+  const parts = [];
+  while (i !== -1) {
+    i = str.indexOf(delim, p);
+    const part = i === -1 || parts.length === limit - 1 ? str.substring(p) : str.substring(p, i);
+    parts.push(onPart?.(part, parts, i) ?? part);
+    if (parts.length === limit) {
+      return parts;
+    }
+    p = i + l;
+  }
+  return parts;
+}
+
+// ../../src/semver/src/version.ts
+var maybeNumber = (s) => {
+  if (!/^[0-9]+$/.test(s)) return s;
+  const n = Number(s);
+  return n <= Number.MAX_SAFE_INTEGER ? n : s;
+};
+var safeNumber = (s, version, field) => {
+  const n = Number(s);
+  if (n > Number.MAX_SAFE_INTEGER) {
+    throw invalidVersion(
+      version,
+      `invalid ${field}, must be <= ${Number.MAX_SAFE_INTEGER}`
+    );
+  }
+  return n;
+};
+var re = {
+  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 = (version, message) => {
+  const er = syntaxError(
+    `invalid version: ${message}`,
+    { version },
+    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(version) {
+    version = version.replace(re.prefix, "").trim();
+    if (version.length > 256) {
+      throw invalidVersion(
+        version,
+        "must be less than 256 characters"
+      );
+    }
+    const parsed = version.match(re.full);
+    if (!parsed) {
+      const main = version.match(re.main);
+      if (!main) {
+        throw invalidVersion(
+          version,
+          "no Major.minor.patch tuple present"
+        );
+      } else {
+        throw invalidVersion(
+          version,
+          "invalid build or patch section"
+        );
+      }
+    }
+    const [_, major_, minor_, patch_, prerelease, build] = parsed;
+    const major2 = safeNumber(major_, version, "major");
+    const minor2 = safeNumber(minor_, version, "minor");
+    const patch2 = safeNumber(patch_, version, "patch");
+    return new _Version(
+      version,
+      major2,
+      minor2,
+      patch2,
+      prerelease,
+      build
+    );
+  }
+  constructor(version, major2, minor2, patch2, prerelease, build) {
+    this.raw = version;
+    this.major = major2;
+    this.minor = minor2;
+    this.patch = patch2;
+    if (prerelease) {
+      this.prerelease = fastSplit(prerelease, ".", -1, (c) => {
+        if (!c) {
+          throw invalidVersion(
+            version,
+            "invalid prerelease, empty identifiers not allowed"
+          );
+        }
+        return maybeNumber(c);
+      });
+    }
+    if (build) {
+      this.build = fastSplit(build, ".", -1, (c) => {
+        if (!c) {
+          throw invalidVersion(
+            version,
+            "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(v) {
+    if (this.major > v.major) return 1;
+    if (this.major < v.major) return -1;
+    if (this.minor > v.minor) return 1;
+    if (this.minor < v.minor) return -1;
+    if (this.patch > v.patch) return 1;
+    if (this.patch < v.patch) return -1;
+    if (!v.prerelease?.length)
+      return !this.prerelease?.length ? 0 : -1;
+    if (!this.prerelease?.length) return 1;
+    const len = Math.max(this.prerelease.length, v.prerelease.length);
+    const me = this.prerelease;
+    const thee = v.prerelease;
+    for (let i = 0; i < len; i++) {
+      const m = me[i];
+      const t = thee[i];
+      if (m === t) continue;
+      if (t === void 0) return 1;
+      if (m === void 0) return -1;
+      if (typeof m !== typeof t) {
+        return typeof m === "string" ? 1 : -1;
+      }
+      return m > t ? 1 : -1;
+    }
+    return 0;
+  }
+  /**
+   * The inverse of compare, for sorting version lists in reverse order
+   */
+  rcompare(v) {
+    return -1 * this.compare(v);
+  }
+  /** true if this version is > the argument */
+  greaterThan(v) {
+    return this.compare(v) === 1;
+  }
+  /** true if this version is >= the argument */
+  greaterThanEqual(v) {
+    return this.compare(v) > -1;
+  }
+  /** true if this version is < the argument */
+  lessThan(v) {
+    return this.compare(v) === -1;
+  }
+  /** true if this version is &lt;= the argument */
+  lessThanEqual(v) {
+    return this.compare(v) < 1;
+  }
+  /** true if these two versions have equal SemVer precedence */
+  equals(v) {
+    return this.compare(v) === 0;
+  }
+  /** just compare the M.m.p parts of the version */
+  tupleEquals(v) {
+    return this.major === v.major && this.minor === v.minor && this.patch === v.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 i = this.prerelease.indexOf(
+          maybeNumber(prereleaseIdentifier)
+        );
+        if (i === -1) {
+          this.prerelease = [prereleaseIdentifier];
+          break;
+        }
+        const baseValue = this.prerelease[i + 1];
+        if (typeof baseValue === "number") {
+          this.prerelease[i + 1] = baseValue + 1;
+          break;
+        }
+        if (i === this.prerelease.length - 1) {
+          this.prerelease.push(0);
+          break;
+        }
+        this.prerelease.splice(i + 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 n = Number(value);
+  if (n !== n) {
+    throw invalidComp(
+      c,
+      `${field} must be numeric or 'x', got: '${value}'`
+    );
+  }
+  return n;
+};
+var assertVersion = (v, comp) => {
+  if (!v) {
+    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, i) => {
+      if (part === "-") {
+        if (hyphen) {
+          throw invalidComp(
+            comp,
+            "multiple hyphen ranges not allowed"
+          );
+        }
+        if (parts.length !== 1 || i === -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, _, 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 [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
+  #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 [M = 0, m = 0, p = 0, pr = z, build] = this.#parseX(raw);
+    if (M === 0 && m === 0 && p === 0 && pr === "0") {
+      this.isNone = true;
+      this.tuples.length = 0;
+      return comparatorNone;
+    }
+    return ["<", new Version(raw, M, m, p, pr, build)];
+  }
+  #validXM(raw, m, p) {
+    assertMissing(m, raw, "major");
+    assertMissing(p, raw, "major");
+    if (m === "" || p === "") {
+      throw invalidComp(raw, `(Did you mean '*'?)`);
+    }
+    return [];
+  }
+  #validXm(raw, M, m, p) {
+    assertMissing(p, raw, "major");
+    if (m === "" || p === "") {
+      throw invalidComp(raw, `(Did you mean '${M}'?)`);
+    }
+    return [assertNumber(M, raw, "major")];
+  }
+  #validXp(raw, M, m, p) {
+    if (p === "") {
+      throw invalidComp(raw, `(Did you mean '${M}.${m}'?)`);
+    }
+    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 patch2 = p.substring(0, pl);
+    const build = p.substring(pl + 1);
+    if (!patch2) {
+      throw invalidComp(raw, "cannot specify build without patch");
+    }
+    if (!build) {
+      throw invalidComp(raw, `encountered '+', but no build value`);
+    }
+    return [
+      assertNumber(M, raw, "major"),
+      assertNumber(m, raw, "minor"),
+      assertNumber(patch2, raw, "patch"),
+      void 0,
+      build
+    ];
+  }
+  #validXpr(raw, M, m, p, hy) {
+    {
+      const patch2 = p.substring(0, hy);
+      const pr = p.substring(hy + 1);
+      if (!patch2) {
+        throw invalidComp(
+          raw,
+          "cannot specify prerelease without patch"
+        );
+      }
+      if (!pr) {
+        throw invalidComp(
+          raw,
+          `encountered '-', but no prerelease value`
+        );
+      }
+      return [
+        assertNumber(M, raw, "major"),
+        assertNumber(m, raw, "minor"),
+        assertNumber(patch2, raw, "patch"),
+        pr,
+        void 0
+      ];
+    }
+  }
+  #validXprbuild(raw, M, m, p, hy, pl) {
+    const patch2 = p.substring(0, hy);
+    const pr = p.substring(hy + 1, pl);
+    const build = p.substring(pl + 1);
+    if (!patch2) {
+      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(M, raw, "major"),
+      assertNumber(m, raw, "minor"),
+      assertNumber(patch2, 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 [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);
+    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 v2 = comp.substring(2);
+    switch (first2) {
+      case "~>":
+        assertVersion(v2, comp);
+        return this.#parseTilde(v2);
+      case ">=":
+        assertVersion(v2, comp);
+        return this.tuples.push(this.#xInclusiveMin(v2));
+      case "<=":
+        assertVersion(v2, comp);
+        return this.tuples.push(this.#xInclusiveMax(v2));
+    }
+    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 [M2] = parsed;
+      this.tuples.push(
+        [">=", new Version(comp, M2, 0, 0, z, void 0)],
+        ["<", new Version(comp, M2 + 1, 0, 0, "0", void 0)]
+      );
+      return;
+    }
+    if (isXPatch(parsed)) {
+      const [M2, m2] = parsed;
+      const z2 = this.includePrerelease ? "0" : void 0;
+      this.tuples.push(
+        [">=", new Version(comp, M2, m2, 0, z2, void 0)],
+        ["<", new Version(comp, M2, m2 + 1, 0, "0", void 0)]
+      );
+      return;
+    }
+    const [M, m, p, pr = z, build] = parsed;
+    this.tuples.push(
+      [">=", new Version(comp, M, m, p, pr, build)],
+      ["<", new Version(comp, M, m + 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(v) {
+    if (this.isNone) return false;
+    const ip = this.includePrerelease;
+    const hasPR = !!v.prerelease?.length;
+    let prOK = ip || !hasPR;
+    for (const c of this.tuples) {
+      if (isAny(c)) {
+        continue;
+      }
+      const [op, cv] = c;
+      prOK ||= !!cv.prerelease?.length && v.tupleEquals(cv);
+      switch (op) {
+        case "":
+          if (!v.equals(cv)) return false;
+          continue;
+        case ">":
+          if (!v.greaterThan(cv)) return false;
+          continue;
+        case ">=":
+          if (!v.greaterThanEqual(cv)) return false;
+          continue;
+        case "<":
+          if (!v.lessThan(cv)) return false;
+          continue;
+        case "<=":
+          if (!v.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: (v) => !v.prerelease?.length
+};
+var comparatorAnyPR = {
+  isAny: true,
+  toString: () => "*",
+  includePrerelease: true,
+  test: (_) => true
+};
+var comparatorNone = {
+  isNone: true,
+  toString: () => "<0.0.0-0",
+  includePrerelease: false,
+  test: (_) => 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;
+    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
+   */
+  test(v) {
+    return this.set.some((c) => c.test(v));
+  }
+  /** 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 parse2 = (version) => {
+  if (version instanceof Version) return version;
+  try {
+    return Version.parse(String(version));
+  } catch {
+    return void 0;
+  }
+};
+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;
+  }
+};
+var satisfies = (version, range, includePrerelease = false) => {
+  if (typeof version === "string") {
+    const parsed = parse2(version);
+    if (!parsed) return false;
+    version = parsed;
+  }
+  if (typeof range === "string") {
+    const parsed = parseRange(range, includePrerelease);
+    if (!parsed) return false;
+    range = parsed;
+  }
+  return version.satisfies(range);
+};
+var compare = (versionA, versionB) => {
+  const a = parse2(versionA);
+  if (!a) {
+    throw syntaxError("invalid version", { found: versionA });
+  }
+  const b = parse2(versionB);
+  if (!b) {
+    throw syntaxError("invalid version", { found: versionB });
+  }
+  return a.compare(b);
+};
+var gt = (versionA, versionB) => compare(versionA, versionB) > 0;
+var gte = (versionA, versionB) => compare(versionA, versionB) >= 0;
+var lt = (versionA, versionB) => compare(versionA, versionB) < 0;
+var lte = (versionA, versionB) => compare(versionA, versionB) <= 0;
+var neq = (versionA, versionB) => compare(versionA, versionB) !== 0;
+var eq = (versionA, versionB) => compare(versionA, versionB) === 0;
+var major = (version) => parse2(version)?.major;
+var minor = (version) => parse2(version)?.minor;
+var patch = (version) => parse2(version)?.patch;
+
+// ../../src/spec/src/browser.ts
+var kCustomInspect = Symbol.for("nodejs.util.inspect.custom");
+var defaultRegistry = "https://registry.npmjs.org/";
+var defaultRegistries = {
+  npm: "https://registry.npmjs.org/"
+};
+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://codeload.github.com/$1/$2/tar.gz/$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 defaultScopeRegistries = {};
+var getOptions = (options) => ({
+  ...options,
+  registry: options?.registry ?? defaultRegistry,
+  "scope-registries": options?.["scope-registries"] ?? {},
+  "git-hosts": options?.["git-hosts"] ? {
+    ...defaultGitHosts,
+    ...options["git-hosts"]
+  } : defaultGitHosts,
+  registries: options?.registries ? {
+    ...defaultRegistries,
+    ...options.registries
+  } : defaultRegistries,
+  "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("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:") || // 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)
+].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 {
+  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) {
+        parsed.name = parsed.subspec.name;
+        parsed.spec = `${parsed.name}@${parsed.bareSpec}`;
+      }
+      return parsed;
+    } else {
+      const hasScope = specOrBareSpec.startsWith("@");
+      const at = findFirstAt(specOrBareSpec, hasScope);
+      if (at > -1) {
+        return this.parse(
+          specOrBareSpec.substring(0, at),
+          specOrBareSpec.substring(at + 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;
+  registry;
+  registrySpec;
+  conventionalRegistryTarball;
+  semver;
+  range;
+  distTag;
+  remoteURL;
+  file;
+  subspec;
+  #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;
+    return this.#final = this.subspec ? this.subspec.final : this;
+  }
+  /**
+   * 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}`;
+    } else {
+      this.spec = spec;
+      const hasScope = spec.startsWith("@");
+      let at = findFirstAt(spec, hasScope);
+      if (at === -1) {
+        at = spec.length;
+        spec += "@";
+      }
+      this.name = spec.substring(0, at);
+      if (hasScope) this.#parseScope(this.name);
+      this.bareSpec = spec.substring(at + 1);
+    }
+    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 ws = this.bareSpec.substring("workspace:".length).trim();
+      const w = ws.lastIndexOf("@");
+      if (w === -1) {
+        this.workspace = this.name;
+      } else {
+        const wsName = ws.substring(0, w);
+        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 = w === -1 ? ws : ws.substring(w + 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 ghosts = Object.entries(this.options["git-hosts"]);
+    for (const [name, template] of ghosts) {
+      if (this.#parseHostedGit(name, template)) {
+        this.type = "git";
+        return;
+      }
+    }
+    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, u] of Object.entries(this.options.registries)) {
+        if (!u.endsWith("/")) {
+          u += "/";
+          this.options.registries[name] = u;
+        }
+        if (u === url) this.namedRegistry = name;
+      }
+      this.#parseRegistrySpec(regSpec, url);
+      this.#guessRegistryTarball();
+      return;
+    }
+    const regs = Object.entries(this.options.registries);
+    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;
+        this.#guessRegistryTarball();
+        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 [path, uri] = getNormalizeFile(
+        this.constructor.nodejsDependencies
+      )(this.bareSpec, this);
+      this.file = path;
+      this.bareSpec = uri.replace(/\/+$/, "");
+      this.spec = `${this.name}@${this.bareSpec}`;
+      return;
+    }
+    if (!this.bareSpec.startsWith("./") && !this.bareSpec.startsWith("../") && this.options["git-hosts"].github) {
+      const hash = this.bareSpec.indexOf("#");
+      const up = hash === -1 ? this.bareSpec : this.bareSpec.substring(0, hash);
+      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 { "scope-registries": scopeRegs, registry } = this.options;
+    const scopeReg = this.scope && scopeRegs[this.scope];
+    this.registry = scopeReg ?? registry;
+    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["scope-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 hash = h === -1 ? "" : this.bareSpec.substring(h);
+      const hostPath = bare.substring(name.length + 1);
+      if (!hostPath) {
+        throw error("invalid named git host specifier", {
+          spec: this
+        });
+      }
+      const split = hostPath.split("/");
+      let t = template;
+      for (let i = 0; i < split.length; i++) {
+        t = t.split(`$${i + 1}`).join(split[i]);
+      }
+      t += hash;
+      this.namedGitHost = name;
+      this.namedGitHostPath = hostPath;
+      this.#parseGitSelector(t);
+      if (this.gitCommittish && !this.gitSelectorParsed?.path) {
+        const archiveHost = this.options["git-host-archives"][name];
+        if (archiveHost) {
+          this.type = "remote";
+          let t2 = archiveHost;
+          t2 = t2.split("$committish").join(this.gitCommittish);
+          for (let i = 0; i < split.length; i++) {
+            t2 = t2.split(`$${i + 1}`).join(split[i]);
+          }
+          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 = /^@[^/]+\//;
+    this.conventionalRegistryTarball = String(
+      new URL(
+        `/${name}/-/${name.replace(stripScope, "")}-${range}.tgz`,
+        registry
+      )
+    );
+  }
+  #parseRegistrySpec(s, url) {
+    this.registry = url;
+    this.subspec = this.constructor.parse(s, {
+      ...this.options,
+      registry: url
+    });
+    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 k = kv.substring(0, c);
+      const v = kv.substring(c + 1);
+      if (k === "semver") {
+        if (committish) {
+          throw error(
+            "Cannot specify a semver range and committish value",
+            { spec }
+          );
+        }
+        range = parseRange(v);
+        if (!range) {
+          throw error(`Invalid git tag semver range: ${v}`, { spec });
+        }
+      }
+      if (k === "semver" || k === "path") {
+        if (k === "path") {
+          if (
+            /* c8 ignore next */
+            this.nodejsDependencies?.isAbsolute(
+              v
+            ) || /(^|\/|\\)\.\.($|\\|\/)/.test(v)
+          ) {
+            throw error("Invalid path in git selector", { spec });
+          }
+          parsed.path = (this.nodejsDependencies ? this.nodejsDependencies.join("/", v).substring(1) : v).replace(/\\/g, "/");
+        } else {
+          parsed[k] = v;
+        }
+      }
+    }
+    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 [a = "", b = "/", c = "/", d = "/"] = rest.split("", 4);
+  if (!a) {
+    return [".", "file:."];
+  }
+  if (a === "/" && b === "~" && c !== "/" || a === "~" && b !== "/") {
+    throw error(
+      `invalid file: specifier. '~username' not supported`,
+      { spec }
+    );
+  }
+  if (a === "~") {
+    return (
+      /* c8 ignore start */
+      opts ? [
+        opts.resolve(opts.homedir(), rest.substring(2)),
+        `file:${rest}`
+      ] : [rest, `file:${rest}`]
+    );
+  }
+  if (a === "/" && 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 (a === "/" && b === "." && (c === "/" || c === "." && d === "/")) {
+    return [rest.substring(1), `file:${rest.substring(1)}`];
+  }
+  if (a === "." && (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/spec/src/index.ts
+var Spec2 = class extends Spec {
+  [kCustomInspect](_depth, options) {
+    const str = inspect(
+      Object.fromEntries(
+        Object.entries(this).filter(([k, v]) => {
+          return k !== "options" && v !== void 0;
+        })
+      ),
+      options
+    );
+    return `@vltpkg/spec.Spec ${str}`;
+  }
+};
+Spec2.nodejsDependencies = {
+  homedir,
+  isAbsolute,
+  join,
+  resolve: resolve2,
+  winPath
+};
+
+export {
+  fastSplit,
+  Version,
+  Range,
+  parse2 as parse,
+  parseRange,
+  satisfies,
+  compare,
+  gt,
+  gte,
+  lt,
+  lte,
+  neq,
+  eq,
+  major,
+  minor,
+  patch,
+  defaultRegistry,
+  defaultRegistries,
+  defaultGitHosts,
+  defaultGitHostArchives,
+  defaultScopeRegistries,
+  Spec,
+  Spec2,
+  isIntegrity,
+  asManifest,
+  asPackument,
+  longDependencyTypes,
+  shortDependencyTypes,
+  dependencyTypes,
+  kIndent,
+  kNewline,
+  parse as parse2,
+  stringify,
+  PackageJson
+};
+//# sourceMappingURL=chunk-OKDQY2GQ.js.map