knip 6.29.0 → 6.31.0

package/dist/util/package-json.d.ts

@@ -5,6 +5,352 @@ interface ExtendedPackageJson extends PackageJson {
     [INDENT]?: string;
     [NEWLINE]?: string;
 }
+export declare const toDeclarationSpecifier: (specifier: string) => string | undefined;
+export declare const getPublishedTypeManifest: (manifest: PackageJson) => {
+    name?: string;
+    main?: string;
+    bin?: string | Record<string, string>;
+    version?: string;
+    private?: boolean;
+    workspaces?: string[] | {
+        packages?: string[];
+        catalog?: import("../types/package-json.ts").Catalog;
+        catalogs?: import("../types/package-json.ts").Catalogs;
+    };
+    exports?: string | string[] | {
+        [x: string & Record<never, never>]: string | string[] | any | {
+            [key: string]: string | string[] | any | any | null;
+        } | null;
+        browser: string | string[] | any | {
+            [key: string]: string | string[] | any | any | null;
+        } | null;
+        default: string | string[] | any | {
+            [key: string]: string | string[] | any | any | null;
+        } | null;
+        deno: string | string[] | any | {
+            [key: string]: string | string[] | any | any | null;
+        } | null;
+        electron: string | string[] | any | {
+            [key: string]: string | string[] | any | any | null;
+        } | null;
+        import: string | string[] | any | {
+            [key: string]: string | string[] | any | any | null;
+        } | null;
+        node: string | string[] | any | {
+            [key: string]: string | string[] | any | any | null;
+        } | null;
+        "node-addons": string | string[] | any | {
+            [key: string]: string | string[] | any | any | null;
+        } | null;
+        "react-native": string | string[] | any | {
+            [key: string]: string | string[] | any | any | null;
+        } | null;
+        require: string | string[] | any | {
+            [key: string]: string | string[] | any | any | null;
+        } | null;
+    } | {
+        [key: string]: string | string[] | any | any | null;
+    } | null;
+    imports?: {
+        [key: `#${string}`]: string | string[] | {
+            [x: string & Record<never, never>]: string | string[] | any | {
+                [key: string]: string | string[] | any | any | null;
+            } | null;
+            browser: string | string[] | any | {
+                [key: string]: string | string[] | any | any | null;
+            } | null;
+            default: string | string[] | any | {
+                [key: string]: string | string[] | any | any | null;
+            } | null;
+            deno: string | string[] | any | {
+                [key: string]: string | string[] | any | any | null;
+            } | null;
+            electron: string | string[] | any | {
+                [key: string]: string | string[] | any | any | null;
+            } | null;
+            import: string | string[] | any | {
+                [key: string]: string | string[] | any | any | null;
+            } | null;
+            node: string | string[] | any | {
+                [key: string]: string | string[] | any | any | null;
+            } | null;
+            "node-addons": string | string[] | any | {
+                [key: string]: string | string[] | any | any | null;
+            } | null;
+            "react-native": string | string[] | any | {
+                [key: string]: string | string[] | any | any | null;
+            } | null;
+            require: string | string[] | any | {
+                [key: string]: string | string[] | any | any | null;
+            } | null;
+        } | {
+            [key: string]: string | string[] | any | any | null;
+        } | null;
+    };
+    scripts?: import("../types/package-json.ts").Scripts;
+    dependencies?: {
+        [x: string]: string;
+    };
+    devDependencies?: {
+        [x: string]: string;
+    };
+    peerDependencies?: {
+        [x: string]: string;
+    };
+    optionalDependencies?: {
+        [x: string]: string;
+    };
+    peerDependenciesMeta?: Record<string, {
+        optional: true;
+    }>;
+    resolutions?: {
+        [x: string]: string;
+    };
+    module?: string;
+    browser?: string;
+    types?: string;
+    typings?: string;
+    typesVersions?: {
+        [x: string]: Record<string, string[]>;
+    };
+    publishConfig?: {
+        directory?: string;
+        main?: string;
+        exports?: string | string[] | {
+            [x: string & Record<never, never>]: string | string[] | any | {
+                [key: string]: string | string[] | any | any | null;
+            } | null;
+            browser: string | string[] | any | {
+                [key: string]: string | string[] | any | any | null;
+            } | null;
+            default: string | string[] | any | {
+                [key: string]: string | string[] | any | any | null;
+            } | null;
+            deno: string | string[] | any | {
+                [key: string]: string | string[] | any | any | null;
+            } | null;
+            electron: string | string[] | any | {
+                [key: string]: string | string[] | any | any | null;
+            } | null;
+            import: string | string[] | any | {
+                [key: string]: string | string[] | any | any | null;
+            } | null;
+            node: string | string[] | any | {
+                [key: string]: string | string[] | any | any | null;
+            } | null;
+            "node-addons": string | string[] | any | {
+                [key: string]: string | string[] | any | any | null;
+            } | null;
+            "react-native": string | string[] | any | {
+                [key: string]: string | string[] | any | any | null;
+            } | null;
+            require: string | string[] | any | {
+                [key: string]: string | string[] | any | any | null;
+            } | null;
+        } | {
+            [key: string]: string | string[] | any | any | null;
+        } | null;
+        types?: string;
+        typings?: string;
+        typesVersions?: {
+            [x: string]: Record<string, string[]>;
+        };
+    };
+    catalog?: import("../types/package-json.ts").Catalog;
+    catalogs?: import("../types/package-json.ts").Catalogs;
+    packageManager?: string;
+    engines?: Record<string, string>;
+    pnpm: {
+        overrides?: {
+            [x: string]: string;
+        };
+        packageExtensions?: import("../types/package-json.ts").PackageExtensions;
+    };
+    knip?: import("../types/config.ts").WorkspaceConfiguration;
+    angular: unknown;
+    astro: unknown;
+    "astro-db": unknown;
+    "astro-markdoc": unknown;
+    "astro-og-canvas": unknown;
+    ava: unknown;
+    babel: unknown;
+    biome: unknown;
+    bumpp: unknown;
+    bun: unknown;
+    c8: unknown;
+    capacitor: unknown;
+    catalyst: unknown;
+    changelogen: unknown;
+    changelogithub: unknown;
+    changesets: unknown;
+    commitizen: unknown;
+    commitlint: unknown;
+    convex: unknown;
+    "create-typescript-app": unknown;
+    cspell: unknown;
+    cucumber: unknown;
+    cypress: unknown;
+    danger: unknown;
+    "dependency-cruiser": unknown;
+    docusaurus: unknown;
+    dotenv: unknown;
+    drizzle: unknown;
+    "electron-vite": unknown;
+    eleventy: unknown;
+    esbuild: unknown;
+    eslint: unknown;
+    eve: unknown;
+    execa: unknown;
+    expo: unknown;
+    "expressive-code": unknown;
+    fast: unknown;
+    fumadocs: unknown;
+    gatsby: unknown;
+    "github-action": unknown;
+    "github-actions": unknown;
+    glob: unknown;
+    "graphql-codegen": unknown;
+    hardhat: unknown;
+    husky: unknown;
+    "i18next-parser": unknown;
+    jest: unknown;
+    karma: unknown;
+    knex: unknown;
+    ladle: unknown;
+    "laravel-vite-plugin": unknown;
+    lefthook: unknown;
+    "lint-staged": unknown;
+    linthtml: unknown;
+    lit: unknown;
+    "lockfile-lint": unknown;
+    "lost-pixel": unknown;
+    lunaria: unknown;
+    markdownlint: unknown;
+    marko: unknown;
+    mdx: unknown;
+    mdxlint: unknown;
+    metro: unknown;
+    mocha: unknown;
+    moonrepo: unknown;
+    msw: unknown;
+    "nano-spawn": unknown;
+    "nano-staged": unknown;
+    nest: unknown;
+    netlify: unknown;
+    next: unknown;
+    "next-intl": unknown;
+    "next-mdx": unknown;
+    nitro: unknown;
+    node: unknown;
+    "node-modules-inspector": unknown;
+    nodemon: unknown;
+    "npm-package-json-lint": unknown;
+    nuxt: unknown;
+    "nuxtjs-i18n": unknown;
+    nx: unknown;
+    nyc: unknown;
+    oclif: unknown;
+    "openapi-ts": unknown;
+    openclaw: unknown;
+    orval: unknown;
+    oxfmt: unknown;
+    oxlint: unknown;
+    "panda-css": unknown;
+    parcel: unknown;
+    payload: unknown;
+    pino: unknown;
+    playwright: unknown;
+    "playwright-ct": unknown;
+    "playwright-test": unknown;
+    plop: unknown;
+    pm2: unknown;
+    postcss: unknown;
+    preconstruct: unknown;
+    prettier: unknown;
+    prisma: unknown;
+    quasar: unknown;
+    qwik: unknown;
+    raycast: unknown;
+    "react-cosmos": unknown;
+    "react-email": unknown;
+    "react-native": unknown;
+    "react-router": unknown;
+    relay: unknown;
+    "release-it": unknown;
+    remark: unknown;
+    remix: unknown;
+    rolldown: unknown;
+    rollup: unknown;
+    rsbuild: unknown;
+    rslib: unknown;
+    rspack: unknown;
+    rstest: unknown;
+    sanity: unknown;
+    "semantic-release": unknown;
+    sentry: unknown;
+    "serverless-framework": unknown;
+    "simple-git-hooks": unknown;
+    "size-limit": unknown;
+    sst: unknown;
+    starlight: unknown;
+    stencil: unknown;
+    storybook: unknown;
+    stryker: unknown;
+    stylelint: unknown;
+    svelte: unknown;
+    "sveltejs-package": unknown;
+    sveltekit: unknown;
+    svgo: unknown;
+    svgr: unknown;
+    swc: unknown;
+    syncpack: unknown;
+    tailwind: unknown;
+    "tanstack-router": unknown;
+    taskfile: unknown;
+    tauri: unknown;
+    temporal: unknown;
+    travis: unknown;
+    "ts-node": unknown;
+    tsdown: unknown;
+    tsup: unknown;
+    tsx: unknown;
+    typedoc: unknown;
+    typescript: unknown;
+    unbuild: unknown;
+    unocss: unknown;
+    "unplugin-auto-import": unknown;
+    "unplugin-icons": unknown;
+    "unplugin-vue-components": unknown;
+    "unplugin-vue-i18n": unknown;
+    "unplugin-vue-markdown": unknown;
+    "unplugin-vue-router": unknown;
+    vercel: unknown;
+    "vercel-og": unknown;
+    vike: unknown;
+    vite: unknown;
+    "vite-plugin-pages": unknown;
+    "vite-plugin-pwa": unknown;
+    "vite-plugin-vue-layouts-next": unknown;
+    "vite-plus": unknown;
+    "vite-pwa-assets-generator": unknown;
+    vitepress: unknown;
+    vitest: unknown;
+    vue: unknown;
+    "webdriver-io": unknown;
+    webpack: unknown;
+    wireit: unknown;
+    wrangler: unknown;
+    wxt: unknown;
+    xo: unknown;
+    yarn: unknown;
+    yorkie: unknown;
+    zx: unknown;
+};
+export declare const getPublishedTypeExportSpecifiers: (exports: PackageJson['exports']) => Set<string>;
+export declare const getPublishedTypeEntrySpecifiers: (manifest: PackageJson) => {
+    candidates: string[];
+    versioned: Set<string>;
+};
 export declare const getPackageMapTarget: (map: unknown, key: string) => {
     target: any;
     patternMatch?: undefined;
@@ -12,6 +358,7 @@ export declare const getPackageMapTarget: (map: unknown, key: string) => {
     target: unknown;
     patternMatch: string;
 } | undefined;
+export declare const isPublishedTypeExportTarget: (exports: PackageJson['exports'], candidate: string) => boolean;
 export declare const load: (filePath: string) => Promise<ExtendedPackageJson>;
 export declare const save: (filePath: string, content: ExtendedPackageJson) => Promise<void>;
 export declare const getEntrySpecifiersFromManifest: (manifest: PackageJson) => Set<string>;

package/dist/util/package-json.js

@@ -1,4 +1,5 @@
 import { readFile, writeFile } from 'node:fs/promises';
+import { IS_DTS } from '../constants.js';
 const INDENT = Symbol.for('indent');
 const NEWLINE = Symbol.for('newline');
 const DEFAULT_NEWLINE = '\n';
@@ -35,6 +36,88 @@ const getEntriesFromExports = (obj) => {
     }
     return values;
 };
