@pnpm/installing.deps-resolver 1008.3.1

package/lib/safeIsInnerLink.d.ts

@@ -0,0 +1,6 @@
+export declare function safeIsInnerLink(projectModulesDir: string, depName: string, opts: {
+    hideAlienModules: boolean;
+    projectDir: string;
+    virtualStoreDir: string;
+    globalVirtualStoreDir: string;
+}): Promise<true | string>;

package/lib/safeIsInnerLink.js

@@ -0,0 +1,31 @@
+import path from 'node:path';
+import { logger } from '@pnpm/logger';
+import { isInnerLink } from 'is-inner-link';
+import { isSubdir } from 'is-subdir';
+import { renameOverwrite } from 'rename-overwrite';
+export async function safeIsInnerLink(projectModulesDir, depName, opts) {
+    try {
+        const link = await isInnerLink(projectModulesDir, depName);
+        if (link.isInner)
+            return true;
+        if (isSubdir(opts.virtualStoreDir, link.target) ||
+            opts.globalVirtualStoreDir !== opts.virtualStoreDir && isSubdir(opts.globalVirtualStoreDir, link.target)) {
+            return true;
+        }
+        return link.target;
+    }
+    catch (err) { // eslint-disable-line
+        if (err.code === 'ENOENT')
+            return true;
+        if (opts.hideAlienModules) {
+            logger.warn({
+                message: `Moving ${depName} that was installed by a different package manager to "node_modules/.ignored"`,
+                prefix: opts.projectDir,
+            });
+            const ignoredDir = path.join(projectModulesDir, '.ignored', depName);
+            await renameOverwrite(path.join(projectModulesDir, depName), ignoredDir);
+        }
+        return true;
+    }
+}
+//# sourceMappingURL=safeIsInnerLink.js.map

package/lib/toResolveImporter.d.ts

@@ -0,0 +1,22 @@
+import type { PreferredVersions, WorkspacePackages } from '@pnpm/resolving.resolver-base';
+import { type WantedDependency } from './getWantedDependencies.js';
+import type { ImporterToResolve } from './index.js';
+import type { ImporterToResolveGeneric } from './resolveDependencyTree.js';
+export interface ResolveImporter extends ImporterToResolve, ImporterToResolveGeneric<{
+    isNew?: boolean;
+}> {
+    wantedDependencies: Array<WantedDependency & {
+        isNew?: boolean;
+        updateDepth: number;
+    }>;
+}
+export declare function toResolveImporter(opts: {
+    defaultUpdateDepth: number;
+    lockfileOnly: boolean;
+    preferredVersions?: PreferredVersions;
+    virtualStoreDir: string;
+    globalVirtualStoreDir: string;
+    workspacePackages: WorkspacePackages;
+    updateToLatest?: boolean;
+    noDependencySelectors: boolean;
+}, project: ImporterToResolve): Promise<ResolveImporter>;

package/lib/toResolveImporter.js

