@pnpm/resolving.npm-resolver 1004.4.1

package/lib/index.js

@@ -0,0 +1,547 @@
+import path from 'node:path';
+import { pickRegistryForPackage } from '@pnpm/config.pick-registry-for-package';
+import { PnpmError } from '@pnpm/error';
+import { storeIndexKey } from '@pnpm/store.index';
+import { readPkgFromCafs, } from '@pnpm/worker';
+import { resolveWorkspaceRange } from '@pnpm/workspace.range-resolver';
+import { LRUCache } from 'lru-cache';
+import normalize from 'normalize-path';
+import pMemoize from 'p-memoize';
+import { clone } from 'ramda';
+import semver from 'semver';
+import ssri from 'ssri';
+import versionSelectorType from 'version-selector-type';
+import { fetchMetadataFromFromRegistry, RegistryResponseError } from './fetch.js';
+import { normalizeRegistryUrl } from './normalizeRegistryUrl.js';
+import { parseBareSpecifier, parseJsrSpecifierToRegistryPackageSpec, } from './parseBareSpecifier.js';
+import { pickPackage, } from './pickPackage.js';
+import { pickVersionByVersionRange } from './pickPackageFromMeta.js';
+import { failIfTrustDowngraded } from './trustChecks.js';
+import { whichVersionIsPinned } from './whichVersionIsPinned.js';
+import { workspacePrefToNpm } from './workspacePrefToNpm.js';
+export class NoMatchingVersionError extends PnpmError {
+    packageMeta;
+    immatureVersion;
+    constructor(opts) {
+        const dep = opts.wantedDependency.alias
+            ? `${opts.wantedDependency.alias}@${opts.wantedDependency.bareSpecifier ?? ''}`
+            : opts.wantedDependency.bareSpecifier;
+        let errorMessage;
+        if (opts.publishedBy && opts.immatureVersion && opts.packageMeta.time) {
+            const time = new Date(opts.packageMeta.time[opts.immatureVersion]);
+            const releaseAgeText = formatTimeAgo(time);
+            const pkgName = opts.wantedDependency.alias ?? opts.packageMeta.name;
+            errorMessage = `Version ${opts.immatureVersion} (released ${releaseAgeText}) of ${pkgName} does not meet the minimumReleaseAge constraint`;
+        }
+        else {
+            errorMessage = `No matching version found for ${dep} while fetching it from ${opts.registry}`;
+        }
+        super(opts.publishedBy ? 'NO_MATURE_MATCHING_VERSION' : 'NO_MATCHING_VERSION', errorMessage);
+        this.packageMeta = opts.packageMeta;
+        this.immatureVersion = opts.immatureVersion;
+    }
+}
+function formatTimeAgo(date) {
+    const now = Date.now();
+    const diffMs = now - date.getTime();
+    // Handle clock skew (future dates) and very recent releases (< 1 minute)
+    if (diffMs < 60 * 1000) {
+        return 'just now';
+    }
+    const diffMinutes = Math.floor(diffMs / (60 * 1000));
+    const diffHours = Math.floor(diffMs / (60 * 60 * 1000));
+    const diffDays = Math.floor(diffMs / (24 * 60 * 60 * 1000));
+    if (diffHours >= 48) {
+        return `${diffDays} day${diffDays === 1 ? '' : 's'} ago`;
+    }
+    if (diffMinutes >= 90) {
+        return `${diffHours} hour${diffHours === 1 ? '' : 's'} ago`;
+    }
+    return `${diffMinutes} minute${diffMinutes === 1 ? '' : 's'} ago`;
+}
+export { parseBareSpecifier, RegistryResponseError, workspacePrefToNpm, };
+export { whichVersionIsPinned } from './whichVersionIsPinned.js';
+export function createNpmResolver(fetchFromRegistry, getAuthHeader, opts) {
+    if (typeof opts.cacheDir !== 'string') {
+        throw new TypeError('`opts.cacheDir` is required and needs to be a string');
+    }
+    const fetchOpts = {
+        fetch: fetchFromRegistry,
+        retry: opts.retry ?? {},
+        timeout: opts.timeout ?? 60000,
+        fetchWarnTimeoutMs: opts.fetchWarnTimeoutMs ?? 10 * 1000, // 10 sec
+    };
+    const fetch = pMemoize(fetchMetadataFromFromRegistry.bind(null, fetchOpts), {
+        cacheKey: (...args) => JSON.stringify(args),
+    });
+    const metaCache = new LRUCache({
+        max: 10000,
+        ttl: 120 * 1000, // 2 minutes
+    });
+    // Create peek function if storeDir is provided
+    const storeDir = opts.storeDir;
+    const peekLockerForPeek = new Map();
+    let peekManifestFromStore;
+    if (storeDir) {
+        peekManifestFromStore = async (peekOpts) => {
+            const filesIndexFile = storeIndexKey(peekOpts.integrity, peekOpts.id);
+            const existingRequest = peekLockerForPeek.get(filesIndexFile);
+            if (existingRequest != null) {
+                return existingRequest;
+            }
+            const request = readPkgFromCafs({
+                storeDir,
+                verifyStoreIntegrity: false,
+            }, filesIndexFile, {
+                expectedPkg: { name: peekOpts.name, version: peekOpts.version },
+            }).then(({ bundledManifest }) => {
+                if (!bundledManifest)
+                    return undefined;
+                return bundledManifest;
+            }).catch(() => undefined);
+            peekLockerForPeek.set(filesIndexFile, request);
+            return request;
+        };
+    }
+    const ctx = {
+        getAuthHeaderValueByURI: getAuthHeader,
+        pickPackage: pickPackage.bind(null, {
+            fetch,
+            fullMetadata: opts.fullMetadata,
+            filterMetadata: opts.filterMetadata,
+            metaCache,
+            offline: opts.offline,
+            preferOffline: opts.preferOffline,
+            cacheDir: opts.cacheDir,
+            strictPublishedByCheck: opts.strictPublishedByCheck,
+        }),
+        registries: opts.registries,
+        saveWorkspaceProtocol: opts.saveWorkspaceProtocol,
+        peekManifestFromStore,
+    };
+    return {
+        resolveFromNpm: resolveNpm.bind(null, ctx),
+        resolveFromJsr: resolveJsr.bind(null, ctx),
+        clearCache: () => {
+            metaCache.clear();
+        },
+    };
+}
+async function resolveNpm(ctx, wantedDependency, opts) {
+    const defaultTag = opts.defaultTag ?? 'latest';
+    const registry = wantedDependency.alias
+        ? pickRegistryForPackage(ctx.registries, wantedDependency.alias, wantedDependency.bareSpecifier)
+        : ctx.registries.default;
+    if (wantedDependency.bareSpecifier?.startsWith('workspace:')) {
+        if (wantedDependency.bareSpecifier.startsWith('workspace:.'))
+            return null;
+        const resolvedFromWorkspace = tryResolveFromWorkspace(wantedDependency, {
+            defaultTag,
+            lockfileDir: opts.lockfileDir,
+            projectDir: opts.projectDir,
+            registry,
+            workspacePackages: opts.workspacePackages,
+            injectWorkspacePackages: opts.injectWorkspacePackages,
+            update: Boolean(opts.update),
+            saveWorkspaceProtocol: ctx.saveWorkspaceProtocol !== false ? ctx.saveWorkspaceProtocol : true,
+            calcSpecifier: opts.calcSpecifier,
+            pinnedVersion: opts.pinnedVersion,
+        });
+        if (resolvedFromWorkspace != null) {
+            return resolvedFromWorkspace;
+        }
+    }
+    const workspacePackages = opts.alwaysTryWorkspacePackages !== false ? opts.workspacePackages : undefined;
+    const spec = wantedDependency.bareSpecifier
+        ? parseBareSpecifier(wantedDependency.bareSpecifier, wantedDependency.alias, defaultTag, registry)
+        : defaultTagForAlias(wantedDependency.alias, defaultTag);
+    if (spec == null)
+        return null;
+    // Fast path: if we have a current resolution with integrity, try to peek the manifest from the store.
+    // This avoids the expensive metadata fetch from the registry.
+    // We do this AFTER ensuring the spec is valid for this resolver to avoids hijacking other resolvers.
+    if (ctx.peekManifestFromStore && opts.currentPkg?.resolution && !opts.update) {
+        const currentResolution = opts.currentPkg.resolution;
+        // Only use this optimization for tarball resolutions with integrity (npm packages)
+        if ('tarball' in currentResolution && currentResolution.integrity) {
+            const manifest = await ctx.peekManifestFromStore({
+                id: opts.currentPkg.id,
+                integrity: currentResolution.integrity,
+                name: opts.currentPkg.name,
+                version: opts.currentPkg.version,
+            });
+            // Verify the manifest matches what we expect
+            if (manifest?.name && manifest?.version) {
+                const id = `${manifest.name}@${manifest.version}`;
+                // Only return if the ID matches what we have in currentPkg
+                if (id === opts.currentPkg.id) {
+                    return {
+                        id,
+                        manifest,
+                        resolution: currentResolution,
+                        resolvedVia: 'npm-registry',
+                        publishedAt: undefined, // Don't have this without metadata
+                    };
+                }
+            }
+        }
+    }
+    const authHeaderValue = ctx.getAuthHeaderValueByURI(registry);
+    let pickResult;
+    try {
+        pickResult = await ctx.pickPackage(spec, {
+            pickLowestVersion: opts.pickLowestVersion,
+            publishedBy: opts.publishedBy,
+            publishedByExclude: opts.publishedByExclude,
+            authHeaderValue,
+            dryRun: opts.dryRun === true,
+            preferredVersionSelectors: opts.preferredVersions?.[spec.name],
+            registry,
+            updateToLatest: opts.update === 'latest',
+            optional: wantedDependency.optional,
+        });
+    }
+    catch (err) { // eslint-disable-line
+        if ((workspacePackages != null) && opts.projectDir) {
+            try {
+                return tryResolveFromWorkspacePackages(workspacePackages, spec, {
+                    wantedDependency,
+                    projectDir: opts.projectDir,
+                    lockfileDir: opts.lockfileDir,
+                    hardLinkLocalPackages: opts.injectWorkspacePackages === true || wantedDependency.injected,
+                    update: false,
+                    saveWorkspaceProtocol: ctx.saveWorkspaceProtocol,
+                    calcSpecifier: opts.calcSpecifier,
+                    pinnedVersion: opts.pinnedVersion,
+                });
+            }
+            catch {
+                // ignore
+            }
+        }
+        throw err;
+    }
+    const pickedPackage = pickResult.pickedPackage;
+    const meta = pickResult.meta;
+    if (pickedPackage == null) {
+        if ((workspacePackages != null) && opts.projectDir) {
+            try {
+                return tryResolveFromWorkspacePackages(workspacePackages, spec, {
+                    wantedDependency,
+                    projectDir: opts.projectDir,
+                    lockfileDir: opts.lockfileDir,
+                    hardLinkLocalPackages: opts.injectWorkspacePackages === true || wantedDependency.injected,
+                    update: false,
+                    saveWorkspaceProtocol: ctx.saveWorkspaceProtocol,
+                    calcSpecifier: opts.calcSpecifier,
+                    pinnedVersion: opts.pinnedVersion,
+                });
+            }
+            catch {
+                // ignore
+            }
+        }
+        if (opts.publishedBy) {
+            const immatureVersion = pickVersionByVersionRange({
+                meta,
+                versionRange: spec.fetchSpec,
+                preferredVersionSelectors: opts.preferredVersions?.[spec.name],
+            });
+            if (immatureVersion) {
+                throw new NoMatchingVersionError({
+                    wantedDependency,
+                    packageMeta: meta,
+                    registry,
+                    immatureVersion,
+                    publishedBy: opts.publishedBy,
+                });
+            }
+        }
+        throw new NoMatchingVersionError({ wantedDependency, packageMeta: meta, registry });
+    }
+    else if (opts.trustPolicy === 'no-downgrade') {
+        failIfTrustDowngraded(meta, pickedPackage.version, opts);
+    }
+    const workspacePkgsMatchingName = workspacePackages?.get(pickedPackage.name);
+    if (workspacePkgsMatchingName && opts.projectDir) {
+        const matchedPkg = workspacePkgsMatchingName.get(pickedPackage.version);
+        if (matchedPkg) {
+            return {
+                ...resolveFromLocalPackage(matchedPkg, spec, {
+                    wantedDependency,
+                    projectDir: opts.projectDir,
+                    lockfileDir: opts.lockfileDir,
+                    hardLinkLocalPackages: opts.injectWorkspacePackages === true || wantedDependency.injected,
+                    saveWorkspaceProtocol: ctx.saveWorkspaceProtocol,
+                    calcSpecifier: opts.calcSpecifier,
+                    pinnedVersion: opts.pinnedVersion,
+                }),
+                latest: meta['dist-tags'].latest,
+            };
+        }
+        const localVersion = pickMatchingLocalVersionOrNull(workspacePkgsMatchingName, spec);
+        if (localVersion && (semver.gt(localVersion, pickedPackage.version) || opts.preferWorkspacePackages)) {
+            return {
+                ...resolveFromLocalPackage(workspacePkgsMatchingName.get(localVersion), spec, {
+                    wantedDependency,
+                    projectDir: opts.projectDir,
+                    lockfileDir: opts.lockfileDir,
+                    hardLinkLocalPackages: opts.injectWorkspacePackages === true || wantedDependency.injected,
+                    saveWorkspaceProtocol: ctx.saveWorkspaceProtocol,
+                    calcSpecifier: opts.calcSpecifier,
+                    pinnedVersion: opts.pinnedVersion,
+                }),
+                latest: meta['dist-tags'].latest,
+            };
+        }
+    }
+    const id = `${pickedPackage.name}@${pickedPackage.version}`;
+    const resolution = {
+        integrity: getIntegrity(pickedPackage.dist),
+        tarball: normalizeRegistryUrl(pickedPackage.dist.tarball),
+    };
+    let normalizedBareSpecifier;
+    if (opts.calcSpecifier) {
+        normalizedBareSpecifier = spec.normalizedBareSpecifier ?? calcSpecifier({
+            wantedDependency,
+            spec,
+            version: pickedPackage.version,
+            defaultPinnedVersion: opts.pinnedVersion,
+        });
+    }
+    return {
+        id,
+        latest: meta['dist-tags'].latest,
+        manifest: pickedPackage,
+        resolution,
+        resolvedVia: 'npm-registry',
+        publishedAt: meta.time?.[pickedPackage.version],
+        normalizedBareSpecifier,
+    };
+}
+async function resolveJsr(ctx, wantedDependency, opts) {
+    if (!wantedDependency.bareSpecifier)
+        return null;
+    const defaultTag = opts.defaultTag ?? 'latest';
+    const registry = ctx.registries['@jsr']; // '@jsr' is always defined
+    const spec = parseJsrSpecifierToRegistryPackageSpec(wantedDependency.bareSpecifier, wantedDependency.alias, defaultTag);
+    if (spec == null)
+        return null;
+    const authHeaderValue = ctx.getAuthHeaderValueByURI(registry);
+    const { meta, pickedPackage } = await ctx.pickPackage(spec, {
+        pickLowestVersion: opts.pickLowestVersion,
+        publishedBy: opts.publishedBy,
+        authHeaderValue,
+        dryRun: opts.dryRun === true,
+        preferredVersionSelectors: opts.preferredVersions?.[spec.name],
+        registry,
+        updateToLatest: opts.update === 'latest',
+    });
+    if (pickedPackage == null) {
+        throw new NoMatchingVersionError({ wantedDependency, packageMeta: meta, registry });
+    }
+    const id = `${pickedPackage.name}@${pickedPackage.version}`;
+    const resolution = {
+        integrity: getIntegrity(pickedPackage.dist),
+        tarball: normalizeRegistryUrl(pickedPackage.dist.tarball),
+    };
+    return {
+        id,
+        latest: meta['dist-tags'].latest,
+        manifest: pickedPackage,
+        normalizedBareSpecifier: opts.calcSpecifier
+            ? calcJsrSpecifier({
+                wantedDependency,
+                spec,
+                version: pickedPackage.version,
+                defaultPinnedVersion: opts.pinnedVersion,
+            })
+            : undefined,
+        resolution,
+        resolvedVia: 'jsr-registry',
+        publishedAt: meta.time?.[pickedPackage.version],
+        alias: spec.jsrPkgName,
+    };
+}
+function calcJsrSpecifier({ wantedDependency, spec, version, defaultPinnedVersion, }) {
+    const range = calcRange(version, wantedDependency, defaultPinnedVersion);
+    if (!wantedDependency.alias || spec.jsrPkgName === wantedDependency.alias)
+        return `jsr:${range}`;
+    return `jsr:${spec.jsrPkgName}@${range}`;
+}
+function calcSpecifier({ wantedDependency, spec, version, defaultPinnedVersion, }) {
+    if (wantedDependency.prevSpecifier === wantedDependency.bareSpecifier && wantedDependency.prevSpecifier && versionSelectorType(wantedDependency.prevSpecifier)?.type === 'tag') {
+        return wantedDependency.prevSpecifier;
+    }
+    const range = calcRange(version, wantedDependency, defaultPinnedVersion);
+    if (!wantedDependency.alias || spec.name === wantedDependency.alias)
+        return range;
+    return `npm:${spec.name}@${range}`;
+}
+function calcRange(version, wantedDependency, defaultPinnedVersion) {
+    if (semver.parse(version)?.prerelease.length) {
+        return version;
+    }
+    const pinnedVersion = (wantedDependency.prevSpecifier ? whichVersionIsPinned(wantedDependency.prevSpecifier) : undefined) ??
+        (wantedDependency.bareSpecifier ? whichVersionIsPinned(wantedDependency.bareSpecifier) : undefined) ??
+        defaultPinnedVersion;
+    return createVersionSpec(version, pinnedVersion);
+}
+function tryResolveFromWorkspace(wantedDependency, opts) {
+    if (!wantedDependency.bareSpecifier?.startsWith('workspace:')) {
+        return null;
+    }
+    const bareSpecifier = workspacePrefToNpm(wantedDependency.bareSpecifier);
+    const spec = parseBareSpecifier(bareSpecifier, wantedDependency.alias, opts.defaultTag, opts.registry);
+    if (spec == null)
+        throw new Error(`Invalid workspace: spec (${wantedDependency.bareSpecifier})`);
+    if (opts.workspacePackages == null) {
+        throw new Error('Cannot resolve package from workspace because opts.workspacePackages is not defined');
+    }
+    if (!opts.projectDir) {
+        throw new Error('Cannot resolve package from workspace because opts.projectDir is not defined');
+    }
+    return tryResolveFromWorkspacePackages(opts.workspacePackages, spec, {
+        wantedDependency,
+        projectDir: opts.projectDir,
+        hardLinkLocalPackages: opts.injectWorkspacePackages === true || wantedDependency.injected,
+        lockfileDir: opts.lockfileDir,
+        update: opts.update,
+        saveWorkspaceProtocol: opts.saveWorkspaceProtocol,
+        calcSpecifier: opts.calcSpecifier,
+        pinnedVersion: opts.pinnedVersion,
+    });
+}
+function tryResolveFromWorkspacePackages(workspacePackages, spec, opts) {
+    const workspacePkgsMatchingName = workspacePackages.get(spec.name);
+    if (!workspacePkgsMatchingName) {
+        throw new PnpmError('WORKSPACE_PKG_NOT_FOUND', `In ${path.relative(process.cwd(), opts.projectDir)}: "${spec.name}@${opts.wantedDependency.bareSpecifier ?? ''}" is in the dependencies but no package named "${spec.name}" is present in the workspace`, {
+            hint: 'Packages found in the workspace: ' + Array.from(workspacePackages.keys()).join(', '),
+        });
+    }
+    const localVersion = pickMatchingLocalVersionOrNull(workspacePkgsMatchingName, opts.update ? { name: spec.name, fetchSpec: '*', type: 'range' } : spec);
+    if (!localVersion) {
+        const availableVersions = Array.from(workspacePkgsMatchingName.keys()).sort((a, b) => semver.rcompare(a, b));
+        throw new PnpmError('NO_MATCHING_VERSION_INSIDE_WORKSPACE', `In ${path.relative(process.cwd(), opts.projectDir)}: No matching version found for ${opts.wantedDependency.alias ?? ''}@${opts.wantedDependency.bareSpecifier ?? ''} inside the workspace` +
+            (availableVersions.length ? `. Available versions: ${availableVersions.join(', ')}` : ''), availableVersions.length
+            ? {
+                hint: `Available workspace versions for "${spec.name}": ${availableVersions.join(', ')}`,
+            }
+            : undefined);
+    }
+    return resolveFromLocalPackage(workspacePkgsMatchingName.get(localVersion), spec, opts);
+}
+function pickMatchingLocalVersionOrNull(versions, spec) {
+    switch (spec.type) {
+        case 'tag':
+            return semver.maxSatisfying(Array.from(versions.keys()), '*', {
+                includePrerelease: true,
+            });
+        case 'version':
+            return versions.has(spec.fetchSpec) ? spec.fetchSpec : null;
+        case 'range':
+            return resolveWorkspaceRange(spec.fetchSpec, Array.from(versions.keys()));
+        default:
+            return null;
+    }
+}
+function resolveFromLocalPackage(localPackage, spec, opts) {
+    let id;
+    let directory;
+    const localPackageDir = resolveLocalPackageDir(localPackage);
+    if (opts.hardLinkLocalPackages) {
+        directory = normalize(path.relative(opts.lockfileDir, localPackageDir));
+        id = `file:${directory}`;
+    }
+    else {
+        directory = localPackageDir;
+        id = `link:${normalize(path.relative(opts.projectDir, localPackageDir))}`;
+    }
+    let normalizedBareSpecifier;
+    if (opts.calcSpecifier) {
+        normalizedBareSpecifier = spec.normalizedBareSpecifier ?? calcSpecifierForWorkspaceDep({
+            wantedDependency: opts.wantedDependency,
+            spec,
+            saveWorkspaceProtocol: opts.saveWorkspaceProtocol,
+            version: localPackage.manifest.version,
+            defaultPinnedVersion: opts.pinnedVersion,
+        });
+    }
+    return {
+        id,
+        manifest: clone(localPackage.manifest),
+        resolution: {
+            directory,
+            type: 'directory',
+        },
+        resolvedVia: 'workspace',
+        normalizedBareSpecifier,
+    };
+}
+function calcSpecifierForWorkspaceDep({ wantedDependency, spec, saveWorkspaceProtocol, version, defaultPinnedVersion, }) {
+    if (!saveWorkspaceProtocol && !wantedDependency.bareSpecifier?.startsWith('workspace:')) {
+        return calcSpecifier({ wantedDependency, spec, version, defaultPinnedVersion });
+    }
+    const prefix = (!wantedDependency.alias || spec.name === wantedDependency.alias) ? 'workspace:' : `workspace:${spec.name}@`;
+    if (saveWorkspaceProtocol === 'rolling') {
+        const specifier = wantedDependency.prevSpecifier ?? wantedDependency.bareSpecifier;
+        if (specifier) {
+            if ([`${prefix}*`, `${prefix}^`, `${prefix}~`].includes(specifier))
+                return specifier;
+            const pinnedVersion = whichVersionIsPinned(specifier);
+            switch (pinnedVersion) {
+                case 'major': return `${prefix}^`;
+                case 'minor': return `${prefix}~`;
+                case 'patch':
+                case 'none': return `${prefix}*`;
+            }
+        }
+        return `${prefix}^`;
+    }
+    if (semver.parse(version)?.prerelease.length) {
+        return `${prefix}${version}`;
+    }
+    const pinnedVersion = (wantedDependency.prevSpecifier ? whichVersionIsPinned(wantedDependency.prevSpecifier) : undefined) ?? defaultPinnedVersion;
+    const range = createVersionSpec(version, pinnedVersion);
+    return `${prefix}${range}`;
+}
+function resolveLocalPackageDir(localPackage) {
+    if (localPackage.manifest.publishConfig?.directory == null ||
+        localPackage.manifest.publishConfig?.linkDirectory === false)
+        return localPackage.rootDir;
+    return path.join(localPackage.rootDir, localPackage.manifest.publishConfig.directory);
+}
+function defaultTagForAlias(alias, defaultTag) {
+    return {
+        fetchSpec: defaultTag,
+        name: alias,
+        type: 'tag',
+    };
+}
+function getIntegrity(dist) {
+    if (dist.integrity) {
+        return dist.integrity;
+    }
+    if (!dist.shasum) {
+        return undefined;
+    }
+    const integrity = ssri.fromHex(dist.shasum, 'sha1');
+    if (!integrity) {
+        throw new PnpmError('INVALID_TARBALL_INTEGRITY', `Tarball "${dist.tarball}" has invalid shasum specified in its metadata: ${dist.shasum}`);
+    }
+    return integrity.toString();
+}
+function createVersionSpec(version, pinnedVersion) {
+    switch (pinnedVersion ?? 'major') {
+        case 'none':
+        case 'major':
+            return `^${version}`;
+        case 'minor':
+            return `~${version}`;
+        case 'patch':
+            return version;
+        default:
+            throw new PnpmError('BAD_PINNED_VERSION', `Cannot pin '${pinnedVersion ?? 'undefined'}'`);
+    }
+}
+//# sourceMappingURL=index.js.map

