knip 0.0.0-angular.0

package/dist/plugins/remix/index.js

@@ -0,0 +1,11 @@
+import { hasDependency } from '../../util/plugin.js';
+export const NAME = 'Remix';
+export const ENABLERS = [/^@remix-run\//];
+export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
+export const ENTRY_FILE_PATTERNS = ['remix.config.js', 'remix.init/index.js'];
+export const PRODUCTION_ENTRY_FILE_PATTERNS = [
+    'app/root.tsx',
+    'app/entry.{client,server}.{js,jsx,ts,tsx}',
+    'app/routes/**/*.{js,ts,tsx}',
+    'server.{js,ts}',
+];

package/dist/plugins/rollup/index.d.ts

@@ -0,0 +1,5 @@
+import type { IsPluginEnabledCallback } from '../../types/plugins.js';
+export declare const NAME = "Rollup";
+export declare const ENABLERS: string[];
+export declare const isEnabled: IsPluginEnabledCallback;
+export declare const ENTRY_FILE_PATTERNS: string[];

package/dist/plugins/rollup/index.js

@@ -0,0 +1,5 @@
+import { hasDependency } from '../../util/plugin.js';
+export const NAME = 'Rollup';
+export const ENABLERS = ['rollup'];
+export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
+export const ENTRY_FILE_PATTERNS = ['rollup.config.{js,mjs,ts}'];

package/dist/plugins/semantic-release/index.d.ts

@@ -0,0 +1,6 @@
+import type { IsPluginEnabledCallback, GenericPluginCallback } from '../../types/plugins.js';
+export declare const NAME = "Semantic Release";
+export declare const ENABLERS: string[];
+export declare const isEnabled: IsPluginEnabledCallback;
+export declare const CONFIG_FILE_PATTERNS: string[];
+export declare const findDependencies: GenericPluginCallback;

package/dist/plugins/semantic-release/index.js

@@ -0,0 +1,17 @@
+import { timerify } from '../../util/Performance.js';
+import { hasDependency, load } from '../../util/plugin.js';
+export const NAME = 'Semantic Release';
+export const ENABLERS = ['semantic-release'];
+export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
+export const CONFIG_FILE_PATTERNS = [
+    '.releaserc',
+    '.releaserc.{yaml,yml,json,js,cjs}',
+    'release.config.{js,cjs}',
+    'package.json',
+];
+const findSemanticReleaseDependencies = async (configFilePath, { manifest }) => {
+    const config = configFilePath.endsWith('package.json') ? manifest.release : await load(configFilePath);
+    const plugins = config?.plugins ?? [];
+    return plugins.map(plugin => (Array.isArray(plugin) ? plugin[0] : plugin));
+};
+export const findDependencies = timerify(findSemanticReleaseDependencies);

package/dist/plugins/semantic-release/types.d.ts

@@ -0,0 +1,3 @@
+export type PluginConfig = {
+    plugins?: (string | [string, Record<string, unknown>])[];
+};

package/dist/plugins/semantic-release/types.js

@@ -0,0 +1 @@
+export {};

package/dist/plugins/sentry/index.d.ts

@@ -0,0 +1,5 @@
+import type { IsPluginEnabledCallback } from '../../types/plugins.js';
+export declare const NAME = "Sentry";
+export declare const ENABLERS: RegExp[];
+export declare const isEnabled: IsPluginEnabledCallback;
+export declare const ENTRY_FILE_PATTERNS: string[];

package/dist/plugins/sentry/index.js

@@ -0,0 +1,5 @@
+import { hasDependency } from '../../util/plugin.js';
+export const NAME = 'Sentry';
+export const ENABLERS = [/^@sentry\//];
+export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
+export const ENTRY_FILE_PATTERNS = ['sentry.{client,server,edge}.config.{js,ts}'];

package/dist/plugins/storybook/index.d.ts

@@ -0,0 +1,8 @@
+import type { IsPluginEnabledCallback, GenericPluginCallback } from '../../types/plugins.js';
+export declare const NAME = "Storybook";
+export declare const ENABLERS: (string | RegExp)[];
+export declare const isEnabled: IsPluginEnabledCallback;
+export declare const CONFIG_FILE_PATTERNS: string[];
+export declare const ENTRY_FILE_PATTERNS: string[];
+export declare const PROJECT_FILE_PATTERNS: string[];
+export declare const findDependencies: GenericPluginCallback;

package/dist/plugins/storybook/index.js

@@ -0,0 +1,19 @@
+import { timerify } from '../../util/Performance.js';
+import { hasDependency, load } from '../../util/plugin.js';
+export const NAME = 'Storybook';
+export const ENABLERS = [/^@storybook\//, '@nrwl/storybook'];
+export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
+export const CONFIG_FILE_PATTERNS = ['.storybook/{main,manager}.{js,ts}'];
+export const ENTRY_FILE_PATTERNS = ['.storybook/preview.{js,jsx,ts,tsx}', '**/*.stories.{js,jsx,ts,tsx}'];
+export const PROJECT_FILE_PATTERNS = ['.storybook/**/*.{js,jsx,ts,tsx}'];
+const findStorybookDependencies = async (configFilePath) => {
+    const config = await load(configFilePath);
+    if (!config)
+        return [];
+    const addons = config.addons?.map(addon => (typeof addon === 'string' ? addon : addon.name)) ?? [];
+    const builder = config?.core?.builder;
+    const builderPackages = builder && /webpack/.test(builder) ? [`@storybook/builder-${builder}`, `@storybook/manager-${builder}`] : [];
+    const frameworks = config.framework?.name ? [config.framework.name] : [];
+    return [...addons, ...builderPackages, ...frameworks];
+};
+export const findDependencies = timerify(findStorybookDependencies);

package/dist/plugins/storybook/types.d.ts

@@ -0,0 +1,11 @@
+export type StorybookConfig = {
+    addons?: (string | {
+        name: string;
+    })[];
+    core?: {
+        builder?: string;
+    };
+    framework?: {
+        name?: string;
+    };
+};

package/dist/plugins/storybook/types.js

@@ -0,0 +1 @@
+export {};

package/dist/plugins/stryker/index.d.ts

@@ -0,0 +1,6 @@
+import type { IsPluginEnabledCallback, GenericPluginCallback } from '../../types/plugins.js';
+export declare const NAME = "Stryker";
+export declare const ENABLERS: string[];
+export declare const isEnabled: IsPluginEnabledCallback;
+export declare const CONFIG_FILE_PATTERNS: string[];
+export declare const findDependencies: GenericPluginCallback;

package/dist/plugins/stryker/index.js

@@ -0,0 +1,17 @@
+import { timerify } from '../../util/Performance.js';
+import { hasDependency, load } from '../../util/plugin.js';
+export const NAME = 'Stryker';
+export const ENABLERS = ['@stryker-mutator/core'];
+export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
+export const CONFIG_FILE_PATTERNS = ['?(.)stryker.{conf,config}.{js,mjs,cjs,json}'];
+const findStrykerDependencies = async (configFilePath) => {
+    const config = await load(configFilePath);
+    if (config) {
+        const runners = config.testRunner ? [`@stryker-mutator/${config.testRunner}-runner`] : [];
+        const checkers = config.checkers ? config.checkers.map(checker => `@stryker-mutator/${checker}-checker`) : [];
+        const plugins = config.plugins ?? [];
+        return [...runners, ...checkers, ...plugins];
+    }
+    return [];
+};
+export const findDependencies = timerify(findStrykerDependencies);

package/dist/plugins/stryker/types.d.ts

@@ -0,0 +1,5 @@
+export type StrykerConfig = {
+    testRunner?: string;
+    checkers?: string[];
+    plugins?: string[];
+};

package/dist/plugins/stryker/types.js

@@ -0,0 +1 @@
+export {};

package/dist/plugins/stylelint/index.d.ts

@@ -0,0 +1,6 @@
+import type { IsPluginEnabledCallback, GenericPluginCallback } from '../../types/plugins.js';
+export declare const NAME = "Stylelint";
+export declare const ENABLERS: string[];
+export declare const isEnabled: IsPluginEnabledCallback;
+export declare const CONFIG_FILE_PATTERNS: string[];
+export declare const findDependencies: GenericPluginCallback;

package/dist/plugins/stylelint/index.js

@@ -0,0 +1,22 @@
+import { isInternal } from '../../util/path.js';
+import { timerify } from '../../util/Performance.js';
+import { hasDependency, load } from '../../util/plugin.js';
+export const NAME = 'Stylelint';
+export const ENABLERS = ['stylelint'];
+export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
+export const CONFIG_FILE_PATTERNS = [
+    '.stylelintrc',
+    '.stylelintrc.{cjs,js,json,yaml,yml}',
+    'stylelint.config.{cjs,mjs,js}',
+];
+const findPluginDependencies = async (configFilePath, { manifest }) => {
+    const config = configFilePath.endsWith('package.json')
+        ? manifest.stylelint
+        : await load(configFilePath);
+    if (!config)
+        return [];
+    const extend = config.extends ? [config.extends].flat().filter(extend => !isInternal(extend)) : [];
+    const plugins = config.plugins ? [config.plugins].flat().filter(plugin => !isInternal(plugin)) : [];
+    return [...extend, ...plugins];
+};
+export const findDependencies = timerify(findPluginDependencies);

package/dist/plugins/stylelint/types.d.ts

@@ -0,0 +1,4 @@
+export type PluginConfig = {
+    extends?: string | string[];
+    plugins?: string[];
+};

package/dist/plugins/stylelint/types.js

@@ -0,0 +1 @@
+export {};

package/dist/plugins/svelte/index.d.ts

@@ -0,0 +1,7 @@
+import type { IsPluginEnabledCallback } from '../../types/plugins.js';
+export declare const NAME = "Svelte";
+export declare const ENABLERS: string[];
+export declare const isEnabled: IsPluginEnabledCallback;
+export declare const ENTRY_FILE_PATTERNS: string[];
+export declare const PRODUCTION_ENTRY_FILE_PATTERNS: string[];
+export declare const PROJECT_FILE_PATTERNS: string[];

package/dist/plugins/svelte/index.js

@@ -0,0 +1,9 @@
+import { hasDependency } from '../../util/plugin.js';
+export const NAME = 'Svelte';
+export const ENABLERS = ['svelte'];
+export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
+export const ENTRY_FILE_PATTERNS = ['svelte.config.js', 'vite.config.ts'];
+export const PRODUCTION_ENTRY_FILE_PATTERNS = [
+    'src/routes/**/+{page,server,page.server,error,layout,layout.server}{,@*}.{js,ts,svelte}',
+];
+export const PROJECT_FILE_PATTERNS = ['src/**/*.{js,ts,svelte}'];

package/dist/plugins/tailwind/index.d.ts

@@ -0,0 +1,5 @@
+import type { IsPluginEnabledCallback } from '../../types/plugins.js';
+export declare const NAME = "Tailwind";
+export declare const ENABLERS: string[];
+export declare const isEnabled: IsPluginEnabledCallback;
+export declare const CONFIG_FILE_PATTERNS: string[];

package/dist/plugins/tailwind/index.js

@@ -0,0 +1,5 @@
+import { hasDependency } from '../../util/plugin.js';
+export const NAME = 'Tailwind';
+export const ENABLERS = ['tailwindcss'];
+export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
+export const CONFIG_FILE_PATTERNS = ['tailwind.config.{js,cjs,mjs,ts}'];

package/dist/plugins/typedoc/index.d.ts

@@ -0,0 +1,6 @@
+import type { IsPluginEnabledCallback, GenericPluginCallback } from '../../types/plugins.js';
+export declare const NAME = "TypeDoc";
+export declare const ENABLERS: string[];
+export declare const isEnabled: IsPluginEnabledCallback;
+export declare const CONFIG_FILE_PATTERNS: string[];
+export declare const findDependencies: GenericPluginCallback;

package/dist/plugins/typedoc/index.js

@@ -0,0 +1,22 @@
+import { timerify } from '../../util/Performance.js';
+import { hasDependency, load } from '../../util/plugin.js';
+export const NAME = 'TypeDoc';
+export const ENABLERS = ['typedoc'];
+export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
+export const CONFIG_FILE_PATTERNS = [
+    'typedoc.{js,cjs,json,jsonc}',
+    'typedoc.config.{js,cjs}',
+    '.config/typedoc.{js,cjs,json,jsonc}',
+    '.config/typedoc.config.{js,cjs}',
+    'package.json',
+    'tsconfig.json',
+];
+const findTypeDocDependencies = async (configFilePath, { manifest }) => {
+    const config = configFilePath.endsWith('package.json')
+        ? manifest.typedocOptions
+        : configFilePath.endsWith('tsconfig.json')
+            ? (await load(configFilePath)).typedocOptions
+            : await load(configFilePath);
+    return config?.plugin ?? [];
+};
+export const findDependencies = timerify(findTypeDocDependencies);

package/dist/plugins/typedoc/types.d.ts

@@ -0,0 +1,3 @@
+export type PluginConfig = {
+    plugin?: string[];
+};

package/dist/plugins/typedoc/types.js

@@ -0,0 +1 @@
+export {};

package/dist/plugins/typescript/index.d.ts

@@ -0,0 +1,7 @@
+import type { IsPluginEnabledCallback, GenericPluginCallback } from '../../types/plugins.js';
+export declare const NAME = "TypeScript";
+export declare const ENABLERS: string[];
+export declare const isEnabled: IsPluginEnabledCallback;
+export declare const CONFIG_FILE_PATTERNS: string[];
+export declare const findTypeScriptDependencies: GenericPluginCallback;
+export declare const findDependencies: GenericPluginCallback;

package/dist/plugins/typescript/index.js

@@ -0,0 +1,42 @@
+import { compact } from '../../util/array.js';
+import { dirname, isInternal, toAbsolute } from '../../util/path.js';
+import { timerify } from '../../util/Performance.js';
+import { hasDependency, load } from '../../util/plugin.js';
+import { loadTSConfig } from '../../util/tsconfig-loader.js';
+export const NAME = 'TypeScript';
+export const ENABLERS = ['typescript'];
+export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
+export const CONFIG_FILE_PATTERNS = ['tsconfig.json'];
+const resolveExtensibleConfig = async (configFilePath) => {
+    const config = await load(configFilePath);
+    config.extends = config.extends ? [config.extends].flat() : [];
+    if (config?.extends) {
+        for (const extend of [config.extends].flat()) {
+            if (isInternal(extend)) {
+                const presetConfigPath = toAbsolute(extend, dirname(configFilePath));
+                const presetConfig = await resolveExtensibleConfig(presetConfigPath);
+                config.extends.push(...(presetConfig.extends ? [presetConfig.extends].flat() : []));
+            }
+        }
+    }
+    return config;
+};
+export const findTypeScriptDependencies = async (configFilePath) => {
+    const compilerOptions = await loadTSConfig(configFilePath);
+    const config = await resolveExtensibleConfig(configFilePath);
+    if (!compilerOptions || !config)
+        return [];
+    const extend = config.extends ? [config.extends].flat().filter(extend => !isInternal(extend)) : [];
+    const types = compilerOptions.types ?? [];
+    const plugins = Array.isArray(compilerOptions?.plugins)
+        ? compilerOptions.plugins.map(plugin => (typeof plugin === 'object' && 'name' in plugin ? plugin.name : ''))
+        : [];
+    const importHelpers = compilerOptions?.importHelpers ? ['tslib'] : [];
+    const jsx = compilerOptions?.jsxImportSource
+        ? [compilerOptions.jsxImportSource]
+        : compilerOptions?.jsx
+            ? ['react']
+            : [];
+    return compact([...extend, ...types, ...plugins, ...importHelpers, ...jsx]);
+};
+export const findDependencies = timerify(findTypeScriptDependencies);

package/dist/plugins/vite/index.d.ts

@@ -0,0 +1,6 @@
+import type { IsPluginEnabledCallback, GenericPluginCallback } from '../../types/plugins.js';
+export declare const NAME = "Vite";
+export declare const ENABLERS: string[];
+export declare const isEnabled: IsPluginEnabledCallback;
+export declare const CONFIG_FILE_PATTERNS: string[];
+export declare const findDependencies: GenericPluginCallback;

package/dist/plugins/vite/index.js

@@ -0,0 +1,12 @@
+import { timerify } from '../../util/Performance.js';
+import { hasDependency, load } from '../../util/plugin.js';
+import { findVitestDeps } from '../vitest/index.js';
+export const NAME = 'Vite';
+export const ENABLERS = ['vite'];
+export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
+export const CONFIG_FILE_PATTERNS = ['vite.config.{js,ts}'];
+const findViteDependencies = async (configFilePath) => {
+    const config = await load(configFilePath);
+    return findVitestDeps(config);
+};
+export const findDependencies = timerify(findViteDependencies);

package/dist/plugins/vite/types.d.ts

@@ -0,0 +1,4 @@
+import type { VitestConfig } from '../vitest/types.js';
+export interface ViteConfig extends VitestConfig {
+    plugins: unknown[];
+}

package/dist/plugins/vite/types.js

@@ -0,0 +1 @@
+export {};

package/dist/plugins/vitest/helpers.d.ts

@@ -0,0 +1,6 @@
+import type { VitestConfig } from './types.js';
+type BuiltinEnvironment = 'node' | 'jsdom' | 'happy-dom' | 'edge-runtime';
+type VitestEnvironment = BuiltinEnvironment | (string & Record<never, never>);
+export declare const getEnvPackageName: (env: VitestEnvironment) => any;
+export declare const getExternalReporters: (reporters?: VitestConfig['test']['reporters']) => unknown[];
+export {};

package/dist/plugins/vitest/helpers.js

@@ -0,0 +1,22 @@
+const environments = {
+    node: null,
+    jsdom: null,
+    'happy-dom': null,
+    'edge-runtime': null,
+};
+const envPackageNames = {
+    jsdom: 'jsdom',
+    'happy-dom': 'happy-dom',
+    'edge-runtime': '@edge-runtime/vm',
+};
+export const getEnvPackageName = (env) => {
+    if (env === 'node')
+        return null;
+    if (env in envPackageNames)
+        return envPackageNames[env];
+    return `vitest-environment-${env}`;
+};
+const builtInReporters = ['default', 'verbose', 'dot', 'json', 'tap', 'tap-flat', 'junit', 'hanging-process'];
+export const getExternalReporters = (reporters) => reporters
+    ? [reporters].flat().filter(reporter => typeof reporter === 'string' && !builtInReporters.includes(reporter))
+    : [];

package/dist/plugins/vitest/index.d.ts

@@ -0,0 +1,9 @@
+import type { VitestConfig } from './types.js';
+import type { IsPluginEnabledCallback, GenericPluginCallback } from '../../types/plugins.js';
+export declare const NAME = "Vitest";
+export declare const ENABLERS: string[];
+export declare const isEnabled: IsPluginEnabledCallback;
+export declare const CONFIG_FILE_PATTERNS: string[];
+export declare const ENTRY_FILE_PATTERNS: never[];
+export declare const findVitestDeps: (config: VitestConfig) => any[];
+export declare const findDependencies: GenericPluginCallback;

package/dist/plugins/vitest/index.js

@@ -0,0 +1,25 @@
+import { compact } from '../../util/array.js';
+import { timerify } from '../../util/Performance.js';
+import { hasDependency, load } from '../../util/plugin.js';
+import { getEnvPackageName, getExternalReporters } from './helpers.js';
+export const NAME = 'Vitest';
+export const ENABLERS = ['vitest'];
+export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
+export const CONFIG_FILE_PATTERNS = ['vitest.config.ts'];
+export const ENTRY_FILE_PATTERNS = [];
+export const findVitestDeps = (config) => {
+    if (!config || !config.test)
+        return [];
+    const cfg = config.test;
+    const environments = cfg.environment ? [getEnvPackageName(cfg.environment)] : [];
+    const reporters = getExternalReporters(cfg.reporters);
+    const coverage = cfg.coverage ? [`@vitest/coverage-${cfg.coverage.provider ?? 'v8'}`] : [];
+    const setupFiles = cfg.setupFiles ? [cfg.setupFiles].flat() : [];
+    const globalSetup = cfg.globalSetup ? [cfg.globalSetup].flat() : [];
+    return compact([...environments, ...reporters, ...coverage, ...setupFiles, ...globalSetup]);
+};
+const findVitestDependencies = async (configFilePath) => {
+    const config = await load(configFilePath);
+    return findVitestDeps(config);
+};
+export const findDependencies = timerify(findVitestDependencies);

package/dist/plugins/vitest/types.d.ts

@@ -0,0 +1,11 @@
+export interface VitestConfig {
+    test: {
+        coverage?: {
+            provider: string;
+        };
+        environment?: string;
+        globalSetup?: string | string[];
+        reporters?: (string | unknown)[];
+        setupFiles?: string | string[];
+    };
+}

package/dist/plugins/vitest/types.js

@@ -0,0 +1 @@
+export {};

package/dist/plugins/webpack/index.d.ts

@@ -0,0 +1,6 @@
+import type { IsPluginEnabledCallback, GenericPluginCallback } from '../../types/plugins.js';
+export declare const NAME = "Webpack";
+export declare const ENABLERS: string[];
+export declare const isEnabled: IsPluginEnabledCallback;
+export declare const CONFIG_FILE_PATTERNS: string[];
+export declare const findDependencies: GenericPluginCallback;

package/dist/plugins/webpack/index.js

@@ -0,0 +1,82 @@
+import { compact } from '../../util/array.js';
+import { join } from '../../util/path.js';
+import { timerify } from '../../util/Performance.js';
+import { hasDependency, load } from '../../util/plugin.js';
+import { getDependenciesFromConfig } from '../babel/index.js';
+export const NAME = 'Webpack';
+export const ENABLERS = ['webpack'];
+export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
+export const CONFIG_FILE_PATTERNS = ['webpack.config*.{js,ts}'];
+const hasBabelOptions = (use) => Boolean(use) &&
+    typeof use !== 'string' &&
+    'loader' in use &&
+    typeof use.loader === 'string' &&
+    use.loader === 'babel-loader' &&
+    typeof use.options === 'object';
+const info = { compiler: '', issuer: '', realResource: '', resource: '', resourceQuery: '' };
+const resolveRuleSetDependencies = (rule) => {
+    if (!rule || typeof rule === 'string')
+        return [];
+    if (typeof rule.use === 'string')
+        return [rule.use];
+    let useItem = rule.use ?? rule.loader ?? rule;
+    if (typeof useItem === 'function')
+        useItem = useItem(info);
+    return [useItem].flat().flatMap((useItem) => {
+        if (!useItem)
+            return [];
+        if (hasBabelOptions(useItem)) {
+            return [
+                ...resolveUseItem(useItem),
+                ...getDependenciesFromConfig(useItem.options),
+            ];
+        }
+        return resolveUseItem(useItem);
+    });
+};
+const resolveUseItem = (use) => {
+    if (!use)
+        return [];
+    if (typeof use === 'string')
+        return [use];
+    if ('loader' in use && typeof use.loader === 'string')
+        return [use.loader];
+    return [];
+};
+const findWebpackDependencies = async (configFilePath, { manifest, isProduction }) => {
+    const config = await load(configFilePath);
+    if (!config)
+        return [];
+    const passes = typeof config === 'function' ? [false, true] : [isProduction];
+    const dependencies = passes.flatMap(isProduction => {
+        const env = { production: isProduction };
+        const argv = { mode: isProduction ? 'production' : 'development' };
+        const cfg = typeof config === 'function' ? config(env, argv) : config;
+        return [cfg].flat().flatMap(config => {
+            const dependencies = (config.module?.rules?.flatMap(resolveRuleSetDependencies) ?? []).map(loader => loader.replace(/\?.*/, ''));
+            const entries = [];
+            if (typeof cfg.entry === 'string')
+                entries.push(cfg.entry);
+            else if (Array.isArray(cfg.entry))
+                entries.push(...cfg.entry);
+            else if (typeof cfg.entry === 'object') {
+                Object.values(cfg.entry).map(entry => {
+                    if (typeof entry === 'string')
+                        entries.push(entry);
+                    else if (Array.isArray(entry))
+                        entries.push(...entry);
+                    else if (typeof entry === 'function')
+                        entries.push(entry());
+                    else if (entry && typeof entry === 'object' && 'filename' in entry)
+                        entries.push(entry['filename']);
+                });
+            }
+            return [...dependencies, ...entries.map(entry => (config.context ? join(config.context, entry) : entry))];
+        });
+    });
+    const scripts = Object.values(manifest.scripts ?? {});
+    const webpackCLI = scripts.some(script => script?.includes('webpack ')) ? ['webpack-cli'] : [];
+    const webpackDevServer = scripts.some(script => script?.includes('webpack serve')) ? ['webpack-dev-server'] : [];
+    return compact([...dependencies, ...webpackCLI, ...webpackDevServer]);
+};
+export const findDependencies = timerify(findWebpackDependencies);

package/dist/plugins/webpack/types.d.ts

@@ -0,0 +1,10 @@
+import type { Configuration } from 'webpack';
+type Mode = 'none' | 'development' | 'production';
+export type Env = {
+    production: boolean;
+};
+export type Argv = {
+    mode: Mode;
+};
+export type WebpackConfig = Configuration | ((env: Env, argv: Argv) => Configuration);
+export {};

package/dist/plugins/webpack/types.js

@@ -0,0 +1 @@
+export {};

package/dist/reporters/codeowners.d.ts

@@ -0,0 +1,3 @@
+import type { ReporterOptions } from '../types/issues.js';
+declare const _default: ({ report, issues, isShowProgress, options }: ReporterOptions) => void;
+export default _default;

package/dist/reporters/codeowners.js

@@ -0,0 +1,62 @@
+import { OwnershipEngine } from '@snyk/github-codeowners/dist/lib/ownership/index.js';
+import chalk from 'chalk';
+import { toRelative, relative, resolve } from '../util/path.js';
+import { getTitle, logTitle, logIssueLine } from './util.js';
+const logIssueSet = (issues) => {
+    issues
+        .sort((a, b) => (a.owner < b.owner ? -1 : 1))
+        .forEach(issue => console.log(chalk.cyan(issue.owner), toRelative(issue.symbol)));
+};
+const logIssueRecord = (issues) => {
+    const sortedByFilePath = issues.sort((a, b) => (a.owner < b.owner ? -1 : 1));
+    sortedByFilePath.forEach(({ filePath, symbols, owner, parentSymbol }) => logIssueLine({ owner, filePath, symbols, parentSymbol }));
+};
+export default ({ report, issues, isShowProgress, options }) => {
+    let opts = {};
+    try {
+        opts = options ? JSON.parse(options) : opts;
+    }
+    catch (error) {
+        console.error(error);
+    }
+    const codeownersFilePath = resolve(opts.path ?? '.github/CODEOWNERS');
+    const codeownersEngine = OwnershipEngine.FromCodeownersFile(codeownersFilePath);
+    const reportMultipleGroups = Object.values(report).filter(Boolean).length > 1;
+    const [dependenciesOwner = '[no-owner]'] = codeownersEngine.calcFileOwnership('package.json');
+    const fallbackOwner = dependenciesOwner;
+    let totalIssues = 0;
+    const calcFileOwnership = (filePath) => codeownersEngine.calcFileOwnership(relative(filePath))[0] ?? fallbackOwner;
+    const addOwner = (issue) => ({ ...issue, owner: calcFileOwnership(issue.filePath) });
+    for (const [reportType, isReportType] of Object.entries(report)) {
+        if (isReportType) {
+            const title = reportMultipleGroups && getTitle(reportType);
+            const isSet = issues[reportType] instanceof Set;
+            const toIssue = (filePath) => ({ type: reportType, filePath, symbol: filePath });
+            const issuesForType = issues[reportType] instanceof Set
+                ? Array.from(issues[reportType])
+                    .map(toIssue)
+                    .map(addOwner)
+                : reportType === 'duplicates'
+                    ? Object.values(issues[reportType]).map(Object.values).flat().map(addOwner)
+                    : Object.values(issues[reportType]).map(issues => {
+                        const items = Object.values(issues);
+                        return addOwner({ ...items[0], symbols: items.map(issue => issue.symbol) });
+                    });
+            if (issuesForType.length > 0) {
+                if (totalIssues)
+                    console.log();
+                title && logTitle(title, issuesForType.length);
+                if (isSet) {
+                    logIssueSet(issuesForType);
+                }
+                else {
+                    logIssueRecord(issuesForType);
+                }
+            }
+            totalIssues = totalIssues + issuesForType.length;
+        }
+    }
+    if (totalIssues === 0 && isShowProgress) {
+        console.log('✂️  Excellent, Knip found no issues.');
+    }
+};

package/dist/reporters/compact.d.ts

@@ -0,0 +1,3 @@
+import type { ReporterOptions } from '../types/issues.js';
+declare const _default: ({ report, issues, isShowProgress }: ReporterOptions) => void;
+export default _default;