@@ -0,0 +1,117 @@
+import { logger } from '@pnpm/logger';
+import { getAllDependenciesFromManifest } from '@pnpm/pkg-manifest.utils';
+import getVerSelType from 'version-selector-type';
+import { getWantedDependencies } from './getWantedDependencies.js';
+import { safeIsInnerLink } from './safeIsInnerLink.js';
+import { unwrapPackageName } from './unwrapPackageName.js';
+import { validatePeerDependencies } from './validatePeerDependencies.js';
+export async function toResolveImporter(opts, project) {
+    validatePeerDependencies(project);
+    const allDeps = getWantedDependencies(project.manifest);
+    const nonLinkedDependencies = await partitionLinkedPackages(allDeps, {
+        lockfileOnly: opts.lockfileOnly,
+        modulesDir: project.modulesDir,
+        projectDir: project.rootDir,
+        virtualStoreDir: opts.virtualStoreDir,
+        globalVirtualStoreDir: opts.globalVirtualStoreDir,
+        workspacePackages: opts.workspacePackages,
+    });
+    const defaultUpdateDepth = (project.update === true || (project.updateMatching != null)) ? opts.defaultUpdateDepth : -1;
+    const existingDeps = nonLinkedDependencies
+        .filter(({ alias }) => !project.wantedDependencies.some((wantedDep) => wantedDep.alias === alias));
+    if (opts.updateToLatest && opts.noDependencySelectors) {
+        for (const dep of existingDeps) {
+            dep.updateSpec = true;
+        }
+    }
+    let wantedDependencies;
+    if (!project.manifest) {
+        wantedDependencies = [
+            ...project.wantedDependencies,
+            ...existingDeps,
+        ]
+            .map((dep) => ({
+            ...dep,
+            updateDepth: defaultUpdateDepth,
+        }));
+    }
+    else {
+        // Direct local tarballs are always checked,
+        // so their update depth should be at least 0
+        const updateLocalTarballs = (dep) => ({
+            ...dep,
+            updateDepth: project.updateMatching != null
+                ? defaultUpdateDepth
+                : (prefIsLocalTarball(dep.bareSpecifier) ? 0 : defaultUpdateDepth),
+        });
+        wantedDependencies = [
+            ...project.wantedDependencies.map(defaultUpdateDepth < 0
+                ? updateLocalTarballs
+                : (dep) => ({ ...dep, updateDepth: defaultUpdateDepth })),
+            ...existingDeps.map(opts.noDependencySelectors && project.updateMatching != null
+                ? updateLocalTarballs
+                : (dep) => ({ ...dep, updateDepth: -1 })),
+        ];
+    }
+    return {
+        ...project,
+        hasRemovedDependencies: Boolean(project.removePackages?.length),
+        preferredVersions: opts.preferredVersions ?? (project.manifest && getPreferredVersionsFromPackage(project.manifest)) ?? {},
+        wantedDependencies,
+    };
+}
+function prefIsLocalTarball(bareSpecifier) {
+    return bareSpecifier.startsWith('file:') && bareSpecifier.endsWith('.tgz');
+}
+async function partitionLinkedPackages(dependencies, opts) {
+    const nonLinkedDependencies = [];
+    const linkedAliases = new Set();
+    await Promise.all(dependencies.map(async (dependency) => {
+        if (!dependency.alias ||
+            opts.workspacePackages?.get(dependency.alias) != null ||
+            dependency.bareSpecifier.startsWith('workspace:')) {
+            nonLinkedDependencies.push(dependency);
+            return;
+        }
+        const isInnerLink = await safeIsInnerLink(opts.modulesDir, dependency.alias, {
+            hideAlienModules: !opts.lockfileOnly,
+            projectDir: opts.projectDir,
+            virtualStoreDir: opts.virtualStoreDir,
+            globalVirtualStoreDir: opts.globalVirtualStoreDir,
+        });
+        if (isInnerLink === true) {
+            nonLinkedDependencies.push(dependency);
+            return;
+        }
+        if (!dependency.bareSpecifier.startsWith('link:')) {
+            // This info-log might be better to be moved to the reporter
+            logger.info({
+                message: `${dependency.alias} is linked to ${opts.modulesDir} from ${isInnerLink}`,
+                prefix: opts.projectDir,
+            });
+        }
+        linkedAliases.add(dependency.alias);
+    }));
+    return nonLinkedDependencies;
+}
+function getPreferredVersionsFromPackage(pkg) {
+    return getVersionSpecsByRealNames(getAllDependenciesFromManifest(pkg));
+}
+function getVersionSpecsByRealNames(deps) {
+    const acc = {};
+    for (const depName in deps) {
+        const currentBareSpecifier = deps[depName];
+        const { pkgName, bareSpecifier } = unwrapPackageName(depName, currentBareSpecifier);
+        // we really care only about semver specs
+        if (bareSpecifier.includes(':')) {
+            continue;
+        }
+        const selector = getVerSelType(bareSpecifier);
+        if (selector != null) {
+            acc[pkgName] = acc[pkgName] || {};
+            acc[pkgName][selector.normalized] = selector.type;
+        }
+    }
+    return acc;
+}
+//# sourceMappingURL=toResolveImporter.js.map

package/lib/unwrapPackageName.d.ts

@@ -0,0 +1,23 @@
+export interface UnwrappedPackageInfo {
+    readonly pkgName: string;
+    readonly bareSpecifier: string;
+}
+/**
+ * When declaring dependencies in a package.json file, it's possible to specify
+ * an "alias".
+ *
+ * An example of this would be:
+ *
+ * @example
+ * ```json
+ * {
+ *   "dependencies": {
+ *     "my-alias": "npm:is-positive@^1.0.0"
+ *   }
+ * }
+ * ```
+ *
+ * This function normalizes out the alias and returns the real package name
+ * (i.e. "is-positive" for this example) if "npm:" is used.
+ */
+export declare function unwrapPackageName(alias: string, originalBareSpecifier: string): UnwrappedPackageInfo;