package/lib/normalizeRegistryUrl.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Remove default ports (80 for HTTP, 443 for HTTPS) to ensure consistency
+ */
+export declare function normalizeRegistryUrl(urlString: string): string;

package/lib/normalizeRegistryUrl.js

@@ -0,0 +1,12 @@
+/**
+ * Remove default ports (80 for HTTP, 443 for HTTPS) to ensure consistency
+ */
+export function normalizeRegistryUrl(urlString) {
+    try {
+        return new URL(urlString).toString();
+    }
+    catch {
+        return urlString;
+    }
+}
+//# sourceMappingURL=normalizeRegistryUrl.js.map

package/lib/parseBareSpecifier.d.ts

@@ -0,0 +1,11 @@
+export interface RegistryPackageSpec {
+    type: 'tag' | 'version' | 'range';
+    name: string;
+    fetchSpec: string;
+    normalizedBareSpecifier?: string;
+}
+export declare function parseBareSpecifier(bareSpecifier: string, alias: string | undefined, defaultTag: string, registry: string): RegistryPackageSpec | null;
+export interface JsrRegistryPackageSpec extends RegistryPackageSpec {
+    jsrPkgName: string;
+}
+export declare function parseJsrSpecifierToRegistryPackageSpec(rawSpecifier: string, alias: string | undefined, defaultTag: string): JsrRegistryPackageSpec | null;

