knip 6.43.0 → 6.44.1

package/dist/session/incremental.js

@@ -0,0 +1,49 @@
+import { isDeepStrictEqual } from 'node:util';
+export const isIncrementalFile = (file) => file.scripts.size === 0 &&
+    file.importGlobs.length === 0 &&
+    file.imports.programFiles.size === 0 &&
+    file.imports.entryFiles.size === 0;
+export const getFileTopology = (file) => {
+    const exports = [];
+    for (const [identifier, item] of file.exports) {
+        const members = [];
+        for (const member of item.members) {
+            members.push({
+                identifier: member.identifier,
+                type: member.type,
+                flags: member.flags,
+                jsDocTags: member.jsDocTags,
+                hasRefsInFile: member.hasRefsInFile,
+            });
+        }
+        exports.push({
+            identifier,
+            binding: item.binding,
+            type: item.type,
+            jsDocTags: item.jsDocTags,
+            hasRefsInFile: item.hasRefsInFile,
+            isRegistered: item.isRegistered,
+            referencedIn: item.referencedIn,
+            isReExport: item.isReExport,
+            isBindingReExport: item.isBindingReExport,
+            members,
+        });
+    }
+    const facts = (items) => {
+        const result = [];
+        for (const { specifier, filePath, identifier, alias, isTypeOnly, modifiers, jsDocTags } of items)
+            result.push({ specifier, filePath, identifier, alias, isTypeOnly, modifiers, jsDocTags });
+        return result;
+    };
+    return {
+        internal: file.imports.internal,
+        paths: [...file.imports.internal.keys()],
+        imports: facts(file.imports.imports),
+        external: facts(file.imports.external),
+        unresolved: facts(file.imports.unresolved),
+        externalRefs: file.imports.externalRefs,
+        exports,
+        skipExports: file.skipExports,
+    };
+};
+export const hasSameTopology = (before, after) => isIncrementalFile(after) && isDeepStrictEqual(before, getFileTopology(after));

package/dist/session/session.d.ts

@@ -1,6 +1,6 @@
 import type { CollectorIssues } from '../IssueCollector.ts';
 import { type Results } from '../run.ts';
-import type { MainOptions } from '../util/create-options.ts';
+import { type MainOptions } from '../util/create-options.ts';
 import type { WatchChange } from '../util/watch.ts';
 import { type FileDescriptorOptions } from './file-descriptor.ts';
 import { type PackageJsonFile } from './package-json-descriptor.ts';

package/dist/session/session.js

@@ -1,36 +1,72 @@
 import { run } from '../run.js';
+import { createOptions } from '../util/create-options.js';
 import { createPreprocessor, toReporterOptions } from '../util/preprocessor.js';
+import { clearResolverCache } from '../util/resolve.js';
+import { clearModuleResolutionCaches } from '../typescript/resolve-module-names.js';
+import { clearGlobCache } from '../util/glob-cache.js';
+import { clearGitignoreCache } from '../util/gitignore-cache.js';
+import { unload } from '../util/loader.js';
 import { buildFileDescriptor } from './file-descriptor.js';
 import { buildPackageJsonDescriptor } from './package-json-descriptor.js';