package/lib/unwrapPackageName.js

@@ -0,0 +1,39 @@
+/**
+ * When declaring dependencies in a package.json file, it's possible to specify
+ * an "alias".
+ *
+ * An example of this would be:
+ *
+ * @example
+ * ```json
+ * {
+ *   "dependencies": {
+ *     "my-alias": "npm:is-positive@^1.0.0"
+ *   }
+ * }
+ * ```
+ *
+ * This function normalizes out the alias and returns the real package name
+ * (i.e. "is-positive" for this example) if "npm:" is used.
+ */
+export function unwrapPackageName(alias, originalBareSpecifier) {
+    // If the specifier doesn't start with "npm:", there's no more work to do. The
+    // "alias" argument is just the real package's name.
+    if (!originalBareSpecifier.startsWith('npm:')) {
+        return { pkgName: alias, bareSpecifier: originalBareSpecifier };
+    }
+    const npmAliasSpecifierValue = originalBareSpecifier.slice(4);
+    const index = npmAliasSpecifierValue.lastIndexOf('@');
+    // If the "@" character isn't found or is the first character, then
+    // this alias is just a package name without a spec. Examples:
+    // "npm:is-positive", "npm:@pnpm/lockfile.fs"
+    //
+    // In this case, the bare specifier will be "*".
+    if (index === -1 || index === 0) {
+        return { pkgName: npmAliasSpecifierValue, bareSpecifier: '*' };
+    }
+    const bareSpecifier = npmAliasSpecifierValue.slice(index + 1);
+    const pkgName = npmAliasSpecifierValue.substring(0, index);
+    return { pkgName, bareSpecifier };
+}
+//# sourceMappingURL=unwrapPackageName.js.map

package/lib/updateLockfile.d.ts

@@ -0,0 +1,10 @@
+import { type LockfileObject } from '@pnpm/lockfile.pruner';
+import type { Registries } from '@pnpm/types';
+import type { DependenciesGraph } from './index.js';
+export declare function updateLockfile({ dependenciesGraph, lockfile, prefix, registries, lockfileIncludeTarballUrl }: {
+    dependenciesGraph: DependenciesGraph;
+    lockfile: LockfileObject;
+    prefix: string;
+    registries: Registries;
+    lockfileIncludeTarballUrl?: boolean;
+}): LockfileObject;

package/lib/updateLockfile.js