package/lib/parseBareSpecifier.js

@@ -0,0 +1,55 @@
+import { parseJsrSpecifier } from '@pnpm/resolving.jsr-specifier-parser';
+import parseNpmTarballUrl from 'parse-npm-tarball-url';
+import getVersionSelectorType from 'version-selector-type';
+export function parseBareSpecifier(bareSpecifier, alias, defaultTag, registry) {
+    let name = alias;
+    if (bareSpecifier.startsWith('npm:')) {
+        bareSpecifier = bareSpecifier.slice(4);
+        const index = bareSpecifier.lastIndexOf('@');
+        if (index < 1) {
+            name = bareSpecifier;
+            bareSpecifier = defaultTag;
+        }
+        else {
+            name = bareSpecifier.slice(0, index);
+            bareSpecifier = bareSpecifier.slice(index + 1);
+        }
+    }
+    if (name) {
+        const selector = getVersionSelectorType(bareSpecifier);
+        if (selector != null) {
+            return {
+                fetchSpec: selector.normalized,
+                name,
+                type: selector.type,
+            };
+        }
+    }
+    if (bareSpecifier.startsWith(registry)) {
+        const pkg = parseNpmTarballUrl.default(bareSpecifier);
+        if (pkg != null) {
+            return {
+                fetchSpec: pkg.version,
+                name: pkg.name,
+                normalizedBareSpecifier: bareSpecifier,
+                type: 'version',
+            };
+        }
+    }
+    return null;
+}
+export function parseJsrSpecifierToRegistryPackageSpec(rawSpecifier, alias, defaultTag) {
+    const spec = parseJsrSpecifier(rawSpecifier, alias);
+    if (!spec?.npmPkgName)
+        return null;
+    const selector = getVersionSelectorType(spec.versionSelector ?? defaultTag);
+    if (selector == null)
+        return null;
+    return {
+        fetchSpec: selector.normalized,
+        name: spec.npmPkgName,
+        type: selector.type,
+        jsrPkgName: spec.jsrPkgName,
+    };
+}
+//# sourceMappingURL=parseBareSpecifier.js.map

