pnpm 7.1.2 → 7.1.3

package/dist/pnpx.cjs

@@ -30974,11 +30974,22 @@ ${foundSettings.join("\n")}`;
       return value;
     }
     function reportPeerDependencyIssuesError(err, msg) {
+      const hasMissingPeers = getHasMissingPeers(msg.issuesByProjects);
+      const hints = [];
+      if (hasMissingPeers) {
+        hints.push('If you want peer dependencies to be automatically installed, set the "auto-install-peers" setting to "true".');
+      }
+      hints.push(`If you don't want pnpm to fail on peer dependency issues, set the "strict-peer-dependencies" setting to "false".`);
       return {
         title: err.message,
-        body: (0, render_peer_issues_1.default)(msg.issuesByProjects)
+        body: `${(0, render_peer_issues_1.default)(msg.issuesByProjects)}
+${hints.map((hint) => `hint: ${hint}`).join("\n")}
+`
       };
     }
+    function getHasMissingPeers(issuesByProjects) {
+      return Object.values(issuesByProjects).some((issues) => Object.values(issues.missing).flat().some(({ optional }) => !optional));
+    }
   }
 });
 
@@ -103976,7 +103987,6 @@ var require_lib84 = __commonJS({
     var dependency_path_1 = require_lib51();
     var difference_1 = __importDefault2(require_difference());
     var isEmpty_1 = __importDefault2(require_isEmpty2());
-    var omit_1 = __importDefault2(require_omit());
     var unnest_1 = __importDefault2(require_unnest());
     __exportStar(require_lib53(), exports2);
     function pruneSharedLockfile(lockfile, opts) {
@@ -104112,7 +104122,7 @@ var require_lib84 = __commonJS({
         } else if (depLockfile.dev === void 0 && !ctx.notProdOnly.has(depPath)) {
           depLockfile.dev = false;
         }
-        const newDependencies = resolvedDepsToDepPaths((0, omit_1.default)(Object.keys(depLockfile.peerDependencies ?? {}) ?? [], depLockfile.dependencies ?? {}));
+        const newDependencies = resolvedDepsToDepPaths(depLockfile.dependencies ?? {});
         copyDependencySubGraph(ctx, newDependencies, opts);
         const newOptionalDependencies = resolvedDepsToDepPaths(depLockfile.optionalDependencies ?? {});
         copyDependencySubGraph(ctx, newOptionalDependencies, { dev: opts.dev, optional: true });
@@ -110496,532 +110506,562 @@ var require_getNonDevWantedDependencies = __commonJS({
   }
 });
 
-// ../resolve-dependencies/lib/wantedDepIsLocallyAvailable.js
-var require_wantedDepIsLocallyAvailable = __commonJS({
-  "../resolve-dependencies/lib/wantedDepIsLocallyAvailable.js"(exports2) {
+// ../../node_modules/.pnpm/semver-range-intersect@0.3.1/node_modules/semver-range-intersect/dist/utils.js
+var require_utils7 = __commonJS({
+  "../../node_modules/.pnpm/semver-range-intersect@0.3.1/node_modules/semver-range-intersect/dist/utils.js"(exports2) {
     "use strict";
     var __importDefault2 = exports2 && exports2.__importDefault || function(mod) {
       return mod && mod.__esModule ? mod : { "default": mod };
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
-    var npm_resolver_1 = require_lib41();
-    var semver_12 = __importDefault2(require_semver2());
-    function wantedDepIsLocallyAvailable(workspacePackages, wantedDependency, opts) {
-      const spec = (0, npm_resolver_1.parsePref)(wantedDependency.pref, wantedDependency.alias, opts.defaultTag || "latest", opts.registry);
-      if (spec == null || !workspacePackages[spec.name])
-        return false;
-      return pickMatchingLocalVersionOrNull(workspacePackages[spec.name], spec) !== null;
+    var semver_12 = __importDefault2(require_semver3());
+    function isNotNull(value) {
+      return value !== null;
     }
-    exports2.default = wantedDepIsLocallyAvailable;
-    function pickMatchingLocalVersionOrNull(versions, spec) {
-      const localVersions = Object.keys(versions);
-      switch (spec.type) {
-        case "tag":
-          return semver_12.default.maxSatisfying(localVersions, "*");
-        case "version":
-          return versions[spec.fetchSpec] ? spec.fetchSpec : null;
-        case "range":
-          return semver_12.default.maxSatisfying(localVersions, spec.fetchSpec, true);
-        default:
-          return null;
-      }
+    exports2.isNotNull = isNotNull;
+    function uniqueArray(array) {
+      return [...new Set(array)];
     }
-  }
-});
-
-// ../resolve-dependencies/lib/resolveDependencies.js
-var require_resolveDependencies = __commonJS({
-  "../resolve-dependencies/lib/resolveDependencies.js"(exports2) {
-    "use strict";
-    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
-      if (k2 === void 0)
-        k2 = k;
-      var desc = Object.getOwnPropertyDescriptor(m, k);
-      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-        desc = { enumerable: true, get: function() {
-          return m[k];
-        } };
-      }
-      Object.defineProperty(o, k2, desc);
-    } : function(o, m, k, k2) {
-      if (k2 === void 0)
-        k2 = k;
-      o[k2] = m[k];
-    });
-    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) {
-      Object.defineProperty(o, "default", { enumerable: true, value: v });
-    } : function(o, v) {
-      o["default"] = v;
-    });
-    var __importStar = exports2 && exports2.__importStar || function(mod) {
-      if (mod && mod.__esModule)
-        return mod;
-      var result2 = {};
-      if (mod != null) {
-        for (var k in mod)
-          if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
-            __createBinding(result2, mod, k);
-      }
-      __setModuleDefault(result2, mod);
-      return result2;
-    };
-    var __importDefault2 = exports2 && exports2.__importDefault || function(mod) {
-      return mod && mod.__esModule ? mod : { "default": mod };
-    };
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.nodeIdToParents = void 0;
-    var path_1 = __importDefault2(require("path"));
-    var core_loggers_1 = require_lib8();
-    var error_1 = __importDefault2(require_lib7());
-    var lockfile_utils_1 = require_lib54();
-    var logger_1 = __importDefault2(require_lib());
-    var pick_registry_for_package_1 = __importDefault2(require_lib49());
-    var dp = __importStar(require_lib51());
-    var path_exists_1 = __importDefault2(require_path_exists());
-    var isEmpty_1 = __importDefault2(require_isEmpty2());
-    var semver_12 = __importDefault2(require_semver2());
-    var encodePkgId_1 = __importDefault2(require_encodePkgId());
-    var getNonDevWantedDependencies_1 = __importDefault2(require_getNonDevWantedDependencies());
-    var nodeIdUtils_1 = require_nodeIdUtils();
-    var wantedDepIsLocallyAvailable_1 = __importDefault2(require_wantedDepIsLocallyAvailable());
-    var dependencyResolvedLogger = (0, logger_1.default)("_dependency_resolved");
-    function nodeIdToParents(nodeId, resolvedPackagesByDepPath) {
-      return (0, nodeIdUtils_1.splitNodeId)(nodeId).slice(1).map((depPath) => {
-        const { id, name, version } = resolvedPackagesByDepPath[depPath];
-        return { id, name, version };
-      });
+    exports2.uniqueArray = uniqueArray;
+    function isNoIncludeNull(value) {
+      return value.every(isNotNull);
     }
-    exports2.nodeIdToParents = nodeIdToParents;
-    async function resolveDependencies(ctx, preferredVersions, wantedDependencies, options) {
-      const extendedWantedDeps = getDepsToResolve(wantedDependencies, ctx.wantedLockfile, {
-        preferredDependencies: options.preferredDependencies,
-        prefix: ctx.prefix,
-        proceed: options.proceed || ctx.forceFullResolution,
-        registries: ctx.registries,
-        resolvedDependencies: options.resolvedDependencies
-      });
-      const postponedResolutionsQueue = [];
-      const pkgAddresses = (await Promise.all(extendedWantedDeps.map(async (extendedWantedDep) => resolveDependenciesOfDependency(postponedResolutionsQueue, ctx, preferredVersions, options, extendedWantedDep)))).filter(Boolean);
-      const newPreferredVersions = { ...preferredVersions };
-      for (const pkgAddress of pkgAddresses) {
-        if (pkgAddress.updated) {
-          ctx.updatedSet.add(pkgAddress.alias);
-        }
-        const resolvedPackage = ctx.resolvedPackagesByDepPath[pkgAddress.depPath];
-        if (!resolvedPackage)
-          continue;
-        if (!newPreferredVersions[resolvedPackage.name]) {
-          newPreferredVersions[resolvedPackage.name] = {};
-        }
-        newPreferredVersions[resolvedPackage.name][resolvedPackage.version] = "version";
+    exports2.isNoIncludeNull = isNoIncludeNull;
+    function isPrerelease(version) {
+      if (version instanceof semver_12.default.SemVer) {
+        return version.prerelease.length !== 0;
+      } else {
+        return false;
       }
-      await Promise.all(postponedResolutionsQueue.map(async (postponedResolution) => postponedResolution(newPreferredVersions)));
-      return pkgAddresses;
     }
-    exports2.default = resolveDependencies;
-    async function resolveDependenciesOfDependency(postponedResolutionsQueue, ctx, preferredVersions, options, extendedWantedDep) {
-      const updateDepth = typeof extendedWantedDep.wantedDependency.updateDepth === "number" ? extendedWantedDep.wantedDependency.updateDepth : options.updateDepth;
-      const updateShouldContinue = options.currentDepth <= updateDepth;
-      const update = extendedWantedDep.infoFromLockfile?.dependencyLockfile == null || updateShouldContinue && (ctx.updateMatching == null || ctx.updateMatching(extendedWantedDep.infoFromLockfile.name)) || Boolean(options.workspacePackages != null && ctx.linkWorkspacePackagesDepth !== -1 && (0, wantedDepIsLocallyAvailable_1.default)(options.workspacePackages, extendedWantedDep.wantedDependency, { defaultTag: ctx.defaultTag, registry: ctx.registries.default })) || ctx.updatedSet.has(extendedWantedDep.infoFromLockfile.name);
-      const resolveDependencyOpts = {
-        currentDepth: options.currentDepth,
-        parentPkg: options.parentPkg,
-        preferredVersions,
-        workspacePackages: options.workspacePackages,
-        currentPkg: extendedWantedDep.infoFromLockfile ?? void 0,
-        proceed: extendedWantedDep.proceed || updateShouldContinue || ctx.updatedSet.size > 0,
-        update,
-        updateDepth
-      };
-      const resolveDependencyResult = await resolveDependency(extendedWantedDep.wantedDependency, ctx, resolveDependencyOpts);
-      if (resolveDependencyResult == null)
-        return null;
-      if (resolveDependencyResult.isLinkedDependency) {
-        ctx.dependenciesTree[resolveDependencyResult.pkgId] = {
-          children: {},
-          depth: -1,
-          installable: true,
-          resolvedPackage: {
-            name: resolveDependencyResult.name,
-            version: resolveDependencyResult.version
-          }
-        };
-        return resolveDependencyResult;
+    exports2.isPrerelease = isPrerelease;
+    function isValidOperator(comparator, operatorList) {
+      return operatorList.includes(comparator.operator);
+    }
+    exports2.isValidOperator = isValidOperator;
+    function equalComparator(comparatorA, comparatorB) {
+      return comparatorA.value === comparatorB.value;
+    }
+    exports2.equalComparator = equalComparator;
+    function comparator2versionStr(comparator) {
+      const compSemver = comparator.semver;
+      return compSemver instanceof semver_12.default.SemVer ? compSemver.version : "";
+    }
+    exports2.comparator2versionStr = comparator2versionStr;
+    function isSameVersionEqualsLikeComparator(comparatorA, comparatorB) {
+      const compVersionA = comparator2versionStr(comparatorA);
+      const compVersionB = comparator2versionStr(comparatorB);
+      return compVersionA !== "" && compVersionB !== "" && compVersionA === compVersionB && /=|^$/.test(comparatorA.operator) && /=|^$/.test(comparatorB.operator);
+    }
+    exports2.isSameVersionEqualsLikeComparator = isSameVersionEqualsLikeComparator;
+    function isEqualsComparator(comparator) {
+      return comparator.semver instanceof semver_12.default.SemVer && isValidOperator(comparator, ["", "="]);
+    }
+    exports2.isEqualsComparator = isEqualsComparator;
+    function filterUniqueComparator(comparator, index, self2) {
+      return self2.findIndex((comp) => equalComparator(comparator, comp)) === index;
+    }
+    exports2.filterUniqueComparator = filterUniqueComparator;
+    function filterOperator(operatorList) {
+      return (comparator) => isValidOperator(comparator, operatorList);
+    }
+    exports2.filterOperator = filterOperator;
+    function isIntersectRanges(semverRangeList) {
+      return semverRangeList.every((rangeA, index, rangeList) => rangeList.slice(index + 1).every((rangeB) => rangeA.intersects(rangeB)));
+    }
+    exports2.isIntersectRanges = isIntersectRanges;
+    function stripSemVerPrerelease(semverVersion) {
+      if (!(semverVersion instanceof semver_12.default.SemVer)) {
+        return "";
       }
-      if (!resolveDependencyResult.isNew)
-        return resolveDependencyResult;
-      postponedResolutionsQueue.push(async (preferredVersions2) => resolveChildren(ctx, resolveDependencyResult, extendedWantedDep.infoFromLockfile?.dependencyLockfile, options.workspacePackages, options.currentDepth, updateDepth, preferredVersions2));
-      return resolveDependencyResult;
+      if (!semverVersion.prerelease.length) {
+        return semverVersion.version;
+      }
+      const newSemverVersion = new semver_12.default.SemVer(semverVersion.version, semverVersion.options);
+      newSemverVersion.prerelease = [];
+      return newSemverVersion.format();
     }
-    async function resolveChildren(ctx, parentPkg, dependencyLockfile, workspacePackages, parentDepth, updateDepth, preferredVersions) {
-      const currentResolvedDependencies = dependencyLockfile != null ? {
-        ...dependencyLockfile.dependencies,
-        ...dependencyLockfile.optionalDependencies
-      } : void 0;
-      const resolvedDependencies = parentPkg.updated ? void 0 : currentResolvedDependencies;
-      const parentDependsOnPeer = Boolean(Object.keys(dependencyLockfile?.peerDependencies ?? parentPkg.pkg.peerDependencies ?? {}).length);
-      const wantedDependencies = (0, getNonDevWantedDependencies_1.default)(parentPkg.pkg);
-      const children = await resolveDependencies(ctx, preferredVersions, wantedDependencies, {
-        currentDepth: parentDepth + 1,
-        parentPkg,
-        preferredDependencies: currentResolvedDependencies,
-        proceed: !parentPkg.depIsLinked || parentDependsOnPeer,
-        resolvedDependencies,
-        updateDepth,
-        workspacePackages
-      });
-      ctx.childrenByParentDepPath[parentPkg.depPath] = children.map((child) => ({
-        alias: child.alias,
-        depPath: child.depPath
-      }));
-      ctx.dependenciesTree[parentPkg.nodeId] = {
-        children: children.reduce((chn, child) => {
-          chn[child.alias] = child["nodeId"] ?? child.pkgId;
-          return chn;
-        }, {}),
-        depth: parentDepth,
-        installable: parentPkg.installable,
-        resolvedPackage: ctx.resolvedPackagesByDepPath[parentPkg.depPath]
-      };
+    exports2.stripSemVerPrerelease = stripSemVerPrerelease;
+    function stripComparatorOperator(comparator) {
+      if (!comparator.operator) {
+        return comparator;
+      }
+      const versionStr = comparator2versionStr(comparator);
+      return new semver_12.default.Comparator(versionStr, comparator.options);
     }
-    function getDepsToResolve(wantedDependencies, wantedLockfile, options) {
-      const resolvedDependencies = options.resolvedDependencies ?? {};
-      const preferredDependencies = options.preferredDependencies ?? {};
-      const extendedWantedDeps = [];
-      let proceedAll = options.proceed;
-      const satisfiesWanted2Args = referenceSatisfiesWantedSpec.bind(null, {
-        lockfile: wantedLockfile,
-        prefix: options.prefix
-      });
-      for (const wantedDependency of wantedDependencies) {
-        let reference = void 0;
-        let proceed = proceedAll;
-        if (wantedDependency.alias) {
-          const satisfiesWanted = satisfiesWanted2Args.bind(null, wantedDependency);
-          if (resolvedDependencies[wantedDependency.alias] && satisfiesWanted(resolvedDependencies[wantedDependency.alias])) {
-            reference = resolvedDependencies[wantedDependency.alias];
-          } else if (semver_12.default.validRange(wantedDependency.pref) !== null && preferredDependencies[wantedDependency.alias] && satisfiesWanted(preferredDependencies[wantedDependency.alias])) {
-            proceed = true;
-            reference = preferredDependencies[wantedDependency.alias];
+    exports2.stripComparatorOperator = stripComparatorOperator;
+    function getLowerBoundComparator(comparatorList, options = {}) {
+      const validComparatorList = comparatorList.filter((comparator) => isValidOperator(comparator, [">", ">="]) || !(comparator.semver instanceof semver_12.default.SemVer));
+      const leComparatorVersionList = comparatorList.filter(filterOperator(["<="])).map(comparator2versionStr);
+      if (validComparatorList.length >= 1) {
+        return validComparatorList.reduce((a, b) => {
+          const semverA = a.semver;
+          const semverB = b.semver;
+          if (!(semverA instanceof semver_12.default.SemVer)) {
+            if (!options.singleRange && isPrerelease(semverB) && !(b.operator === ">=" && leComparatorVersionList.some((version) => version === String(semverB)))) {
+              return new semver_12.default.Comparator(`>=${stripSemVerPrerelease(semverB)}`, b.options);
+            }
+            return b;
+          } else if (!(semverB instanceof semver_12.default.SemVer)) {
+            if (!options.singleRange && isPrerelease(semverA) && !(a.operator === ">=" && leComparatorVersionList.some((version) => version === String(semverA)))) {
+              return new semver_12.default.Comparator(`>=${stripSemVerPrerelease(semverA)}`, a.options);
+            }
+            return a;
           }
-        }
-        const infoFromLockfile = getInfoFromLockfile(wantedLockfile, options.registries, reference, wantedDependency.alias);
-        if (!proceedAll && (infoFromLockfile == null || infoFromLockfile.dependencyLockfile != null && (infoFromLockfile.dependencyLockfile.peerDependencies != null || infoFromLockfile.dependencyLockfile.transitivePeerDependencies?.length))) {
-          proceed = true;
-          proceedAll = true;
-          for (const extendedWantedDep of extendedWantedDeps) {
-            if (!extendedWantedDep.proceed) {
-              extendedWantedDep.proceed = true;
+          const semverCmp = semver_12.default.compare(semverA, semverB);
+          if (a.operator === b.operator || semverCmp !== 0) {
+            if (!options.singleRange) {
+              const semverCmpMain = semverA.compareMain(semverB);
+              if (semverCmpMain !== 0 && semverA.prerelease.length && semverB.prerelease.length) {
+                if (semverCmpMain > 0) {
+                  return new semver_12.default.Comparator(a.operator + stripSemVerPrerelease(semverA), a.options);
+                } else {
+                  return new semver_12.default.Comparator(b.operator + stripSemVerPrerelease(semverB), b.options);
+                }
+              }
+            }
+            if (semverCmp > 0) {
+              return a;
+            } else {
+              return b;
+            }
+          } else {
+            if (a.operator === ">") {
+              return a;
+            } else {
+              return b;
             }
           }
-        }
-        extendedWantedDeps.push({
-          infoFromLockfile,
-          proceed,
-          wantedDependency
-        });
-      }
-      return extendedWantedDeps;
-    }
-    function referenceSatisfiesWantedSpec(opts, wantedDep, preferredRef) {
-      const depPath = dp.refToRelative(preferredRef, wantedDep.alias);
-      if (depPath === null)
-        return false;
-      const pkgSnapshot = opts.lockfile.packages?.[depPath];
-      if (pkgSnapshot == null) {
-        logger_1.default.warn({
-          message: `Could not find preferred package ${depPath} in lockfile`,
-          prefix: opts.prefix
         });
-        return false;
+      } else {
+        return new semver_12.default.Comparator("");
       }
-      const { version } = (0, lockfile_utils_1.nameVerFromPkgSnapshot)(depPath, pkgSnapshot);
-      return semver_12.default.satisfies(version, wantedDep.pref, true);
     }
-    function getInfoFromLockfile(lockfile, registries, reference, alias) {
-      if (!reference || !alias) {
-        return void 0;
-      }
-      const depPath = dp.refToRelative(reference, alias);
-      if (!depPath) {
-        return void 0;
-      }
-      let dependencyLockfile = lockfile.packages?.[depPath];
-      if (dependencyLockfile != null) {
-        if (dependencyLockfile.peerDependencies != null && dependencyLockfile.dependencies != null) {
-          const dependencies = {};
-          for (const [depName, ref] of Object.entries(dependencyLockfile.dependencies ?? {})) {
-            if (dependencyLockfile.peerDependencies[depName])
-              continue;
-            dependencies[depName] = ref;
+    exports2.getLowerBoundComparator = getLowerBoundComparator;
+    function getUpperBoundComparator(comparatorList, options = {}) {
+      const validComparatorList = comparatorList.filter((comparator) => isValidOperator(comparator, ["<", "<="]) || !(comparator.semver instanceof semver_12.default.SemVer));
+      const geComparatorVersionList = comparatorList.filter(filterOperator([">="])).map(comparator2versionStr);
+      if (validComparatorList.length >= 1) {
+        return validComparatorList.reduce((a, b) => {
+          const semverA = a.semver;
+          const semverB = b.semver;
+          if (!(semverA instanceof semver_12.default.SemVer)) {
+            if (!options.singleRange && isPrerelease(semverB) && !(b.operator === "<=" && geComparatorVersionList.some((version) => version === String(semverB)))) {
+              return new semver_12.default.Comparator(`<${stripSemVerPrerelease(semverB)}`, b.options);
+            }
+            return b;
+          } else if (!(semverB instanceof semver_12.default.SemVer)) {
+            if (!options.singleRange && isPrerelease(semverA) && !(a.operator === "<=" && geComparatorVersionList.some((version) => version === String(semverA)))) {
+              return new semver_12.default.Comparator(`<${stripSemVerPrerelease(semverA)}`, a.options);
+            }
+            return a;
           }
-          dependencyLockfile = {
-            ...dependencyLockfile,
-            dependencies
-          };
-        }
-        return {
-          ...(0, lockfile_utils_1.nameVerFromPkgSnapshot)(depPath, dependencyLockfile),
-          dependencyLockfile,
-          depPath,
-          pkgId: (0, lockfile_utils_1.packageIdFromSnapshot)(depPath, dependencyLockfile, registries),
-          resolution: dependencyLockfile.resolution && (0, lockfile_utils_1.pkgSnapshotToResolution)(depPath, dependencyLockfile, registries)
-        };
+          const semverCmp = semver_12.default.compare(semverA, semverB);
+          if (a.operator === b.operator || semverCmp !== 0) {
+            if (!options.singleRange) {
+              const semverCmpMain = semverA.compareMain(semverB);
+              if (semverCmpMain !== 0 && semverA.prerelease.length && semverB.prerelease.length) {
+                if (semverCmpMain < 0) {
+                  return new semver_12.default.Comparator(`<${stripSemVerPrerelease(semverA)}`, a.options);
+                } else {
+                  return new semver_12.default.Comparator(`<${stripSemVerPrerelease(semverB)}`, b.options);
+                }
+              }
+            }
+            if (semverCmp < 0) {
+              return a;
+            } else {
+              return b;
+            }
+          } else {
+            if (a.operator === "<") {
+              return a;
+            } else {
+              return b;
+            }
+          }
+        });
       } else {
-        return {
-          depPath,
-          pkgId: dp.tryGetPackageId(registries, depPath) ?? depPath
-        };
+        return new semver_12.default.Comparator("");
       }
     }
-    async function resolveDependency(wantedDependency, ctx, options) {
-      const currentPkg = options.currentPkg ?? {};
-      const currentLockfileContainsTheDep = currentPkg.depPath ? Boolean(ctx.currentLockfile.packages?.[currentPkg.depPath]) : void 0;
-      const depIsLinked = Boolean(currentLockfileContainsTheDep && currentPkg.depPath && currentPkg.dependencyLockfile && await (0, path_exists_1.default)(path_1.default.join(ctx.virtualStoreDir, dp.depPathToFilename(currentPkg.depPath), "node_modules", currentPkg.name, "package.json")));
-      if (!options.update && !options.proceed && currentPkg.resolution != null && depIsLinked) {
-        return null;
+    exports2.getUpperBoundComparator = getUpperBoundComparator;
+  }
+});
+
+// ../../node_modules/.pnpm/semver-range-intersect@0.3.1/node_modules/semver-range-intersect/dist/single-range.js
+var require_single_range = __commonJS({
+  "../../node_modules/.pnpm/semver-range-intersect@0.3.1/node_modules/semver-range-intersect/dist/single-range.js"(exports2) {
+    "use strict";
+    var __importDefault2 = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    var semver_12 = __importDefault2(require_semver3());
+    var utils_1 = require_utils7();
+    var SingleVer = class {
+      constructor(comp) {
+        this.comp = comp;
       }
-      let pkgResponse;
-      if (!options.parentPkg.installable) {
-        wantedDependency = {
-          ...wantedDependency,
-          optional: true
-        };
+      toString() {
+        return this.comp.value;
       }
-      try {
-        pkgResponse = await ctx.storeController.requestPackage(wantedDependency, {
-          alwaysTryWorkspacePackages: ctx.linkWorkspacePackagesDepth >= options.currentDepth,
-          currentPkg: currentPkg ? {
-            id: currentPkg.pkgId,
-            resolution: currentPkg.resolution
-          } : void 0,
-          expectedPkg: currentPkg,
-          defaultTag: ctx.defaultTag,
-          downloadPriority: -options.currentDepth,
-          lockfileDir: ctx.lockfileDir,
-          preferredVersions: options.preferredVersions,
-          preferWorkspacePackages: ctx.preferWorkspacePackages,
-          projectDir: options.currentDepth > 0 && !wantedDependency.pref.startsWith("file:") ? ctx.lockfileDir : options.parentPkg.rootDir,
-          registry: wantedDependency.alias && (0, pick_registry_for_package_1.default)(ctx.registries, wantedDependency.alias, wantedDependency.pref) || ctx.registries.default,
-          skipFetch: false,
-          update: options.update,
-          workspacePackages: options.workspacePackages
-        });
-      } catch (err) {
-        if (wantedDependency.optional) {
-          core_loggers_1.skippedOptionalDependencyLogger.debug({
-            details: err.toString(),
-            package: {
-              name: wantedDependency.alias,
-              pref: wantedDependency.pref,
-              version: wantedDependency.alias ? wantedDependency.pref : void 0
-            },
-            parents: nodeIdToParents(options.parentPkg.nodeId, ctx.resolvedPackagesByDepPath),
-            prefix: ctx.prefix,
-            reason: "resolution_failure"
-          });
+      intersect(singleRange) {
+        if (semver_12.default.intersects(String(this), String(singleRange))) {
+          return this;
+        } else {
           return null;
         }
-        err.pkgsStack = nodeIdToParents(options.parentPkg.nodeId, ctx.resolvedPackagesByDepPath);
-        throw err;
       }
-      dependencyResolvedLogger.debug({
-        resolution: pkgResponse.body.id,
-        wanted: {
-          dependentId: options.parentPkg.depPath,
-          name: wantedDependency.alias,
-          rawSpec: wantedDependency.pref
+      merge(singleRange) {
+        if (semver_12.default.intersects(String(this), String(singleRange))) {
+          return singleRange;
         }
-      });
-      pkgResponse.body.id = (0, encodePkgId_1.default)(pkgResponse.body.id);
-      if (!pkgResponse.body.updated && options.currentDepth === Math.max(0, options.updateDepth) && depIsLinked && !ctx.force && !options.proceed) {
         return null;
       }
-      if (pkgResponse.body.isLocal) {
-        const manifest = pkgResponse.body.manifest ?? await pkgResponse.bundledManifest();
-        return {
-          alias: wantedDependency.alias || manifest.name,
-          depPath: pkgResponse.body.id,
-          dev: wantedDependency.dev,
-          isLinkedDependency: true,
-          name: manifest.name,
-          normalizedPref: pkgResponse.body.normalizedPref,
-          optional: wantedDependency.optional,
-          pkgId: pkgResponse.body.id,
-          resolution: pkgResponse.body.resolution,
-          version: manifest.version
-        };
+    };
+    exports2.SingleVer = SingleVer;
+    var SingleRange = class {
+      constructor(lowerBound, upperBound) {
+        this.lowerBound = lowerBound;
+        this.upperBound = upperBound;
+        if (!lowerBound.intersects(upperBound)) {
+          throw new Error(`Invalid range; version range does not intersect: ${this}`);
+        }
       }
-      let pkg;
-      let prepare;
-      let hasBin;
-      pkg = ctx.readPackageHook != null ? await ctx.readPackageHook(pkgResponse.body.manifest ?? await pkgResponse.bundledManifest()) : pkgResponse.body.manifest ?? await pkgResponse.bundledManifest();
-      if (!pkg.name) {
-        throw new error_1.default("MISSING_PACKAGE_NAME", `Can't install ${wantedDependency.pref}: Missing package name`);
+      toString() {
+        return [this.lowerBound.value, this.upperBound.value].filter((v) => v !== "").join(" ");
       }
-      const depPath = dp.relative(ctx.registries, pkg.name, pkgResponse.body.id);
-      if ((0, nodeIdUtils_1.nodeIdContainsSequence)(options.parentPkg.nodeId, options.parentPkg.depPath, depPath) || depPath === options.parentPkg.depPath) {
+      intersect(singleRange) {
+        if (semver_12.default.intersects(String(this), String(singleRange))) {
+          if (singleRange instanceof SingleVer) {
+            return singleRange;
+          } else {
+            const lowerBoundComparatorList = [
+              this.lowerBound,
+              singleRange.lowerBound
+            ];
+            const upperBoundComparatorList = [
+              this.upperBound,
+              singleRange.upperBound
+            ];
+            const lowerBound = utils_1.getLowerBoundComparator([
+              ...lowerBoundComparatorList,
+              ...upperBoundComparatorList.filter((comparator) => comparator.semver instanceof semver_12.default.SemVer)
+            ]);
+            const upperBound = utils_1.getUpperBoundComparator([
+              ...upperBoundComparatorList,
+              ...lowerBoundComparatorList.filter((comparator) => comparator.semver instanceof semver_12.default.SemVer)
+            ]);
+            if (utils_1.isSameVersionEqualsLikeComparator(lowerBound, upperBound)) {
+              return new SingleVer(utils_1.stripComparatorOperator(lowerBound));
+            }
+            return new SingleRange(lowerBound, upperBound);
+          }
+        } else {
+          return null;
+        }
+      }
+      merge(singleRange) {
+        if (semver_12.default.intersects(String(this), String(singleRange))) {
+          if (singleRange instanceof SingleVer) {
+            return this;
+          } else {
+            const lowerBound = ((a, b) => {
+              const semverA = a.semver;
+              const semverB = b.semver;
+              if (!(semverA instanceof semver_12.default.SemVer)) {
+                if (utils_1.isPrerelease(semverB)) {
+                  return null;
+                }
+                return a;
+              } else if (!(semverB instanceof semver_12.default.SemVer)) {
+                if (utils_1.isPrerelease(semverA)) {
+                  return null;
+                }
+                return b;
+              }
+              const cmpMain = semverA.compareMain(semverB);
+              if (cmpMain < 0 && utils_1.isPrerelease(semverB) || cmpMain > 0 && utils_1.isPrerelease(semverA)) {
+                return null;
+              }
+              const semverCmp = semver_12.default.compare(semverA, semverB);
+              if (a.operator === b.operator || semverCmp !== 0) {
+                if (semverCmp < 0) {
+                  return a;
+                } else {
+                  return b;
+                }
+              } else {
+                if (a.operator === ">=") {
+                  return a;
+                } else {
+                  return b;
+                }
+              }
+            })(this.lowerBound, singleRange.lowerBound);
+            const upperBound = ((a, b) => {
+              const semverA = a.semver;
+              const semverB = b.semver;
+              if (!(semverA instanceof semver_12.default.SemVer)) {
+                if (utils_1.isPrerelease(semverB)) {
+                  return null;
+                }
+                return a;
+              } else if (!(semverB instanceof semver_12.default.SemVer)) {
+                if (utils_1.isPrerelease(semverA)) {
+                  return null;
+                }
+                return b;
+              }
+              const cmpMain = semverA.compareMain(semverB);
+              if (cmpMain > 0 && utils_1.isPrerelease(semverB) || cmpMain < 0 && utils_1.isPrerelease(semverA)) {
+                return null;
+              }
+              const semverCmp = semver_12.default.compare(semverA, semverB);
+              if (a.operator === b.operator || semverCmp !== 0) {
+                if (semverCmp > 0) {
+                  return a;
+                } else {
+                  return b;
+                }
+              } else {
+                if (a.operator === "<=") {
+                  return a;
+                } else {
+                  return b;
+                }
+              }
+            })(this.upperBound, singleRange.upperBound);
+            if (lowerBound && upperBound) {
+              return new SingleRange(lowerBound, upperBound);
+            }
+          }
+        }
         return null;
       }
-      if (!options.update && currentPkg.dependencyLockfile != null && currentPkg.depPath && !pkgResponse.body.updated && currentPkg.dependencyLockfile.peerDependencies == null) {
-        prepare = currentPkg.dependencyLockfile.prepare === true;
-        hasBin = currentPkg.dependencyLockfile.hasBin === true;
-        pkg = {
-          ...(0, lockfile_utils_1.nameVerFromPkgSnapshot)(currentPkg.depPath, currentPkg.dependencyLockfile),
-          ...currentPkg.dependencyLockfile,
-          ...pkg
-        };
-      } else {
-        prepare = Boolean(pkgResponse.body.resolvedVia === "git-repository" && typeof pkg.scripts?.prepare === "string");
-        if (currentPkg.dependencyLockfile?.deprecated && !pkgResponse.body.updated && !pkg.deprecated) {
-          pkg.deprecated = currentPkg.dependencyLockfile.deprecated;
+    };
+    exports2.SingleRange = SingleRange;
+    function createSingleRange(comparatorList) {
+      const equalsComparatorList = comparatorList.filter(utils_1.isEqualsComparator).filter(utils_1.filterUniqueComparator);
+      switch (equalsComparatorList.length) {
+        case 0: {
+          const lowerBound = utils_1.getLowerBoundComparator(comparatorList, {
+            singleRange: true
+          });
+          const upperBound = utils_1.getUpperBoundComparator(comparatorList, {
+            singleRange: true
+          });
+          if (utils_1.isSameVersionEqualsLikeComparator(lowerBound, upperBound)) {
+            return new SingleVer(utils_1.stripComparatorOperator(lowerBound));
+          }
+          try {
+            return new SingleRange(lowerBound, upperBound);
+          } catch (err) {
+            return null;
+          }
         }
-        hasBin = Boolean((pkg.bin && !(0, isEmpty_1.default)(pkg.bin)) ?? pkg.directories?.bin);
+        case 1:
+          return new SingleVer(equalsComparatorList[0]);
+        default:
+          return null;
       }
-      if (options.currentDepth === 0 && pkgResponse.body.latest && pkgResponse.body.latest !== pkg.version) {
-        ctx.outdatedDependencies[pkgResponse.body.id] = pkgResponse.body.latest;
+    }
+    exports2.createSingleRange = createSingleRange;
+    function isSingleRange(value) {
+      return value instanceof SingleVer || value instanceof SingleRange;
+    }
+    exports2.isSingleRange = isSingleRange;
+  }
+});
+
+// ../../node_modules/.pnpm/semver-range-intersect@0.3.1/node_modules/semver-range-intersect/dist/multi-range.js
+var require_multi_range = __commonJS({
+  "../../node_modules/.pnpm/semver-range-intersect@0.3.1/node_modules/semver-range-intersect/dist/multi-range.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    var single_range_1 = require_single_range();
+    var utils_1 = require_utils7();
+    function normalizeSingleRangeList(singleRangeList) {
+      return singleRangeList.reduce((singleRangeList2, singleRange) => {
+        if (!singleRange) {
+          return [...singleRangeList2, singleRange];
+        }
+        let insertFirst = false;
+        const removeIndexList = [];
+        const appendSingleRange = singleRangeList2.reduce((appendSingleRange2, insertedSingleRange, index) => {
+          if (insertedSingleRange && appendSingleRange2) {
+            const mergedSingleRange = insertedSingleRange.merge(appendSingleRange2);
+            if (mergedSingleRange) {
+              if (String(mergedSingleRange) === String(insertedSingleRange)) {
+                return;
+              } else {
+                removeIndexList.push(index);
+                if (insertedSingleRange instanceof single_range_1.SingleRange && appendSingleRange2 instanceof single_range_1.SingleRange) {
+                  insertFirst = true;
+                }
+                return mergedSingleRange;
+              }
+            }
+          }
+          return appendSingleRange2;
+        }, singleRange);
+        const removedSingleRangeList = singleRangeList2.filter((_, index) => !removeIndexList.includes(index));
+        if (appendSingleRange) {
+          if (insertFirst) {
+            return [appendSingleRange, ...removedSingleRangeList];
+          } else {
+            return [...removedSingleRangeList, appendSingleRange];
+          }
+        }
+        return removedSingleRangeList;
+      }, []);
+    }
+    exports2.normalizeSingleRangeList = normalizeSingleRangeList;
+    var MultiRange = class {
+      get valid() {
+        return this.set.length >= 1;
       }
-      if (pkg.deprecated) {
-        core_loggers_1.deprecationLogger.debug({
-          deprecated: pkg.deprecated,
-          depth: options.currentDepth,
-          pkgId: pkgResponse.body.id,
-          pkgName: pkg.name,
-          pkgVersion: pkg.version,
-          prefix: ctx.prefix
-        });
+      constructor(rangeList) {
+        if (rangeList) {
+          const singleRangeList = normalizeSingleRangeList(rangeList.map((singleRangeOrComparatorList) => {
+            if (single_range_1.isSingleRange(singleRangeOrComparatorList) || !singleRangeOrComparatorList) {
+              return singleRangeOrComparatorList;
+            } else {
+              return single_range_1.createSingleRange(singleRangeOrComparatorList);
+            }
+          }));
+          this.set = singleRangeList.filter(utils_1.isNotNull);
+        } else {
+          this.set = [];
+        }
       }
-      const nodeId = pkgIsLeaf(pkg) ? pkgResponse.body.id : (0, nodeIdUtils_1.createNodeId)(options.parentPkg.nodeId, depPath);
-      const parentIsInstallable = options.parentPkg.installable === void 0 || options.parentPkg.installable;
-      const installable = parentIsInstallable && pkgResponse.body.isInstallable !== false;
-      const isNew = !ctx.resolvedPackagesByDepPath[depPath];
-      if (isNew) {
-        if (pkgResponse.body.isInstallable === false || !parentIsInstallable) {
-          ctx.skipped.add(pkgResponse.body.id);
+      toString() {
+        if (!this.valid) {
+          throw new Error("Invalid range");
         }
-        core_loggers_1.progressLogger.debug({
-          packageId: pkgResponse.body.id,
-          requester: ctx.lockfileDir,
-          status: "resolved"
-        });
-        ctx.resolvedPackagesByDepPath[depPath] = getResolvedPackage({
-          allowBuild: ctx.allowBuild,
-          dependencyLockfile: currentPkg.dependencyLockfile,
-          depPath,
-          force: ctx.force,
-          hasBin,
-          pkg,
-          pkgResponse,
-          prepare,
-          wantedDependency
-        });
-      } else {
-        ctx.resolvedPackagesByDepPath[depPath].prod = ctx.resolvedPackagesByDepPath[depPath].prod || !wantedDependency.dev && !wantedDependency.optional;
-        ctx.resolvedPackagesByDepPath[depPath].dev = ctx.resolvedPackagesByDepPath[depPath].dev || wantedDependency.dev;
-        ctx.resolvedPackagesByDepPath[depPath].optional = ctx.resolvedPackagesByDepPath[depPath].optional && wantedDependency.optional;
-        if (ctx.resolvedPackagesByDepPath[depPath].fetchingFiles == null && pkgResponse.files != null) {
-          ctx.resolvedPackagesByDepPath[depPath].fetchingFiles = pkgResponse.files;
-          ctx.resolvedPackagesByDepPath[depPath].filesIndexFile = pkgResponse.filesIndexFile;
-          ctx.resolvedPackagesByDepPath[depPath].finishing = pkgResponse.finishing;
-          ctx.resolvedPackagesByDepPath[depPath].fetchingBundledManifest = pkgResponse.bundledManifest;
+        return utils_1.uniqueArray(this.set.map(String)).join(" || ");
+      }
+      intersect(multiRange) {
+        if (this.valid && multiRange.valid) {
+          const singleRangeList = this.set.map((singleRangeA) => multiRange.set.map((singleRangeB) => singleRangeA.intersect(singleRangeB))).reduce((a, b) => [...a, ...b]).filter(utils_1.isNotNull);
+          return new MultiRange(singleRangeList);
+        } else if (this.valid) {
+          return this;
+        } else if (multiRange.valid) {
+          return multiRange;
+        } else {
+          return new MultiRange(null);
         }
-        if (ctx.dependenciesTree[nodeId]) {
-          ctx.dependenciesTree[nodeId].depth = Math.min(ctx.dependenciesTree[nodeId].depth, options.currentDepth);
+      }
+    };
+    exports2.MultiRange = MultiRange;
+  }
+});
+
+// ../../node_modules/.pnpm/semver-range-intersect@0.3.1/node_modules/semver-range-intersect/dist/index.js
+var require_dist12 = __commonJS({
+  "../../node_modules/.pnpm/semver-range-intersect@0.3.1/node_modules/semver-range-intersect/dist/index.js"(exports2) {
+    "use strict";
+    var __importDefault2 = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    var semver_12 = __importDefault2(require_semver3());
+    var multi_range_1 = require_multi_range();
+    var utils_1 = require_utils7();
+    function intersect(...ranges) {
+      const semverRangeList = (() => {
+        try {
+          return ranges.map((rangeStr) => new semver_12.default.Range(rangeStr));
+        } catch (err) {
+          return null;
+        }
+      })();
+      if (!semverRangeList || !utils_1.isIntersectRanges(semverRangeList)) {
+        return null;
+      }
+      const intersectRange = semverRangeList.map((range) => new multi_range_1.MultiRange(range.set)).reduce((multiRangeA, multiRangeB) => multiRangeA.intersect(multiRangeB), new multi_range_1.MultiRange(null));
+      return intersectRange.valid ? String(intersectRange) || "*" : null;
+    }
+    exports2.intersect = intersect;
+  }
+});
+
+// ../resolve-dependencies/lib/mergePeers.js
+var require_mergePeers = __commonJS({
+  "../resolve-dependencies/lib/mergePeers.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.safeIntersect = exports2.mergePeers = void 0;
+    var semver_range_intersect_1 = require_dist12();
+    function mergePeers(missingPeers) {
+      const conflicts = [];
+      const intersections = {};
+      for (const [peerName, ranges] of Object.entries(missingPeers)) {
+        if (ranges.every(({ optional }) => optional))
+          continue;
+        if (ranges.length === 1) {
+          intersections[peerName] = ranges[0].wantedRange;
+          continue;
+        }
+        const intersection = safeIntersect(ranges.map(({ wantedRange }) => wantedRange));
+        if (intersection === null) {
+          conflicts.push(peerName);
         } else {
-          ctx.pendingNodes.push({
-            alias: wantedDependency.alias || pkg.name,
-            depth: options.currentDepth,
-            installable,
-            nodeId,
-            resolvedPackage: ctx.resolvedPackagesByDepPath[depPath]
-          });
+          intersections[peerName] = intersection;
         }
       }
-      const rootDir = pkgResponse.body.resolution.type === "directory" ? path_1.default.resolve(ctx.lockfileDir, pkgResponse.body.resolution["directory"]) : ctx.prefix;
-      return {
-        alias: wantedDependency.alias || pkg.name,
-        depIsLinked,
-        depPath,
-        isNew,
-        nodeId,
-        normalizedPref: options.currentDepth === 0 ? pkgResponse.body.normalizedPref : void 0,
-        pkgId: pkgResponse.body.id,
-        rootDir,
-        installable,
-        isLinkedDependency: void 0,
-        pkg,
-        updated: pkgResponse.body.updated
-      };
+      return { conflicts, intersections };
     }
-    function pkgIsLeaf(pkg) {
-      return (0, isEmpty_1.default)(pkg.dependencies ?? {}) && (0, isEmpty_1.default)(pkg.optionalDependencies ?? {}) && (0, isEmpty_1.default)(pkg.peerDependencies ?? {});
+    exports2.mergePeers = mergePeers;
+    function safeIntersect(ranges) {
+      try {
+        return (0, semver_range_intersect_1.intersect)(...ranges);
+      } catch {
+        return null;
+      }
     }
-    function getResolvedPackage(options) {
-      const peerDependencies = peerDependenciesWithoutOwn(options.pkg);
-      const requiresBuild = options.allowBuild == null || options.allowBuild(options.pkg.name) ? options.dependencyLockfile != null ? Boolean(options.dependencyLockfile.requiresBuild) : void 0 : false;
-      return {
-        additionalInfo: {
-          bundledDependencies: options.pkg.bundledDependencies,
-          bundleDependencies: options.pkg.bundleDependencies,
-          cpu: options.pkg.cpu,
-          deprecated: options.pkg.deprecated,
-          engines: options.pkg.engines,
-          os: options.pkg.os,
-          libc: options.pkg.libc
-        },
-        depPath: options.depPath,
-        dev: options.wantedDependency.dev,
-        fetchingBundledManifest: options.pkgResponse.bundledManifest,
-        fetchingFiles: options.pkgResponse.files,
-        filesIndexFile: options.pkgResponse.filesIndexFile,
-        finishing: options.pkgResponse.finishing,
-        hasBin: options.hasBin,
-        hasBundledDependencies: !((options.pkg.bundledDependencies ?? options.pkg.bundleDependencies) == null),
-        id: options.pkgResponse.body.id,
-        name: options.pkg.name,
-        optional: options.wantedDependency.optional,
-        optionalDependencies: new Set(Object.keys(options.pkg.optionalDependencies ?? {})),
-        peerDependencies: peerDependencies ?? {},
-        peerDependenciesMeta: options.pkg.peerDependenciesMeta,
-        prepare: options.prepare,
-        prod: !options.wantedDependency.dev && !options.wantedDependency.optional,
-        requiresBuild,
-        resolution: options.pkgResponse.body.resolution,
-        version: options.pkg.version
-      };
+    exports2.safeIntersect = safeIntersect;
+  }
+});
+
+// ../resolve-dependencies/lib/wantedDepIsLocallyAvailable.js
+var require_wantedDepIsLocallyAvailable = __commonJS({
+  "../resolve-dependencies/lib/wantedDepIsLocallyAvailable.js"(exports2) {
+    "use strict";
+    var __importDefault2 = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    var npm_resolver_1 = require_lib41();
+    var semver_12 = __importDefault2(require_semver2());
+    function wantedDepIsLocallyAvailable(workspacePackages, wantedDependency, opts) {
+      const spec = (0, npm_resolver_1.parsePref)(wantedDependency.pref, wantedDependency.alias, opts.defaultTag || "latest", opts.registry);
+      if (spec == null || !workspacePackages[spec.name])
+        return false;
+      return pickMatchingLocalVersionOrNull(workspacePackages[spec.name], spec) !== null;
     }
-    function peerDependenciesWithoutOwn(pkg) {
-      if (pkg.peerDependencies == null && pkg.peerDependenciesMeta == null)
-        return pkg.peerDependencies;
-      const ownDeps = /* @__PURE__ */ new Set([
-        ...Object.keys(pkg.dependencies ?? {}),
-        ...Object.keys(pkg.optionalDependencies ?? {})
-      ]);
-      const result2 = {};
-      if (pkg.peerDependencies != null) {
-        for (const [peerName, peerRange] of Object.entries(pkg.peerDependencies)) {
-          if (ownDeps.has(peerName))
-            continue;
-          result2[peerName] = peerRange;
-        }
-      }
-      if (pkg.peerDependenciesMeta != null) {
-        for (const [peerName, peerMeta] of Object.entries(pkg.peerDependenciesMeta)) {
-          if (ownDeps.has(peerName) || result2[peerName] || peerMeta.optional !== true)
-            continue;
-          result2[peerName] = "*";
-        }
+    exports2.default = wantedDepIsLocallyAvailable;
+    function pickMatchingLocalVersionOrNull(versions, spec) {
+      const localVersions = Object.keys(versions);
+      switch (spec.type) {
+        case "tag":
+          return semver_12.default.maxSatisfying(localVersions, "*");
+        case "version":
+          return versions[spec.fetchSpec] ? spec.fetchSpec : null;
+        case "range":
+          return semver_12.default.maxSatisfying(localVersions, spec.fetchSpec, true);
+        default:
+          return null;
       }
-      if ((0, isEmpty_1.default)(result2))
-        return void 0;
-      return result2;
     }
   }
 });
 
-// ../resolve-dependencies/lib/resolveDependencyTree.js
-var require_resolveDependencyTree = __commonJS({
-  "../resolve-dependencies/lib/resolveDependencyTree.js"(exports2) {
+// ../resolve-dependencies/lib/resolveDependencies.js
+var require_resolveDependencies = __commonJS({
+  "../resolve-dependencies/lib/resolveDependencies.js"(exports2) {
     "use strict";
     var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
       if (k2 === void 0)
@@ -111038,857 +111078,875 @@ var require_resolveDependencyTree = __commonJS({
         k2 = k;
       o[k2] = m[k];
     });
-    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
-      for (var p in m)
-        if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p))
-          __createBinding(exports3, m, p);
+    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports2 && exports2.__importStar || function(mod) {
+      if (mod && mod.__esModule)
+        return mod;
+      var result2 = {};
+      if (mod != null) {
+        for (var k in mod)
+          if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
+            __createBinding(result2, mod, k);
+      }
+      __setModuleDefault(result2, mod);
+      return result2;
     };
     var __importDefault2 = exports2 && exports2.__importDefault || function(mod) {
       return mod && mod.__esModule ? mod : { "default": mod };
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
-    var partition_1 = __importDefault2(require_partition4());
+    exports2.nodeIdToParents = void 0;
+    var path_1 = __importDefault2(require("path"));
+    var core_loggers_1 = require_lib8();
+    var error_1 = __importDefault2(require_lib7());
+    var lockfile_utils_1 = require_lib54();
+    var logger_1 = __importDefault2(require_lib());
+    var pick_registry_for_package_1 = __importDefault2(require_lib49());
+    var dp = __importStar(require_lib51());
+    var path_exists_1 = __importDefault2(require_path_exists());
+    var isEmpty_1 = __importDefault2(require_isEmpty2());
+    var semver_12 = __importDefault2(require_semver2());
+    var encodePkgId_1 = __importDefault2(require_encodePkgId());
+    var getNonDevWantedDependencies_1 = __importDefault2(require_getNonDevWantedDependencies());
+    var mergePeers_1 = require_mergePeers();
     var nodeIdUtils_1 = require_nodeIdUtils();
-    var resolveDependencies_1 = __importDefault2(require_resolveDependencies());
-    __exportStar(require_nodeIdUtils(), exports2);
-    async function default_1(importers, opts) {
-      const directDepsByImporterId = {};
-      const wantedToBeSkippedPackageIds = /* @__PURE__ */ new Set();
-      const ctx = {
-        allowBuild: opts.allowBuild,
-        childrenByParentDepPath: {},
-        currentLockfile: opts.currentLockfile,
-        defaultTag: opts.tag,
-        dependenciesTree: {},
-        dryRun: opts.dryRun,
-        engineStrict: opts.engineStrict,
-        force: opts.force,
-        forceFullResolution: opts.forceFullResolution,
-        linkWorkspacePackagesDepth: opts.linkWorkspacePackagesDepth ?? -1,
-        lockfileDir: opts.lockfileDir,
-        nodeVersion: opts.nodeVersion,
-        outdatedDependencies: {},
-        pendingNodes: [],
-        pnpmVersion: opts.pnpmVersion,
-        preferWorkspacePackages: opts.preferWorkspacePackages,
-        readPackageHook: opts.hooks.readPackage,
-        registries: opts.registries,
-        resolvedPackagesByDepPath: {},
-        skipped: wantedToBeSkippedPackageIds,
-        storeController: opts.storeController,
-        updateMatching: opts.updateMatching,
-        virtualStoreDir: opts.virtualStoreDir,
-        wantedLockfile: opts.wantedLockfile
-      };
-      await Promise.all(importers.map(async (importer) => {
-        const projectSnapshot = opts.wantedLockfile.importers[importer.id];
-        const linkedDependencies = [];
-        const resolveCtx = {
-          ...ctx,
-          updatedSet: /* @__PURE__ */ new Set(),
-          linkedDependencies,
-          modulesDir: importer.modulesDir,
-          prefix: importer.rootDir
-        };
-        const proceed = importer.id === "." || importer.hasRemovedDependencies === true || importer.wantedDependencies.some((wantedDep) => wantedDep["isNew"]);
-        const resolveOpts = {
-          currentDepth: 0,
-          parentPkg: {
-            installable: true,
-            nodeId: `>${importer.id}>`,
-            optional: false,
-            depPath: importer.id,
-            rootDir: importer.rootDir
-          },
-          proceed,
-          resolvedDependencies: {
-            ...projectSnapshot.dependencies,
-            ...projectSnapshot.devDependencies,
-            ...projectSnapshot.optionalDependencies
-          },
-          updateDepth: -1,
-          workspacePackages: opts.workspacePackages
-        };
-        directDepsByImporterId[importer.id] = await (0, resolveDependencies_1.default)(resolveCtx, importer.preferredVersions ?? {}, importer.wantedDependencies, resolveOpts);
-      }));
-      ctx.pendingNodes.forEach((pendingNode) => {
-        ctx.dependenciesTree[pendingNode.nodeId] = {
-          children: () => buildTree(ctx, pendingNode.nodeId, pendingNode.resolvedPackage.id, ctx.childrenByParentDepPath[pendingNode.resolvedPackage.depPath], pendingNode.depth + 1, pendingNode.installable),
-          depth: pendingNode.depth,
-          installable: pendingNode.installable,
-          resolvedPackage: pendingNode.resolvedPackage
-        };
+    var wantedDepIsLocallyAvailable_1 = __importDefault2(require_wantedDepIsLocallyAvailable());
+    var dependencyResolvedLogger = (0, logger_1.default)("_dependency_resolved");
+    function nodeIdToParents(nodeId, resolvedPackagesByDepPath) {
+      return (0, nodeIdUtils_1.splitNodeId)(nodeId).slice(1).map((depPath) => {
+        const { id, name, version } = resolvedPackagesByDepPath[depPath];
+        return { id, name, version };
       });
-      const resolvedImporters = {};
-      for (const { id } of importers) {
-        const directDeps = directDepsByImporterId[id];
-        const [linkedDependencies, directNonLinkedDeps] = (0, partition_1.default)((dep) => dep.isLinkedDependency === true, directDeps);
-        resolvedImporters[id] = {
-          directDependencies: directDeps.map((dep) => {
-            if (dep.isLinkedDependency === true) {
-              return dep;
-            }
-            const resolvedPackage = ctx.dependenciesTree[dep.nodeId].resolvedPackage;
-            return {
-              alias: dep.alias,
-              dev: resolvedPackage.dev,
-              name: resolvedPackage.name,
-              normalizedPref: dep.normalizedPref,
-              optional: resolvedPackage.optional,
-              pkgId: resolvedPackage.id,
-              resolution: resolvedPackage.resolution,
-              version: resolvedPackage.version
-            };
-          }),
-          directNodeIdsByAlias: directNonLinkedDeps.reduce((acc, dependency) => {
-            acc[dependency.alias] = dependency.nodeId;
-            return acc;
-          }, {}),
-          linkedDependencies
-        };
-      }
-      return {
-        dependenciesTree: ctx.dependenciesTree,
-        outdatedDependencies: ctx.outdatedDependencies,
-        resolvedImporters,
-        resolvedPackagesByDepPath: ctx.resolvedPackagesByDepPath,
-        wantedToBeSkippedPackageIds
-      };
     }
-    exports2.default = default_1;
-    function buildTree(ctx, parentNodeId, parentId, children, depth, installable) {
-      const childrenNodeIds = {};
-      for (const child of children) {
-        if (child.depPath.startsWith("link:")) {
-          childrenNodeIds[child.alias] = child.depPath;
-          continue;
+    exports2.nodeIdToParents = nodeIdToParents;
+    async function resolveDependencies(ctx, preferredVersions, wantedDependencies, options) {
+      let extendedWantedDeps = [];
+      const postponedResolutionsQueue = [];
+      const pkgAddresses = [];
+      while (true) {
+        extendedWantedDeps = getDepsToResolve(wantedDependencies, ctx.wantedLockfile, {
+          preferredDependencies: options.preferredDependencies,
+          prefix: ctx.prefix,
+          proceed: options.proceed || ctx.forceFullResolution,
+          registries: ctx.registries,
+          resolvedDependencies: options.resolvedDependencies
+        });
+        const newPkgAddresses = (await Promise.all(extendedWantedDeps.map(async (extendedWantedDep) => resolveDependenciesOfDependency(postponedResolutionsQueue, ctx, preferredVersions, options, extendedWantedDep)))).filter(Boolean);
+        pkgAddresses.push(...newPkgAddresses);
+        if (!ctx.autoInstallPeers)
+          break;
+        const allMissingPeers = mergePkgsDeps(newPkgAddresses.map(({ missingPeers }) => missingPeers));
+        if (!Object.keys(allMissingPeers).length)
+          break;
+        wantedDependencies = (0, getNonDevWantedDependencies_1.default)({ dependencies: allMissingPeers });
+      }
+      const newPreferredVersions = { ...preferredVersions };
+      const newParentPkgAliases = { ...options.parentPkgAliases };
+      for (const pkgAddress of pkgAddresses) {
+        newParentPkgAliases[pkgAddress.alias] = true;
+        if (pkgAddress.updated) {
+          ctx.updatedSet.add(pkgAddress.alias);
         }
-        if ((0, nodeIdUtils_1.nodeIdContainsSequence)(parentNodeId, parentId, child.depPath) || parentId === child.depPath) {
+        const resolvedPackage = ctx.resolvedPackagesByDepPath[pkgAddress.depPath];
+        if (!resolvedPackage)
           continue;
+        if (!newPreferredVersions[resolvedPackage.name]) {
+          newPreferredVersions[resolvedPackage.name] = {};
         }
-        const childNodeId = (0, nodeIdUtils_1.createNodeId)(parentNodeId, child.depPath);
-        childrenNodeIds[child.alias] = childNodeId;
-        installable = installable && !ctx.skipped.has(child.depPath);
-        ctx.dependenciesTree[childNodeId] = {
-          children: () => buildTree(ctx, childNodeId, child.depPath, ctx.childrenByParentDepPath[child.depPath], depth + 1, installable),
-          depth,
-          installable,
-          resolvedPackage: ctx.resolvedPackagesByDepPath[child.depPath]
-        };
+        newPreferredVersions[resolvedPackage.name][resolvedPackage.version] = "version";
       }
-      return childrenNodeIds;
+      await Promise.all(postponedResolutionsQueue.map(async (postponedResolution) => postponedResolution(newPreferredVersions, newParentPkgAliases)));
+      return pkgAddresses;
     }
-  }
-});
-
-// ../../node_modules/.pnpm/trim-repeated@1.0.0/node_modules/trim-repeated/index.js
-var require_trim_repeated = __commonJS({
-  "../../node_modules/.pnpm/trim-repeated@1.0.0/node_modules/trim-repeated/index.js"(exports2, module2) {
-    "use strict";
-    var escapeStringRegexp = require_escape_string_regexp();
-    module2.exports = function(str, target) {
-      if (typeof str !== "string" || typeof target !== "string") {
-        throw new TypeError("Expected a string");
-      }
-      return str.replace(new RegExp("(?:" + escapeStringRegexp(target) + "){2,}", "g"), target);
-    };
-  }
-});
-
-// ../../node_modules/.pnpm/filename-reserved-regex@2.0.0/node_modules/filename-reserved-regex/index.js
-var require_filename_reserved_regex = __commonJS({
-  "../../node_modules/.pnpm/filename-reserved-regex@2.0.0/node_modules/filename-reserved-regex/index.js"(exports2, module2) {
-    "use strict";
-    module2.exports = () => /[<>:"\/\\|?*\x00-\x1F]/g;
-    module2.exports.windowsNames = () => /^(con|prn|aux|nul|com[0-9]|lpt[0-9])$/i;
-  }
-});
-
-// ../../node_modules/.pnpm/strip-outer@1.0.1/node_modules/strip-outer/index.js
-var require_strip_outer = __commonJS({
-  "../../node_modules/.pnpm/strip-outer@1.0.1/node_modules/strip-outer/index.js"(exports2, module2) {
-    "use strict";
-    var escapeStringRegexp = require_escape_string_regexp();
-    module2.exports = function(str, sub) {
-      if (typeof str !== "string" || typeof sub !== "string") {
-        throw new TypeError();
-      }
-      sub = escapeStringRegexp(sub);
-      return str.replace(new RegExp("^" + sub + "|" + sub + "$", "g"), "");
-    };
-  }
-});
-
-// ../../node_modules/.pnpm/filenamify@4.3.0/node_modules/filenamify/filenamify.js
-var require_filenamify = __commonJS({
-  "../../node_modules/.pnpm/filenamify@4.3.0/node_modules/filenamify/filenamify.js"(exports2, module2) {
-    "use strict";
-    var trimRepeated = require_trim_repeated();
-    var filenameReservedRegex = require_filename_reserved_regex();
-    var stripOuter = require_strip_outer();
-    var MAX_FILENAME_LENGTH = 100;
-    var reControlChars = /[\u0000-\u001f\u0080-\u009f]/g;
-    var reRelativePath = /^\.+/;
-    var reTrailingPeriods = /\.+$/;
-    var filenamify = (string, options = {}) => {
-      if (typeof string !== "string") {
-        throw new TypeError("Expected a string");
-      }
-      const replacement = options.replacement === void 0 ? "!" : options.replacement;
-      if (filenameReservedRegex().test(replacement) && reControlChars.test(replacement)) {
-        throw new Error("Replacement string cannot contain reserved filename characters");
-      }
-      string = string.replace(filenameReservedRegex(), replacement);
-      string = string.replace(reControlChars, replacement);
-      string = string.replace(reRelativePath, replacement);
-      string = string.replace(reTrailingPeriods, "");
-      if (replacement.length > 0) {
-        string = trimRepeated(string, replacement);
-        string = string.length > 1 ? stripOuter(string, replacement) : string;
-      }
-      string = filenameReservedRegex.windowsNames().test(string) ? string + replacement : string;
-      string = string.slice(0, typeof options.maxLength === "number" ? options.maxLength : MAX_FILENAME_LENGTH);
-      return string;
-    };
-    module2.exports = filenamify;
-  }
-});
-
-// ../../node_modules/.pnpm/filenamify@4.3.0/node_modules/filenamify/filenamify-path.js
-var require_filenamify_path = __commonJS({
-  "../../node_modules/.pnpm/filenamify@4.3.0/node_modules/filenamify/filenamify-path.js"(exports2, module2) {
-    "use strict";
-    var path2 = require("path");
-    var filenamify = require_filenamify();
-    var filenamifyPath = (filePath, options) => {
-      filePath = path2.resolve(filePath);
-      return path2.join(path2.dirname(filePath), filenamify(path2.basename(filePath), options));
-    };
-    module2.exports = filenamifyPath;
-  }
-});
-
-// ../../node_modules/.pnpm/filenamify@4.3.0/node_modules/filenamify/index.js
-var require_filenamify2 = __commonJS({
-  "../../node_modules/.pnpm/filenamify@4.3.0/node_modules/filenamify/index.js"(exports2, module2) {
-    "use strict";
-    var filenamify = require_filenamify();
-    var filenamifyPath = require_filenamify_path();
-    var filenamifyCombined = filenamify;
-    filenamifyCombined.path = filenamifyPath;
-    module2.exports = filenamify;
-  }
-});
-
-// ../../node_modules/.pnpm/@yarnpkg+core@3.2.0/node_modules/@yarnpkg/core/lib/semverUtils.js
-var require_semverUtils = __commonJS({
-  "../../node_modules/.pnpm/@yarnpkg+core@3.2.0/node_modules/@yarnpkg/core/lib/semverUtils.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.clean = exports2.validRange = exports2.satisfiesWithPrereleases = exports2.SemVer = void 0;
-    var tslib_12 = require_tslib();
-    var semver_12 = tslib_12.__importDefault(require_semver2());
-    var semver_2 = require_semver2();
-    Object.defineProperty(exports2, "SemVer", { enumerable: true, get: function() {
-      return semver_2.SemVer;
-    } });
-    var satisfiesWithPrereleasesCache = /* @__PURE__ */ new Map();
-    function satisfiesWithPrereleases(version, range, loose = false) {
-      if (!version)
-        return false;
-      const key = `${range}${loose}`;
-      let semverRange = satisfiesWithPrereleasesCache.get(key);
-      if (typeof semverRange === `undefined`) {
-        try {
-          semverRange = new semver_12.default.Range(range, { includePrerelease: true, loose });
-        } catch {
-          return false;
-        } finally {
-          satisfiesWithPrereleasesCache.set(key, semverRange || null);
+    exports2.default = resolveDependencies;
+    function mergePkgsDeps(pkgsDeps) {
+      const groupedRanges = {};
+      for (const deps of pkgsDeps) {
+        for (const [name, range] of Object.entries(deps)) {
+          if (!groupedRanges[name]) {
+            groupedRanges[name] = [];
+          }
+          groupedRanges[name].push(range);
         }
-      } else if (semverRange === null) {
-        return false;
       }
-      let semverVersion;
-      try {
-        semverVersion = new semver_12.default.SemVer(version, semverRange);
-      } catch (err) {
-        return false;
+      const mergedPkgDeps = {};
+      for (const [name, ranges] of Object.entries(groupedRanges)) {
+        const intersection = (0, mergePeers_1.safeIntersect)(ranges);
+        if (intersection) {
+          mergedPkgDeps[name] = intersection;
+        }
       }
-      if (semverRange.test(semverVersion))
-        return true;
-      if (semverVersion.prerelease)
-        semverVersion.prerelease = [];
-      return semverRange.set.some((comparatorSet) => {
-        for (const comparator of comparatorSet)
-          if (comparator.semver.prerelease)
-            comparator.semver.prerelease = [];
-        return comparatorSet.every((comparator) => {
-          return comparator.test(semverVersion);
-        });
-      });
+      return mergedPkgDeps;
     }
-    exports2.satisfiesWithPrereleases = satisfiesWithPrereleases;
-    var rangesCache = /* @__PURE__ */ new Map();
-    function validRange(potentialRange) {
-      if (potentialRange.indexOf(`:`) !== -1)
+    async function resolveDependenciesOfDependency(postponedResolutionsQueue, ctx, preferredVersions, options, extendedWantedDep) {
+      const updateDepth = typeof extendedWantedDep.wantedDependency.updateDepth === "number" ? extendedWantedDep.wantedDependency.updateDepth : options.updateDepth;
+      const updateShouldContinue = options.currentDepth <= updateDepth;
+      const update = extendedWantedDep.infoFromLockfile?.dependencyLockfile == null || updateShouldContinue && (ctx.updateMatching == null || ctx.updateMatching(extendedWantedDep.infoFromLockfile.name)) || Boolean(options.workspacePackages != null && ctx.linkWorkspacePackagesDepth !== -1 && (0, wantedDepIsLocallyAvailable_1.default)(options.workspacePackages, extendedWantedDep.wantedDependency, { defaultTag: ctx.defaultTag, registry: ctx.registries.default })) || ctx.updatedSet.has(extendedWantedDep.infoFromLockfile.name);
+      const resolveDependencyOpts = {
+        currentDepth: options.currentDepth,
+        parentPkg: options.parentPkg,
+        parentPkgAliases: options.parentPkgAliases,
+        preferredVersions,
+        workspacePackages: options.workspacePackages,
+        currentPkg: extendedWantedDep.infoFromLockfile ?? void 0,
+        proceed: extendedWantedDep.proceed || updateShouldContinue || ctx.updatedSet.size > 0,
+        update,
+        updateDepth
+      };
+      const resolveDependencyResult = await resolveDependency(extendedWantedDep.wantedDependency, ctx, resolveDependencyOpts);
+      if (resolveDependencyResult == null)
         return null;
-      let range = rangesCache.get(potentialRange);
-      if (typeof range !== `undefined`)
-        return range;
-      try {
-        range = new semver_12.default.Range(potentialRange);
-      } catch {
-        range = null;
+      if (resolveDependencyResult.isLinkedDependency) {
+        ctx.dependenciesTree[resolveDependencyResult.pkgId] = {
+          children: {},
+          depth: -1,
+          installable: true,
+          resolvedPackage: {
+            name: resolveDependencyResult.name,
+            version: resolveDependencyResult.version
+          }
+        };
+        return resolveDependencyResult;
       }
-      rangesCache.set(potentialRange, range);
-      return range;
+      if (!resolveDependencyResult.isNew)
+        return resolveDependencyResult;
+      postponedResolutionsQueue.push(async (preferredVersions2, parentPkgAliases) => resolveChildren(ctx, resolveDependencyResult, parentPkgAliases, extendedWantedDep.infoFromLockfile?.dependencyLockfile, options.workspacePackages, options.currentDepth, updateDepth, preferredVersions2));
+      return resolveDependencyResult;
     }
-    exports2.validRange = validRange;
-    var CLEAN_SEMVER_REGEXP = /^(?:[\sv=]*?)((0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?)(?:\s*)$/;
-    function clean(potentialVersion) {
-      const version = CLEAN_SEMVER_REGEXP.exec(potentialVersion);
-      return version ? version[1] : null;
+    async function resolveChildren(ctx, parentPkg, parentPkgAliases, dependencyLockfile, workspacePackages, parentDepth, updateDepth, preferredVersions) {
+      const currentResolvedDependencies = dependencyLockfile != null ? {
+        ...dependencyLockfile.dependencies,
+        ...dependencyLockfile.optionalDependencies
+      } : void 0;
+      const resolvedDependencies = parentPkg.updated ? void 0 : currentResolvedDependencies;
+      const parentDependsOnPeer = Boolean(Object.keys(dependencyLockfile?.peerDependencies ?? parentPkg.pkg.peerDependencies ?? {}).length);
+      const wantedDependencies = (0, getNonDevWantedDependencies_1.default)(parentPkg.pkg);
+      const children = await resolveDependencies(ctx, preferredVersions, wantedDependencies, {
+        currentDepth: parentDepth + 1,
+        parentPkg,
+        parentPkgAliases,
+        preferredDependencies: currentResolvedDependencies,
+        proceed: !parentPkg.depIsLinked || parentDependsOnPeer,
+        resolvedDependencies,
+        updateDepth,
+        workspacePackages
+      });
+      ctx.childrenByParentDepPath[parentPkg.depPath] = children.map((child) => ({
+        alias: child.alias,
+        depPath: child.depPath
+      }));
+      ctx.dependenciesTree[parentPkg.nodeId] = {
+        children: children.reduce((chn, child) => {
+          chn[child.alias] = child["nodeId"] ?? child.pkgId;
+          return chn;
+        }, {}),
+        depth: parentDepth,
+        installable: parentPkg.installable,
+        resolvedPackage: ctx.resolvedPackagesByDepPath[parentPkg.depPath]
+      };
     }
-    exports2.clean = clean;
-  }
-});
-
-// ../../node_modules/.pnpm/ramda@0.27.2/node_modules/ramda/src/scan.js
-var require_scan4 = __commonJS({
-  "../../node_modules/.pnpm/ramda@0.27.2/node_modules/ramda/src/scan.js"(exports2, module2) {
-    var _curry3 = require_curry3();
-    var scan = /* @__PURE__ */ _curry3(function scan2(fn2, acc, list) {
-      var idx = 0;
-      var len = list.length;
-      var result2 = [acc];
-      while (idx < len) {
-        acc = fn2(acc, list[idx]);
-        result2[idx + 1] = acc;
-        idx += 1;
+    function getDepsToResolve(wantedDependencies, wantedLockfile, options) {
+      const resolvedDependencies = options.resolvedDependencies ?? {};
+      const preferredDependencies = options.preferredDependencies ?? {};
+      const extendedWantedDeps = [];
+      let proceedAll = options.proceed;
+      const satisfiesWanted2Args = referenceSatisfiesWantedSpec.bind(null, {
+        lockfile: wantedLockfile,
+        prefix: options.prefix
+      });
+      for (const wantedDependency of wantedDependencies) {
+        let reference = void 0;
+        let proceed = proceedAll;
+        if (wantedDependency.alias) {
+          const satisfiesWanted = satisfiesWanted2Args.bind(null, wantedDependency);
+          if (resolvedDependencies[wantedDependency.alias] && satisfiesWanted(resolvedDependencies[wantedDependency.alias])) {
+            reference = resolvedDependencies[wantedDependency.alias];
+          } else if (semver_12.default.validRange(wantedDependency.pref) !== null && preferredDependencies[wantedDependency.alias] && satisfiesWanted(preferredDependencies[wantedDependency.alias])) {
+            proceed = true;
+            reference = preferredDependencies[wantedDependency.alias];
+          }
+        }
+        const infoFromLockfile = getInfoFromLockfile(wantedLockfile, options.registries, reference, wantedDependency.alias);
+        if (!proceedAll && (infoFromLockfile == null || infoFromLockfile.dependencyLockfile != null && (infoFromLockfile.dependencyLockfile.peerDependencies != null || infoFromLockfile.dependencyLockfile.transitivePeerDependencies?.length))) {
+          proceed = true;
+          proceedAll = true;
+          for (const extendedWantedDep of extendedWantedDeps) {
+            if (!extendedWantedDep.proceed) {
+              extendedWantedDep.proceed = true;
+            }
+          }
+        }
+        extendedWantedDeps.push({
+          infoFromLockfile,
+          proceed,
+          wantedDependency
+        });
       }
-      return result2;
-    });
-    module2.exports = scan;
-  }
-});
-
-// ../../node_modules/.pnpm/semver-range-intersect@0.3.1/node_modules/semver-range-intersect/dist/utils.js
-var require_utils7 = __commonJS({
-  "../../node_modules/.pnpm/semver-range-intersect@0.3.1/node_modules/semver-range-intersect/dist/utils.js"(exports2) {
-    "use strict";
-    var __importDefault2 = exports2 && exports2.__importDefault || function(mod) {
-      return mod && mod.__esModule ? mod : { "default": mod };
-    };
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    var semver_12 = __importDefault2(require_semver3());
-    function isNotNull(value) {
-      return value !== null;
-    }
-    exports2.isNotNull = isNotNull;
-    function uniqueArray(array) {
-      return [...new Set(array)];
-    }
-    exports2.uniqueArray = uniqueArray;
-    function isNoIncludeNull(value) {
-      return value.every(isNotNull);
+      return extendedWantedDeps;
     }
-    exports2.isNoIncludeNull = isNoIncludeNull;
-    function isPrerelease(version) {
-      if (version instanceof semver_12.default.SemVer) {
-        return version.prerelease.length !== 0;
-      } else {
+    function referenceSatisfiesWantedSpec(opts, wantedDep, preferredRef) {
+      const depPath = dp.refToRelative(preferredRef, wantedDep.alias);
+      if (depPath === null)
+        return false;
+      const pkgSnapshot = opts.lockfile.packages?.[depPath];
+      if (pkgSnapshot == null) {
+        logger_1.default.warn({
+          message: `Could not find preferred package ${depPath} in lockfile`,
+          prefix: opts.prefix
+        });
         return false;
       }
+      const { version } = (0, lockfile_utils_1.nameVerFromPkgSnapshot)(depPath, pkgSnapshot);
+      return semver_12.default.satisfies(version, wantedDep.pref, true);
     }
-    exports2.isPrerelease = isPrerelease;
-    function isValidOperator(comparator, operatorList) {
-      return operatorList.includes(comparator.operator);
-    }
-    exports2.isValidOperator = isValidOperator;
-    function equalComparator(comparatorA, comparatorB) {
-      return comparatorA.value === comparatorB.value;
-    }
-    exports2.equalComparator = equalComparator;
-    function comparator2versionStr(comparator) {
-      const compSemver = comparator.semver;
-      return compSemver instanceof semver_12.default.SemVer ? compSemver.version : "";
-    }
-    exports2.comparator2versionStr = comparator2versionStr;
-    function isSameVersionEqualsLikeComparator(comparatorA, comparatorB) {
-      const compVersionA = comparator2versionStr(comparatorA);
-      const compVersionB = comparator2versionStr(comparatorB);
-      return compVersionA !== "" && compVersionB !== "" && compVersionA === compVersionB && /=|^$/.test(comparatorA.operator) && /=|^$/.test(comparatorB.operator);
-    }
-    exports2.isSameVersionEqualsLikeComparator = isSameVersionEqualsLikeComparator;
-    function isEqualsComparator(comparator) {
-      return comparator.semver instanceof semver_12.default.SemVer && isValidOperator(comparator, ["", "="]);
-    }
-    exports2.isEqualsComparator = isEqualsComparator;
-    function filterUniqueComparator(comparator, index, self2) {
-      return self2.findIndex((comp) => equalComparator(comparator, comp)) === index;
-    }
-    exports2.filterUniqueComparator = filterUniqueComparator;
-    function filterOperator(operatorList) {
-      return (comparator) => isValidOperator(comparator, operatorList);
-    }
-    exports2.filterOperator = filterOperator;
-    function isIntersectRanges(semverRangeList) {
-      return semverRangeList.every((rangeA, index, rangeList) => rangeList.slice(index + 1).every((rangeB) => rangeA.intersects(rangeB)));
-    }
-    exports2.isIntersectRanges = isIntersectRanges;
-    function stripSemVerPrerelease(semverVersion) {
-      if (!(semverVersion instanceof semver_12.default.SemVer)) {
-        return "";
-      }
-      if (!semverVersion.prerelease.length) {
-        return semverVersion.version;
-      }
-      const newSemverVersion = new semver_12.default.SemVer(semverVersion.version, semverVersion.options);
-      newSemverVersion.prerelease = [];
-      return newSemverVersion.format();
-    }
-    exports2.stripSemVerPrerelease = stripSemVerPrerelease;
-    function stripComparatorOperator(comparator) {
-      if (!comparator.operator) {
-        return comparator;
+    function getInfoFromLockfile(lockfile, registries, reference, alias) {
+      if (!reference || !alias) {
+        return void 0;
       }
-      const versionStr = comparator2versionStr(comparator);
-      return new semver_12.default.Comparator(versionStr, comparator.options);
-    }
-    exports2.stripComparatorOperator = stripComparatorOperator;
-    function getLowerBoundComparator(comparatorList, options = {}) {
-      const validComparatorList = comparatorList.filter((comparator) => isValidOperator(comparator, [">", ">="]) || !(comparator.semver instanceof semver_12.default.SemVer));
-      const leComparatorVersionList = comparatorList.filter(filterOperator(["<="])).map(comparator2versionStr);
-      if (validComparatorList.length >= 1) {
-        return validComparatorList.reduce((a, b) => {
-          const semverA = a.semver;
-          const semverB = b.semver;
-          if (!(semverA instanceof semver_12.default.SemVer)) {
-            if (!options.singleRange && isPrerelease(semverB) && !(b.operator === ">=" && leComparatorVersionList.some((version) => version === String(semverB)))) {
-              return new semver_12.default.Comparator(`>=${stripSemVerPrerelease(semverB)}`, b.options);
-            }
-            return b;
-          } else if (!(semverB instanceof semver_12.default.SemVer)) {
-            if (!options.singleRange && isPrerelease(semverA) && !(a.operator === ">=" && leComparatorVersionList.some((version) => version === String(semverA)))) {
-              return new semver_12.default.Comparator(`>=${stripSemVerPrerelease(semverA)}`, a.options);
-            }
-            return a;
-          }
-          const semverCmp = semver_12.default.compare(semverA, semverB);
-          if (a.operator === b.operator || semverCmp !== 0) {
-            if (!options.singleRange) {
-              const semverCmpMain = semverA.compareMain(semverB);
-              if (semverCmpMain !== 0 && semverA.prerelease.length && semverB.prerelease.length) {
-                if (semverCmpMain > 0) {
-                  return new semver_12.default.Comparator(a.operator + stripSemVerPrerelease(semverA), a.options);
-                } else {
-                  return new semver_12.default.Comparator(b.operator + stripSemVerPrerelease(semverB), b.options);
-                }
-              }
-            }
-            if (semverCmp > 0) {
-              return a;
-            } else {
-              return b;
-            }
-          } else {
-            if (a.operator === ">") {
-              return a;
-            } else {
-              return b;
-            }
-          }
-        });
-      } else {
-        return new semver_12.default.Comparator("");
+      const depPath = dp.refToRelative(reference, alias);
+      if (!depPath) {
+        return void 0;
       }
-    }
-    exports2.getLowerBoundComparator = getLowerBoundComparator;
-    function getUpperBoundComparator(comparatorList, options = {}) {
-      const validComparatorList = comparatorList.filter((comparator) => isValidOperator(comparator, ["<", "<="]) || !(comparator.semver instanceof semver_12.default.SemVer));
-      const geComparatorVersionList = comparatorList.filter(filterOperator([">="])).map(comparator2versionStr);
-      if (validComparatorList.length >= 1) {
-        return validComparatorList.reduce((a, b) => {
-          const semverA = a.semver;
-          const semverB = b.semver;
-          if (!(semverA instanceof semver_12.default.SemVer)) {
-            if (!options.singleRange && isPrerelease(semverB) && !(b.operator === "<=" && geComparatorVersionList.some((version) => version === String(semverB)))) {
-              return new semver_12.default.Comparator(`<${stripSemVerPrerelease(semverB)}`, b.options);
-            }
-            return b;
-          } else if (!(semverB instanceof semver_12.default.SemVer)) {
-            if (!options.singleRange && isPrerelease(semverA) && !(a.operator === "<=" && geComparatorVersionList.some((version) => version === String(semverA)))) {
-              return new semver_12.default.Comparator(`<${stripSemVerPrerelease(semverA)}`, a.options);
-            }
-            return a;
-          }
-          const semverCmp = semver_12.default.compare(semverA, semverB);
-          if (a.operator === b.operator || semverCmp !== 0) {
-            if (!options.singleRange) {
-              const semverCmpMain = semverA.compareMain(semverB);
-              if (semverCmpMain !== 0 && semverA.prerelease.length && semverB.prerelease.length) {
-                if (semverCmpMain < 0) {
-                  return new semver_12.default.Comparator(`<${stripSemVerPrerelease(semverA)}`, a.options);
-                } else {
-                  return new semver_12.default.Comparator(`<${stripSemVerPrerelease(semverB)}`, b.options);
-                }
-              }
-            }
-            if (semverCmp < 0) {
-              return a;
-            } else {
-              return b;
-            }
-          } else {
-            if (a.operator === "<") {
-              return a;
-            } else {
-              return b;
-            }
+      let dependencyLockfile = lockfile.packages?.[depPath];
+      if (dependencyLockfile != null) {
+        if (dependencyLockfile.peerDependencies != null && dependencyLockfile.dependencies != null) {
+          const dependencies = {};
+          for (const [depName, ref] of Object.entries(dependencyLockfile.dependencies ?? {})) {
+            if (dependencyLockfile.peerDependencies[depName])
+              continue;
+            dependencies[depName] = ref;
           }
-        });
+          dependencyLockfile = {
+            ...dependencyLockfile,
+            dependencies
+          };
+        }
+        return {
+          ...(0, lockfile_utils_1.nameVerFromPkgSnapshot)(depPath, dependencyLockfile),
+          dependencyLockfile,
+          depPath,
+          pkgId: (0, lockfile_utils_1.packageIdFromSnapshot)(depPath, dependencyLockfile, registries),
+          resolution: dependencyLockfile.resolution && (0, lockfile_utils_1.pkgSnapshotToResolution)(depPath, dependencyLockfile, registries)
+        };
       } else {
-        return new semver_12.default.Comparator("");
+        return {
+          depPath,
+          pkgId: dp.tryGetPackageId(registries, depPath) ?? depPath
+        };
       }
     }
-    exports2.getUpperBoundComparator = getUpperBoundComparator;
-  }
-});
-
-// ../../node_modules/.pnpm/semver-range-intersect@0.3.1/node_modules/semver-range-intersect/dist/single-range.js
-var require_single_range = __commonJS({
-  "../../node_modules/.pnpm/semver-range-intersect@0.3.1/node_modules/semver-range-intersect/dist/single-range.js"(exports2) {
-    "use strict";
-    var __importDefault2 = exports2 && exports2.__importDefault || function(mod) {
-      return mod && mod.__esModule ? mod : { "default": mod };
-    };
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    var semver_12 = __importDefault2(require_semver3());
-    var utils_1 = require_utils7();
-    var SingleVer = class {
-      constructor(comp) {
-        this.comp = comp;
+    async function resolveDependency(wantedDependency, ctx, options) {
+      const currentPkg = options.currentPkg ?? {};
+      const currentLockfileContainsTheDep = currentPkg.depPath ? Boolean(ctx.currentLockfile.packages?.[currentPkg.depPath]) : void 0;
+      const depIsLinked = Boolean(currentLockfileContainsTheDep && currentPkg.depPath && currentPkg.dependencyLockfile && await (0, path_exists_1.default)(path_1.default.join(ctx.virtualStoreDir, dp.depPathToFilename(currentPkg.depPath), "node_modules", currentPkg.name, "package.json")));
+      if (!options.update && !options.proceed && currentPkg.resolution != null && depIsLinked) {
+        return null;
       }
-      toString() {
-        return this.comp.value;
+      let pkgResponse;
+      if (!options.parentPkg.installable) {
+        wantedDependency = {
+          ...wantedDependency,
+          optional: true
+        };
       }
-      intersect(singleRange) {
-        if (semver_12.default.intersects(String(this), String(singleRange))) {
-          return this;
-        } else {
+      try {
+        pkgResponse = await ctx.storeController.requestPackage(wantedDependency, {
+          alwaysTryWorkspacePackages: ctx.linkWorkspacePackagesDepth >= options.currentDepth,
+          currentPkg: currentPkg ? {
+            id: currentPkg.pkgId,
+            resolution: currentPkg.resolution
+          } : void 0,
+          expectedPkg: currentPkg,
+          defaultTag: ctx.defaultTag,
+          downloadPriority: -options.currentDepth,
+          lockfileDir: ctx.lockfileDir,
+          preferredVersions: options.preferredVersions,
+          preferWorkspacePackages: ctx.preferWorkspacePackages,
+          projectDir: options.currentDepth > 0 && !wantedDependency.pref.startsWith("file:") ? ctx.lockfileDir : options.parentPkg.rootDir,
+          registry: wantedDependency.alias && (0, pick_registry_for_package_1.default)(ctx.registries, wantedDependency.alias, wantedDependency.pref) || ctx.registries.default,
+          skipFetch: false,
+          update: options.update,
+          workspacePackages: options.workspacePackages
+        });
+      } catch (err) {
+        if (wantedDependency.optional) {
+          core_loggers_1.skippedOptionalDependencyLogger.debug({
+            details: err.toString(),
+            package: {
+              name: wantedDependency.alias,
+              pref: wantedDependency.pref,
+              version: wantedDependency.alias ? wantedDependency.pref : void 0
+            },
+            parents: nodeIdToParents(options.parentPkg.nodeId, ctx.resolvedPackagesByDepPath),
+            prefix: ctx.prefix,
+            reason: "resolution_failure"
+          });
           return null;
         }
+        err.pkgsStack = nodeIdToParents(options.parentPkg.nodeId, ctx.resolvedPackagesByDepPath);
+        throw err;
       }
-      merge(singleRange) {
-        if (semver_12.default.intersects(String(this), String(singleRange))) {
-          return singleRange;
+      dependencyResolvedLogger.debug({
+        resolution: pkgResponse.body.id,
+        wanted: {
+          dependentId: options.parentPkg.depPath,
+          name: wantedDependency.alias,
+          rawSpec: wantedDependency.pref
         }
+      });
+      pkgResponse.body.id = (0, encodePkgId_1.default)(pkgResponse.body.id);
+      if (!pkgResponse.body.updated && options.currentDepth === Math.max(0, options.updateDepth) && depIsLinked && !ctx.force && !options.proceed) {
         return null;
       }
-    };
-    exports2.SingleVer = SingleVer;
-    var SingleRange = class {
-      constructor(lowerBound, upperBound) {
-        this.lowerBound = lowerBound;
-        this.upperBound = upperBound;
-        if (!lowerBound.intersects(upperBound)) {
-          throw new Error(`Invalid range; version range does not intersect: ${this}`);
+      if (pkgResponse.body.isLocal) {
+        const manifest = pkgResponse.body.manifest ?? await pkgResponse.bundledManifest();
+        return {
+          alias: wantedDependency.alias || manifest.name,
+          depPath: pkgResponse.body.id,
+          dev: wantedDependency.dev,
+          isLinkedDependency: true,
+          name: manifest.name,
+          normalizedPref: pkgResponse.body.normalizedPref,
+          optional: wantedDependency.optional,
+          pkgId: pkgResponse.body.id,
+          resolution: pkgResponse.body.resolution,
+          version: manifest.version
+        };
+      }
+      let pkg;
+      let prepare;
+      let hasBin;
+      pkg = ctx.readPackageHook != null ? await ctx.readPackageHook(pkgResponse.body.manifest ?? await pkgResponse.bundledManifest()) : pkgResponse.body.manifest ?? await pkgResponse.bundledManifest();
+      if (!pkg.name) {
+        throw new error_1.default("MISSING_PACKAGE_NAME", `Can't install ${wantedDependency.pref}: Missing package name`);
+      }
+      const depPath = dp.relative(ctx.registries, pkg.name, pkgResponse.body.id);
+      if ((0, nodeIdUtils_1.nodeIdContainsSequence)(options.parentPkg.nodeId, options.parentPkg.depPath, depPath) || depPath === options.parentPkg.depPath) {
+        return null;
+      }
+      if (!options.update && currentPkg.dependencyLockfile != null && currentPkg.depPath && !pkgResponse.body.updated && currentPkg.dependencyLockfile.peerDependencies == null) {
+        prepare = currentPkg.dependencyLockfile.prepare === true;
+        hasBin = currentPkg.dependencyLockfile.hasBin === true;
+        pkg = {
+          ...(0, lockfile_utils_1.nameVerFromPkgSnapshot)(currentPkg.depPath, currentPkg.dependencyLockfile),
+          ...currentPkg.dependencyLockfile,
+          ...pkg
+        };
+      } else {
+        prepare = Boolean(pkgResponse.body.resolvedVia === "git-repository" && typeof pkg.scripts?.prepare === "string");
+        if (currentPkg.dependencyLockfile?.deprecated && !pkgResponse.body.updated && !pkg.deprecated) {
+          pkg.deprecated = currentPkg.dependencyLockfile.deprecated;
         }
+        hasBin = Boolean((pkg.bin && !(0, isEmpty_1.default)(pkg.bin)) ?? pkg.directories?.bin);
       }
-      toString() {
-        return [this.lowerBound.value, this.upperBound.value].filter((v) => v !== "").join(" ");
+      if (options.currentDepth === 0 && pkgResponse.body.latest && pkgResponse.body.latest !== pkg.version) {
+        ctx.outdatedDependencies[pkgResponse.body.id] = pkgResponse.body.latest;
       }
-      intersect(singleRange) {
-        if (semver_12.default.intersects(String(this), String(singleRange))) {
-          if (singleRange instanceof SingleVer) {
-            return singleRange;
-          } else {
-            const lowerBoundComparatorList = [
-              this.lowerBound,
-              singleRange.lowerBound
-            ];
-            const upperBoundComparatorList = [
-              this.upperBound,
-              singleRange.upperBound
-            ];
-            const lowerBound = utils_1.getLowerBoundComparator([
-              ...lowerBoundComparatorList,
-              ...upperBoundComparatorList.filter((comparator) => comparator.semver instanceof semver_12.default.SemVer)
-            ]);
-            const upperBound = utils_1.getUpperBoundComparator([
-              ...upperBoundComparatorList,
-              ...lowerBoundComparatorList.filter((comparator) => comparator.semver instanceof semver_12.default.SemVer)
-            ]);
-            if (utils_1.isSameVersionEqualsLikeComparator(lowerBound, upperBound)) {
-              return new SingleVer(utils_1.stripComparatorOperator(lowerBound));
-            }
-            return new SingleRange(lowerBound, upperBound);
-          }
+      if (pkg.deprecated) {
+        core_loggers_1.deprecationLogger.debug({
+          deprecated: pkg.deprecated,
+          depth: options.currentDepth,
+          pkgId: pkgResponse.body.id,
+          pkgName: pkg.name,
+          pkgVersion: pkg.version,
+          prefix: ctx.prefix
+        });
+      }
+      const nodeId = pkgIsLeaf(pkg) ? pkgResponse.body.id : (0, nodeIdUtils_1.createNodeId)(options.parentPkg.nodeId, depPath);
+      const parentIsInstallable = options.parentPkg.installable === void 0 || options.parentPkg.installable;
+      const installable = parentIsInstallable && pkgResponse.body.isInstallable !== false;
+      const isNew = !ctx.resolvedPackagesByDepPath[depPath];
+      if (isNew) {
+        if (pkgResponse.body.isInstallable === false || !parentIsInstallable) {
+          ctx.skipped.add(pkgResponse.body.id);
+        }
+        core_loggers_1.progressLogger.debug({
+          packageId: pkgResponse.body.id,
+          requester: ctx.lockfileDir,
+          status: "resolved"
+        });
+        ctx.resolvedPackagesByDepPath[depPath] = getResolvedPackage({
+          allowBuild: ctx.allowBuild,
+          dependencyLockfile: currentPkg.dependencyLockfile,
+          depPath,
+          force: ctx.force,
+          hasBin,
+          pkg,
+          pkgResponse,
+          prepare,
+          wantedDependency
+        });
+      } else {
+        ctx.resolvedPackagesByDepPath[depPath].prod = ctx.resolvedPackagesByDepPath[depPath].prod || !wantedDependency.dev && !wantedDependency.optional;
+        ctx.resolvedPackagesByDepPath[depPath].dev = ctx.resolvedPackagesByDepPath[depPath].dev || wantedDependency.dev;
+        ctx.resolvedPackagesByDepPath[depPath].optional = ctx.resolvedPackagesByDepPath[depPath].optional && wantedDependency.optional;
+        if (ctx.resolvedPackagesByDepPath[depPath].fetchingFiles == null && pkgResponse.files != null) {
+          ctx.resolvedPackagesByDepPath[depPath].fetchingFiles = pkgResponse.files;
+          ctx.resolvedPackagesByDepPath[depPath].filesIndexFile = pkgResponse.filesIndexFile;
+          ctx.resolvedPackagesByDepPath[depPath].finishing = pkgResponse.finishing;
+          ctx.resolvedPackagesByDepPath[depPath].fetchingBundledManifest = pkgResponse.bundledManifest;
+        }
+        if (ctx.dependenciesTree[nodeId]) {
+          ctx.dependenciesTree[nodeId].depth = Math.min(ctx.dependenciesTree[nodeId].depth, options.currentDepth);
         } else {
-          return null;
+          ctx.pendingNodes.push({
+            alias: wantedDependency.alias || pkg.name,
+            depth: options.currentDepth,
+            installable,
+            nodeId,
+            resolvedPackage: ctx.resolvedPackagesByDepPath[depPath]
+          });
         }
       }
-      merge(singleRange) {
-        if (semver_12.default.intersects(String(this), String(singleRange))) {
-          if (singleRange instanceof SingleVer) {
-            return this;
-          } else {
-            const lowerBound = ((a, b) => {
-              const semverA = a.semver;
-              const semverB = b.semver;
-              if (!(semverA instanceof semver_12.default.SemVer)) {
-                if (utils_1.isPrerelease(semverB)) {
-                  return null;
-                }
-                return a;
-              } else if (!(semverB instanceof semver_12.default.SemVer)) {
-                if (utils_1.isPrerelease(semverA)) {
-                  return null;
-                }
-                return b;
-              }
-              const cmpMain = semverA.compareMain(semverB);
-              if (cmpMain < 0 && utils_1.isPrerelease(semverB) || cmpMain > 0 && utils_1.isPrerelease(semverA)) {
-                return null;
-              }
-              const semverCmp = semver_12.default.compare(semverA, semverB);
-              if (a.operator === b.operator || semverCmp !== 0) {
-                if (semverCmp < 0) {
-                  return a;
-                } else {
-                  return b;
-                }
-              } else {
-                if (a.operator === ">=") {
-                  return a;
-                } else {
-                  return b;
-                }
-              }
-            })(this.lowerBound, singleRange.lowerBound);
-            const upperBound = ((a, b) => {
-              const semverA = a.semver;
-              const semverB = b.semver;
-              if (!(semverA instanceof semver_12.default.SemVer)) {
-                if (utils_1.isPrerelease(semverB)) {
-                  return null;
-                }
-                return a;
-              } else if (!(semverB instanceof semver_12.default.SemVer)) {
-                if (utils_1.isPrerelease(semverA)) {
-                  return null;
-                }
-                return b;
-              }
-              const cmpMain = semverA.compareMain(semverB);
-              if (cmpMain > 0 && utils_1.isPrerelease(semverB) || cmpMain < 0 && utils_1.isPrerelease(semverA)) {
-                return null;
-              }
-              const semverCmp = semver_12.default.compare(semverA, semverB);
-              if (a.operator === b.operator || semverCmp !== 0) {
-                if (semverCmp > 0) {
-                  return a;
-                } else {
-                  return b;
-                }
-              } else {
-                if (a.operator === "<=") {
-                  return a;
-                } else {
-                  return b;
-                }
-              }
-            })(this.upperBound, singleRange.upperBound);
-            if (lowerBound && upperBound) {
-              return new SingleRange(lowerBound, upperBound);
-            }
-          }
+      const rootDir = pkgResponse.body.resolution.type === "directory" ? path_1.default.resolve(ctx.lockfileDir, pkgResponse.body.resolution["directory"]) : ctx.prefix;
+      return {
+        alias: wantedDependency.alias || pkg.name,
+        depIsLinked,
+        depPath,
+        isNew,
+        nodeId,
+        normalizedPref: options.currentDepth === 0 ? pkgResponse.body.normalizedPref : void 0,
+        pkgId: pkgResponse.body.id,
+        rootDir,
+        missingPeers: getMissingPeers(pkg, options.parentPkgAliases),
+        installable,
+        isLinkedDependency: void 0,
+        pkg,
+        updated: pkgResponse.body.updated
+      };
+    }
+    function getMissingPeers(pkg, parentPkgAliases) {
+      const missingPeers = {};
+      for (const [peerName, peerVersion] of Object.entries(pkg.peerDependencies ?? {})) {
+        if (!parentPkgAliases[peerName] && !pkg.peerDependenciesMeta?.[peerName]?.optional) {
+          missingPeers[peerName] = peerVersion;
+        }
+      }
+      return missingPeers;
+    }
+    function pkgIsLeaf(pkg) {
+      return (0, isEmpty_1.default)(pkg.dependencies ?? {}) && (0, isEmpty_1.default)(pkg.optionalDependencies ?? {}) && (0, isEmpty_1.default)(pkg.peerDependencies ?? {});
+    }
+    function getResolvedPackage(options) {
+      const peerDependencies = peerDependenciesWithoutOwn(options.pkg);
+      const requiresBuild = options.allowBuild == null || options.allowBuild(options.pkg.name) ? options.dependencyLockfile != null ? Boolean(options.dependencyLockfile.requiresBuild) : void 0 : false;
+      return {
+        additionalInfo: {
+          bundledDependencies: options.pkg.bundledDependencies,
+          bundleDependencies: options.pkg.bundleDependencies,
+          cpu: options.pkg.cpu,
+          deprecated: options.pkg.deprecated,
+          engines: options.pkg.engines,
+          os: options.pkg.os,
+          libc: options.pkg.libc
+        },
+        depPath: options.depPath,
+        dev: options.wantedDependency.dev,
+        fetchingBundledManifest: options.pkgResponse.bundledManifest,
+        fetchingFiles: options.pkgResponse.files,
+        filesIndexFile: options.pkgResponse.filesIndexFile,
+        finishing: options.pkgResponse.finishing,
+        hasBin: options.hasBin,
+        hasBundledDependencies: !((options.pkg.bundledDependencies ?? options.pkg.bundleDependencies) == null),
+        id: options.pkgResponse.body.id,
+        name: options.pkg.name,
+        optional: options.wantedDependency.optional,
+        optionalDependencies: new Set(Object.keys(options.pkg.optionalDependencies ?? {})),
+        peerDependencies: peerDependencies ?? {},
+        peerDependenciesMeta: options.pkg.peerDependenciesMeta,
+        prepare: options.prepare,
+        prod: !options.wantedDependency.dev && !options.wantedDependency.optional,
+        requiresBuild,
+        resolution: options.pkgResponse.body.resolution,
+        version: options.pkg.version
+      };
+    }
+    function peerDependenciesWithoutOwn(pkg) {
+      if (pkg.peerDependencies == null && pkg.peerDependenciesMeta == null)
+        return pkg.peerDependencies;
+      const ownDeps = /* @__PURE__ */ new Set([
+        ...Object.keys(pkg.dependencies ?? {}),
+        ...Object.keys(pkg.optionalDependencies ?? {})
+      ]);
+      const result2 = {};
+      if (pkg.peerDependencies != null) {
+        for (const [peerName, peerRange] of Object.entries(pkg.peerDependencies)) {
+          if (ownDeps.has(peerName))
+            continue;
+          result2[peerName] = peerRange;
         }
-        return null;
       }
-    };
-    exports2.SingleRange = SingleRange;
-    function createSingleRange(comparatorList) {
-      const equalsComparatorList = comparatorList.filter(utils_1.isEqualsComparator).filter(utils_1.filterUniqueComparator);
-      switch (equalsComparatorList.length) {
-        case 0: {
-          const lowerBound = utils_1.getLowerBoundComparator(comparatorList, {
-            singleRange: true
-          });
-          const upperBound = utils_1.getUpperBoundComparator(comparatorList, {
-            singleRange: true
-          });
-          if (utils_1.isSameVersionEqualsLikeComparator(lowerBound, upperBound)) {
-            return new SingleVer(utils_1.stripComparatorOperator(lowerBound));
-          }
-          try {
-            return new SingleRange(lowerBound, upperBound);
-          } catch (err) {
-            return null;
-          }
+      if (pkg.peerDependenciesMeta != null) {
+        for (const [peerName, peerMeta] of Object.entries(pkg.peerDependenciesMeta)) {
+          if (ownDeps.has(peerName) || result2[peerName] || peerMeta.optional !== true)
+            continue;
+          result2[peerName] = "*";
         }
-        case 1:
-          return new SingleVer(equalsComparatorList[0]);
-        default:
-          return null;
       }
+      if ((0, isEmpty_1.default)(result2))
+        return void 0;
+      return result2;
     }
-    exports2.createSingleRange = createSingleRange;
-    function isSingleRange(value) {
-      return value instanceof SingleVer || value instanceof SingleRange;
-    }
-    exports2.isSingleRange = isSingleRange;
   }
 });
 
-// ../../node_modules/.pnpm/semver-range-intersect@0.3.1/node_modules/semver-range-intersect/dist/multi-range.js
-var require_multi_range = __commonJS({
-  "../../node_modules/.pnpm/semver-range-intersect@0.3.1/node_modules/semver-range-intersect/dist/multi-range.js"(exports2) {
+// ../resolve-dependencies/lib/resolveDependencyTree.js
+var require_resolveDependencyTree = __commonJS({
+  "../resolve-dependencies/lib/resolveDependencyTree.js"(exports2) {
     "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      o[k2] = m[k];
+    });
+    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
+      for (var p in m)
+        if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p))
+          __createBinding(exports3, m, p);
+    };
+    var __importDefault2 = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
     Object.defineProperty(exports2, "__esModule", { value: true });
-    var single_range_1 = require_single_range();
-    var utils_1 = require_utils7();
-    function normalizeSingleRangeList(singleRangeList) {
-      return singleRangeList.reduce((singleRangeList2, singleRange) => {
-        if (!singleRange) {
-          return [...singleRangeList2, singleRange];
-        }
-        let insertFirst = false;
-        const removeIndexList = [];
-        const appendSingleRange = singleRangeList2.reduce((appendSingleRange2, insertedSingleRange, index) => {
-          if (insertedSingleRange && appendSingleRange2) {
-            const mergedSingleRange = insertedSingleRange.merge(appendSingleRange2);
-            if (mergedSingleRange) {
-              if (String(mergedSingleRange) === String(insertedSingleRange)) {
-                return;
-              } else {
-                removeIndexList.push(index);
-                if (insertedSingleRange instanceof single_range_1.SingleRange && appendSingleRange2 instanceof single_range_1.SingleRange) {
-                  insertFirst = true;
-                }
-                return mergedSingleRange;
-              }
+    var partition_1 = __importDefault2(require_partition4());
+    var nodeIdUtils_1 = require_nodeIdUtils();
+    var resolveDependencies_1 = __importDefault2(require_resolveDependencies());
+    __exportStar(require_nodeIdUtils(), exports2);
+    async function default_1(importers, opts) {
+      const directDepsByImporterId = {};
+      const wantedToBeSkippedPackageIds = /* @__PURE__ */ new Set();
+      const ctx = {
+        autoInstallPeers: opts.autoInstallPeers === true,
+        allowBuild: opts.allowBuild,
+        childrenByParentDepPath: {},
+        currentLockfile: opts.currentLockfile,
+        defaultTag: opts.tag,
+        dependenciesTree: {},
+        dryRun: opts.dryRun,
+        engineStrict: opts.engineStrict,
+        force: opts.force,
+        forceFullResolution: opts.forceFullResolution,
+        linkWorkspacePackagesDepth: opts.linkWorkspacePackagesDepth ?? -1,
+        lockfileDir: opts.lockfileDir,
+        nodeVersion: opts.nodeVersion,
+        outdatedDependencies: {},
+        pendingNodes: [],
+        pnpmVersion: opts.pnpmVersion,
+        preferWorkspacePackages: opts.preferWorkspacePackages,
+        readPackageHook: opts.hooks.readPackage,
+        registries: opts.registries,
+        resolvedPackagesByDepPath: {},
+        skipped: wantedToBeSkippedPackageIds,
+        storeController: opts.storeController,
+        updateMatching: opts.updateMatching,
+        virtualStoreDir: opts.virtualStoreDir,
+        wantedLockfile: opts.wantedLockfile
+      };
+      await Promise.all(importers.map(async (importer) => {
+        const projectSnapshot = opts.wantedLockfile.importers[importer.id];
+        const linkedDependencies = [];
+        const resolveCtx = {
+          ...ctx,
+          updatedSet: /* @__PURE__ */ new Set(),
+          linkedDependencies,
+          modulesDir: importer.modulesDir,
+          prefix: importer.rootDir
+        };
+        const proceed = importer.id === "." || importer.hasRemovedDependencies === true || importer.wantedDependencies.some((wantedDep) => wantedDep["isNew"]);
+        const resolveOpts = {
+          currentDepth: 0,
+          parentPkg: {
+            installable: true,
+            nodeId: `>${importer.id}>`,
+            optional: false,
+            depPath: importer.id,
+            rootDir: importer.rootDir
+          },
+          parentPkgAliases: {},
+          proceed,
+          resolvedDependencies: {
+            ...projectSnapshot.dependencies,
+            ...projectSnapshot.devDependencies,
+            ...projectSnapshot.optionalDependencies
+          },
+          updateDepth: -1,
+          workspacePackages: opts.workspacePackages
+        };
+        directDepsByImporterId[importer.id] = await (0, resolveDependencies_1.default)(resolveCtx, importer.preferredVersions ?? {}, importer.wantedDependencies, resolveOpts);
+      }));
+      ctx.pendingNodes.forEach((pendingNode) => {
+        ctx.dependenciesTree[pendingNode.nodeId] = {
+          children: () => buildTree(ctx, pendingNode.nodeId, pendingNode.resolvedPackage.id, ctx.childrenByParentDepPath[pendingNode.resolvedPackage.depPath], pendingNode.depth + 1, pendingNode.installable),
+          depth: pendingNode.depth,
+          installable: pendingNode.installable,
+          resolvedPackage: pendingNode.resolvedPackage
+        };
+      });
+      const resolvedImporters = {};
+      for (const { id } of importers) {
+        const directDeps = directDepsByImporterId[id];
+        const [linkedDependencies, directNonLinkedDeps] = (0, partition_1.default)((dep) => dep.isLinkedDependency === true, directDeps);
+        resolvedImporters[id] = {
+          directDependencies: directDeps.map((dep) => {
+            if (dep.isLinkedDependency === true) {
+              return dep;
             }
-          }
-          return appendSingleRange2;
-        }, singleRange);
-        const removedSingleRangeList = singleRangeList2.filter((_, index) => !removeIndexList.includes(index));
-        if (appendSingleRange) {
-          if (insertFirst) {
-            return [appendSingleRange, ...removedSingleRangeList];
-          } else {
-            return [...removedSingleRangeList, appendSingleRange];
-          }
-        }
-        return removedSingleRangeList;
-      }, []);
-    }
-    exports2.normalizeSingleRangeList = normalizeSingleRangeList;
-    var MultiRange = class {
-      get valid() {
-        return this.set.length >= 1;
+            const resolvedPackage = ctx.dependenciesTree[dep.nodeId].resolvedPackage;
+            return {
+              alias: dep.alias,
+              dev: resolvedPackage.dev,
+              name: resolvedPackage.name,
+              normalizedPref: dep.normalizedPref,
+              optional: resolvedPackage.optional,
+              pkgId: resolvedPackage.id,
+              resolution: resolvedPackage.resolution,
+              version: resolvedPackage.version
+            };
+          }),
+          directNodeIdsByAlias: directNonLinkedDeps.reduce((acc, dependency) => {
+            acc[dependency.alias] = dependency.nodeId;
+            return acc;
+          }, {}),
+          linkedDependencies
+        };
       }
-      constructor(rangeList) {
-        if (rangeList) {
-          const singleRangeList = normalizeSingleRangeList(rangeList.map((singleRangeOrComparatorList) => {
-            if (single_range_1.isSingleRange(singleRangeOrComparatorList) || !singleRangeOrComparatorList) {
-              return singleRangeOrComparatorList;
-            } else {
-              return single_range_1.createSingleRange(singleRangeOrComparatorList);
-            }
-          }));
-          this.set = singleRangeList.filter(utils_1.isNotNull);
-        } else {
-          this.set = [];
+      return {
+        dependenciesTree: ctx.dependenciesTree,
+        outdatedDependencies: ctx.outdatedDependencies,
+        resolvedImporters,
+        resolvedPackagesByDepPath: ctx.resolvedPackagesByDepPath,
+        wantedToBeSkippedPackageIds
+      };
+    }
+    exports2.default = default_1;
+    function buildTree(ctx, parentNodeId, parentId, children, depth, installable) {
+      const childrenNodeIds = {};
+      for (const child of children) {
+        if (child.depPath.startsWith("link:")) {
+          childrenNodeIds[child.alias] = child.depPath;
+          continue;
         }
-      }
-      toString() {
-        if (!this.valid) {
-          throw new Error("Invalid range");
+        if ((0, nodeIdUtils_1.nodeIdContainsSequence)(parentNodeId, parentId, child.depPath) || parentId === child.depPath) {
+          continue;
         }
-        return utils_1.uniqueArray(this.set.map(String)).join(" || ");
+        const childNodeId = (0, nodeIdUtils_1.createNodeId)(parentNodeId, child.depPath);
+        childrenNodeIds[child.alias] = childNodeId;
+        installable = installable && !ctx.skipped.has(child.depPath);
+        ctx.dependenciesTree[childNodeId] = {
+          children: () => buildTree(ctx, childNodeId, child.depPath, ctx.childrenByParentDepPath[child.depPath], depth + 1, installable),
+          depth,
+          installable,
+          resolvedPackage: ctx.resolvedPackagesByDepPath[child.depPath]
+        };
       }
-      intersect(multiRange) {
-        if (this.valid && multiRange.valid) {
-          const singleRangeList = this.set.map((singleRangeA) => multiRange.set.map((singleRangeB) => singleRangeA.intersect(singleRangeB))).reduce((a, b) => [...a, ...b]).filter(utils_1.isNotNull);
-          return new MultiRange(singleRangeList);
-        } else if (this.valid) {
-          return this;
-        } else if (multiRange.valid) {
-          return multiRange;
-        } else {
-          return new MultiRange(null);
-        }
+      return childrenNodeIds;
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/trim-repeated@1.0.0/node_modules/trim-repeated/index.js
+var require_trim_repeated = __commonJS({
+  "../../node_modules/.pnpm/trim-repeated@1.0.0/node_modules/trim-repeated/index.js"(exports2, module2) {
+    "use strict";
+    var escapeStringRegexp = require_escape_string_regexp();
+    module2.exports = function(str, target) {
+      if (typeof str !== "string" || typeof target !== "string") {
+        throw new TypeError("Expected a string");
       }
+      return str.replace(new RegExp("(?:" + escapeStringRegexp(target) + "){2,}", "g"), target);
     };
-    exports2.MultiRange = MultiRange;
   }
 });
 
-// ../../node_modules/.pnpm/semver-range-intersect@0.3.1/node_modules/semver-range-intersect/dist/index.js
-var require_dist12 = __commonJS({
-  "../../node_modules/.pnpm/semver-range-intersect@0.3.1/node_modules/semver-range-intersect/dist/index.js"(exports2) {
+// ../../node_modules/.pnpm/filename-reserved-regex@2.0.0/node_modules/filename-reserved-regex/index.js
+var require_filename_reserved_regex = __commonJS({
+  "../../node_modules/.pnpm/filename-reserved-regex@2.0.0/node_modules/filename-reserved-regex/index.js"(exports2, module2) {
     "use strict";
-    var __importDefault2 = exports2 && exports2.__importDefault || function(mod) {
-      return mod && mod.__esModule ? mod : { "default": mod };
+    module2.exports = () => /[<>:"\/\\|?*\x00-\x1F]/g;
+    module2.exports.windowsNames = () => /^(con|prn|aux|nul|com[0-9]|lpt[0-9])$/i;
+  }
+});
+
+// ../../node_modules/.pnpm/strip-outer@1.0.1/node_modules/strip-outer/index.js
+var require_strip_outer = __commonJS({
+  "../../node_modules/.pnpm/strip-outer@1.0.1/node_modules/strip-outer/index.js"(exports2, module2) {
+    "use strict";
+    var escapeStringRegexp = require_escape_string_regexp();
+    module2.exports = function(str, sub) {
+      if (typeof str !== "string" || typeof sub !== "string") {
+        throw new TypeError();
+      }
+      sub = escapeStringRegexp(sub);
+      return str.replace(new RegExp("^" + sub + "|" + sub + "$", "g"), "");
     };
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    var semver_12 = __importDefault2(require_semver3());
-    var multi_range_1 = require_multi_range();
-    var utils_1 = require_utils7();
-    function intersect(...ranges) {
-      const semverRangeList = (() => {
-        try {
-          return ranges.map((rangeStr) => new semver_12.default.Range(rangeStr));
-        } catch (err) {
-          return null;
-        }
-      })();
-      if (!semverRangeList || !utils_1.isIntersectRanges(semverRangeList)) {
-        return null;
+  }
+});
+
+// ../../node_modules/.pnpm/filenamify@4.3.0/node_modules/filenamify/filenamify.js
+var require_filenamify = __commonJS({
+  "../../node_modules/.pnpm/filenamify@4.3.0/node_modules/filenamify/filenamify.js"(exports2, module2) {
+    "use strict";
+    var trimRepeated = require_trim_repeated();
+    var filenameReservedRegex = require_filename_reserved_regex();
+    var stripOuter = require_strip_outer();
+    var MAX_FILENAME_LENGTH = 100;
+    var reControlChars = /[\u0000-\u001f\u0080-\u009f]/g;
+    var reRelativePath = /^\.+/;
+    var reTrailingPeriods = /\.+$/;
+    var filenamify = (string, options = {}) => {
+      if (typeof string !== "string") {
+        throw new TypeError("Expected a string");
       }
-      const intersectRange = semverRangeList.map((range) => new multi_range_1.MultiRange(range.set)).reduce((multiRangeA, multiRangeB) => multiRangeA.intersect(multiRangeB), new multi_range_1.MultiRange(null));
-      return intersectRange.valid ? String(intersectRange) || "*" : null;
-    }
-    exports2.intersect = intersect;
+      const replacement = options.replacement === void 0 ? "!" : options.replacement;
+      if (filenameReservedRegex().test(replacement) && reControlChars.test(replacement)) {
+        throw new Error("Replacement string cannot contain reserved filename characters");
+      }
+      string = string.replace(filenameReservedRegex(), replacement);
+      string = string.replace(reControlChars, replacement);
+      string = string.replace(reRelativePath, replacement);
+      string = string.replace(reTrailingPeriods, "");
+      if (replacement.length > 0) {
+        string = trimRepeated(string, replacement);
+        string = string.length > 1 ? stripOuter(string, replacement) : string;
+      }
+      string = filenameReservedRegex.windowsNames().test(string) ? string + replacement : string;
+      string = string.slice(0, typeof options.maxLength === "number" ? options.maxLength : MAX_FILENAME_LENGTH);
+      return string;
+    };
+    module2.exports = filenamify;
   }
 });
 
-// ../resolve-dependencies/lib/mergePeers.js
-var require_mergePeers = __commonJS({
-  "../resolve-dependencies/lib/mergePeers.js"(exports2) {
+// ../../node_modules/.pnpm/filenamify@4.3.0/node_modules/filenamify/filenamify-path.js
+var require_filenamify_path = __commonJS({
+  "../../node_modules/.pnpm/filenamify@4.3.0/node_modules/filenamify/filenamify-path.js"(exports2, module2) {
+    "use strict";
+    var path2 = require("path");
+    var filenamify = require_filenamify();
+    var filenamifyPath = (filePath, options) => {
+      filePath = path2.resolve(filePath);
+      return path2.join(path2.dirname(filePath), filenamify(path2.basename(filePath), options));
+    };
+    module2.exports = filenamifyPath;
+  }
+});
+
+// ../../node_modules/.pnpm/filenamify@4.3.0/node_modules/filenamify/index.js
+var require_filenamify2 = __commonJS({
+  "../../node_modules/.pnpm/filenamify@4.3.0/node_modules/filenamify/index.js"(exports2, module2) {
+    "use strict";
+    var filenamify = require_filenamify();
+    var filenamifyPath = require_filenamify_path();
+    var filenamifyCombined = filenamify;
+    filenamifyCombined.path = filenamifyPath;
+    module2.exports = filenamify;
+  }
+});
+
+// ../../node_modules/.pnpm/@yarnpkg+core@3.2.0/node_modules/@yarnpkg/core/lib/semverUtils.js
+var require_semverUtils = __commonJS({
+  "../../node_modules/.pnpm/@yarnpkg+core@3.2.0/node_modules/@yarnpkg/core/lib/semverUtils.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.mergePeers = void 0;
-    var semver_range_intersect_1 = require_dist12();
-    function mergePeers(missingPeers) {
-      const conflicts = [];
-      const intersections = {};
-      for (const [peerName, ranges] of Object.entries(missingPeers)) {
-        if (ranges.every(({ optional }) => optional))
-          continue;
-        if (ranges.length === 1) {
-          intersections[peerName] = ranges[0].wantedRange;
-          continue;
-        }
-        const intersection = safeIntersect(ranges.map(({ wantedRange }) => wantedRange));
-        if (intersection === null) {
-          conflicts.push(peerName);
-        } else {
-          intersections[peerName] = intersection;
+    exports2.clean = exports2.validRange = exports2.satisfiesWithPrereleases = exports2.SemVer = void 0;
+    var tslib_12 = require_tslib();
+    var semver_12 = tslib_12.__importDefault(require_semver2());
+    var semver_2 = require_semver2();
+    Object.defineProperty(exports2, "SemVer", { enumerable: true, get: function() {
+      return semver_2.SemVer;
+    } });
+    var satisfiesWithPrereleasesCache = /* @__PURE__ */ new Map();
+    function satisfiesWithPrereleases(version, range, loose = false) {
+      if (!version)
+        return false;
+      const key = `${range}${loose}`;
+      let semverRange = satisfiesWithPrereleasesCache.get(key);
+      if (typeof semverRange === `undefined`) {
+        try {
+          semverRange = new semver_12.default.Range(range, { includePrerelease: true, loose });
+        } catch {
+          return false;
+        } finally {
+          satisfiesWithPrereleasesCache.set(key, semverRange || null);
         }
+      } else if (semverRange === null) {
+        return false;
       }
-      return { conflicts, intersections };
+      let semverVersion;
+      try {
+        semverVersion = new semver_12.default.SemVer(version, semverRange);
+      } catch (err) {
+        return false;
+      }
+      if (semverRange.test(semverVersion))
+        return true;
+      if (semverVersion.prerelease)
+        semverVersion.prerelease = [];
+      return semverRange.set.some((comparatorSet) => {
+        for (const comparator of comparatorSet)
+          if (comparator.semver.prerelease)
+            comparator.semver.prerelease = [];
+        return comparatorSet.every((comparator) => {
+          return comparator.test(semverVersion);
+        });
+      });
     }
-    exports2.mergePeers = mergePeers;
-    function safeIntersect(ranges) {
+    exports2.satisfiesWithPrereleases = satisfiesWithPrereleases;
+    var rangesCache = /* @__PURE__ */ new Map();
+    function validRange(potentialRange) {
+      if (potentialRange.indexOf(`:`) !== -1)
+        return null;
+      let range = rangesCache.get(potentialRange);
+      if (typeof range !== `undefined`)
+        return range;
       try {
-        return (0, semver_range_intersect_1.intersect)(...ranges);
+        range = new semver_12.default.Range(potentialRange);
       } catch {
-        return null;
+        range = null;
       }
+      rangesCache.set(potentialRange, range);
+      return range;
+    }
+    exports2.validRange = validRange;
+    var CLEAN_SEMVER_REGEXP = /^(?:[\sv=]*?)((0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?)(?:\s*)$/;
+    function clean(potentialVersion) {
+      const version = CLEAN_SEMVER_REGEXP.exec(potentialVersion);
+      return version ? version[1] : null;
     }
+    exports2.clean = clean;
+  }
+});
+
+// ../../node_modules/.pnpm/ramda@0.27.2/node_modules/ramda/src/scan.js
+var require_scan4 = __commonJS({
+  "../../node_modules/.pnpm/ramda@0.27.2/node_modules/ramda/src/scan.js"(exports2, module2) {
+    var _curry3 = require_curry3();
+    var scan = /* @__PURE__ */ _curry3(function scan2(fn2, acc, list) {
+      var idx = 0;
+      var len = list.length;
+      var result2 = [acc];
+      while (idx < len) {
+        acc = fn2(acc, list[idx]);
+        result2[idx + 1] = acc;
+        idx += 1;
+      }
+      return result2;
+    });
+    module2.exports = scan;
   }
 });
 
@@ -112629,7 +112687,7 @@ var require_updateProjectManifest = __commonJS({
       if (!importer.manifest) {
         throw new Error("Cannot save because no package.json found");
       }
-      const specsToUpsert = opts.directDependencies.filter((rdd, index) => importer.wantedDependencies[index].updateSpec).map((rdd, index) => {
+      const specsToUpsert = opts.directDependencies.filter((rdd, index) => importer.wantedDependencies[index]?.updateSpec).map((rdd, index) => {
         const wantedDep = importer.wantedDependencies[index];
         return resolvedDirectDepToSpecObject({ ...rdd, isNew: wantedDep.isNew, specRaw: wantedDep.raw }, importer, {
           nodeExecPath: wantedDep.nodeExecPath,
@@ -112776,7 +112834,7 @@ var require_lib97 = __commonJS({
           const projectSnapshot = opts.wantedLockfile.importers[project.id];
           opts.wantedLockfile.importers[project.id] = addDirectDependenciesToLockfile(updatedManifest, projectSnapshot, resolvedImporter.linkedDependencies, resolvedImporter.directDependencies, opts.registries);
         }
-        const topParents = project.manifest ? await getTopParents((0, difference_1.default)(Object.keys((0, manifest_utils_1.getAllDependenciesFromManifest)(project.manifest)), resolvedImporter.directDependencies.filter((dep, index2) => project.wantedDependencies[index2].isNew === true).map(({ alias }) => alias) || []), project.modulesDir) : [];
+        const topParents = project.manifest ? await getTopParents((0, difference_1.default)(Object.keys((0, manifest_utils_1.getAllDependenciesFromManifest)(project.manifest)), resolvedImporter.directDependencies.filter((dep, index2) => project.wantedDependencies[index2]?.isNew === true).map(({ alias }) => alias) || []), project.modulesDir) : [];
         resolvedImporter.linkedDependencies.forEach((linkedDependency) => {
           topParents.push({
             name: linkedDependency.alias,
@@ -114313,6 +114371,7 @@ var require_extendInstallOptions = __commonJS({
         version: pnpmPkgJson_1.default.version
       };
       return {
+        autoInstallPeers: false,
         childConcurrency: 5,
         depth: 0,
         enablePnp: false,
@@ -115305,6 +115364,7 @@ var require_install = __commonJS({
       }
       let { dependenciesGraph, dependenciesByProjectId, finishLockfileUpdates, linkedDependenciesByProjectId, newLockfile, outdatedDependencies, peerDependencyIssuesByProjects, wantedToBeSkippedPackageIds, waitTillAllFetchingsFinish } = await (0, resolve_dependencies_1.default)(projects, {
         allowBuild: createAllowBuildFunction(opts),
+        autoInstallPeers: opts.autoInstallPeers,
         currentLockfile: ctx.currentLockfile,
         defaultUpdateDepth: opts.update || opts.updateMatching != null ? opts.depth : -1,
         dryRun: opts.lockfileOnly,
@@ -116409,7 +116469,6 @@ var require_installDeps = __commonJS({
     var logger_1 = __importDefault2(require_lib());
     var sort_packages_1 = require_lib82();
     var is_subdir_1 = __importDefault2(require_is_subdir());
-    var isEmpty_1 = __importDefault2(require_isEmpty2());
     var getOptionsFromRootManifest_1 = __importDefault2(require_getOptionsFromRootManifest());
     var getPinnedVersion_1 = __importDefault2(require_getPinnedVersion());
     var getSaveType_1 = __importDefault2(require_getSaveType());
@@ -116533,28 +116592,8 @@ var require_installDeps = __commonJS({
           rootDir: opts.dir,
           targetDependenciesField: (0, getSaveType_1.default)(opts)
         };
-        let [updatedImporter] = await (0, core_1.mutateModules)([mutatedProject], {
-          ...installOpts,
-          strictPeerDependencies: opts.autoInstallPeers ? false : installOpts.strictPeerDependencies
-        });
+        const [updatedImporter] = await (0, core_1.mutateModules)([mutatedProject], installOpts);
         if (opts.save !== false) {
-          if (opts.autoInstallPeers && !(0, isEmpty_1.default)(updatedImporter.peerDependencyIssues?.intersections ?? {})) {
-            logger_1.default.info({
-              message: "Installing missing peer dependencies",
-              prefix: opts.dir
-            });
-            const dependencySelectors = Object.entries(updatedImporter.peerDependencyIssues.intersections).map(([name, version]) => `${name}@${version}`);
-            const result2 = await (0, core_1.mutateModules)([
-              {
-                ...mutatedProject,
-                dependencySelectors,
-                manifest: updatedImporter.manifest,
-                peer: false,
-                targetDependenciesField: "devDependencies"
-              }
-            ], installOpts);
-            updatedImporter = result2[0];
-          }
           await writeProjectManifest(updatedImporter.manifest);
         }
         return;