+const declarationExtensionMap = new Map([
+    ['.js', '.d.ts'],
+    ['.mjs', '.d.mts'],
+    ['.cjs', '.d.cts'],
+]);
+export const toDeclarationSpecifier = (specifier) => {
+    for (const [extension, declarationExtension] of declarationExtensionMap) {
+        if (specifier.endsWith(extension))
+            return specifier.slice(0, -extension.length) + declarationExtension;
+    }
+    if (IS_DTS.test(specifier))
+        return specifier;
+};
+export const getPublishedTypeManifest = (manifest) => {
+    const { publishConfig } = manifest;
+    if (!publishConfig)
+        return manifest;
+    const publishedManifest = { ...manifest };
+    if (Object.hasOwn(publishConfig, 'main'))
+        publishedManifest.main = publishConfig.main;
+    if (Object.hasOwn(publishConfig, 'exports'))
+        publishedManifest.exports = publishConfig.exports;
+    if (Object.hasOwn(publishConfig, 'types'))
+        publishedManifest.types = publishConfig.types;
+    if (Object.hasOwn(publishConfig, 'typings'))
+        publishedManifest.typings = publishConfig.typings;
+    if (Object.hasOwn(publishConfig, 'typesVersions'))
+        publishedManifest.typesVersions = publishConfig.typesVersions;
+    return publishedManifest;
+};
+const isLocalTypeTarget = (target) => !target.startsWith('/') && !target.split('/').some(segment => segment === '..' || segment === 'node_modules');
+const collectPublishedTypeTargets = (value, targets) => {
+    if (typeof value === 'string') {
+        const specifier = toDeclarationSpecifier(value);
+        if (specifier && isLocalTypeTarget(specifier))
+            targets.add(specifier);
+        return;
+    }
+    if (!value || typeof value !== 'object')
+        return;
+    if (Array.isArray(value)) {
+        for (const child of value)
+            collectPublishedTypeTargets(child, targets);
+        return;
+    }
+    const children = Object.entries(value);
+    const typeConditions = children.filter(([condition]) => condition === 'types' || condition.startsWith('types@'));
+    for (const [, child] of typeConditions.length > 0 ? typeConditions : children)
+        collectPublishedTypeTargets(child, targets);
+};
+export const getPublishedTypeExportSpecifiers = (exports) => {
+    const specifiers = new Set();
+    if (exports)
+        collectPublishedTypeTargets(exports, specifiers);
+    return specifiers;
+};
+export const getPublishedTypeEntrySpecifiers = (manifest) => {
+    const versioned = new Set();
+    if (manifest.typesVersions) {
+        for (const paths of Object.values(manifest.typesVersions)) {
+            for (const targets of Object.values(paths)) {
+                if (!Array.isArray(targets))
+                    continue;
+                for (const target of targets) {
+                    if (typeof target === 'string' && isLocalTypeTarget(target))
+                        versioned.add(target);
+                }
+            }
+        }
+    }
+    const candidates = [];
+    for (const field of [manifest.types, manifest.typings, manifest.main]) {
+        if (typeof field !== 'string')
+            continue;
+        const specifier = toDeclarationSpecifier(field);
+        if (specifier && isLocalTypeTarget(specifier) && !candidates.includes(specifier))
+            candidates.push(specifier);
+    }
+    if (!candidates.includes('index.d.ts'))
+        candidates.push('index.d.ts');
+    return { candidates, versioned };
+};
 export const getPackageMapTarget = (map, key) => {
     if (!map || typeof map !== 'object' || Array.isArray(map))
         return key === '.' ? { target: map } : undefined;
@@ -72,6 +155,46 @@ export const getPackageMapTarget = (map, key) => {
     if (best)
         return { target: best.target, patternMatch: best.patternMatch };
 };
+const matchPublishedTypeTarget = (pattern, candidate) => {
+    const parts = pattern.split('*');
+    if (parts.length === 1)
+        return pattern === candidate ? { patternMatch: undefined } : undefined;
+    const starCount = parts.length - 1;
+    const matchLength = (candidate.length - pattern.length + starCount) / starCount;
+    if (matchLength < 0 || !Number.isInteger(matchLength))
+        return;
+    const patternMatch = candidate.slice(parts[0].length, parts[0].length + matchLength);
+    if (parts.join(patternMatch) === candidate)
+        return { patternMatch };
+};
+const getExportEntries = (exports) => {
+    if (!Array.isArray(exports) && typeof exports === 'object') {
+        const entries = Object.entries(exports);
+        if (entries.some(([key]) => key.startsWith('.')))
+            return entries.filter(([key]) => key.startsWith('.'));
+    }
+    return [['.', exports]];
+};
+export const isPublishedTypeExportTarget = (exports, candidate) => {
+    if (!exports)
+        return false;
+    for (const [subpath, target] of getExportEntries(exports)) {
+        for (const pattern of getPublishedTypeExportSpecifiers(target)) {
+            const match = matchPublishedTypeTarget(pattern, candidate);
+            if (!match)
+                continue;
+            const publicSubpath = match.patternMatch === undefined ? subpath : subpath.replaceAll('*', match.patternMatch);
+            const resolved = getPackageMapTarget(exports, publicSubpath);
+            if (!resolved)
+                continue;
+            for (const selected of getPublishedTypeExportSpecifiers(resolved.target)) {
+                if (matchPublishedTypeTarget(selected, candidate))
+                    return true;
+            }
+        }
+    }
+    return false;
+};
 export const load = async (filePath) => {
     const file = await readFile(filePath, 'utf8');
     return parseJson(file);

package/dist/util/path.d.ts

@@ -1,13 +1,14 @@
-export declare const isAbsolute: (path: string) => boolean;
-export declare const dirname: (path: string) => string;
-export declare const extname: (path: string) => string;
-export declare const basename: (path: string, suffix?: string) => string;
-export declare const join: (...paths: string[]) => string;
+import path from 'node:path';
+export declare const isAbsolute: typeof path.isAbsolute;
+export declare const dirname: typeof path.dirname;
+export declare const extname: typeof path.extname;
+export declare const basename: typeof path.basename;
+export declare const join: typeof path.join;
 export declare const toPosix: (value: string) => string;
-export declare const resolve: (...paths: string[]) => string;
+export declare const resolve: typeof path.resolve;
 export declare const relative: (from: string, to: string) => string;
 export declare const isInNodeModules: (filePath: string) => boolean;
 export declare const toAbsolute: (id: string, base: string) => string;
 export declare const toRelative: (id: string, base: string) => string;
 export declare const isInternal: (id: string) => boolean;
-export declare const normalize: (path: string) => string;
+export declare const normalize: typeof path.normalize;

package/dist/util/resolve.d.ts

@@ -1,5 +1,11 @@
 export declare const extensionAlias: Record<string, string[]>;
 export declare const _resolveModuleSync: (specifier: string, basePath: string) => string | undefined;
+declare const resolveDeclarationSync: (specifier: string, containingFile: string) => {
+    path: string;
+    packageJsonPath: string | undefined;
+} | undefined;
+export declare const _resolveDeclarationSync: typeof resolveDeclarationSync;
 export declare const _createSyncModuleResolver: (extensions: string[], tsConfigFile?: string) => (specifier: string, basePath: string) => string | undefined;
 export declare function clearResolverCache(): void;
 export declare const _resolveSync: (specifier: string, baseDir: string) => string | undefined;
+export {};

package/dist/util/resolve.js

@@ -9,6 +9,20 @@ export const extensionAlias = {
     '.cjs': ['.cjs', '.cts', '.d.cts'],
 };
 const resolverInstances = [];
+const declarationResolver = new ResolverFactory({
+    extensions: [...DTS_EXTENSIONS, ...DEFAULT_EXTENSIONS],
+    extensionAlias: {
+        '.ts': ['.d.ts', '.ts'],
+        '.mts': ['.d.mts', '.mts'],
+        '.cts': ['.d.cts', '.cts'],
+        '.js': ['.d.ts', '.js'],
+        '.mjs': ['.d.mts', '.mjs'],
+        '.cjs': ['.d.cts', '.cjs'],
+    },
+    conditionNames: ['types', 'import', 'require', 'node', 'default'],
+    nodePath: false,
+});
+resolverInstances.push(declarationResolver);
 const createSyncModuleResolver = (extensions, tsConfigFile) => {
     const baseOptions = {
         extensions,
@@ -38,6 +52,16 @@ const createSyncModuleResolver = (extensions, tsConfigFile) => {
 };
 const resolveModuleSync = createSyncModuleResolver([...DEFAULT_EXTENSIONS, ...DTS_EXTENSIONS, '.json', '.jsonc']);
 export const _resolveModuleSync = timerify(resolveModuleSync, 'resolveModuleSync');
+const resolveDeclarationSync = (specifier, containingFile) => {
+    const result = declarationResolver.resolveFileSync(containingFile, specifier);
+    if (!result.path)
+        return;
+    return {
+        path: toPosix(result.path),
+        packageJsonPath: result.packageJsonPath ? toPosix(result.packageJsonPath) : undefined,
+    };
+};
+export const _resolveDeclarationSync = timerify(resolveDeclarationSync, 'resolveDeclarationSync');
 export const _createSyncModuleResolver = (extensions, tsConfigFile) => timerify(createSyncModuleResolver(extensions, tsConfigFile), 'resolveModuleSync');
 const createSyncResolver = (extensions) => {
     const resolver = new ResolverFactory({

package/dist/util/string.d.ts

@@ -1,4 +1,6 @@
 export declare const ELLIPSIS = "\u2026";
+export declare const substringBefore: (value: string, separator: string) => string;
+export declare const compareStrings: (a: string, b: string) => number;
 export declare const truncate: (text: string, width: number) => string;
 export declare const truncateStart: (text: string, width: number) => string;
 export declare const pad: (text: string, width: number, fillString?: string, align?: 'left' | 'center' | 'right') => string;

package/dist/util/string.js

@@ -1,6 +1,12 @@
 import { stripVTControlCharacters } from 'node:util';
 const CONTROL_CHARACTERS = /\u001b\[[0-9;]+m/g;
 export const ELLIPSIS = '…';
+export const substringBefore = (value, separator) => {
+    const index = value.indexOf(separator);
+    return index === -1 ? value : value.slice(0, index);
+};
+const collator = new Intl.Collator();
+export const compareStrings = (a, b) => collator.compare(a, b);
 const getTruncatedParts = (input, limit, fromStart) => {
     const parts = [];
     let width = 0;

package/dist/util/table.js

@@ -1,5 +1,5 @@
 import { stripVTControlCharacters } from 'node:util';
-import { pad, truncate, truncateStart } from './string.js';
+import { compareStrings, pad, truncate, truncateStart } from './string.js';
 const MIN_TRUNCATED_WIDTH = 4;
 const COLUMN_SEPARATOR = '  ';
 const visibleLength = (text) => stripVTControlCharacters(text).length;
@@ -36,7 +36,7 @@ export class Table {
             const vA = a[column]?.value;
             const vB = b[column]?.value;
             if (typeof vA === 'string' && typeof vB === 'string')
-                return dir * vA.localeCompare(vB);
+                return dir * compareStrings(vA, vB);
             if (typeof vA === 'number' && typeof vB === 'number')
                 return dir * (vA - vB);
             return !isPrintable(vA) ? 1 : !isPrintable(vB) ? -1 : 0;

package/dist/util/to-source-path.js

@@ -5,7 +5,7 @@ import { _glob, prependDirToPattern } from './glob.js';
 import { getPackageNameFromModuleSpecifier } from './modules.js';
 import { getPackageMapTarget } from './package-json.js';
 import { isAbsolute, isInternal, join, toRelative } from './path.js';
-const defaultExtensions = `.{${[...DEFAULT_EXTENSIONS].map(ext => ext.slice(1)).join(',')}}`;
+const defaultExtensions = `.{${Array.from(DEFAULT_EXTENSIONS, ext => ext.slice(1)).join(',')}}`;
 const hasTSExt = /(?<!\.d)\.(m|c)?tsx?$/;
 const matchExt = /(\.d)?\.(m|c)?(j|t)s$/;
 const sourceExtensions = [...DEFAULT_EXTENSIONS];

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "6.29.0";
+export declare const version = "6.31.0";

package/dist/version.js

@@ -1 +1 @@
-export const version = '6.29.0';
+export const version = '6.31.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "6.29.0",
+  "version": "6.31.0",
   "description": "Find and fix unused dependencies, exports and files in your TypeScript and JavaScript projects",
   "keywords": [
     "analysis",
@@ -81,13 +81,13 @@
     "formatly": "^0.3.0",
     "get-tsconfig": "4.14.0",
     "jiti": "^2.7.0",
-    "oxc-parser": "^0.140.0",
+    "oxc-parser": "^0.142.0",
     "oxc-resolver": "11.24.2",
     "picomatch": "^4.0.5",
-    "smol-toml": "^1.7.0",
+    "smol-toml": "^1.7.1",
     "strip-json-comments": "5.0.3",
     "tinyglobby": "^0.2.17",
-    "unbash": "^4.0.3",
+    "unbash": "^4.0.4",
     "yaml": "^2.9.0",
     "zod": "^4.4.3"
   },
@@ -97,7 +97,7 @@
     "@types/picomatch": "^4.0.3",
     "@types/webpack": "^5.28.5",
     "codeclimate-types": "^0.3.1",
-    "prettier": "^3.9.5",
+    "prettier": "^3.9.6",
     "tsx": "^4.23.1",
     "typescript": "7.0.2"
   },