@@ -0,0 +1,121 @@
+import * as dp from '@pnpm/deps.path';
+import { pruneSharedLockfile, } from '@pnpm/lockfile.pruner';
+import { toLockfileResolution } from '@pnpm/lockfile.utils';
+import { logger } from '@pnpm/logger';
+import { partition } from 'ramda';
+import { depPathToRef } from './depPathToRef.js';
+export function updateLockfile({ dependenciesGraph, lockfile, prefix, registries, lockfileIncludeTarballUrl }) {
+    lockfile.packages = lockfile.packages ?? {};
+    for (const [depPath, depNode] of Object.entries(dependenciesGraph)) {
+        const [updatedOptionalDeps, updatedDeps] = partition((child) => depNode.optionalDependencies.has(child.alias) || depNode.peerDependencies[child.alias]?.optional === true, Object.entries(depNode.children).map(([alias, depPath]) => ({ alias, depPath })));
+        lockfile.packages[depPath] = toLockfileDependency(depNode, {
+            depGraph: dependenciesGraph,
+            depPath,
+            prevSnapshot: lockfile.packages[depPath],
+            registries,
+            registry: dp.getRegistryByPackageName(registries, depNode.name),
+            updatedDeps,
+            updatedOptionalDeps,
+            lockfileIncludeTarballUrl,
+        });
+    }
+    const warn = (message) => {
+        logger.warn({ message, prefix });
+    };
+    return pruneSharedLockfile(lockfile, { warn, dependenciesGraph });
+}
+function toLockfileDependency(pkg, opts) {
+    const lockfileResolution = toLockfileResolution({ name: pkg.name, version: pkg.version }, pkg.resolution, opts.registry, opts.lockfileIncludeTarballUrl);
+    const newResolvedDeps = updateResolvedDeps(opts.updatedDeps, opts.depGraph);
+    const newResolvedOptionalDeps = updateResolvedDeps(opts.updatedOptionalDeps, opts.depGraph);
+    const result = {
+        resolution: lockfileResolution,
+    };
+    if (opts.depPath.includes(':')) {
+        // There is no guarantee that a non-npmjs.org-hosted package is going to have a version field.
+        // Also, for local directory dependencies, the version is not needed.
+        if (pkg.version &&
+            (!('type' in lockfileResolution) ||
+                lockfileResolution.type !== 'directory')) {
+            result['version'] = pkg.version;
+        }
+    }
+    if (Object.keys(newResolvedDeps).length > 0) {
+        result['dependencies'] = newResolvedDeps;
+    }
+    if (Object.keys(newResolvedOptionalDeps).length > 0) {
+        result['optionalDependencies'] = newResolvedOptionalDeps;
+    }
+    if (pkg.optional) {
+        result['optional'] = true;
+    }
+    if (pkg.transitivePeerDependencies.size) {
+        result['transitivePeerDependencies'] = Array.from(pkg.transitivePeerDependencies).sort();
+    }
+    if (Object.keys(pkg.peerDependencies ?? {}).length > 0) {
+        const peerPkgs = {};
+        const normalizedPeerDependenciesMeta = {};
+        for (const [peer, { version, optional }] of Object.entries(pkg.peerDependencies)) {
+            peerPkgs[peer] = version;
+            if (optional) {
+                normalizedPeerDependenciesMeta[peer] = { optional: true };
+            }
+        }
+        result['peerDependencies'] = peerPkgs;
+        if (Object.keys(normalizedPeerDependenciesMeta).length > 0) {
+            result['peerDependenciesMeta'] = normalizedPeerDependenciesMeta;
+        }
+    }
+    if (pkg.additionalInfo.engines != null) {
+        for (const [engine, version] of Object.entries(pkg.additionalInfo.engines)) {
+            if (version === '*')
+                continue;
+            result.engines = result.engines ?? {}; // eslint-disable-line @typescript-eslint/no-explicit-any
+            result.engines[engine] = version;
+        }
+    }
+    if (pkg.additionalInfo.cpu != null) {
+        result['cpu'] = pkg.additionalInfo.cpu;
+    }
+    if (pkg.additionalInfo.os != null) {
+        result['os'] = pkg.additionalInfo.os;
+    }
+    if (pkg.additionalInfo.libc != null) {
+        result['libc'] = pkg.additionalInfo.libc;
+    }
+    if (Array.isArray(pkg.additionalInfo.bundledDependencies) ||
+        pkg.additionalInfo.bundledDependencies === true) {
+        result['bundledDependencies'] = pkg.additionalInfo.bundledDependencies;
+    }
+    else if (Array.isArray(pkg.additionalInfo.bundleDependencies) ||
+        pkg.additionalInfo.bundleDependencies === true) {
+        result['bundledDependencies'] = pkg.additionalInfo.bundleDependencies;
+    }
+    if (pkg.additionalInfo.deprecated) {
+        result['deprecated'] = pkg.additionalInfo.deprecated;
+    }
+    if (pkg.hasBin) {
+        result['hasBin'] = true;
+    }
+    if (pkg.patch) {
+        result['patched'] = true;
+    }
+    return result;
+}
+function updateResolvedDeps(updatedDeps, depGraph) {
+    return Object.fromEntries(updatedDeps
+        .map(({ alias, depPath }) => {
+        if (depPath.startsWith('link:')) {
+            return [alias, depPath];
+        }
+        const depNode = depGraph[depPath];
+        return [
+            alias,
+            depPathToRef(depPath, {
+                alias,
+                realName: depNode.name,
+            }),
+        ];
+    }));
+}
+//# sourceMappingURL=updateLockfile.js.map

package/lib/updateProjectManifest.d.ts

@@ -0,0 +1,8 @@
+import type { ProjectManifest } from '@pnpm/types';
+import type { ImporterToResolve } from './index.js';
+import type { ResolvedDirectDependency } from './resolveDependencyTree.js';
+export declare function updateProjectManifest(importer: ImporterToResolve, opts: {
+    directDependencies: ResolvedDirectDependency[];
+    preserveWorkspaceProtocol: boolean;
+    saveWorkspaceProtocol: boolean | 'rolling';
+}): Promise<Array<ProjectManifest | undefined>>;