+import { SessionConfigurationChangedError } from './configuration.js';
 export const createSession = async (options) => {
-    const { session, results } = await run(options);
-    if (!session)
-        throw new Error('Unable to initialize watch session');
-    const adapter = {
-        handleFileChanges: session.handleFileChanges,
-        getIssues: session.getIssues,
-        getResults: () => results,
-        describeFile: (filePath, opts) => buildFileDescriptor(filePath, options.cwd, session.getGraph(), session.getEntryPaths(), opts),
-        describePackageJson: () => buildPackageJsonDescriptor(session.getGraph(), session.getEntryPaths()),
+    const initialize = async (options) => {
+        const { session, results } = await run(options);
+        if (!session)
+            throw new Error('Unable to initialize watch session');
+        const preprocess = options.preprocessor.length > 0 ? await createPreprocessor(options.preprocessor) : undefined;
+        const updateResults = async () => {
+            const collected = session.getIssues();
+            const data = preprocess
+                ? await preprocess({ ...toReporterOptions(options, results), ...structuredClone(collected) })
+                : collected;
+            results.issues = data.issues;
+            results.counters = data.counters;
+            results.tagHints = data.tagHints;
+            results.configurationHints = data.configurationHints;
+            results.hasConfigLoadErrors = collected.hasConfigLoadErrors;
+        };
+        await updateResults();
+        return { session, results, options, updateResults, preprocess };
     };
-    if (options.preprocessor.length === 0)
-        return adapter;
-    const input = toReporterOptions(options, results);
-    const preprocess = await createPreprocessor(options.preprocessor);
-    const updateResults = async () => {
-        const data = await preprocess({ ...input, ...structuredClone(session.getIssues()) });
-        results.issues = data.issues;
-        results.counters = data.counters;
-        results.tagHints = data.tagHints;
-        results.configurationHints = data.configurationHints;
+    let current = await initialize(options);
+    const results = current.results;
+    let pending = Promise.resolve();
+    const processChanges = async (changes) => {
+        try {
+            const update = await current.session.handleFileChanges(changes);
+            if (update) {
+                await current.updateResults();
+                Object.assign(results, current.results);
+            }
+            return update;
+        }
+        catch (error) {
+            if (!(error instanceof SessionConfigurationChangedError))
+                throw error;
+            const startTime = performance.now();
+            clearResolverCache();
+            clearModuleResolutionCaches();
+            clearGlobCache();
+            clearGitignoreCache();
+            const { configurationFiles } = current.session;
+            if (configurationFiles)
+                unload(configurationFiles.getAffected(changes, current.options.cwd));
+            const nextOptions = await createOptions(current.options.createdFrom, true);
+            current = await initialize({ ...nextOptions, isCache: false });
+            Object.assign(results, current.results);
+            return { duration: performance.now() - startTime, mem: process.memoryUsage().heapUsed };
+        }
     };
-    await updateResults();
-    adapter.handleFileChanges = async (changes) => {
-        const update = await session.handleFileChanges(changes);
-        if (update)
-            await updateResults();
-        return update;
+    return {
+        handleFileChanges: changes => {
+            const update = pending.then(() => processChanges(changes));
+            pending = update.then(() => { }, () => { });
+            return update;
+        },
+        getIssues: () => (current.preprocess ? results : current.session.getIssues()),
+        getResults: () => results,
+        describeFile: (filePath, opts) => buildFileDescriptor(filePath, current.options.cwd, current.session.getGraph(), current.session.getEntryPaths(), opts),
+        describePackageJson: () => buildPackageJsonDescriptor(current.session.getGraph(), current.session.getEntryPaths()),
     };
-    adapter.getIssues = () => results;
-    return adapter;
 };

package/dist/session/watch.d.ts

@@ -0,0 +1,2 @@
+import type { MainOptions } from '../util/create-options.ts';
+export declare const watchSession: (options: MainOptions) => Promise<void>;

package/dist/session/watch.js

@@ -0,0 +1,41 @@
+import { watch } from 'node:fs';
+import { ConsoleStreamer } from '../ConsoleStreamer.js';
+import watchReporter from '../reporters/watch.js';
+import { debugLog } from '../util/debug.js';
+import { hasErrorCause } from '../util/errors.js';
+import { isFile } from '../util/fs.js';
+import { logError } from '../util/log.js';
+import { toPosix } from '../util/path.js';
+import { createSession } from './session.js';
+export const watchSession = async (options) => {
+    const streamer = new ConsoleStreamer(options);
+    const session = await createSession(options);
+    const report = (duration) => {
+        const { issues, counters } = session.getIssues();
+        watchReporter(options, { issues, streamer, size: counters.processed - counters.files, duration });
+    };
+    const onError = (error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        const reason = error instanceof Error && hasErrorCause(error) ? `\nReason: ${error.cause.message}` : '';
+        logError(message + reason);
+        process.exitCode = 2;
+    };
+    const watcher = watch(options.cwd, { recursive: true }, (eventType, filePath) => {
+        debugLog('*', `(raw) ${eventType} ${filePath}`);
+        if (typeof filePath !== 'string')
+            return;
+        const path = toPosix(filePath);
+        const type = eventType === 'rename' ? (isFile(options.cwd, path) ? 'added' : 'deleted') : 'modified';
+        session.handleFileChanges([{ type, filePath: path }]).then(update => {
+            if (!update)
+                return;
+            process.exitCode = 0;
+            report(update.duration);
+        }, onError);
+    });
+    watcher.on('error', error => {
+        onError(error);
+        watcher.close();
+    });
+    report();
+};

package/dist/types/PluginNames.d.ts

@@ -1,2 +1,2 @@
-export type PluginName = 'angular' | 'astro' | 'astro-db' | 'astro-markdoc' | 'astro-og-canvas' | 'ava' | 'babel' | 'biome' | 'borp' | 'buf' | 'bumpp' | 'bun' | 'c8' | 'capacitor' | 'catalyst' | 'changelogen' | 'changelogithub' | 'changesets' | 'commitizen' | 'commitlint' | 'convex' | 'create-typescript-app' | 'cspell' | 'cucumber' | 'cypress' | 'danger' | 'dependency-cruiser' | 'docusaurus' | 'dotenv' | 'drizzle' | 'electron-forge' | 'electron-vite' | 'eleventy' | 'esbuild' | 'eslint' | 'eve' | 'execa' | 'expo' | 'expo-router' | 'expressive-code' | 'fast' | 'filesystem-routing' | 'flue' | 'fumadocs' | 'gatsby' | 'github-action' | 'github-actions' | 'glob' | 'graphql-codegen' | 'hardhat' | 'husky' | 'i18next-parser' | 'jasmine' | 'jest' | 'karma' | 'knex' | 'ladle' | 'laravel-vite-plugin' | 'lefthook' | 'lint-staged' | 'linthtml' | 'lit' | 'lockfile-lint' | 'lost-pixel' | 'lunaria' | 'markdownlint' | 'marko' | 'mcp' | 'mdx' | 'mdxlint' | 'metro' | 'mise' | 'mocha' | 'moonrepo' | 'msw' | 'nano-spawn' | 'nano-staged' | 'nest' | 'netlify' | 'next' | 'next-intl' | 'next-mdx' | 'nitro' | 'node' | 'node-modules-inspector' | 'nodemon' | 'npm-package-json-lint' | 'nuxt' | 'nuxtjs-i18n' | 'nx' | 'nyc' | 'oclif' | 'openapi-ts' | 'openclaw' | 'orval' | 'osls' | 'oxfmt' | 'oxlint' | 'panda-css' | 'parcel' | 'payload' | 'pino' | 'playwright' | 'playwright-ct' | 'playwright-test' | 'plop' | 'pm2' | 'pnpm' | 'postcss' | 'pre-commit' | 'preconstruct' | 'prettier' | 'prisma' | 'quasar' | 'qwik' | 'railway' | 'raycast' | 'react-cosmos' | 'react-email' | 'react-native' | 'react-router' | 'relay' | 'release-it' | 'remark' | 'remix' | 'rolldown' | 'rollup' | 'rsbuild' | 'rslib' | 'rspack' | 'rstest' | 'sanity' | 'semantic-release' | 'sentry' | 'serverless-framework' | 'simple-git-hooks' | 'size-limit' | 'solidjs-vite-plugin' | 'sst' | 'starlight' | 'stencil' | 'storybook' | 'stryker' | 'stylelint' | 'svelte' | 'sveltejs-package' | 'sveltekit' | 'svgo' | 'svgr' | 'swc' | 'syncpack' | 'tailwind' | 'tanstack-router' | 'taskfile' | 'tauri' | 'temporal' | 'textlint' | 'travis' | 'ts-node' | 'tsd' | 'tsdown' | 'tsrs' | 'tsup' | 'tsx' | 'turbo' | 'typedoc' | 'typescript' | 'typescript-content-mapper' | 'unbuild' | 'unocss' | 'unplugin-auto-import' | 'unplugin-icons' | 'unplugin-vue-components' | 'unplugin-vue-i18n' | 'unplugin-vue-markdown' | 'unplugin-vue-router' | 'varlock' | 'vercel' | 'vercel-og' | 'vike' | 'vite' | 'vite-plugin-pages' | 'vite-plugin-pwa' | 'vite-plugin-vue-layouts-next' | 'vite-plus' | 'vite-pwa-assets-generator' | 'vitepress' | 'vitest' | 'vue' | 'webdriver-io' | 'webpack' | 'wireit' | 'wrangler' | 'wxt' | 'xo' | 'yarn' | 'yorkie' | 'zx';
-export declare const pluginNames: readonly ['angular', 'astro', 'astro-db', 'astro-markdoc', 'astro-og-canvas', 'ava', 'babel', 'biome', 'borp', 'buf', 'bumpp', 'bun', 'c8', 'capacitor', 'catalyst', 'changelogen', 'changelogithub', 'changesets', 'commitizen', 'commitlint', 'convex', 'create-typescript-app', 'cspell', 'cucumber', 'cypress', 'danger', 'dependency-cruiser', 'docusaurus', 'dotenv', 'drizzle', 'electron-forge', 'electron-vite', 'eleventy', 'esbuild', 'eslint', 'eve', 'execa', 'expo', 'expo-router', 'expressive-code', 'fast', 'filesystem-routing', 'flue', 'fumadocs', 'gatsby', 'github-action', 'github-actions', 'glob', 'graphql-codegen', 'hardhat', 'husky', 'i18next-parser', 'jasmine', 'jest', 'karma', 'knex', 'ladle', 'laravel-vite-plugin', 'lefthook', 'lint-staged', 'linthtml', 'lit', 'lockfile-lint', 'lost-pixel', 'lunaria', 'markdownlint', 'marko', 'mcp', 'mdx', 'mdxlint', 'metro', 'mise', 'mocha', 'moonrepo', 'msw', 'nano-spawn', 'nano-staged', 'nest', 'netlify', 'next', 'next-intl', 'next-mdx', 'nitro', 'node', 'node-modules-inspector', 'nodemon', 'npm-package-json-lint', 'nuxt', 'nuxtjs-i18n', 'nx', 'nyc', 'oclif', 'openapi-ts', 'openclaw', 'orval', 'osls', 'oxfmt', 'oxlint', 'panda-css', 'parcel', 'payload', 'pino', 'playwright', 'playwright-ct', 'playwright-test', 'plop', 'pm2', 'pnpm', 'postcss', 'pre-commit', 'preconstruct', 'prettier', 'prisma', 'quasar', 'qwik', 'railway', 'raycast', 'react-cosmos', 'react-email', 'react-native', 'react-router', 'relay', 'release-it', 'remark', 'remix', 'rolldown', 'rollup', 'rsbuild', 'rslib', 'rspack', 'rstest', 'sanity', 'semantic-release', 'sentry', 'serverless-framework', 'simple-git-hooks', 'size-limit', 'solidjs-vite-plugin', 'sst', 'starlight', 'stencil', 'storybook', 'stryker', 'stylelint', 'svelte', 'sveltejs-package', 'sveltekit', 'svgo', 'svgr', 'swc', 'syncpack', 'tailwind', 'tanstack-router', 'taskfile', 'tauri', 'temporal', 'textlint', 'travis', 'ts-node', 'tsd', 'tsdown', 'tsrs', 'tsup', 'tsx', 'turbo', 'typedoc', 'typescript', 'typescript-content-mapper', 'unbuild', 'unocss', 'unplugin-auto-import', 'unplugin-icons', 'unplugin-vue-components', 'unplugin-vue-i18n', 'unplugin-vue-markdown', 'unplugin-vue-router', 'varlock', 'vercel', 'vercel-og', 'vike', 'vite', 'vite-plugin-pages', 'vite-plugin-pwa', 'vite-plugin-vue-layouts-next', 'vite-plus', 'vite-pwa-assets-generator', 'vitepress', 'vitest', 'vue', 'webdriver-io', 'webpack', 'wireit', 'wrangler', 'wxt', 'xo', 'yarn', 'yorkie', 'zx'];
+export type PluginName = 'angular' | 'astro' | 'astro-db' | 'astro-markdoc' | 'astro-og-canvas' | 'ava' | 'babel' | 'biome' | 'borp' | 'buf' | 'bumpp' | 'bun' | 'c8' | 'capacitor' | 'catalyst' | 'changelogen' | 'changelogithub' | 'changesets' | 'commitizen' | 'commitlint' | 'convex' | 'create-typescript-app' | 'cspell' | 'cucumber' | 'cypress' | 'danger' | 'dependency-cruiser' | 'docusaurus' | 'dotenv' | 'drizzle' | 'electron-forge' | 'electron-vite' | 'eleventy' | 'esbuild' | 'eslint' | 'eve' | 'execa' | 'expo' | 'expo-router' | 'expressive-code' | 'fast' | 'filesystem-routing' | 'flue' | 'fumadocs' | 'gatsby' | 'github-action' | 'github-actions' | 'glob' | 'graphql-codegen' | 'hardhat' | 'husky' | 'i18next-parser' | 'jasmine' | 'jest' | 'karma' | 'knex' | 'kysely-codegen' | 'ladle' | 'laravel-vite-plugin' | 'lefthook' | 'lingui' | 'lint-staged' | 'linthtml' | 'lit' | 'lockfile-lint' | 'lost-pixel' | 'lunaria' | 'markdownlint' | 'marko' | 'mastra' | 'mcp' | 'mdx' | 'mdxlint' | 'metro' | 'mise' | 'mocha' | 'moonrepo' | 'msw' | 'nano-spawn' | 'nano-staged' | 'nest' | 'netlify' | 'next' | 'next-intl' | 'next-mdx' | 'nitro' | 'node' | 'node-modules-inspector' | 'nodemon' | 'npm-package-json-lint' | 'nuxt' | 'nuxtjs-i18n' | 'nx' | 'nyc' | 'oclif' | 'openapi-ts' | 'openclaw' | 'orval' | 'osls' | 'oxfmt' | 'oxlint' | 'panda-css' | 'parcel' | 'payload' | 'pino' | 'playwright' | 'playwright-ct' | 'playwright-test' | 'plop' | 'pm2' | 'pnpm' | 'postcss' | 'pre-commit' | 'preconstruct' | 'prettier' | 'prisma' | 'purgecss' | 'quasar' | 'qwik' | 'railway' | 'raycast' | 'react-cosmos' | 'react-email' | 'react-native' | 'react-router' | 'relay' | 'release-it' | 'remark' | 'remix' | 'rolldown' | 'rollup' | 'rsbuild' | 'rslib' | 'rspack' | 'rstest' | 'sanity' | 'semantic-release' | 'sentry' | 'serverless-framework' | 'simple-git-hooks' | 'size-limit' | 'solidjs-vite-plugin' | 'sst' | 'starlight' | 'stencil' | 'storybook' | 'stryker' | 'stylelint' | 'svelte' | 'sveltejs-package' | 'sveltekit' | 'svgo' | 'svgr' | 'swc' | 'syncpack' | 'tailwind' | 'tanstack-router' | 'taskfile' | 'tauri' | 'temporal' | 'textlint' | 'travis' | 'ts-node' | 'tsd' | 'tsdown' | 'tsrs' | 'tsup' | 'tsx' | 'turbo' | 'typedoc' | 'typescript' | 'typescript-content-mapper' | 'unbuild' | 'unocss' | 'unplugin-auto-import' | 'unplugin-icons' | 'unplugin-vue-components' | 'unplugin-vue-i18n' | 'unplugin-vue-markdown' | 'unplugin-vue-router' | 'varlock' | 'vercel' | 'vercel-og' | 'vike' | 'vite' | 'vite-plugin-pages' | 'vite-plugin-pwa' | 'vite-plugin-vue-layouts-next' | 'vite-plus' | 'vite-pwa-assets-generator' | 'vitepress' | 'vitest' | 'vue' | 'webdriver-io' | 'webpack' | 'wireit' | 'wrangler' | 'wxt' | 'xo' | 'yarn' | 'yorkie' | 'zx';
+export declare const pluginNames: readonly ['angular', 'astro', 'astro-db', 'astro-markdoc', 'astro-og-canvas', 'ava', 'babel', 'biome', 'borp', 'buf', 'bumpp', 'bun', 'c8', 'capacitor', 'catalyst', 'changelogen', 'changelogithub', 'changesets', 'commitizen', 'commitlint', 'convex', 'create-typescript-app', 'cspell', 'cucumber', 'cypress', 'danger', 'dependency-cruiser', 'docusaurus', 'dotenv', 'drizzle', 'electron-forge', 'electron-vite', 'eleventy', 'esbuild', 'eslint', 'eve', 'execa', 'expo', 'expo-router', 'expressive-code', 'fast', 'filesystem-routing', 'flue', 'fumadocs', 'gatsby', 'github-action', 'github-actions', 'glob', 'graphql-codegen', 'hardhat', 'husky', 'i18next-parser', 'jasmine', 'jest', 'karma', 'knex', 'kysely-codegen', 'ladle', 'laravel-vite-plugin', 'lefthook', 'lingui', 'lint-staged', 'linthtml', 'lit', 'lockfile-lint', 'lost-pixel', 'lunaria', 'markdownlint', 'marko', 'mastra', 'mcp', 'mdx', 'mdxlint', 'metro', 'mise', 'mocha', 'moonrepo', 'msw', 'nano-spawn', 'nano-staged', 'nest', 'netlify', 'next', 'next-intl', 'next-mdx', 'nitro', 'node', 'node-modules-inspector', 'nodemon', 'npm-package-json-lint', 'nuxt', 'nuxtjs-i18n', 'nx', 'nyc', 'oclif', 'openapi-ts', 'openclaw', 'orval', 'osls', 'oxfmt', 'oxlint', 'panda-css', 'parcel', 'payload', 'pino', 'playwright', 'playwright-ct', 'playwright-test', 'plop', 'pm2', 'pnpm', 'postcss', 'pre-commit', 'preconstruct', 'prettier', 'prisma', 'purgecss', 'quasar', 'qwik', 'railway', 'raycast', 'react-cosmos', 'react-email', 'react-native', 'react-router', 'relay', 'release-it', 'remark', 'remix', 'rolldown', 'rollup', 'rsbuild', 'rslib', 'rspack', 'rstest', 'sanity', 'semantic-release', 'sentry', 'serverless-framework', 'simple-git-hooks', 'size-limit', 'solidjs-vite-plugin', 'sst', 'starlight', 'stencil', 'storybook', 'stryker', 'stylelint', 'svelte', 'sveltejs-package', 'sveltekit', 'svgo', 'svgr', 'swc', 'syncpack', 'tailwind', 'tanstack-router', 'taskfile', 'tauri', 'temporal', 'textlint', 'travis', 'ts-node', 'tsd', 'tsdown', 'tsrs', 'tsup', 'tsx', 'turbo', 'typedoc', 'typescript', 'typescript-content-mapper', 'unbuild', 'unocss', 'unplugin-auto-import', 'unplugin-icons', 'unplugin-vue-components', 'unplugin-vue-i18n', 'unplugin-vue-markdown', 'unplugin-vue-router', 'varlock', 'vercel', 'vercel-og', 'vike', 'vite', 'vite-plugin-pages', 'vite-plugin-pwa', 'vite-plugin-vue-layouts-next', 'vite-plus', 'vite-pwa-assets-generator', 'vitepress', 'vitest', 'vue', 'webdriver-io', 'webpack', 'wireit', 'wrangler', 'wxt', 'xo', 'yarn', 'yorkie', 'zx'];

package/dist/types/PluginNames.js

@@ -55,9 +55,11 @@ export const pluginNames = [
     'jest',
     'karma',
     'knex',
+    'kysely-codegen',
     'ladle',
     'laravel-vite-plugin',
     'lefthook',
+    'lingui',
     'lint-staged',
     'linthtml',
     'lit',
@@ -66,6 +68,7 @@ export const pluginNames = [
     'lunaria',
     'markdownlint',
     'marko',
+    'mastra',
     'mcp',
     'mdx',
     'mdxlint',
@@ -112,6 +115,7 @@ export const pluginNames = [
     'preconstruct',
     'prettier',
     'prisma',
+    'purgecss',
     'quasar',
     'qwik',
     'railway',

package/dist/types/config.d.ts

@@ -17,6 +17,7 @@ export interface GetInputsFromScriptsOptions extends BaseOptions {
     optionalBinaries?: boolean;
     containingFilePath: string;
     expandedScripts?: Set<string>;
+    manifestDir?: string;
 }
 export type GetInputsFromScripts<T = GetInputsFromScriptsOptions> = (npmScripts: string | string[] | Set<string>, options: T) => Input[];
 export type GetInputsFromScriptsPartial = (npmScripts: string | string[] | Set<string>, options?: Partial<GetInputsFromScriptsOptions>) => Input[];

package/dist/types/issues.d.ts

@@ -71,6 +71,10 @@ export type ReporterOptions = {
     selectedWorkspaces: string[] | undefined;
     configFilePath: string | undefined;
     maxShowIssues?: number;
+    write?: (output: string) => void;
+};
+export type InternalReporterOptions = ReporterOptions & {
+    write: (output: string) => void;
 };
 export type Reporter = (options: ReporterOptions) => void;
 export type Preprocessor = (options: ReporterOptions) => ReporterOptions;

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

@@ -28,9 +28,6 @@ type Dependencies = Record<string, string>;
 type TypesVersions = Record<string, Record<string, string[]>>;
 export type PackageExtensions = Record<string, {
     peerDependencies?: Dependencies;
-    peerDependenciesMeta?: Record<string, {
-        optional?: boolean;
-    }>;
 }>;
 export type PackageJson = {
     name?: string;

package/dist/typescript/get-imports-and-exports.js

@@ -26,6 +26,7 @@ const getImportsAndExports = (filePath, sourceText, resolveModule, options, igno
     const scripts = new Set();
     const importGlobs = [];
     const handledImportExpressions = new Set();
+    const caughtImportExpressions = new Set();
     const importAliases = new Map();
     const addImportAlias = (aliasName, id, importFilePath) => {
         const aliases = importAliases.get(aliasName);
@@ -342,6 +343,7 @@ const getImportsAndExports = (filePath, sourceText, resolveModule, options, igno
         programFiles,
         entryFiles,
         handledImportExpressions,
+        caughtImportExpressions,
         visitor,
         getJSDocTags,
     });

package/dist/typescript/visitors/calls.js

@@ -1,5 +1,6 @@
 import { IMPORT_FLAGS, OPAQUE } from '../../constants.js';
 import { addValue } from '../../util/module-graph.js';
+import { isStartsLikePackageName } from '../../util/modules.js';
 import { getSafeScriptFromArgs, getScriptFromArg, getStringValue, isStringLiteral } from '../ast-nodes.js';
 import { isShadowed } from './walk.js';
 function getRegisteredCustomElement(node, s) {
@@ -136,23 +137,26 @@ export function handleCallExpression(node, s) {
         s.addImport(specifier, undefined, undefined, undefined, node.arguments[0].start, IMPORT_FLAGS.ENTRY);
         return;
     }
-    if (s.hasNodeModuleImport &&
-        ((node.callee.type === 'MemberExpression' &&
-            node.callee.object.type === 'Identifier' &&
-            node.callee.object.name === 'module' &&
-            !node.callee.computed &&
-            node.callee.property.name === 'register') ||
-            (node.callee.type === 'Identifier' && node.callee.name === 'register')) &&
-        node.arguments.length >= 1 &&
-        isStringLiteral(node.arguments[0])) {
+    if (s.hasNodeModuleImport && node.arguments.length >= 1 && isStringLiteral(node.arguments[0])) {
+        const { callee } = node;
+        const nodeModuleMethod = callee.type === 'Identifier'
+            ? callee.name
+            : callee.type === 'MemberExpression' &&
+                !callee.computed &&
+                callee.object.type === 'Identifier' &&
+                callee.object.name === 'module' &&
+                callee.property.type === 'Identifier' &&
+                callee.property.name;
         const specifier = getStringValue(node.arguments[0]);
         const arg1 = node.arguments[1];
-        if (specifier &&
+        if ((nodeModuleMethod === 'register' &&
+            specifier &&
             (!specifier.startsWith('.') ||
                 (arg1?.type === 'MemberExpression' &&
                     !arg1.computed &&
                     arg1.object.type === 'MetaProperty' &&
-                    arg1.property.name === 'url'))) {
+                    arg1.property.name === 'url'))) ||
+            (nodeModuleMethod === 'findPackageJSON' && isStartsLikePackageName(specifier) && !URL.canParse(specifier))) {
             s.addImport(specifier, undefined, undefined, undefined, node.arguments[0].start, IMPORT_FLAGS.ENTRY);
             return;
         }

package/dist/typescript/visitors/imports.d.ts

@@ -1,4 +1,6 @@
-import type { ImportExpression, VariableDeclarator } from 'oxc-parser';
+import type { ArrayExpression, CallExpression, Expression, ImportExpression, VariableDeclarator } from 'oxc-parser';
 import type { WalkState } from './walk.ts';
+export declare function getPromiseAllElements(expression: Expression): ArrayExpression['elements'] | undefined;
 export declare function handleVariableDeclarator(node: VariableDeclarator, s: WalkState): void;
+export declare function handleImportThen(node: CallExpression, s: WalkState): void;
 export declare function handleImportExpression(node: ImportExpression, s: WalkState): void;

package/dist/typescript/visitors/imports.js

@@ -2,6 +2,17 @@ import { IMPORT_FLAGS, IMPORT_STAR, OPAQUE } from '../../constants.js';
 import { addValue } from '../../util/module-graph.js';
 import { isInNodeModules } from '../../util/path.js';
 import { getStringValue, isStringLiteral } from '../ast-nodes.js';
+export function getPromiseAllElements(expression) {
+    if (expression.type === 'CallExpression' &&
+        expression.callee.type === 'MemberExpression' &&
+        !expression.callee.computed &&
+        expression.callee.object.type === 'Identifier' &&
+        expression.callee.object.name === 'Promise' &&
+        expression.callee.property.name === 'all' &&
+        expression.arguments[0]?.type === 'ArrayExpression') {
+        return expression.arguments[0].elements;
+    }
+}
 export function handleVariableDeclarator(node, s) {
     const init = node.init;
     if (!init)
@@ -14,45 +25,8 @@ export function handleVariableDeclarator(node, s) {
         importExpr = init;
     }
     if (importExpr && isStringLiteral(importExpr.source)) {
-        s.handledImportExpressions.add(importExpr.start);
-        const specifier = getStringValue(importExpr.source);
-        if (node.id.type === 'ObjectPattern') {
-            for (const prop of node.id.properties) {
-                if (prop.type === 'Property') {
-                    const importedName = prop.key?.type === 'Identifier'
-                        ? prop.key.name
-                        : prop.key?.type === 'Literal' && typeof prop.key.value === 'string'
-                            ? prop.key.value
-                            : undefined;
-                    const localName = prop.value?.type === 'Identifier' ? prop.value.name : importedName;
-                    const alias = localName !== importedName ? localName : undefined;
-                    s.addImport(specifier, importedName, alias, undefined, prop.key?.start ?? prop.start, IMPORT_FLAGS.DYNAMIC);
-                }
-                else if (prop.type === 'RestElement' && prop.argument?.type === 'Identifier') {
-                    s.addImport(specifier, IMPORT_STAR, prop.argument.name, undefined, prop.start, IMPORT_FLAGS.DYNAMIC);
-                }
-            }
-        }
-        else if (node.id.type === 'Identifier') {
-            if (init.type === 'AwaitExpression') {
-                s.addImport(specifier, 'default', node.id.name, undefined, importExpr.source.start, IMPORT_FLAGS.DYNAMIC);
-                const resolved = s.resolveModule(specifier, s.filePath);
-                if (resolved && !resolved.isExternalLibraryImport && !isInNodeModules(resolved.resolvedFileName)) {
-                    s.localImportMap.set(node.id.name, {
-                        importedName: IMPORT_STAR,
-                        filePath: resolved.resolvedFileName,
-                        isNamespace: true,
-                        isDynamicImport: true,
-                    });
-                }
-            }
-            else {
-                s.addImport(specifier, undefined, undefined, undefined, importExpr.source.start, IMPORT_FLAGS.DYNAMIC | IMPORT_FLAGS.OPAQUE);
-            }
-        }
-        else {
-            s.addImport(specifier, undefined, undefined, undefined, importExpr.source.start, IMPORT_FLAGS.DYNAMIC | IMPORT_FLAGS.OPAQUE);
-        }
+        const caughtFlag = init.type === 'AwaitExpression' && s.caughtTryBlockEnds.length > 0 ? IMPORT_FLAGS.CAUGHT : IMPORT_FLAGS.NONE;
+        handleDynamicImportBinding(node.id, importExpr, init.type === 'AwaitExpression', caughtFlag, s);
         return;
     }
     if (init.type === 'CallExpression' &&
@@ -87,16 +61,8 @@ export function handleVariableDeclarator(node, s) {
         }
         return;
     }
-    if (init.type === 'AwaitExpression' &&
-        init.argument.type === 'CallExpression' &&
-        init.argument.callee.type === 'MemberExpression' &&
-        !init.argument.callee.computed &&
-        init.argument.callee.object.type === 'Identifier' &&
-        init.argument.callee.object.name === 'Promise' &&
-        init.argument.callee.property.name === 'all' &&
-        init.argument.arguments[0]?.type === 'ArrayExpression' &&
-        node.id.type === 'ArrayPattern') {
-        const imports = init.argument.arguments[0].elements;
+    const imports = init.type === 'AwaitExpression' ? getPromiseAllElements(init.argument) : undefined;
+    if (imports && node.id.type === 'ArrayPattern') {
         const bindings = node.id.elements;
         for (let i = 0; i < imports.length; i++) {
             const imp = imports[i];
@@ -106,6 +72,7 @@ export function handleVariableDeclarator(node, s) {
             if (imp?.type === 'ImportExpression' && isStringLiteral(imp.source)) {
                 s.handledImportExpressions.add(imp.start);
                 const specifier = getStringValue(imp.source);
+                const caughtFlag = s.caughtTryBlockEnds.length > 0 ? IMPORT_FLAGS.CAUGHT : IMPORT_FLAGS.NONE;
                 if (binding?.type === 'ObjectPattern') {
                     for (const prop of binding.properties) {
                         if (prop.type === 'Property') {
@@ -114,12 +81,12 @@ export function handleVariableDeclarator(node, s) {
                                 : prop.key?.type === 'Literal' && typeof prop.key.value === 'string'
                                     ? prop.key.value
                                     : undefined;
-                            s.addImport(specifier, importedName, undefined, undefined, prop.key?.start ?? prop.start, IMPORT_FLAGS.NONE);
+                            s.addImport(specifier, importedName, undefined, undefined, prop.key?.start ?? prop.start, caughtFlag);
                         }
                     }
                 }
                 else if (binding?.type === 'Identifier') {
-                    s.addImport(specifier, 'default', binding.name, undefined, imp.source.start, IMPORT_FLAGS.DYNAMIC);
+                    s.addImport(specifier, 'default', binding.name, undefined, imp.source.start, IMPORT_FLAGS.DYNAMIC | caughtFlag);
                     const resolved = s.resolveModule(specifier, s.filePath);
                     if (resolved && !resolved.isExternalLibraryImport && !isInNodeModules(resolved.resolvedFileName)) {
                         s.localImportMap.set(binding.name, {
@@ -131,7 +98,7 @@ export function handleVariableDeclarator(node, s) {
                     }
                 }
                 else {
-                    s.addImport(specifier, undefined, undefined, undefined, imp.source.start, IMPORT_FLAGS.DYNAMIC | IMPORT_FLAGS.SIDE_EFFECTS);
+                    s.addImport(specifier, undefined, undefined, undefined, imp.source.start, IMPORT_FLAGS.DYNAMIC | IMPORT_FLAGS.SIDE_EFFECTS | caughtFlag);
                 }
             }
         }
@@ -263,11 +230,68 @@ export function handleVariableDeclarator(node, s) {
         }
     }
 }
+function handleDynamicImportBinding(id, importExpr, isAwaited, caughtFlag, s) {
+    s.handledImportExpressions.add(importExpr.start);
+    const specifier = getStringValue(importExpr.source);
+    if (id.type === 'ObjectPattern') {
+        for (const prop of id.properties) {
+            if (prop.type === 'Property') {
+                const importedName = prop.key?.type === 'Identifier'
+                    ? prop.key.name
+                    : prop.key?.type === 'Literal' && typeof prop.key.value === 'string'
+                        ? prop.key.value
+                        : undefined;
+                const localName = prop.value?.type === 'Identifier' ? prop.value.name : importedName;
+                const alias = localName !== importedName ? localName : undefined;
+                s.addImport(specifier, importedName, alias, undefined, prop.key?.start ?? prop.start, IMPORT_FLAGS.DYNAMIC | caughtFlag);
+            }
+            else if (prop.type === 'RestElement' && prop.argument?.type === 'Identifier') {
+                s.addImport(specifier, IMPORT_STAR, prop.argument.name, undefined, prop.start, IMPORT_FLAGS.DYNAMIC | caughtFlag);
+            }
+        }
+    }
+    else if (id.type === 'Identifier') {
+        if (isAwaited) {
+            s.addImport(specifier, 'default', id.name, undefined, importExpr.source.start, IMPORT_FLAGS.DYNAMIC | caughtFlag);
+            const resolved = s.resolveModule(specifier, s.filePath);
+            if (resolved && !resolved.isExternalLibraryImport && !isInNodeModules(resolved.resolvedFileName)) {
+                s.localImportMap.set(id.name, {
+                    importedName: IMPORT_STAR,
+                    filePath: resolved.resolvedFileName,
+                    isNamespace: true,
+                    isDynamicImport: true,
+                });
+            }
+        }
+        else {
+            s.addImport(specifier, undefined, undefined, undefined, importExpr.source.start, IMPORT_FLAGS.DYNAMIC | IMPORT_FLAGS.OPAQUE | caughtFlag);
+        }
+    }
+    else {
+        s.addImport(specifier, undefined, undefined, undefined, importExpr.source.start, IMPORT_FLAGS.DYNAMIC | IMPORT_FLAGS.OPAQUE | caughtFlag);
+    }
+}
+export function handleImportThen(node, s) {
+    const callee = node.callee;
+    if (callee.type !== 'MemberExpression' || callee.computed || callee.property.name !== 'then')
+        return;
+    if (callee.object.type !== 'ImportExpression' || !isStringLiteral(callee.object.source))
+        return;
+    const fn = node.arguments[0];
+    if (fn?.type !== 'ArrowFunctionExpression' && fn?.type !== 'FunctionExpression')
+        return;
+    const param = fn.params[0];
+    if (param?.type !== 'Identifier' && param?.type !== 'ObjectPattern')
+        return;
+    const caughtFlag = s.caughtImportExpressions.has(callee.object.start) ? IMPORT_FLAGS.CAUGHT : IMPORT_FLAGS.NONE;
+    handleDynamicImportBinding(param, callee.object, true, caughtFlag, s);
+}
 export function handleImportExpression(node, s) {
     if (s.handledImportExpressions.has(node.start))
         return;
     const specifier = getStringValue(node.source);
     if (specifier) {
-        s.addImport(specifier, undefined, undefined, undefined, node.source.start, IMPORT_FLAGS.DYNAMIC | IMPORT_FLAGS.OPAQUE);
+        const caughtFlag = s.caughtImportExpressions.has(node.start) ? IMPORT_FLAGS.CAUGHT : IMPORT_FLAGS.NONE;
+        s.addImport(specifier, undefined, undefined, undefined, node.source.start, IMPORT_FLAGS.DYNAMIC | IMPORT_FLAGS.OPAQUE | caughtFlag);
     }
 }