knip 6.39.0 → 6.41.0

package/dist/plugins/oxlint/index.js

@@ -1,15 +1,11 @@
-import { Visitor } from 'oxc-parser';
-import { findProperty, getPropertyValues } from '../../typescript/ast-helpers.js';
 import { toConfig, toDependency, toEntry } from '../../util/input.js';
 import { dirname, isInternal, toAbsolute } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
 import { getInputsFromSettings } from '../eslint/helpers.js';
-import { getInputsFromSettingsAST } from '../eslint/resolveFromAST.js';
 const title = 'Oxlint';
 const enablers = ['oxlint', 'vite-plus'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = ['.oxlintrc.{json,jsonc}', 'oxlint.config.{ts,mts}', 'vite.config.{js,mjs,ts,cjs,mts,cts}'];
-const isViteConfig = (configFileName) => configFileName.startsWith('vite.config.');
+const config = ['.oxlintrc.{json,jsonc}', 'oxlint.config.{ts,mts}'];
 const args = {
     config: true,
 };
@@ -25,8 +21,7 @@ const resolveJsPlugins = (jsPlugins, configFilePath) => {
     }
     return inputs;
 };
-const isLoadConfig = ({ configFileName }) => !isViteConfig(configFileName);
-const resolveExtendedConfig = (config, configFilePath) => {
+export const resolveExtendedConfig = (config, configFilePath) => {
     const inputs = [];
     for (const entry of config.extends ?? []) {
         if (typeof entry === 'string') {
@@ -43,43 +38,21 @@ const resolveExtendedConfig = (config, configFilePath) => {
     for (const override of config.overrides ?? []) {
         for (const input of resolveJsPlugins(override.jsPlugins, configFilePath))
             inputs.push(input);
+        for (const input of getInputsFromSettings(override.settings))
+            inputs.push(input);
     }
     for (const input of getInputsFromSettings(config.settings))
         inputs.push(input);
     return inputs;
 };
 const resolveConfig = (config, options) => resolveExtendedConfig(config, options.configFilePath);
-const resolveFromAST = (program, options) => {
-    if (!isViteConfig(options.configFileName))
-        return [];
-    const jsPlugins = new Set();
-    const visitor = new Visitor({
-        ObjectExpression(node) {
-            const lint = findProperty(node, 'lint');
-            if (lint?.type !== 'ObjectExpression')
-                return;
-            for (const specifier of getPropertyValues(lint, 'jsPlugins'))
-                jsPlugins.add(specifier);
-            for (const plugin of findProperty(lint, 'jsPlugins')?.elements ?? []) {
-                if (plugin?.type !== 'ObjectExpression')
-                    continue;
-                for (const specifier of getPropertyValues(plugin, 'specifier'))
-                    jsPlugins.add(specifier);
-            }
-        },
-    });
-    visitor.visit(program);
-    return [...resolveJsPlugins([...jsPlugins], options.configFilePath), ...getInputsFromSettingsAST(program)];
-};
 const isFilterTransitiveDependencies = true;
 const plugin = {
     title,
     enablers,
     isEnabled,
     config,
-    isLoadConfig,
     resolveConfig,
-    resolveFromAST,
     isFilterTransitiveDependencies,
     args,
 };

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

@@ -4,6 +4,7 @@ type JsPlugin = string | {
     specifier: string;
 };
 type Override = {
+    settings?: Settings;
     jsPlugins?: JsPlugin[];
 };
 export type OxlintConfig = {

package/dist/plugins/playwright/index.js

@@ -21,6 +21,23 @@ export const resolveConfig = async (localConfig, options) => {
         inputs.push(toEntry(toAbsolute(id, configFileDir)));
     for (const id of arrayify(localConfig.globalTeardown))
         inputs.push(toEntry(toAbsolute(id, configFileDir)));
+    for (const server of [localConfig.webServer].flat()) {
+        if (!server?.command)
+            continue;
+        const dir = server.cwd ? toAbsolute(server.cwd, configFileDir) : configFileDir;
+        for (const input of options.getInputsFromScripts(server.command, {
+            optionalBinaries: true,
+            cwd: dir,
+            manifest: options.getManifest(dir) ?? options.manifest,
+        })) {
+            const inputDir = input.dir ?? dir;
+            inputs.push({
+                ...input,
+                ...(input.type === 'entry' ? { specifier: toAbsolute(input.specifier, inputDir) } : {}),
+                dir: inputDir,
+            });
+        }
+    }
     const projects = localConfig.projects ? [localConfig, ...localConfig.projects] : [localConfig];
     const reporters = [localConfig.reporter].flat().flatMap(reporter => {
         const name = typeof reporter === 'string' ? reporter : reporter?.[0];

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

@@ -31,6 +31,10 @@ type Project = {
     use: string;
     testMatch?: string | RegExp | (string | RegExp)[];
 };
+type TestConfigWebServer = {
+    command: string;
+    cwd?: string;
+};
 export type PlaywrightTestConfig = {
     projects?: Project[];
     testMatch?: string | RegExp | (string | RegExp)[];
@@ -38,5 +42,6 @@ export type PlaywrightTestConfig = {
     reporter?: LiteralUnion<'dot' | 'line' | 'list' | 'junit' | 'html' | 'json' | 'github' | 'null', string> | ReporterDescription[];
     globalSetup?: string | Array<string>;
     globalTeardown?: string | Array<string>;
+    webServer?: TestConfigWebServer | TestConfigWebServer[];
 };
 export {};

package/dist/plugins/postcss/index.js

@@ -11,7 +11,11 @@ const config = [
 ];
 const resolveConfig = config => {
     const plugins = config.plugins
-        ? (Array.isArray(config.plugins) ? config.plugins : Object.keys(config.plugins)).flatMap(plugin => {
+        ? (Array.isArray(config.plugins)
+            ? config.plugins
+            : Object.entries(config.plugins)
+                .filter(([, options]) => options !== false)
+                .map(([plugin]) => plugin)).flatMap(plugin => {
             if (typeof plugin === 'string')
                 return plugin;
             if (Array.isArray(plugin) && typeof plugin[0] === 'string')

package/dist/plugins/react-native/index.js

@@ -3,7 +3,7 @@ import { hasDependency } from '../../util/plugin.js';
 const title = 'React Native';
 const enablers = ['react-native'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = ['react-native.config.js'];
+const config = ['react-native.config.{js,cjs,mjs,ts}'];
 const RN_CLI_PACKAGES = [
     '@react-native-community/cli',
     '@react-native-community/cli-platform-android',

package/dist/plugins/rsbuild/index.js

@@ -1,11 +1,25 @@
 import { toProductionEntry } from '../../util/input.js';
 import { hasDependency } from '../../util/plugin.js';
+import { resolveConfig as resolveRspackConfig } from '../rspack/index.js';
 const title = 'Rsbuild';
 const enablers = ['@rsbuild/core'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = ['rsbuild*.config.{mjs,ts,js,cjs,mts,cts}'];
-const resolveConfig = async (config) => {
+const configParams = [
+    { env: 'development', command: 'dev', envMode: 'development' },
+    { env: 'production', command: 'build', envMode: 'production' },
+];
+const getConfigs = async (configOrFn) => {
+    if (typeof configOrFn !== 'function')
+        return [configOrFn];
+    const configs = [];
+    for (const params of configParams)
+        configs.push(await configOrFn(params));
+    return configs;
+};
+const resolveConfig = async (configOrFn, options) => {
     const entries = new Set();
+    const inputs = [];
     const checkSource = (source) => {
         if (source?.entry) {
             for (const entry of Object.values(source.entry)) {
@@ -32,13 +46,51 @@ const resolveConfig = async (config) => {
                     entries.add(e);
         }
     };
-    checkSource(config.source);
-    if (config.environments) {
-        for (const environment of Object.values(config.environments)) {
-            checkSource(environment.source);
+    const checkConfig = async (localConfig, config) => {
+        checkSource(localConfig.source);
+        if (!localConfig.tools?.rspack)
+            return;
+        const target = localConfig.output?.target ?? config.output?.target ?? 'web';
+        const mode = localConfig.mode ?? config.mode;
+        const passes = mode ? [mode === 'production'] : options.isProduction ? [true] : [false, true];
+        for (const rspack of [localConfig.tools.rspack].flat()) {
+            for (const isProduction of typeof rspack === 'function' ? passes : [options.isProduction]) {
+                const baseConfig = {
+                    mode: mode ?? (isProduction ? 'production' : 'development'),
+                    entry: {},
+                    resolve: { alias: {} },
+                    module: { rules: [] },
+                    plugins: [],
+                };
+                const utils = {
+                    env: process.env.NODE_ENV ?? '',
+                    isDev: baseConfig.mode === 'development',
+                    isProd: baseConfig.mode === 'production',
+                    target,
+                    isServer: target === 'node',
+                    isWebWorker: target === 'web-worker',
+                };
+                const resolvedConfig = typeof rspack === 'function' ? await rspack(baseConfig, utils) : rspack;
+                const resolvedInputs = await resolveRspackConfig(resolvedConfig ?? baseConfig, {
+                    ...options,
+                    isProduction: options.isProduction || isProduction,
+                });
+                for (const input of resolvedInputs)
+                    inputs.push(input);
+            }
+        }
+    };
+    for (const config of await getConfigs(configOrFn)) {
+        await checkConfig(config, config);
+        if (config.environments) {
+            for (const environment of Object.values(config.environments)) {
+                await checkConfig(environment, config);
+            }
         }
     }
-    return Array.from(entries).map(input => toProductionEntry(input));
+    for (const entry of entries)
+        inputs.push(toProductionEntry(entry));
+    return inputs;
 };
 const plugin = {
     title,

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

@@ -1,15 +1,38 @@
+import type { Configuration } from 'webpack';
 type EntryDescription = Record<string, unknown>;
 type Entry = Record<string, string | string[] | (EntryDescription & {
     html?: boolean;
 })>;
+type RspackConfigUtils = {
+    env: string;
+    isDev: boolean;
+    isProd: boolean;
+    target: 'web' | 'node' | 'web-worker';
+    isServer: boolean;
+    isWebWorker: boolean;
+};
+type RspackConfig = Configuration | ((config: Configuration, utils: RspackConfigUtils) => Configuration | void | Promise<Configuration | void>);
 export type RsbuildConfig = {
     plugins?: unknown[];
+    mode?: 'development' | 'production' | 'none';
+    output?: {
+        target?: RspackConfigUtils['target'];
+    };
     source?: {
         entry?: Entry;
         preEntry?: string | string[];
     };
+    tools?: {
+        rspack?: RspackConfig | RspackConfig[];
+    };
     environments?: {
-        [k: string]: Pick<RsbuildConfig, 'plugins' | 'source'>;
+        [k: string]: Omit<RsbuildConfig, 'environments'>;
     };
 };
+export type ConfigParams = {
+    env: string;
+    command: string;
+    envMode: string;
+};
+export type RsbuildConfigOrFn = RsbuildConfig | ((params: ConfigParams) => RsbuildConfig | Promise<RsbuildConfig>);
 export {};

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

@@ -1,3 +1,5 @@
-import type { Plugin } from '../../types/config.ts';
+import type { Plugin, ResolveConfig } from '../../types/config.ts';
+import type { WebpackConfig } from '../webpack/types.ts';
+export declare const resolveConfig: ResolveConfig<WebpackConfig>;
 declare const plugin: Plugin;
 export default plugin;

package/dist/plugins/rspack/index.js

@@ -5,7 +5,7 @@ const title = 'Rspack';
 const enablers = ['@rspack/core'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = ['rspack.config*.{js,ts,mjs,mts,cjs,cts}'];
-const resolveConfig = async (localConfig, options) => {
+export const resolveConfig = async (localConfig, options) => {
     const inputs = await findWebpackDependenciesFromConfig(localConfig, options);
     return inputs.filter(input => !input.specifier.startsWith('builtin:'));
 };

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

@@ -1,3 +1,4 @@
+import type { ConfigParams } from '../rsbuild/types.ts';
 type TestEnvironment = 'node' | 'jsdom' | 'happy-dom';
 export type RstestProjectConfig = {
     root?: string;
@@ -23,10 +24,5 @@ type RstestConfig = RstestProjectConfig & {
         provider?: 'istanbul' | 'v8';
     };
 };
-type ConfigParams = {
-    env: string;
-    command: string;
-    envMode: string;
-};
 export type RstestConfigOrFn = RstestConfig | ((params: ConfigParams) => RstestConfig | Promise<RstestConfig>);
 export {};

package/dist/plugins/serverless-framework/index.d.ts

@@ -1,3 +1,6 @@
-import type { Plugin } from '../../types/config.ts';
+import type { Plugin, ResolveConfig } from '../../types/config.ts';
+import type { PluginConfig } from './types.ts';
+export declare const config: string[];
+export declare const resolveConfig: ResolveConfig<PluginConfig>;
 declare const plugin: Plugin;
 export default plugin;

package/dist/plugins/serverless-framework/index.js

@@ -1,22 +1,55 @@
 import { arrayify } from '../../util/array.js';
 import { toDependency, toProductionEntry } from '../../util/input.js';
-import { isInternal, join } from '../../util/path.js';
+import { _load } from '../../util/loader.js';
+import { get } from '../../util/object.js';
+import { isInternal, join, toAbsolute } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
 const title = 'Serverless Framework';
 const enablers = ['serverless'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = ['serverless.{js,cjs,mjs,ts,cts,mts,yml,yaml}'];
+export const config = ['serverless.{js,cjs,mjs,ts,cts,mts,yml,yaml}'];
+const fileVariable = /^\$\{file\(([^()$]+)\)(?::([^\s,}]+))?/;
+const isRecord = (value) => typeof value === 'object' && value !== null;
+const resolveFileVariable = async (value, dir) => {
+    const match = typeof value === 'string' && value.match(fileVariable);
+    if (!match)
+        return value;
+    try {
+        const content = await _load(toAbsolute(match[1].trim(), dir));
+        return match[2] ? get(content, match[2]) : content;
+    }
+    catch {
+        return undefined;
+    }
+};
 const handlerToEntry = (handler) => {
     const dot = handler.lastIndexOf('.');
-    return toProductionEntry(`${handler.slice(0, dot)}.{js,ts}`);
+    const file = handler.slice(0, dot);
+    return toProductionEntry(/\.(?:[cm]?[jt]s|[jt]sx)$/.test(file) ? file : `${file}.{js,ts}`);
 };
 const pluginToInput = (plugin, dir) => isInternal(plugin) ? toProductionEntry(join(dir, plugin)) : toDependency(plugin);
+const getFunctionEntries = async (functions, dir) => {
+    const entries = [];
+    const resolved = await resolveFileVariable(functions, dir);
+    for (const group of Array.isArray(resolved) ? resolved : [resolved]) {
+        const fns = await resolveFileVariable(group, dir);
+        if (!isRecord(fns))
+            continue;
+        for (const name in fns) {
+            const fn = await resolveFileVariable(fns[name], dir);
+            if (isRecord(fn) && typeof fn.handler === 'string')
+                entries.push(handlerToEntry(fn.handler));
+        }
+    }
+    return entries;
+};
 const getInjectEntries = (esbuild, dir) => esbuild && typeof esbuild === 'object' ? arrayify(esbuild.inject).map(id => toProductionEntry(join(dir, id))) : [];
-const resolveConfig = async (config, options) => {
-    const functions = config.functions
-        ? Object.values(config.functions).flatMap(fn => (fn.handler ? [handlerToEntry(fn.handler)] : []))
+export const resolveConfig = async (config, options) => {
+    const functions = await getFunctionEntries(config.functions, options.configFileDir);
+    const resolvedPlugins = await resolveFileVariable(config.plugins, options.configFileDir);
+    const plugins = Array.isArray(resolvedPlugins)
+        ? resolvedPlugins.filter((plugin) => typeof plugin === 'string')
         : [];
-    const plugins = config.plugins?.filter((plugin) => typeof plugin === 'string') ?? [];
     const esbuild = config.custom?.esbuild || config.build?.esbuild ? [toDependency('esbuild', { optional: true })] : [];
     const injectEntries = [
         ...getInjectEntries(config.custom?.esbuild, options.configFileDir),

package/dist/plugins/serverless-framework/types.d.ts

@@ -5,9 +5,11 @@ export type PluginConfig = {
     custom?: {
         esbuild?: EsbuildConfig;
     };
-    functions?: Record<string, ServerlessFunction>;
-    plugins?: unknown[];
+    functions?: Functions | Array<Functions | FileVariable> | FileVariable;
+    plugins?: unknown[] | FileVariable;
 };
+type FileVariable = string;
+type Functions = Record<string, ServerlessFunction | FileVariable>;
 export type EsbuildConfig = {
     inject?: string[];
 } | boolean;

package/dist/plugins/simple-git-hooks/index.js

@@ -3,7 +3,7 @@ import { hasDependency } from '../../util/plugin.js';
 const title = 'simple-git-hooks';
 const enablers = ['simple-git-hooks'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = ['.simple-git-hooks.{js,cjs,json}', 'simple-git-hooks.{js,cjs,json}', 'package.json'];
+const config = ['.simple-git-hooks.{js,cjs,mjs,json}', 'simple-git-hooks.{js,cjs,mjs,json}', 'package.json'];
 const resolveConfig = async (config, options) => {
     if (options.isProduction)
         return [];

package/dist/plugins/sveltejs-package/helpers.js

@@ -1,5 +1,6 @@
 import parseArgs from '../../util/parse-args.js';
 import { parse } from 'unbash';
+import { getCommandWords, walkCommands } from '../../util/scripts.js';
 const BIN = 'svelte-package';
 export const DEFAULT_INPUT = 'src/lib';
 export const DEFAULT_OUTPUT = 'dist';
@@ -7,48 +8,6 @@ const parseCommandIO = (args) => {
     const parsed = parseArgs(args, { string: ['i', 'o', 'input', 'output'], alias: { input: ['i'], output: ['o'] } });
     return { input: parsed.input ?? DEFAULT_INPUT, output: parsed.output ?? DEFAULT_OUTPUT };
 };
-const collectFromCommands = (statements, out) => {
-    for (const stmt of statements)
-        visit(stmt.command, out);
-};
-const visit = (node, out) => {
-    switch (node.type) {
-        case 'Command':
-            if (node.name?.value === BIN)
-                out.push(parseCommandIO(node.suffix.map(w => w.value)));
-            return;
-        case 'AndOr':
-        case 'Pipeline':
-            for (const n of node.commands)
-                visit(n, out);
-            return;
-        case 'If':
-            collectFromCommands(node.clause.commands, out);
-            collectFromCommands(node.then.commands, out);
-            if (node.else)
-                visit(node.else, out);
-            return;
-        case 'While':
-            collectFromCommands(node.clause.commands, out);
-            collectFromCommands(node.body.commands, out);
-            return;
-        case 'For':
-        case 'Select':
-        case 'Subshell':
-        case 'BraceGroup':
-            collectFromCommands(node.body.commands, out);
-            return;
-        case 'CompoundList':
-            collectFromCommands(node.commands, out);
-            return;
-        case 'Function':
-        case 'Coproc':
-            visit(node.body, out);
-            return;
-        case 'Statement':
-            visit(node.command, out);
-    }
-};
 export const parseScripts = (scripts) => {
     const out = [];
     for (const script of Object.values(scripts ?? {})) {
@@ -56,8 +15,12 @@ export const parseScripts = (scripts) => {
             continue;
         try {
             const parsed = parse(script);
-            if (parsed.commands)
-                collectFromCommands(parsed.commands, out);
+            for (const statement of parsed.commands) {
+                for (const node of walkCommands(statement.command)) {
+                    if (node.name?.value === BIN)
+                        out.push(parseCommandIO(getCommandWords(node).map(word => word.value)));
+                }
+            }
         }
         catch { }
     }

package/dist/plugins/vitest/index.js

@@ -1,9 +1,11 @@
 import { DEFAULT_EXTENSIONS } from '../../constants.js';
+import { filterTransitiveDependencies } from '../../util/filter-transitive-dependencies.js';
 import { _glob } from '../../util/glob.js';
 import { toConfig, toDeferResolve, toDependency, toEntry, toProductionEntry } from '../../util/input.js';
 import { getPackageNameFromModuleSpecifier } from '../../util/modules.js';
 import { isAbsolute, isInternal, join, toAbsolute, toPosix } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
+import { resolveExtendedConfig } from '../oxlint/index.js';
 import { getHtmlScriptEntries, getIndexHtmlEntries } from '../vite/helpers.js';
 import { getAliasInputs, getEnvSpecifier, getExternalReporters } from './helpers.js';
 import { createVitestMockVisitor } from './visitors/mock.js';
@@ -107,6 +109,7 @@ const getConfigs = async (localConfig) => {
 };
 export const resolveConfig = async (localConfig, options) => {
     const inputs = new Set();
+    const lintInputs = [];
     inputs.add(toEntry(join(options.cwd, 'src/vite-env.d.ts')));
     const configs = await getConfigs(localConfig);
     for (const cfg of configs) {
@@ -134,6 +137,11 @@ export const resolveConfig = async (localConfig, options) => {
     };
     const seenRoots = new Set();
     for (const cfg of configs) {
+        const lint = cfg.lint;
+        if (lint && options.enabledPlugins.includes('oxlint')) {
+            for (const input of resolveExtendedConfig(lint, options.configFilePath))
+                lintInputs.push(input);
+        }
         const viteRoot = toAbsolute(cfg.root ?? '.', options.cwd);
         const publicDir = cfg.publicDir === false || cfg.publicDir === ''
             ? undefined
@@ -143,10 +151,11 @@ export const resolveConfig = async (localConfig, options) => {
             for (const entry of await getIndexHtmlEntries(viteRoot, publicDir))
                 inputs.add(entry);
         }
-        const vitestRoot = cfg.test?.root || !options.isResolvedConfigFile
+        const testRoot = cfg.test?.root || !options.isResolvedConfigFile
             ? toAbsolute(cfg.test?.root ?? '.', options.cwd)
             : toAbsolute('.', options.configFileDir);
-        const dir = cfg.test?.dir ? toAbsolute(cfg.test.dir, vitestRoot) : vitestRoot;
+        const vitestRoot = !cfg.test?.root && cfg.root && !options.isResolvedConfigFile ? toAbsolute(cfg.root, options.cwd) : testRoot;
+        const dir = cfg.test?.dir ? toAbsolute(cfg.test.dir, testRoot) : vitestRoot;
         if (cfg.test) {
             if (cfg.test?.include) {
                 for (const dependency of cfg.test.include)
@@ -205,6 +214,11 @@ export const resolveConfig = async (localConfig, options) => {
         for (const dependency of deps)
             inputs.add(dependency);
     }
+    if (lintInputs.length > 0) {
+        filterTransitiveDependencies(lintInputs, options.configFilePath);
+        for (const input of lintInputs)
+            inputs.add(input);
+    }
     return Array.from(inputs);
 };
 const args = {

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

@@ -1,3 +1,4 @@
+import type { OxlintConfig } from '../oxlint/types.ts';
 interface Alias {
     find: string | RegExp;
     replacement: string;
@@ -37,6 +38,7 @@ interface VitestConfig {
     };
 }
 export interface ViteConfig extends VitestConfig {
+    lint?: OxlintConfig;
     extends?: string | true;
     root?: string;
     publicDir?: string | false;

package/dist/run.js

@@ -17,10 +17,12 @@ import { getGitIgnoredHandler } from './util/glob-core.js';
 import { isCatalog } from './util/input.js';
 import { createManifest } from './util/package-json.js';
 import { getModuleSourcePathHandler, getWorkspacePackageTargetHandler } from './util/to-source-path.js';
+import { clearResolverCache } from './util/resolve.js';
 import { getSessionHandler } from './util/watch.js';
 export const run = async (options) => {
     debugLogObject('*', 'Unresolved configuration', options);
     debugLogObject('*', 'Included issue types', options.includedIssueTypes);
+    clearResolverCache();
     if (options.isCache) {
         initGlobCache(options.cacheLocation);
         initGitignoreCache(options.cacheLocation);