package/lib/updateProjectManifest.js

@@ -0,0 +1,34 @@
+import { updateProjectManifestObject, } from '@pnpm/pkg-manifest.utils';
+export async function updateProjectManifest(importer, opts) {
+    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 wantedDep = importer.wantedDependencies[index];
+        return {
+            alias: rdd.alias,
+            peer: importer.peer,
+            bareSpecifier: rdd.catalogLookup?.userSpecifiedBareSpecifier ?? rdd.normalizedBareSpecifier ?? wantedDep.bareSpecifier,
+            resolvedVersion: rdd.version,
+            pinnedVersion: importer.pinnedVersion,
+            saveType: importer.targetDependenciesField,
+        };
+    });
+    for (const pkgToInstall of importer.wantedDependencies) {
+        if (pkgToInstall.updateSpec && pkgToInstall.alias && !specsToUpsert.some(({ alias }) => alias === pkgToInstall.alias)) {
+            specsToUpsert.push({
+                alias: pkgToInstall.alias,
+                peer: importer.peer,
+                saveType: importer.targetDependenciesField,
+            });
+        }
+    }
+    const hookedManifest = await updateProjectManifestObject(importer.rootDir, importer.manifest, specsToUpsert);
+    const originalManifest = (importer.originalManifest != null)
+        ? await updateProjectManifestObject(importer.rootDir, importer.originalManifest, specsToUpsert)
+        : undefined;
+    return [hookedManifest, originalManifest];
+}
+//# sourceMappingURL=updateProjectManifest.js.map

package/lib/validatePeerDependencies.d.ts

@@ -0,0 +1,6 @@
+import type { ProjectManifest } from '@pnpm/types';
+export interface ProjectToValidate {
+    rootDir: string;
+    manifest: Pick<ProjectManifest, 'name' | 'peerDependencies'>;
+}
+export declare function validatePeerDependencies(project: ProjectToValidate): void;

package/lib/validatePeerDependencies.js

@@ -0,0 +1,15 @@
+import { isValidPeerRange } from '@pnpm/deps.peer-range';
+import { PnpmError } from '@pnpm/error';
+export function validatePeerDependencies(project) {
+    const { name, peerDependencies } = project.manifest;
+    const projectId = name ?? project.rootDir;
+    for (const depName in peerDependencies) {
+        const version = peerDependencies[depName];
+        if (!isValidPeerRange(version)) {
+            throw new PnpmError('INVALID_PEER_DEPENDENCY_SPECIFICATION', `The peerDependencies field named '${depName}' of package '${projectId}' has an invalid value: '${version}'`, {
+                hint: 'The values in peerDependencies should be either a valid semver range, a `workspace:` spec, or a `catalog:` spec',
+            });
+        }
+    }
+}
+//# sourceMappingURL=validatePeerDependencies.js.map

package/lib/wantedDepIsLocallyAvailable.d.ts

@@ -0,0 +1,6 @@
+import type { WorkspacePackages } from '@pnpm/resolving.resolver-base';
+import type { WantedDependency } from './getNonDevWantedDependencies.js';
+export declare function wantedDepIsLocallyAvailable(workspacePackages: WorkspacePackages, wantedDependency: WantedDependency, opts: {
+    defaultTag: string;
+    registry: string;
+}): boolean;

package/lib/wantedDepIsLocallyAvailable.js

@@ -0,0 +1,23 @@
+import { parseBareSpecifier } from '@pnpm/resolving.npm-resolver';
+import semver from 'semver';
+export function wantedDepIsLocallyAvailable(workspacePackages, wantedDependency, opts) {
+    const spec = parseBareSpecifier(wantedDependency.bareSpecifier, wantedDependency.alias, opts.defaultTag || 'latest', opts.registry);
+    if ((spec == null) || !workspacePackages.has(spec.name))
+        return false;
+    return pickMatchingLocalVersionOrNull(workspacePackages.get(spec.name), spec) !== null;
+}
+// TODO: move this function to separate package or import from @pnpm/resolving.npm-resolver
+function pickMatchingLocalVersionOrNull(versions, spec) {
+    const localVersions = Array.from(versions.keys());
+    switch (spec.type) {
+        case 'tag':
+            return semver.maxSatisfying(localVersions, '*');
+        case 'version':
+            return versions.has(spec.fetchSpec) ? spec.fetchSpec : null;
+        case 'range':
+            return semver.maxSatisfying(localVersions, spec.fetchSpec, true);
+        default:
+            return null;
+    }
+}
+//# sourceMappingURL=wantedDepIsLocallyAvailable.js.map

