migrate-barrel-imports 0.0.0

package/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Martin Brandhaug <martin@brandhaug.net> (https://brandhaug.net)
+
+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,63 @@
+# migrate-barrel-imports
+
+A CLI tool to migrate barrel imports in JavaScript/TypeScript monorepos.
+
+Inspired by [Please Stop Using Barrel Files](https://tkdodo.eu/blog/please-stop-using-barrel-files)
+
+```typescript
+// Before 
+import { foo, bar } from '@repo/package';
+
+// After
+import { foo } from '@repo/package/src/foo';
+import { bar } from '@repo/package/src/bar';
+```
+
+## Usage
+
+Install the tool globally using npm:
+
+```bash
+npm install -g migrate-barrel-imports
+migrate-barrel-imports <source-path> [target-path] [options]
+```
+
+Or use it directly with npx:
+
+```bash
+npx migrate-barrel-imports <source-path> [target-path] [options]
+```
+
+### Arguments
+
+- `source-path`: Path to the package containing barrel files (required)
+- `target-path`: Path to the directory where imports should be migrated (default: current directory)
+
+### Options
+
+Options can be specified either before or after the arguments:
+
+- `--ignore-source-files <patterns>`: Comma-separated list of file patterns to ignore in source directory
+- `--ignore-target-files <patterns>`: Comma-separated list of file patterns to ignore in target directory
+- `--no-extension`: Exclude `js|jsx|ts|tsx|mjs|cjs` file extensions from import statements
+
+## Example
+
+```bash
+# Options after arguments
+migrate-barrel-imports ./packages/my-lib --ignore-source-files "**/__tests__/**,**/__mocks__/**" --ignore-target-files "**/*.test.ts"
+
+# Options before arguments
+migrate-barrel-imports --no-extension ./packages/my-lib .
+
+# Mix of options before and after arguments
+migrate-barrel-imports --no-extension ./packages/my-lib --ignore-target-files "**/*.test.ts"
+```
+
+## Contributing
+
+Contributions are welcome! Feel free to open an issue or submit a pull request on GitHub.
+
+## License
+
+This project is licensed under the MIT License.

package/dist/index.js

@@ -0,0 +1,466 @@
+#!/usr/bin/env node
+import {Command as $cUHbR$Command} from "commander";
+import {readFileSync as $cUHbR$readFileSync, writeFileSync as $cUHbR$writeFileSync} from "node:fs";
+import $cUHbR$nodepath, {join as $cUHbR$join} from "node:path";
+import $cUHbR$babelgenerator from "@babel/generator";
+import {parse as $cUHbR$parse} from "@babel/parser";
+import $cUHbR$babeltraverse from "@babel/traverse";
+import {isVariableDeclaration as $cUHbR$isVariableDeclaration, isIdentifier as $cUHbR$isIdentifier, isExportSpecifier as $cUHbR$isExportSpecifier, isFunctionDeclaration as $cUHbR$isFunctionDeclaration, isImportSpecifier as $cUHbR$isImportSpecifier, importDeclaration as $cUHbR$importDeclaration, importSpecifier as $cUHbR$importSpecifier, stringLiteral as $cUHbR$stringLiteral} from "@babel/types";
+import $cUHbR$fastglob from "fast-glob";
+import $cUHbR$micromatch from "micromatch";
+
+
+/**
+ * @fileoverview Tool for migrating TypeScript projects from barrel file exports to direct file imports
+ *
+ * This tool helps migrate TypeScript projects that use barrel files (index.ts files that re-export)
+ * to use direct imports from source files instead. This improves:
+ * - Tree-shaking efficiency
+ * - Build performance
+ * - Code maintainability
+ * - TypeScript compilation speed
+ *
+ * The migration process:
+ * 1. Scans source package for all exports
+ * 2. Finds all files importing from the package
+ * 3. Updates imports to point directly to source files
+ * 4. Preserves original import names and types
+ */ 
+
+
+
+
+
+
+
+/**
+ * Reads and parses the package.json file for a given package path
+ *
+ * @param {string} packagePath - The path to the package directory
+ * @returns {Promise<PackageJson>} The parsed package.json contents
+ * @throws {Error} If package.json cannot be read or parsed
+ */ async function $1d95f64f52ade133$var$getPackageInfo(packagePath) {
+    const packageJsonPath = (0, $cUHbR$join)(packagePath, 'package.json');
+    const content = (0, $cUHbR$readFileSync)(packageJsonPath, 'utf-8');
+    return JSON.parse(content);
+}
+/**
+ * Recursively finds all exports in a package by scanning all TypeScript files
+ *
+ * This function:
+ * 1. Scans all .ts and .tsx files in the package
+ * 2. Identifies both named exports and default exports
+ * 3. Skips re-exports to avoid circular dependencies
+ * 4. Filters out ignored files based on patterns
+ *
+ * @param {FindExportsParams} params - Parameters for finding exports
+ * @returns {Promise<ExportInfo[]>} Array of export information, including source file and exported names
+ */ async function $1d95f64f52ade133$var$findExports({ packagePath: packagePath, ignoreSourceFiles: ignoreSourceFiles = [], stats: stats }) {
+    const exports = [];
+    console.log(`Scanning for TypeScript files in: ${packagePath}`);
+    const allFiles = await (0, $cUHbR$fastglob)('**/*.{ts,tsx}', {
+        cwd: packagePath,
+        ignore: [
+            '**/node_modules/**',
+            '**/dist/**',
+            '**/build/**'
+        ]
+    });
+    console.log(`Found ${allFiles.length} TypeScript files`);
+    for (const file of allFiles){
+        // Mark files that match ignore patterns but still process them
+        const isIgnored = ignoreSourceFiles.some((pattern)=>(0, $cUHbR$micromatch).isMatch(file, pattern));
+        if (isIgnored) {
+            console.log(`File matches ignore pattern but will be preserved: ${file}`);
+            if (stats) stats.sourceFilesSkipped++;
+        }
+        const fullPath = (0, $cUHbR$join)(packagePath, file);
+        console.log(`\nProcessing file: ${file}`);
+        const content = (0, $cUHbR$readFileSync)(fullPath, 'utf-8');
+        try {
+            const ast = (0, $cUHbR$parse)(content, {
+                sourceType: 'module',
+                plugins: [
+                    'typescript',
+                    'jsx',
+                    'decorators-legacy',
+                    'classProperties',
+                    'classPrivateProperties',
+                    'classPrivateMethods',
+                    'exportDefaultFrom',
+                    'exportNamespaceFrom',
+                    'functionBind',
+                    'functionSent',
+                    'dynamicImport',
+                    'nullishCoalescingOperator',
+                    'optionalChaining',
+                    'objectRestSpread',
+                    'asyncGenerators',
+                    'doExpressions',
+                    'importMeta',
+                    'logicalAssignment',
+                    'moduleBlocks',
+                    'moduleStringNames',
+                    'numericSeparator',
+                    'partialApplication',
+                    'privateIn',
+                    'throwExpressions',
+                    'topLevelAwait'
+                ]
+            });
+            (0, $cUHbR$babeltraverse)(ast, {
+                ExportNamedDeclaration (path) {
+                    console.log(`Found named export in ${file}`);
+                    // Skip exports from other files (we only want direct exports)
+                    if (path.node.source) {
+                        console.log(`Skipping re-export from ${path.node.source.value}`);
+                        return;
+                    }
+                    // Handle variable declarations with exports
+                    if (path.node.declaration) {
+                        if ($cUHbR$isVariableDeclaration(path.node.declaration)) {
+                            const declarations = path.node.declaration.declarations;
+                            const namedExports = declarations.map((d)=>{
+                                if ($cUHbR$isIdentifier(d.id)) return d.id.name;
+                                return null;
+                            }).filter((name)=>name !== null);
+                            if (namedExports.length > 0) {
+                                console.log(`Named exports found: ${namedExports.join(', ')}`);
+                                exports.push({
+                                    source: file,
+                                    exports: namedExports,
+                                    isIgnored: isIgnored
+                                });
+                            }
+                        }
+                        return;
+                    }
+                    // Handle export specifiers
+                    const namedExports = path.node.specifiers.map((s)=>{
+                        if ($cUHbR$isExportSpecifier(s)) {
+                            const exported = s.exported;
+                            return $cUHbR$isIdentifier(exported) ? exported.name : exported.value;
+                        }
+                        return null;
+                    }).filter((name)=>name !== null);
+                    if (namedExports.length > 0) {
+                        console.log(`Named exports found: ${namedExports.join(', ')}`);
+                        exports.push({
+                            source: file,
+                            exports: namedExports,
+                            isIgnored: isIgnored
+                        });
+                    }
+                },
+                ExportDefaultDeclaration (path) {
+                    console.log(`Found default export in ${file}`);
+                    const exported = path.node.declaration;
+                    if ($cUHbR$isIdentifier(exported)) {
+                        console.log(`Default export name: ${exported.name}`);
+                        exports.push({
+                            source: file,
+                            exports: [
+                                exported.name
+                            ],
+                            isIgnored: isIgnored
+                        });
+                    } else if ($cUHbR$isFunctionDeclaration(exported) && exported.id) {
+                        console.log(`Default export name: ${exported.id.name}`);
+                        exports.push({
+                            source: file,
+                            exports: [
+                                exported.id.name
+                            ],
+                            isIgnored: isIgnored
+                        });
+                    } else console.log('Default export is not an identifier or named function');
+                }
+            });
+        } catch (error) {
+            console.error(`Error parsing ${file}:`, error);
+        }
+    }
+    console.log(`\nTotal exports found: ${exports.length}`);
+    return exports;
+}
+/**
+ * Finds all files in the monorepo that import from a specific package
+ *
+ * This function:
+ * 1. Uses fast-glob to find all TypeScript files
+ * 2. Parses each file's AST to find imports
+ * 3. Handles both direct package imports and subpath imports
+ * 4. Excludes node_modules, dist, and build directories
+ *
+ * @param {FindImportsParams} params - Parameters for finding imports
+ * @returns {Promise<string[]>} Array of file paths that import from the package
+ */ async function $1d95f64f52ade133$var$findImports({ packageName: packageName, monorepoRoot: monorepoRoot }) {
+    try {
+        const allFiles = new Set();
+        // Find all TypeScript files in the monorepo
+        const files = await (0, $cUHbR$fastglob)([
+            '**/*.{ts,tsx}'
+        ], {
+            cwd: monorepoRoot,
+            absolute: true,
+            ignore: [
+                '**/node_modules/**',
+                '**/dist/**',
+                '**/build/**'
+            ],
+            followSymbolicLinks: false
+        });
+        console.log(`Found ${files.length} TypeScript files to scan`);
+        // Scan each file for imports
+        for (const file of files)try {
+            const content = (0, $cUHbR$readFileSync)(file, 'utf-8');
+            const ast = (0, $cUHbR$parse)(content, {
+                sourceType: 'module',
+                plugins: [
+                    'typescript',
+                    'jsx'
+                ]
+            });
+            (0, $cUHbR$babeltraverse)(ast, {
+                ImportDeclaration (path) {
+                    const source = path.node.source.value;
+                    // Check for exact package import or subpath import
+                    if (source === packageName || source.startsWith(`${packageName}/`)) allFiles.add(file);
+                }
+            });
+        } catch (error) {
+            console.error(`Error processing file ${file}:`, error);
+        }
+        const uniqueFiles = Array.from(allFiles);
+        if (uniqueFiles.length > 0) {
+            console.log(`Found total of ${uniqueFiles.length} files with imports from ${packageName}`);
+            console.log('Files found:');
+            for (const file of uniqueFiles)console.log(`  ${file}`);
+        } else console.log(`No files found importing from ${packageName}`);
+        return uniqueFiles;
+    } catch (error) {
+        console.error('Error finding imports:', error);
+        return [];
+    }
+}
+/**
+ * Updates imports in a file to point directly to source files instead of using barrel files
+ *
+ * This function:
+ * 1. Parses the file's AST to find imports from the package
+ * 2. For each import, finds the source file containing the export
+ * 3. Updates the import to point directly to the source file
+ * 4. Preserves original import names and types
+ * 5. Only modifies the file if changes are needed
+ *
+ * @param {UpdateImportsParams} params - Parameters for updating imports
+ * @returns {Promise<void>}
+ */ async function $1d95f64f52ade133$var$updateImports({ filePath: filePath, packageName: packageName, exports: exports, includeExtension: includeExtension = true }) {
+    console.log(`\nProcessing file: ${filePath}`);
+    const content = (0, $cUHbR$readFileSync)(filePath, 'utf-8');
+    try {
+        const ast = (0, $cUHbR$parse)(content, {
+            sourceType: 'module',
+            plugins: [
+                'typescript',
+                'jsx',
+                'decorators-legacy',
+                'classProperties',
+                'classPrivateProperties',
+                'classPrivateMethods',
+                'exportDefaultFrom',
+                'exportNamespaceFrom',
+                'functionBind',
+                'functionSent',
+                'dynamicImport',
+                'nullishCoalescingOperator',
+                'optionalChaining',
+                'objectRestSpread',
+                'asyncGenerators',
+                'doExpressions',
+                'importMeta',
+                'logicalAssignment',
+                'moduleBlocks',
+                'moduleStringNames',
+                'numericSeparator',
+                'partialApplication',
+                'privateIn',
+                'throwExpressions',
+                'topLevelAwait'
+            ]
+        });
+        let modified = false;
+        let importCount = 0;
+        (0, $cUHbR$babeltraverse)(ast, {
+            ImportDeclaration (path) {
+                if (path.node.source.value === packageName) {
+                    importCount++;
+                    console.log(`Found import from ${packageName}`);
+                    const specifiers = path.node.specifiers;
+                    const newImports = [];
+                    for (const specifier of specifiers)if ($cUHbR$isImportSpecifier(specifier)) {
+                        const imported = specifier.imported;
+                        const importName = $cUHbR$isIdentifier(imported) ? imported.name : imported.value;
+                        const exportInfo = exports.find((e)=>e.exports.includes(importName));
+                        if (exportInfo) {
+                            console.log(`  Found export ${importName} in ${exportInfo.source}`);
+                            // Skip modifying imports from ignored files
+                            if (exportInfo.isIgnored) {
+                                console.log(`  Keeping original import for ignored file: ${exportInfo.source}`);
+                                continue;
+                            }
+                            const importPath = includeExtension ? `${packageName}/${exportInfo.source}` : `${packageName}/${exportInfo.source.replace(/\.(js|jsx|ts|tsx|mjs|cjs)$/, '')}`;
+                            newImports.push($cUHbR$importDeclaration([
+                                $cUHbR$importSpecifier(specifier.local, specifier.imported)
+                            ], $cUHbR$stringLiteral(importPath)));
+                            modified = true;
+                        } else console.log(`  Warning: Could not find export ${importName}`);
+                    }
+                    if (newImports.length > 0) {
+                        // If there are any remaining specifiers that weren't moved to direct imports,
+                        // create a new import declaration for them
+                        const remainingSpecifiers = specifiers.filter((s)=>{
+                            if (!$cUHbR$isImportSpecifier(s)) return true;
+                            const importName = $cUHbR$isIdentifier(s.imported) ? s.imported.name : s.imported.value;
+                            const exportInfo = exports.find((e)=>e.exports.includes(importName));
+                            return !exportInfo || exportInfo.isIgnored;
+                        });
+                        if (remainingSpecifiers.length > 0) newImports.unshift($cUHbR$importDeclaration(remainingSpecifiers, $cUHbR$stringLiteral(packageName)));
+                        path.replaceWithMultiple(newImports);
+                        console.log('  Replaced import with direct imports from source files');
+                    }
+                }
+            }
+        });
+        if (modified) {
+            console.log(`Writing changes to ${filePath}`);
+            const output = (0, $cUHbR$babelgenerator)(ast, {
+                retainLines: false,
+                retainFunctionParens: true
+            }, content);
+            (0, $cUHbR$writeFileSync)(filePath, output.code);
+        } else if (importCount > 0) console.log(`No changes needed for ${importCount} imports`);
+        else console.log('No imports found to update');
+    } catch (error) {
+        console.error(`Error processing ${filePath}:`, error);
+    }
+}
+async function $1d95f64f52ade133$export$eb4d0c836e660010(options) {
+    const { sourcePath: sourcePath, targetPath: targetPath, ignoreSourceFiles: ignoreSourceFiles, ignoreTargetFiles: ignoreTargetFiles } = options;
+    // Track migration statistics
+    const stats = {
+        totalFiles: 0,
+        filesProcessed: 0,
+        filesSkipped: 0,
+        importsUpdated: 0,
+        filesWithNoUpdates: 0,
+        errors: 0,
+        totalExports: 0,
+        sourceFilesScanned: 0,
+        sourceFilesWithExports: 0,
+        sourceFilesSkipped: 0,
+        targetFilesFound: []
+    };
+    const packageInfo = await $1d95f64f52ade133$var$getPackageInfo(sourcePath);
+    const exports = await $1d95f64f52ade133$var$findExports({
+        packagePath: sourcePath,
+        ignoreSourceFiles: ignoreSourceFiles,
+        stats: stats
+    });
+    // Calculate total number of unique exports and source files
+    stats.totalExports = exports.reduce((total, exp)=>total + exp.exports.length, 0);
+    stats.sourceFilesWithExports = new Set(exports.map((exp)=>exp.source)).size;
+    stats.sourceFilesScanned = (await (0, $cUHbR$fastglob)('**/*.{ts,tsx}', {
+        cwd: sourcePath,
+        ignore: [
+            '**/node_modules/**',
+            '**/dist/**',
+            '**/build/**'
+        ]
+    })).length;
+    const files = await $1d95f64f52ade133$var$findImports({
+        packageName: packageInfo.name,
+        monorepoRoot: targetPath
+    });
+    stats.totalFiles = files.length;
+    stats.targetFilesFound = files;
+    for (const file of files){
+        const relativeFile = (0, $cUHbR$nodepath).relative(targetPath, file);
+        if (ignoreTargetFiles.some((pattern)=>(0, $cUHbR$micromatch).isMatch(relativeFile, pattern))) {
+            console.log(`Skipping ignored file: ${file} (matches pattern in ${ignoreTargetFiles.join(', ')})`);
+            stats.filesSkipped++;
+            continue;
+        }
+        try {
+            const originalContent = (0, $cUHbR$readFileSync)(file, 'utf-8');
+            await $1d95f64f52ade133$var$updateImports({
+                filePath: file,
+                packageName: packageInfo.name,
+                exports: exports,
+                includeExtension: options.includeExtension
+            });
+            const updatedContent = (0, $cUHbR$readFileSync)(file, 'utf-8');
+            if (originalContent !== updatedContent) stats.importsUpdated++;
+            else stats.filesWithNoUpdates++;
+            stats.filesProcessed++;
+        } catch (error) {
+            stats.errors++;
+            console.error(`Error processing ${file}:`, error);
+        }
+    }
+    // Print migration summary
+    console.log('\nMigration Summary');
+    console.log(`Source files found: ${stats.sourceFilesScanned}`);
+    console.log(`Source files with exports: ${stats.sourceFilesWithExports}`);
+    console.log(`Source files skipped: ${stats.sourceFilesSkipped}`);
+    console.log(`Exports found: ${stats.totalExports}`);
+    console.log(`Target files found: ${stats.totalFiles}`);
+    console.log(`Target files processed: ${stats.filesProcessed}`);
+    console.log(`Target files with imports updated: ${stats.importsUpdated}`);
+    console.log(`Target files with no changes needed: ${stats.filesWithNoUpdates}`);
+    console.log(`Target files skipped: ${stats.filesSkipped}`);
+    if (stats.errors > 0) console.log(`\nWarning: ${stats.errors} errors encountered during processing`);
+}
+
+
+/**
+ * Configuration options for the migration process
+ * @property {string} sourcePath - Path to the package being migrated
+ * @property {string} targetPath - Path to the monorepo root to search for imports
+ * @property {string[]} ignoreSourceFiles - Patterns to ignore when scanning source files
+ * @property {string[]} ignoreTargetFiles - Patterns to ignore when scanning target files
+ * @property {boolean} [includeExtension] - Whether to include file extensions in imports
+ */ const $bf36973fbb2420ae$export$ba43bf67f3d48107 = {
+    targetPath: '.',
+    ignoreSourceFiles: [],
+    ignoreTargetFiles: [],
+    includeExtension: false
+};
+
+
+async function $f2a4372f35794f3d$export$f22da7240b7add18() {
+    const program = new (0, $cUHbR$Command)();
+    program.name('migrate-barrel-imports').description('CLI tool to migrate barrel files imports to direct imports').argument('<source-path>', 'Path to the package containing barrel files').argument('[target-path]', 'Path to the directory where imports should be migrated (default: current directory)').option('--ignore-source-files <patterns>', 'Comma-separated list of file patterns to ignore in source directory').option('--ignore-target-files <patterns>', 'Comma-separated list of file patterns to ignore in target directory').option('--no-extension', 'Exclude js|jsx|ts|tsx|mjs|cjs file extensions from import statements').allowUnknownOption(false).parse(process.argv);
+    const args = program.args;
+    if (!args[0]) {
+        console.error('Error: source-path is required');
+        process.exit(1);
+    }
+    const sourcePath = args[0];
+    const targetPath = args[1] || (0, $bf36973fbb2420ae$export$ba43bf67f3d48107).targetPath;
+    const options = program.opts();
+    await (0, $1d95f64f52ade133$export$eb4d0c836e660010)({
+        sourcePath: sourcePath,
+        targetPath: targetPath,
+        ignoreSourceFiles: options.ignoreSourceFiles ? options.ignoreSourceFiles.split(',') : (0, $bf36973fbb2420ae$export$ba43bf67f3d48107).ignoreSourceFiles,
+        ignoreTargetFiles: options.ignoreTargetFiles ? options.ignoreTargetFiles.split(',') : (0, $bf36973fbb2420ae$export$ba43bf67f3d48107).ignoreTargetFiles,
+        includeExtension: options.extension !== false ? true : (0, $bf36973fbb2420ae$export$ba43bf67f3d48107).includeExtension
+    });
+}
+
+
+(async ()=>{
+    await (0, $f2a4372f35794f3d$export$f22da7240b7add18)();
+})();
+
+

package/package.json

@@ -0,0 +1,78 @@
+{
+	"name": "migrate-barrel-imports",
+	"version": "0.0.0",
+	"description": "A CLI tool to migrate barrel imports in JavaScript/TypeScript monorepos",
+	"files": ["dist/"],
+	"main": "./dist/index.js",
+	"keywords": [
+		"typescript",
+		"javascript",
+		"monorepo",
+		"cli",
+		"tool",
+		"migrate",
+		"barrel",
+		"import",
+		"imports"
+	],
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/brandhaug/migrate-barrel-imports.git"
+	},
+	"bugs": {
+		"url": "https://github.com/brandhaug/migrate-barrel-imports/issues"
+	},
+	"homepage": "https://github.com/brandhaug/migrate-barrel-imports#readme",
+	"type": "module",
+	"bin": {
+		"migrate-barrel-imports": "dist/index.js"
+	},
+	"scripts": {
+		"build": "parcel build src/index.ts --no-source-maps",
+		"start": "node dist/index.js",
+		"lint": "biome lint",
+		"check-write": "biome check --write",
+		"typecheck": "tsc",
+		"prepare": "husky",
+		"test": "vitest",
+		"validate": "npm run lint && npm run typecheck && npm run test"
+	},
+	"dependencies": {
+		"@babel/generator": "7.26.10",
+		"@babel/parser": "7.26.10",
+		"@babel/traverse": "7.26.10",
+		"@babel/types": "7.26.10",
+		"commander": "13.1.0",
+		"fast-glob": "3.3.3",
+		"micromatch": "4.0.8",
+		"ts-morph": "25.0.1"
+	},
+	"devDependencies": {
+		"@biomejs/biome": "1.9.4",
+		"@commitlint/cli": "19.8.0",
+		"@commitlint/config-conventional": "19.8.0",
+		"@semantic-release/changelog": "6.0.3",
+		"@semantic-release/git": "10.0.1",
+		"@types/babel__generator": "7.6.8",
+		"@types/babel__traverse": "7.20.6",
+		"@types/micromatch": "4.0.9",
+		"execa": "9.5.2",
+		"husky": "9.1.7",
+		"lint-staged": "15.5.0",
+		"parcel": "2.14.1",
+		"semantic-release": "24.2.3",
+		"tsc-files": "1.1.4",
+		"tsx": "4.19.3",
+		"typescript": "5.8.2",
+		"vitest": "3.0.9"
+	},
+	"author": "Martin Brandhaug",
+	"license": "MIT",
+	"lint-staged": {
+		"*.{ts,json}": ["biome check --write"],
+		"*.ts": ["tsc-files"]
+	},
+	"engines": {
+		"node": ">=20"
+	}
+}