package/lib/pickPackage.d.ts

@@ -0,0 +1,34 @@
+import type { PackageInRegistry, PackageMeta } from '@pnpm/resolving.registry.types';
+import type { FetchMetadataResult } from './fetch.js';
+import type { RegistryPackageSpec } from './parseBareSpecifier.js';
+import { type PickPackageFromMetaOptions } from './pickPackageFromMeta.js';
+export interface PackageMetaCache {
+    get: (key: string) => PackageMeta | undefined;
+    set: (key: string, meta: PackageMeta) => void;
+    has: (key: string) => boolean;
+}
+export interface PickPackageOptions extends PickPackageFromMetaOptions {
+    authHeaderValue?: string;
+    pickLowestVersion?: boolean;
+    registry: string;
+    dryRun: boolean;
+    updateToLatest?: boolean;
+    optional?: boolean;
+}
+export declare function pickPackage(ctx: {
+    fetch: (pkgName: string, opts: {
+        registry: string;
+        authHeaderValue?: string;
+        fullMetadata?: boolean;
+    }) => Promise<FetchMetadataResult>;
+    fullMetadata?: boolean;
+    metaCache: PackageMetaCache;
+    cacheDir: string;
+    offline?: boolean;
+    preferOffline?: boolean;
+    filterMetadata?: boolean;
+    strictPublishedByCheck?: boolean;
+}, spec: RegistryPackageSpec, opts: PickPackageOptions): Promise<{
+    meta: PackageMeta;
+    pickedPackage: PackageInRegistry | null;
+}>;