@pnpm/workspace.projects-filter 1000.0.43

package/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-2016 Rico Sta. Cruz and other contributors
+Copyright (c) 2016-2026 Zoltan Kochan and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,15 @@
+# @pnpm/filter-workspace-packages
+
+> Filters packages in a workspace
+
+[![npm version](https://img.shields.io/npm/v/@pnpm/filter-workspace-packages.svg)](https://www.npmjs.com/package/@pnpm/filter-workspace-packages)
+
+## Installation
+
+```sh
+pnpm add @pnpm/filter-workspace-packages
+```
+
+## License
+
+MIT

package/lib/filterProjectsFromDir.d.ts

@@ -0,0 +1,8 @@
+import type { SupportedArchitectures } from '@pnpm/types';
+import { type ProjectSelector, type ReadProjectsResult } from './index.js';
+export declare function filterProjectsBySelectorObjectsFromDir(workspaceDir: string, projectSelectors: ProjectSelector[], opts?: {
+    engineStrict?: boolean;
+    linkWorkspacePackages?: boolean;
+    changedFilesIgnorePattern?: string[];
+    supportedArchitectures?: SupportedArchitectures;
+}): Promise<ReadProjectsResult>;

package/lib/filterProjectsFromDir.js

@@ -0,0 +1,22 @@
+import { findWorkspaceProjects } from '@pnpm/workspace.projects-reader';
+import { readWorkspaceManifest } from '@pnpm/workspace.workspace-manifest-reader';
+import { filterProjectsBySelectorObjects } from './index.js';
+export async function filterProjectsBySelectorObjectsFromDir(workspaceDir, projectSelectors, opts) {
+    const workspaceManifest = await readWorkspaceManifest(workspaceDir);
+    const allProjects = await findWorkspaceProjects(workspaceDir, {
+        patterns: workspaceManifest?.packages,
+        engineStrict: opts?.engineStrict,
+        supportedArchitectures: opts?.supportedArchitectures ?? {
+            os: ['current'],
+            cpu: ['current'],
+            libc: ['current'],
+        },
+    });
+    const { allProjectsGraph, selectedProjectsGraph } = await filterProjectsBySelectorObjects(allProjects, projectSelectors, {
+        linkWorkspacePackages: opts?.linkWorkspacePackages,
+        workspaceDir,
+        changedFilesIgnorePattern: opts?.changedFilesIgnorePattern,
+    });
+    return { allProjects, allProjectsGraph, selectedProjectsGraph };
+}
+//# sourceMappingURL=filterProjectsFromDir.js.map

package/lib/getChangedProjects.d.ts

@@ -0,0 +1,6 @@
+import type { ProjectRootDir } from '@pnpm/types';
+export declare function getChangedProjects(projectDirs: ProjectRootDir[], commit: string, opts: {
+    workspaceDir: string;
+    testPattern?: string[];
+    changedFilesIgnorePattern?: string[];
+}): Promise<[ProjectRootDir[], ProjectRootDir[]]>;

package/lib/getChangedProjects.js

@@ -0,0 +1,84 @@
+import assert from 'node:assert';
+import path from 'node:path';
+import util from 'node:util';
+import { PnpmError } from '@pnpm/error';
+import { safeExeca as execa } from 'execa';
+import { findUp } from 'find-up';
+import * as micromatch from 'micromatch';
+export async function getChangedProjects(projectDirs, commit, opts) {
+    // .git is a directory in regular repos, but a file in worktrees
+    const gitPath = await findUp('.git', { cwd: opts.workspaceDir, type: 'directory' }) ??
+        await findUp('.git', { cwd: opts.workspaceDir, type: 'file' });
+    const repoRoot = path.resolve(gitPath ?? opts.workspaceDir, '..');
+    const changedDirs = (await getChangedDirsSinceCommit(commit, opts.workspaceDir, opts.testPattern ?? [], opts.changedFilesIgnorePattern ?? []))
+        .map(changedDir => ({ ...changedDir, dir: path.join(repoRoot, changedDir.dir) }));
+    const projectChangeTypes = new Map();
+    for (const projectDir of projectDirs) {
+        projectChangeTypes.set(projectDir, undefined);
+    }
+    for (const changedDir of changedDirs) {
+        let currentDir = changedDir.dir;
+        while (!projectChangeTypes.has(currentDir)) {
+            const nextDir = path.dirname(currentDir);
+            if (nextDir === currentDir)
+                break;
+            currentDir = nextDir;
+        }
+        if (projectChangeTypes.get(currentDir) === 'source')
+            continue;
+        projectChangeTypes.set(currentDir, changedDir.changeType);
+    }
+    const changedProjects = [];
+    const ignoreDependentForPkgs = [];
+    for (const [changedDir, changeType] of projectChangeTypes.entries()) {
+        switch (changeType) {
+            case 'source':
+                changedProjects.push(changedDir);
+                break;
+            case 'test':
+                ignoreDependentForPkgs.push(changedDir);
+                break;
+        }
+    }
+    return [changedProjects, ignoreDependentForPkgs];
+}
+async function getChangedDirsSinceCommit(commit, workingDir, testPattern, changedFilesIgnorePattern) {
+    let diff;
+    try {
+        diff = (await execa('git', [
+            'diff',
+            '--name-only',
+            commit,
+            '--',
+            workingDir,
+        ], { cwd: workingDir })).stdout;
+    }
+    catch (err) {
+        assert(util.types.isNativeError(err));
+        throw new PnpmError('FILTER_CHANGED', `Filtering by changed packages failed. ${'stderr' in err ? err.stderr : ''}`);
+    }
+    const changedDirs = new Map();
+    if (!diff) {
+        return [];
+    }
+    const allChangedFiles = diff.split('\n')
+        // The prefix and suffix '"' are appended to the Korean path
+        .map(line => line.replace(/^"/, '').replace(/"$/, ''));
+    const patterns = changedFilesIgnorePattern.filter((pattern) => pattern.length);
+    const changedFiles = (patterns.length > 0)
+        ? micromatch.default.not(allChangedFiles, patterns, {
+            dot: true,
+        })
+        : allChangedFiles;
+    for (const changedFile of changedFiles) {
+        const dir = path.dirname(changedFile);
+        if (changedDirs.get(dir) === 'source')
+            continue;
+        const changeType = testPattern.some(pattern => micromatch.default.isMatch(changedFile, pattern))
+            ? 'test'
+            : 'source';
+        changedDirs.set(dir, changeType);
+    }
+    return Array.from(changedDirs.entries()).map(([dir, changeType]) => ({ dir, changeType }));
+}
+//# sourceMappingURL=getChangedProjects.js.map

package/lib/index.d.ts

@@ -0,0 +1,62 @@
+import type { ProjectRootDir, SupportedArchitectures } from '@pnpm/types';
+import { type BaseProject, type ProjectGraphNode } from '@pnpm/workspace.projects-graph';
+import { type Project } from '@pnpm/workspace.projects-reader';
+import { filterProjectsBySelectorObjectsFromDir } from './filterProjectsFromDir.js';
+import { parseProjectSelector, type ProjectSelector } from './parseProjectSelector.js';
+export { filterProjectsBySelectorObjectsFromDir, parseProjectSelector, type ProjectSelector };
+export interface WorkspaceFilter {
+    filter: string;
+    followProdDepsOnly: boolean;
+}
+export interface ProjectGraph<Pkg extends BaseProject> {
+    [id: ProjectRootDir]: ProjectGraphNode<Pkg>;
+}
+export interface ReadProjectsResult {
+    allProjects: Project[];
+    allProjectsGraph: ProjectGraph<Project>;
+    selectedProjectsGraph: ProjectGraph<Project>;
+}
+export interface FilterProjectsOptions {
+    linkWorkspacePackages?: boolean;
+    prefix: string;
+    workspaceDir: string;
+    testPattern?: string[];
+    changedFilesIgnorePattern?: string[];
+    useGlobDirFiltering?: boolean;
+    sharedWorkspaceLockfile?: boolean;
+}
+export interface FilterProjectsFromDirResult extends FilterProjectsResult<Project> {
+    allProjects: Project[];
+}
+export declare function filterProjectsFromDir(workspaceDir: string, filter: WorkspaceFilter[], opts: FilterProjectsOptions & {
+    engineStrict?: boolean;
+    nodeVersion?: string;
+    patterns?: string[];
+    supportedArchitectures?: SupportedArchitectures;
+}): Promise<FilterProjectsFromDirResult>;
+export interface FilterProjectsResult<Pkg extends BaseProject> {
+    allProjectsGraph: ProjectGraph<Pkg>;
+    selectedProjectsGraph: ProjectGraph<Pkg>;
+    unmatchedFilters: string[];
+}
+export declare function filterProjects<Pkg extends BaseProject>(projects: Pkg[], filter: WorkspaceFilter[], opts: FilterProjectsOptions): Promise<FilterProjectsResult<Pkg>>;
+export declare function filterProjectsBySelectorObjects<Pkg extends BaseProject>(projects: Pkg[], projectSelectors: ProjectSelector[], opts: {
+    linkWorkspacePackages?: boolean;
+    workspaceDir: string;
+    testPattern?: string[];
+    changedFilesIgnorePattern?: string[];
+    useGlobDirFiltering?: boolean;
+}): Promise<{
+    allProjectsGraph: ProjectGraph<Pkg>;
+    selectedProjectsGraph: ProjectGraph<Pkg>;
+    unmatchedFilters: string[];
+}>;
+export declare function filterWorkspaceProjects<Pkg extends BaseProject>(projectsGraph: ProjectGraph<Pkg>, projectSelectors: ProjectSelector[], opts: {
+    workspaceDir: string;
+    testPattern?: string[];
+    changedFilesIgnorePattern?: string[];
+    useGlobDirFiltering?: boolean;
+}): Promise<{
+    selectedProjectsGraph: ProjectGraph<Pkg>;
+    unmatchedFilters: string[];
+}>;

package/lib/index.js

@@ -0,0 +1,202 @@
+import { createMatcher } from '@pnpm/config.matcher';
+import { createProjectsGraph } from '@pnpm/workspace.projects-graph';
+import { findWorkspaceProjects } from '@pnpm/workspace.projects-reader';
+import { isSubdir } from 'is-subdir';
+import * as micromatch from 'micromatch';
+import { difference, partition, pick } from 'ramda';
+import { filterProjectsBySelectorObjectsFromDir } from './filterProjectsFromDir.js';
+import { getChangedProjects } from './getChangedProjects.js';
+import { parseProjectSelector } from './parseProjectSelector.js';
+export { filterProjectsBySelectorObjectsFromDir, parseProjectSelector };
+export async function filterProjectsFromDir(workspaceDir, filter, opts) {
+    const allProjects = await findWorkspaceProjects(workspaceDir, {
+        engineStrict: opts?.engineStrict,
+        patterns: opts.patterns,
+        sharedWorkspaceLockfile: opts.sharedWorkspaceLockfile,
+        nodeVersion: opts.nodeVersion,
+        supportedArchitectures: opts.supportedArchitectures,
+    });
+    return {
+        allProjects,
+        ...(await filterProjects(allProjects, filter, opts)),
+    };
+}
+export async function filterProjects(projects, filter, opts) {
+    const projectSelectors = filter.map(({ filter: f, followProdDepsOnly }) => ({ ...parseProjectSelector(f, opts.prefix), followProdDepsOnly }));
+    return filterProjectsBySelectorObjects(projects, projectSelectors, opts);
+}
+export async function filterProjectsBySelectorObjects(projects, projectSelectors, opts) {
+    const [prodProjectSelectors, allProjectSelectors] = partition(({ followProdDepsOnly }) => !!followProdDepsOnly, projectSelectors);
+    if ((allProjectSelectors.length > 0) || (prodProjectSelectors.length > 0)) {
+        let filteredGraph;
+        const { graph } = createProjectsGraph(projects, { linkWorkspacePackages: opts.linkWorkspacePackages });
+        if (allProjectSelectors.length > 0) {
+            filteredGraph = await filterWorkspaceProjects(graph, allProjectSelectors, {
+                workspaceDir: opts.workspaceDir,
+                testPattern: opts.testPattern,
+                changedFilesIgnorePattern: opts.changedFilesIgnorePattern,
+                useGlobDirFiltering: opts.useGlobDirFiltering,
+            });
+        }
+        let prodFilteredGraph;
+        if (prodProjectSelectors.length > 0) {
+            const { graph } = createProjectsGraph(projects, { ignoreDevDeps: true, linkWorkspacePackages: opts.linkWorkspacePackages });
+            prodFilteredGraph = await filterWorkspaceProjects(graph, prodProjectSelectors, {
+                workspaceDir: opts.workspaceDir,
+                testPattern: opts.testPattern,
+                changedFilesIgnorePattern: opts.changedFilesIgnorePattern,
+                useGlobDirFiltering: opts.useGlobDirFiltering,
+            });
+        }
+        return {
+            allProjectsGraph: graph,
+            selectedProjectsGraph: {
+                ...prodFilteredGraph?.selectedProjectsGraph,
+                ...filteredGraph?.selectedProjectsGraph,
+            },
+            unmatchedFilters: [
+                ...(prodFilteredGraph !== undefined ? prodFilteredGraph.unmatchedFilters : []),
+                ...(filteredGraph !== undefined ? filteredGraph.unmatchedFilters : []),
+            ],
+        };
+    }
+    else {
+        const { graph } = createProjectsGraph(projects, { linkWorkspacePackages: opts.linkWorkspacePackages });
+        return { allProjectsGraph: graph, selectedProjectsGraph: graph, unmatchedFilters: [] };
+    }
+}
+export async function filterWorkspaceProjects(projectsGraph, projectSelectors, opts) {
+    const [excludeSelectors, includeSelectors] = partition((selector) => selector.exclude === true, projectSelectors);
+    const fg = _filterGraph.bind(null, projectsGraph, opts);
+    const include = includeSelectors.length === 0
+        ? { selected: Object.keys(projectsGraph), unmatchedFilters: [] }
+        : await fg(includeSelectors);
+    const exclude = await fg(excludeSelectors);
+    return {
+        selectedProjectsGraph: pick(difference(include.selected, exclude.selected), projectsGraph),
+        unmatchedFilters: [...include.unmatchedFilters, ...exclude.unmatchedFilters],
+    };
+}
+async function _filterGraph(projectsGraph, opts, projectSelectors) {
+    const cherryPickedProjects = [];
+    const walkedDependencies = new Set();
+    const walkedDependents = new Set();
+    const walkedDependentsDependencies = new Set();
+    const graph = projectsGraphToGraph(projectsGraph);
+    const unmatchedFilters = [];
+    let reversedGraph;
+    const matchProjectsByPath = opts.useGlobDirFiltering === true
+        ? matchProjectsByGlob
+        : matchProjectsByExactPath;
+    for (const selector of projectSelectors) {
+        let entryProjects = null;
+        if (selector.diff) {
+            let ignoreDependentForProjects = [];
+            [entryProjects, ignoreDependentForProjects] = await getChangedProjects(Object.keys(projectsGraph), selector.diff, {
+                changedFilesIgnorePattern: opts.changedFilesIgnorePattern,
+                testPattern: opts.testPattern,
+                workspaceDir: selector.parentDir ?? opts.workspaceDir,
+            });
+            selectEntries({
+                ...selector,
+                includeDependents: false,
+            }, ignoreDependentForProjects);
+        }
+        else if (selector.parentDir) {
+            entryProjects = matchProjectsByPath(projectsGraph, selector.parentDir);
+        }
+        if (selector.namePattern) {
+            if (entryProjects == null) {
+                entryProjects = matchProjects(projectsGraph, selector.namePattern);
+            }
+            else {
+                entryProjects = matchProjects(pick(entryProjects, projectsGraph), selector.namePattern);
+            }
+        }
+        if (entryProjects == null) {
+            throw new Error(`Unsupported project selector: ${JSON.stringify(selector)}`);
+        }
+        if (entryProjects.length === 0) {
+            if (selector.namePattern) {
+                unmatchedFilters.push(selector.namePattern);
+            }
+            if (selector.parentDir) {
+                unmatchedFilters.push(selector.parentDir);
+            }
+        }
+        selectEntries(selector, entryProjects);
+    }
+    const walked = new Set([...walkedDependencies, ...walkedDependents, ...walkedDependentsDependencies]);
+    cherryPickedProjects.forEach((cherryPickedProject) => walked.add(cherryPickedProject));
+    return {
+        selected: Array.from(walked),
+        unmatchedFilters,
+    };
+    function selectEntries(selector, entryProjects) {
+        if (selector.includeDependencies) {
+            pickSubgraph(graph, entryProjects, walkedDependencies, { includeRoot: !selector.excludeSelf });
+        }
+        if (selector.includeDependents) {
+            if (reversedGraph == null) {
+                reversedGraph = reverseGraph(graph);
+            }
+            pickSubgraph(reversedGraph, entryProjects, walkedDependents, { includeRoot: !selector.excludeSelf });
+        }
+        if (selector.includeDependencies && selector.includeDependents) {
+            pickSubgraph(graph, Array.from(walkedDependents), walkedDependentsDependencies, { includeRoot: false });
+        }
+        if (!selector.includeDependencies && !selector.includeDependents) {
+            cherryPickedProjects.push(...entryProjects);
+        }
+    }
+}
+function projectsGraphToGraph(projectsGraph) {
+    const graph = {};
+    for (const nodeId of Object.keys(projectsGraph)) {
+        graph[nodeId] = projectsGraph[nodeId].dependencies;
+    }
+    return graph;
+}
+function reverseGraph(graph) {
+    const reversedGraph = {};
+    for (const dependentNodeId of Object.keys(graph)) {
+        for (const dependencyNodeId of graph[dependentNodeId]) {
+            if (!reversedGraph[dependencyNodeId]) {
+                reversedGraph[dependencyNodeId] = [dependentNodeId];
+            }
+            else {
+                reversedGraph[dependencyNodeId].push(dependentNodeId);
+            }
+        }
+    }
+    return reversedGraph;
+}
+function matchProjects(graph, pattern) {
+    const match = createMatcher(pattern);
+    const matches = Object.keys(graph).filter((id) => graph[id].package.manifest.name && match(graph[id].package.manifest.name));
+    if (matches.length === 0 && !(pattern[0] === '@') && !pattern.includes('/')) {
+        const scopedMatches = matchProjects(graph, `@*/${pattern}`);
+        return scopedMatches.length !== 1 ? [] : scopedMatches;
+    }
+    return matches;
+}
+function matchProjectsByExactPath(graph, pathStartsWith) {
+    return Object.keys(graph).filter((parentDir) => isSubdir(pathStartsWith, parentDir));
+}
+function matchProjectsByGlob(graph, pathStartsWith) {
+    const format = (str) => str.replace(/\/$/, '');
+    const formattedFilter = pathStartsWith.replace(/\\/g, '/').replace(/\/$/, '');
+    return Object.keys(graph).filter((parentDir) => micromatch.default.isMatch(parentDir, formattedFilter, { format }));
+}
+function pickSubgraph(graph, nextNodeIds, walked, opts) {
+    for (const nextNodeId of nextNodeIds) {
+        if (!walked.has(nextNodeId)) {
+            if (opts.includeRoot) {
+                walked.add(nextNodeId);
+            }
+            if (graph[nextNodeId])
+                pickSubgraph(graph, graph[nextNodeId], walked, { includeRoot: true });
+        }
+    }
+}
+//# sourceMappingURL=index.js.map

package/lib/parseProjectSelector.d.ts

@@ -0,0 +1,11 @@
+export interface ProjectSelector {
+    diff?: string;
+    exclude?: boolean;
+    excludeSelf?: boolean;
+    includeDependencies?: boolean;
+    includeDependents?: boolean;
+    namePattern?: string;
+    parentDir?: string;
+    followProdDepsOnly?: boolean;
+}
+export declare function parseProjectSelector(rawSelector: string, prefix: string): ProjectSelector;

package/lib/parseProjectSelector.js

@@ -0,0 +1,62 @@
+import path from 'node:path';
+export function parseProjectSelector(rawSelector, prefix) {
+    let exclude = false;
+    if (rawSelector[0] === '!') {
+        exclude = true;
+        rawSelector = rawSelector.substring(1);
+    }
+    let excludeSelf = false;
+    const includeDependencies = rawSelector.endsWith('...');
+    if (includeDependencies) {
+        rawSelector = rawSelector.slice(0, -3);
+        if (rawSelector.endsWith('^')) {
+            excludeSelf = true;
+            rawSelector = rawSelector.slice(0, -1);
+        }
+    }
+    const includeDependents = rawSelector.startsWith('...');
+    if (includeDependents) {
+        rawSelector = rawSelector.substring(3);
+        if (rawSelector[0] === '^') {
+            excludeSelf = true;
+            rawSelector = rawSelector.slice(1);
+        }
+    }
+    const matches = rawSelector.match(/^([^.][^{}[\]]*)?(\{[^}]+\})?(\[[^\]]+\])?$/);
+    if (matches === null) {
+        if (isSelectorByLocation(rawSelector)) {
+            return {
+                exclude,
+                excludeSelf: false,
+                parentDir: path.join(prefix, rawSelector),
+            };
+        }
+        return {
+            excludeSelf: false,
+            namePattern: rawSelector,
+        };
+    }
+    return {
+        diff: matches[3]?.slice(1, -1),
+        exclude,
+        excludeSelf,
+        includeDependencies,
+        includeDependents,
+        namePattern: matches[1],
+        parentDir: matches[2] && path.join(prefix, matches[2].slice(1, -1)),
+    };
+}
+function isSelectorByLocation(rawSelector) {
+    if (rawSelector[0] !== '.')
+        return false;
+    // . or ./ or .\
+    if (rawSelector.length === 1 || rawSelector[1] === '/' || rawSelector[1] === '\\')
+        return true;
+    if (rawSelector[1] !== '.')
+        return false;
+    // .. or ../ or ..\
+    return (rawSelector.length === 2 ||
+        rawSelector[2] === '/' ||
+        rawSelector[2] === '\\');
+}
+//# sourceMappingURL=parseProjectSelector.js.map

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@pnpm/workspace.projects-filter",
+  "version": "1000.0.43",
+  "description": "Filters packages in a workspace",
+  "keywords": [
+    "pnpm",
+    "pnpm11"
+  ],
+  "license": "MIT",
+  "funding": "https://opencollective.com/pnpm",
+  "repository": "https://github.com/pnpm/pnpm/tree/main/workspace/projects-filter",
+  "homepage": "https://github.com/pnpm/pnpm/tree/main/workspace/projects-filter#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": {
+    "execa": "npm:safe-execa@0.3.0",
+    "find-up": "^7.0.0",
+    "is-subdir": "^2.0.0",
+    "micromatch": "^4.0.8",
+    "ramda": "npm:@pnpm/ramda@0.28.1",
+    "@pnpm/config.matcher": "1000.1.0",
+    "@pnpm/error": "1000.0.5",
+    "@pnpm/workspace.projects-reader": "1000.0.43",
+    "@pnpm/workspace.workspace-manifest-reader": "1000.2.5",
+    "@pnpm/workspace.projects-graph": "1000.0.25"
+  },
+  "devDependencies": {
+    "@types/is-windows": "^1.0.2",
+    "@types/micromatch": "^4.0.9",
+    "@types/ramda": "0.29.12",
+    "@types/touch": "^3.1.5",
+    "ci-info": "^4.3.0",
+    "is-windows": "^1.0.2",
+    "tempy": "3.0.0",
+    "touch": "3.1.0",
+    "@pnpm/types": "1000.9.0",
+    "@pnpm/workspace.projects-filter": "1000.0.43"
+  },
+  "engines": {
+    "node": ">=22.13"
+  },
+  "jest": {
+    "preset": "@pnpm/jest-config"
+  },
+  "scripts": {
+    "lint": "eslint \"src/**/*.ts\" \"test/**/*.ts\"",
+    "_test": "cross-env NODE_OPTIONS=\"$NODE_OPTIONS --experimental-vm-modules --disable-warning=ExperimentalWarning --disable-warning=DEP0169\" jest",
+    "test": "pnpm run compile && pnpm run _test",
+    "compile": "tsgo --build && pnpm run lint --fix"
+  }
+}