package/package.json

@@ -0,0 +1,91 @@
+{
+  "name": "@pnpm/installing.deps-resolver",
+  "version": "1008.3.1",
+  "description": "Resolves dependency graph of a package",
+  "keywords": [
+    "pnpm",
+    "pnpm11"
+  ],
+  "license": "MIT",
+  "funding": "https://opencollective.com/pnpm",
+  "repository": "https://github.com/pnpm/pnpm/tree/main/installing/deps-resolver",
+  "homepage": "https://github.com/pnpm/pnpm/tree/main/installing/deps-resolver#readme",
+  "bugs": {
+    "url": "https://github.com/pnpm/pnpm/issues"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": "./lib/index.js"
+  },
+  "files": [
+    "lib",
+    "!*.map"
+  ],
+  "dependencies": {
+    "@pnpm/util.lex-comparator": "^3.0.2",
+    "@yarnpkg/core": "4.2.0",
+    "filenamify": "^6.0.0",
+    "graph-cycles": "3.0.0",
+    "is-inner-link": "^5.0.0",
+    "is-subdir": "^2.0.0",
+    "normalize-path": "^3.0.0",
+    "p-defer": "^4.0.1",
+    "path-exists": "^5.0.0",
+    "promise-share": "^2.0.0",
+    "ramda": "npm:@pnpm/ramda@0.28.1",
+    "rename-overwrite": "^7.0.0",
+    "safe-promise-defer": "^2.0.0",
+    "semver": "^7.7.2",
+    "semver-range-intersect": "^0.3.1",
+    "version-selector-type": "^3.0.0",
+    "@pnpm/catalogs.resolver": "1000.0.5",
+    "@pnpm/catalogs.types": "1000.0.0",
+    "@pnpm/config.version-policy": "1000.0.0",
+    "@pnpm/constants": "1001.3.1",
+    "@pnpm/core-loggers": "1001.0.4",
+    "@pnpm/deps.peer-range": "1000.0.0",
+    "@pnpm/deps.path": "1001.1.3",
+    "@pnpm/fetching.pick-fetcher": "1001.0.0",
+    "@pnpm/deps.graph-hasher": "1002.0.8",
+    "@pnpm/error": "1000.0.5",
+    "@pnpm/lockfile.preferred-versions": "1000.0.22",
+    "@pnpm/lockfile.types": "1002.0.2",
+    "@pnpm/hooks.types": "1001.0.12",
+    "@pnpm/lockfile.pruner": "1001.0.17",
+    "@pnpm/lockfile.utils": "1003.0.3",
+    "@pnpm/patching.config": "1001.0.11",
+    "@pnpm/patching.types": "1000.1.0",
+    "@pnpm/pkg-manifest.utils": "1001.0.6",
+    "@pnpm/resolving.npm-resolver": "1004.4.1",
+    "@pnpm/pkg-manifest.reader": "1000.1.2",
+    "@pnpm/store.controller-types": "1004.1.0",
+    "@pnpm/types": "1000.9.0",
+    "@pnpm/workspace.spec-parser": "1000.0.0",
+    "@pnpm/resolving.resolver-base": "1005.1.0"
+  },
+  "peerDependencies": {
+    "@pnpm/logger": ">=1001.0.0 <1002.0.0"
+  },
+  "devDependencies": {
+    "@types/normalize-path": "^3.0.2",
+    "@types/ramda": "0.29.12",
+    "@types/semver": "7.7.1",
+    "@pnpm/installing.deps-resolver": "1008.3.1",
+    "@pnpm/logger": "1001.0.1"
+  },
+  "engines": {
+    "node": ">=22.13"
+  },
+  "jest": {
+    "preset": "@pnpm/jest-config"
+  },
+  "scripts": {
+    "start": "tsgo --watch",
+    "test": "pnpm run compile && pnpm run _test",
+    "lint": "eslint \"src/**/*.ts\" \"test/**/*.ts\"",
+    "compile": "tsgo --build && pnpm run lint --fix",
+    "_test": "cross-env NODE_OPTIONS=\"$NODE_OPTIONS --experimental-vm-modules --disable-warning=ExperimentalWarning --disable-warning=DEP0169\" jest"
+  }
+}