knip 6.35.0 → 6.36.0

package/dist/graph-explorer/operations/resolve-export-origins.js

@@ -0,0 +1,255 @@
+import { isBuiltin } from 'node:module';
+import { IMPORT_FLAGS, IMPORT_STAR } from '../../constants.js';
+import { getCachedExportTable, setCachedExportTable } from '../cache.js';
+import { forEachAliasReExport, forEachNamespaceReExport, forEachPassThroughReExport, getStarReExportSources, } from '../visitors.js';
+const originKey = (origin) => origin.filePath + '\0' + origin.identifier;
+const isExplicit = (info, name) => info.node?.exports.has(name) || info.terminals.has(name);
+export const createExportResolver = (graph) => {
+    const infos = new Map();
+    const getInfo = (filePath) => {
+        const cached = infos.get(filePath);
+        if (cached)
+            return cached;
+        const node = graph.get(filePath);
+        const info = { node, references: new Map(), terminals: new Map(), stars: [] };
+        infos.set(filePath, info);
+        if (!node)
+            return info;
+        const add = (map, name, origin) => {
+            const list = map.get(name);
+            if (list)
+                list.push(origin);
+            else
+                map.set(name, [origin]);
+        };
+        for (const [sourcePath, imports] of node.imports.internal) {
+            if (getStarReExportSources(imports))
+                info.stars.push(sourcePath);
+            forEachNamespaceReExport(imports, name => {
+                const exp = node.exports.get(name);
+                if (!exp || exp.isBindingReExport)
+                    add(info.terminals, name, { filePath: sourcePath, identifier: IMPORT_STAR });
+            });
+            forEachPassThroughReExport(imports, name => {
+                if (node.exports.get(name)?.isBindingReExport)
+                    add(info.references, name, { filePath: sourcePath, identifier: name });
+            });
+            forEachAliasReExport(imports, (identifier, alias) => {
+                if (node.exports.get(alias)?.isBindingReExport)
+                    add(info.references, alias, { filePath: sourcePath, identifier });
+            });
+        }
+        const addExternal = (record) => {
+            if (!(record.modifiers & IMPORT_FLAGS.RE_EXPORT) || !record.identifier)
+                return;
+            const name = record.alias ?? record.identifier;
+            const exp = node.exports.get(name);
+            if ((!exp && !(record.identifier === IMPORT_STAR && record.alias)) ||
+                (record.isTypeOnly && exp && !exp.isBindingReExport) ||
+                info.references.has(name))
+                return;
+            add(info.terminals, name, { filePath: record.specifier, identifier: record.identifier });
+        };
+        for (const record of node.imports.external)
+            addExternal(record);
+        for (const record of node.imports.imports)
+            if (isBuiltin(record.specifier))
+                addExternal(record);
+        return info;
+    };
+    const build = (filePath, identifier) => {
+        const states = new Map();
+        const discovery = [];
+        const updates = [];
+        const request = (path, name) => {
+            let state = states.get(path);
+            if (!state) {
+                state = {
+                    filePath: path,
+                    info: getInfo(path),
+                    names: new Set(),
+                    all: false,
+                    entries: new Map(),
+                    dependents: new Map(),
+                    pending: new Set(),
+                };
+                states.set(path, state);
+            }
+            if (state.all || (name !== undefined && state.names.has(name)))
+                return state;
+            if (name === undefined)
+                state.all = true;
+            else
+                state.names.add(name);
+            discovery.push([state, name]);
+            return state;
+        };
+        const merge = (state, name, origins) => {
+            let entry = state.entries.get(name);
+            let changed = false;
+            if (!entry) {
+                entry = { origins, hasExplicitExport: !!isExplicit(state.info, name) };
+                state.entries.set(name, entry);
+                changed = origins.size > 0;
+            }
+            else if (entry.origins.size === 0) {
+                entry.origins = origins;
+                changed = origins.size > 0;
+            }
+            else {
+                let merged;
+                for (const [key, origin] of origins) {
+                    if (!entry.origins.has(key))
+                        (merged ??= new Map(entry.origins)).set(key, origin);
+                }
+                if (merged) {
+                    entry.origins = merged;
+                    changed = true;
+                }
+            }
+            if (changed) {
+                if (state.pending.size === 0)
+                    updates.push(state);
+                state.pending.add(name);
+            }
+        };
+        const connect = (source, target, sourceName, targetName) => {
+            let edge = source.dependents.get(target);
+            if (!edge)
+                source.dependents.set(target, (edge = { star: false, aliases: new Map() }));
+            if (sourceName === undefined || targetName === undefined)
+                edge.star = true;
+            else {
+                let aliases = edge.aliases.get(sourceName);
+                if (!aliases)
+                    edge.aliases.set(sourceName, (aliases = new Set()));
+                aliases.add(targetName);
+            }
+        };
+        request(filePath, identifier);
+        for (let index = 0; index < discovery.length; index++) {
+            const [state, name] = discovery[index];
+            const cached = getCachedExportTable(graph, state.filePath);
+            if (name === undefined && cached?.complete) {
+                for (const [id, entry] of cached.entries)
+                    merge(state, id, entry.origins);
+                continue;
+            }
+            const seed = (id) => {
+                const entry = cached?.entries.get(id);
+                if (entry) {
+                    merge(state, id, entry.origins);
+                    return;
+                }
+                const terminals = state.info.terminals.get(id);
+                const references = state.info.references.get(id);
+                const exp = state.info.node?.exports.get(id);
+                if (terminals || exp) {
+                    const origins = new Map();
+                    if (terminals)
+                        for (const origin of terminals)
+                            origins.set(originKey(origin), origin);
+                    else if (exp && !exp.isBindingReExport) {
+                        const origin = { filePath: state.filePath, identifier: exp.binding };
+                        origins.set(originKey(origin), origin);
+                    }
+                    merge(state, id, origins);
+                }
+                if (references)
+                    for (const source of references)
+                        connect(request(source.filePath, source.identifier), state, source.identifier, id);
+            };
+            if (name === undefined) {
+                if (state.info.node)
+                    for (const id of state.info.node.exports.keys())
+                        seed(id);
+                for (const id of state.info.terminals.keys())
+                    if (!state.info.node?.exports.has(id))
+                        seed(id);
+                for (const source of state.info.stars)
+                    connect(request(source), state);
+            }
+            else {
+                seed(name);
+                if (cached?.complete || cached?.entries.has(name) || isExplicit(state.info, name) || name === 'default')
+                    continue;
+                for (const source of state.info.stars)
+                    connect(request(source, name), state);
+            }
+        }
+        for (let index = 0; index < updates.length; index++) {
+            const state = updates[index];
+            const names = state.pending;
+            state.pending = new Set();
+            for (const [target, edge] of state.dependents) {
+                for (const name of names) {
+                    const entry = state.entries.get(name);
+                    if (!entry)
+                        continue;
+                    if (edge.star &&
+                        name !== 'default' &&
+                        !isExplicit(target.info, name) &&
+                        (target.all || target.names.has(name)))
+                        merge(target, name, entry.origins);
+                    const aliases = edge.aliases.get(name);
+                    if (aliases)
+                        for (const alias of aliases)
+                            merge(target, alias, entry.origins);
+                }
+            }
+        }
+        for (const state of states.values()) {
+            const cached = getCachedExportTable(graph, state.filePath);
+            if (cached && !state.all) {
+                for (const [name, entry] of state.entries)
+                    cached.entries.set(name, entry);
+            }
+            else
+                setCachedExportTable(graph, state.filePath, { entries: state.entries, complete: state.all });
+        }
+    };
+    const getTable = (filePath) => {
+        if (!getCachedExportTable(graph, filePath)?.complete)
+            build(filePath);
+        return getCachedExportTable(graph, filePath)?.entries ?? new Map();
+    };
+    const resolve = (filePath, identifier) => {
+        const cached = getCachedExportTable(graph, filePath);
+        if (!cached?.complete && !cached?.entries.has(identifier))
+            build(filePath, identifier);
+        return getCachedExportTable(graph, filePath)?.entries.get(identifier);
+    };
+    const getSources = (filePath, identifier) => {
+        const info = getInfo(filePath);
+        if (isExplicit(info, identifier))
+            return info.references.get(identifier) ?? [];
+        return identifier === 'default' ? [] : info.stars.map(source => ({ filePath: source, identifier }));
+    };
+    const reachesOrigin = (source, origin, site) => {
+        const visited = new Set([originKey(site)]);
+        const queue = [source];
+        const key = originKey(origin);
+        for (let index = 0; index < queue.length; index++) {
+            const current = queue[index];
+            const currentKey = originKey(current);
+            if (visited.has(currentKey))
+                continue;
+            visited.add(currentKey);
+            if (current.identifier === IMPORT_STAR && currentKey === key)
+                return true;
+            const info = getInfo(current.filePath);
+            const exp = info.node?.exports.get(current.identifier);
+            if (info.terminals.get(current.identifier)?.some(value => originKey(value) === key))
+                return true;
+            if (exp && !exp.isBindingReExport && originKey({ filePath: current.filePath, identifier: exp.binding }) === key)
+                return true;
+            queue.push(...getSources(current.filePath, current.identifier));
+        }
+        return false;
+    };
+    return { getTable, resolve, getInfo, reachesOrigin };
+};
+export const resolveExportOrigins = (graph, filePath, identifier) => {
+    const entry = createExportResolver(graph).resolve(filePath, identifier);
+    return { origins: entry ? [...entry.origins.values()] : [], hasExplicitExport: entry?.hasExplicitExport ?? false };
+};

package/dist/graph-explorer/utils.js

@@ -27,6 +27,14 @@ export const getExportedIdentifiers = (graph, filePath, visited = new Set()) =>
             continue;
         addIdentifier(identifier);
     }
+    for (const _import of node.imports.imports) {
+        if (!_import.filePath &&
+            _import.modifiers & IMPORT_FLAGS.RE_EXPORT &&
+            _import.identifier === IMPORT_STAR &&
+            _import.alias) {
+            addIdentifier(_import.alias, true);
+        }
+    }
     if (node.imports?.internal) {
         for (const [importedPath, importDetails] of node.imports.internal) {
             forEachPassThroughReExport(importDetails, (id, _sources) => {

package/dist/index.d.ts

@@ -4,6 +4,7 @@ export declare const main: (options: MainOptions) => Promise<{
     counters: import("./types/issues.ts").Counters;
     tagHints: Set<import("./types/issues.ts").TagHint>;
     configurationHints: import("./types/issues.ts").ConfigurationHint[];
+    hasConfigLoadErrors: boolean;
     selectedWorkspaces: string[] | undefined;
     includedWorkspaceDirs: string[];
     enabledPlugins: {

package/dist/plugins/eslint/helpers.js

@@ -16,20 +16,36 @@ export const getInputs = (config, options) => {
     return compact(dependencies).map(id => toDeferResolve(id, { optional: true }));
 };
 const getInputsDeprecated = (config, options) => {
-    const extendsSpecifiers = config.extends ? compact([config.extends].flat().map(resolveExtendSpecifier)) : [];
+    const extendsList = config.extends ? [config.extends].flat() : [];
+    const extendsSpecifiers = compact(extendsList.map(resolveExtendSpecifier));
     if (extendsSpecifiers.some(specifier => specifier?.startsWith('eslint-plugin-prettier')))
         extendsSpecifiers.push('eslint-config-prettier');
-    const extendConfigs = extendsSpecifiers.map(specifier => toConfig('eslint', specifier, { containingFilePath: options.configFilePath }));
+    const extendConfigs = [...extendsList.filter(isInternal), ...extendsSpecifiers].map(specifier => toConfig('eslint', specifier, { containingFilePath: options.configFilePath }));
     const plugins = config.plugins ? config.plugins.map(resolvePluginSpecifier) : [];
-    const parser = config.parser ?? config.parserOptions?.parser;
+    const parsers = getParsers(config);
     const babelDependencies = config.parserOptions?.babelOptions
         ? getDependenciesFromConfig(config.parserOptions.babelOptions)
         : [];
     const settings = config.settings ? getDependenciesFromSettings(config.settings) : [];
     const rules = getDependenciesFromRules({});
     const overrides = config.overrides ? [config.overrides].flat().flatMap(d => getInputsDeprecated(d, options)) : [];
-    const deferred = compact([...extendsSpecifiers, ...plugins, parser, ...settings, ...rules]).map(id => toDeferResolve(id));
-    return [...extendConfigs, ...deferred, ...babelDependencies, ...overrides];
+    const deferred = compact([...extendsSpecifiers, ...plugins, ...settings, ...rules]).map(id => toDeferResolve(id));
+    return [...extendConfigs, ...deferred, ...parsers, ...babelDependencies, ...overrides];
+};
+const isParserObject = (value) => typeof value.parseForESLint === 'function' || typeof value.parse === 'function';
+const toParser = (name) => toDeferResolve(name, name === 'espree' ? { optional: true } : {});
+const getParsers = ({ parser, parserOptions }) => {
+    const inputs = [];
+    for (const value of [parser, parserOptions?.parser]) {
+        if (typeof value === 'string')
+            inputs.push(toParser(value));
+        else if (value && typeof value === 'object' && !isParserObject(value)) {
+            for (const name of Object.values(value))
+                if (typeof name === 'string')
+                    inputs.push(toParser(name));
+        }
+    }
+    return inputs;
 };
 const isQualifiedSpecifier = (specifier) => specifier === 'eslint' ||
     /\/eslint-(config|plugin)$/.test(specifier) ||
@@ -58,10 +74,19 @@ const resolveExtendSpecifier = (specifier) => {
     return resolveSpecifier(namespace, specifier);
 };
 const getDependenciesFromRules = (rules = {}) => Object.keys(rules).flatMap(ruleKey => ruleKey.includes('/') ? [resolveSpecifier('eslint-plugin', ruleKey.split('/').slice(0, -1).join('/'))] : []);
+const getResolverNames = (value) => {
+    if (typeof value === 'string')
+        return [value];
+    if (Array.isArray(value))
+        return value.flatMap(getResolverNames);
+    if (value && typeof value === 'object')
+        return Object.keys(value);
+    return [];
+};
 const getDependenciesFromSettings = (settings = {}) => {
     return Object.entries(settings).flatMap(([settingKey, settings]) => {
         if (settingKey === 'import/resolver') {
-            return (typeof settings === 'string' ? [settings] : Object.keys(settings))
+            return getResolverNames(settings)
                 .filter(key => key !== 'node')
                 .map(key => {
                 if (isInternal(key))

package/dist/plugins/eslint/resolveFromAST.js

@@ -11,6 +11,21 @@ export const getInputsFromSettingsAST = (program) => {
         const dep = key === 'import/resolver' ? `eslint-import-resolver-${resolver}` : resolver;
         inputs.push(toDeferResolve(dep, { optional: true }));
     };
+    const addResolvers = (key, node) => {
+        if (node?.type === 'ArrayExpression') {
+            for (const element of node.elements)
+                addResolvers(key, element);
+        }
+        else if (node?.type === 'ObjectExpression') {
+            for (const prop of node.properties) {
+                if (prop.type === 'Property')
+                    addResolver(key, getPropertyKey(prop));
+            }
+        }
+        else {
+            addResolver(key, getStringValue(node));
+        }
+    };
     const visitor = new Visitor({
         ObjectExpression(node) {
             const settingsNode = findProperty(node, 'settings');
@@ -20,17 +35,8 @@ export const getInputsFromSettingsAST = (program) => {
                 if (prop.type !== 'Property')
                     continue;
                 const key = getPropertyKey(prop);
-                if (key !== 'import/resolver' && key !== 'import/parsers')
-                    continue;
-                if (prop.value?.type === 'ObjectExpression') {
-                    for (const p of prop.value.properties ?? []) {
-                        if (p.type === 'Property')
-                            addResolver(key, getPropertyKey(p));
-                    }
-                }
-                else {
-                    addResolver(key, getStringValue(prop.value));
-                }
+                if (key === 'import/resolver' || key === 'import/parsers')
+                    addResolvers(key, prop.value);
             }
         },
     });

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

@@ -1,14 +1,14 @@
 type ParserOptions = {
     project?: string;
-    parser?: string;
+    parser?: string | Record<string, unknown>;
     babelOptions?: {
         plugins: string[];
         presets: string[];
     };
 };
-export type Settings = Record<string, Record<string, unknown> | string>;
+export type Settings = Record<string, Record<string, unknown> | string | unknown[]>;
 type Rules = Record<string, string | number>;
-type BaseConfig = {
+export type BaseConfig = {
     extends?: string | string[];
     parser?: string;
     parserOptions?: ParserOptions;

package/dist/plugins/index.d.ts

@@ -150,6 +150,7 @@ export declare const Plugins: {
     taskfile: import("../types/config.ts").Plugin;
     tauri: import("../types/config.ts").Plugin;
     temporal: import("../types/config.ts").Plugin;
+    textlint: import("../types/config.ts").Plugin;
     travis: import("../types/config.ts").Plugin;
     'ts-node': import("../types/config.ts").Plugin;
     tsd: import("../types/config.ts").Plugin;
@@ -166,6 +167,7 @@ export declare const Plugins: {
     'unplugin-vue-i18n': import("../types/config.ts").Plugin;
     'unplugin-vue-markdown': import("../types/config.ts").Plugin;
     'unplugin-vue-router': import("../types/config.ts").Plugin;
+    varlock: import("../types/config.ts").Plugin;
     vercel: import("../types/config.ts").Plugin;
     'vercel-og': import("../types/config.ts").Plugin;
     vike: import("../types/config.ts").Plugin;

package/dist/plugins/index.js

@@ -144,6 +144,7 @@ import { default as tanstackRouter } from './tanstack-router/index.js';
 import { default as taskfile } from './taskfile/index.js';
 import { default as tauri } from './tauri/index.js';
 import { default as temporal } from './temporal/index.js';
+import { default as textlint } from './textlint/index.js';
 import { default as travis } from './travis/index.js';
 import { default as tsNode } from './ts-node/index.js';
 import { default as tsd } from './tsd/index.js';
@@ -160,6 +161,7 @@ import { default as unpluginVueComponents } from './unplugin-vue-components/inde
 import { default as unpluginVueI18n } from './unplugin-vue-i18n/index.js';
 import { default as unpluginVueMarkdown } from './unplugin-vue-markdown/index.js';
 import { default as unpluginVueRouter } from './unplugin-vue-router/index.js';
+import { default as varlock } from './varlock/index.js';
 import { default as vercel } from './vercel/index.js';
 import { default as vercelOg } from './vercel-og/index.js';
 import { default as vike } from './vike/index.js';
@@ -328,6 +330,7 @@ export const Plugins = {
     taskfile,
     tauri,
     temporal,
+    textlint,
     travis,
     'ts-node': tsNode,
     tsd,
@@ -344,6 +347,7 @@ export const Plugins = {
     'unplugin-vue-i18n': unpluginVueI18n,
     'unplugin-vue-markdown': unpluginVueMarkdown,
     'unplugin-vue-router': unpluginVueRouter,
+    varlock,
     vercel,
     'vercel-og': vercelOg,
     vike,

package/dist/plugins/next/index.js

@@ -1,6 +1,8 @@
-import { collectPropertyValues } from '../../typescript/ast-helpers.js';
+import { Visitor } from 'oxc-parser';
+import { findProperty, getPropertyValues } from '../../typescript/ast-helpers.js';
+import { getStringValue } from '../../typescript/ast-nodes.js';
 import { isDirectory } from '../../util/fs.js';
-import { toConfig, toProductionEntry } from '../../util/input.js';
+import { toConfig, toDeferResolve, toProductionEntry } from '../../util/input.js';
 import { join } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
 const title = 'Next.js';
@@ -38,10 +40,42 @@ const getEntryFilePatterns = (pageExtensions = defaultPageExtensions, cwd) => {
 };
 const production = getEntryFilePatterns();
 const resolveFromAST = (program, { configFileDir }) => {
-    const pageExtensions = [...collectPropertyValues(program, 'pageExtensions')];
-    const extensions = pageExtensions.length > 0 ? pageExtensions : defaultPageExtensions;
+    const pageExtensions = new Set();
+    const loaders = new Set();
+    const collectLoaders = (node) => {
+        if (node?.type === 'ArrayExpression') {
+            for (const element of node.elements)
+                collectLoaders(element);
+        }
+        else {
+            const loader = getStringValue(node) ?? getStringValue(findProperty(node, 'loader'));
+            if (loader)
+                loaders.add(loader);
+            const nested = findProperty(node, 'loaders');
+            if (nested?.type === 'ArrayExpression')
+                collectLoaders(nested);
+        }
+    };
+    const visitor = new Visitor({
+        ObjectExpression(node) {
+            for (const extension of getPropertyValues(node, 'pageExtensions'))
+                pageExtensions.add(extension);
+            const rules = findProperty(findProperty(node, 'turbopack'), 'rules');
+            if (rules?.type !== 'ObjectExpression')
+                return;
+            for (const rule of rules.properties) {
+                if (rule.type === 'Property')
+                    collectLoaders(rule.value);
+            }
+        },
+    });
+    visitor.visit(program);
+    const extensions = pageExtensions.size > 0 ? [...pageExtensions] : defaultPageExtensions;
     const patterns = [...getEntryFilePatterns(extensions, configFileDir), 'next-env.d.ts'];
-    return patterns.map(id => toProductionEntry(join(configFileDir, id)));
+    const inputs = patterns.map(id => toProductionEntry(join(configFileDir, id)));
+    for (const loader of loaders)
+        inputs.push(toDeferResolve(loader));
+    return inputs;
 };
 const commands = new Set(['dev', 'build', 'start']);
 const args = {

package/dist/plugins/node/index.js

@@ -38,12 +38,18 @@ const args = {
     resolve: ['test-reporter'],
     boolean: [
         'deprecation',
+        'enable-source-maps',
+        'experimental-detect-module',
+        'experimental-json-modules',
         'experimental-strip-types',
         'experimental-transform-types',
+        'experimental-vm-modules',
+        'expose-gc',
         'harmony',
         'inspect-brk',
         'inspect-wait',
         'inspect',
+        'openssl-legacy-provider',
         'test-only',
         'test',
         'warnings',

package/dist/plugins/tailwind/compiler.js

@@ -1,5 +1,5 @@
+import { hasUrlScheme } from '../../util/url.js';
 const directiveMatcher = /"(?:\\(?:\r\n|[\s\S]|$)|[^"\\\r\n\f])*(?:"|[\r\n\f]|$)|'(?:\\(?:\r\n|[\s\S]|$)|[^'\\\r\n\f])*(?:'|[\r\n\f]|$)|\/\*[\s\S]*?(?:\*\/|$)|@(?:(?:import|config|plugin)\s+['"]([^'"]+)['"]|import\s+url\(\s*(?:['"]([^'"]+)['"]|([^'")\s]+))\s*\))[^;]*;/g;
-const urlSchemeMatcher = /^[a-z][a-z\d+.-]*:/i;
 const compiler = (text) => {
     if (!text.includes('@import') && !text.includes('@config') && !text.includes('@plugin'))
         return '';
@@ -10,7 +10,7 @@ const compiler = (text) => {
     while ((match = directiveMatcher.exec(text))) {
         const url = match[2] ?? match[3];
         const specifier = match[1] ?? url;
-        if (!specifier || (url && (url.startsWith('//') || urlSchemeMatcher.test(url))))
+        if (!specifier || (url && (url.startsWith('//') || hasUrlScheme(url))))
             continue;
         imports.push(`import _$${index++} from '${specifier}';`);
     }

package/dist/plugins/tailwind/index.js

@@ -2,7 +2,13 @@ import { toProductionEntry } from '../../util/input.js';
 import { hasDependency } from '../../util/plugin.js';
 import compiler from './compiler.js';
 const title = 'Tailwind';
-const enablers = ['tailwindcss', '@tailwindcss/vite', '@tailwindcss/postcss', '@tailwindcss/cli'];
+const enablers = [
+    'tailwindcss',
+    '@tailwindcss/vite',
+    '@tailwindcss/webpack',
+    '@tailwindcss/postcss',
+    '@tailwindcss/cli',
+];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const entry = ['tailwind.config.{js,cjs,mjs,ts,cts,mts}'];
 const registerCompilers = ({ registerCompiler, hasDependency }) => {

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

@@ -0,0 +1,4 @@
+import type { Manifest } from '../../util/package-json.ts';
+export declare const toRuleDependency: (key: string, manifest: Manifest, cwd: string) => import("../../util/input.ts").Input;
+export declare const toFilterRuleDependency: (key: string, manifest: Manifest, cwd: string) => import("../../util/input.ts").Input;
+export declare const toPluginDependency: (key: string, manifest: Manifest, cwd: string) => import("../../util/input.ts").Input;

package/dist/plugins/textlint/helpers.js

@@ -0,0 +1,39 @@
+import { toDependency, toDeferResolveEntry } from '../../util/input.js';
+import { isInternal, toAbsolute } from '../../util/path.js';
+const RULE_PREFIX = 'textlint-rule-';
+const PRESET_PREFIX = 'textlint-rule-preset-';
+const FILTER_RULE_PREFIX = 'textlint-filter-rule-';
+const PLUGIN_PREFIX = 'textlint-plugin-';
+const createFullPackageName = (prefix, name) => {
+    if (name.charAt(0) === '@') {
+        const scopedName = name.slice(name.indexOf('/') + 1);
+        if (scopedName !== prefix && !scopedName.startsWith(`${prefix}-`)) {
+            return name.replace(/^@([^/]+)\/(.*)$/, `@$1/${prefix}$2`);
+        }
+    }
+    return `${prefix}${name}`;
+};
+const hasPrefix = (prefix, name) => (name.charAt(0) === '@' ? name.slice(name.indexOf('/') + 1) : name).startsWith(prefix);
+const isDeclared = (manifest, name) => Boolean(manifest.dependencies?.[name] ??
+    manifest.devDependencies?.[name] ??
+    manifest.optionalDependencies?.[name] ??
+    manifest.peerDependencies?.[name]);
+const toPackageDependency = (prefix, name, candidates, manifest) => toDependency(candidates.find(candidate => isDeclared(manifest, candidate)) ??
+    (hasPrefix(prefix, name) ? name : createFullPackageName(prefix, name)));
+const isPresetRuleKey = (key) => key.startsWith('preset-') ||
+    key.startsWith(PRESET_PREFIX) ||
+    (key.charAt(0) === '@' && (key.includes('/preset-') || key.includes(`/${PRESET_PREFIX}`)));
+const toPresetDependency = (key, manifest) => {
+    const name = key.replace(/^preset-/, '').replace(/^@([^/]+)\/preset-(.*)$/, '@$1/$2');
+    const candidates = [`${PRESET_PREFIX}${name}`, name, createFullPackageName(PRESET_PREFIX, name), key];
+    return toPackageDependency(PRESET_PREFIX, name, candidates, manifest);
+};
+const toModuleDependency = (prefix, key, manifest) => toPackageDependency(prefix, key, [createFullPackageName(prefix, key), key], manifest);
+const toLocalEntry = (key, cwd) => toDeferResolveEntry(toAbsolute(key, cwd));
+export const toRuleDependency = (key, manifest, cwd) => {
+    if (isInternal(key))
+        return toLocalEntry(key, cwd);
+    return isPresetRuleKey(key) ? toPresetDependency(key, manifest) : toModuleDependency(RULE_PREFIX, key, manifest);
+};
+export const toFilterRuleDependency = (key, manifest, cwd) => isInternal(key) ? toLocalEntry(key, cwd) : toModuleDependency(FILTER_RULE_PREFIX, key, manifest);
+export const toPluginDependency = (key, manifest, cwd) => isInternal(key) ? toLocalEntry(key, cwd) : toModuleDependency(PLUGIN_PREFIX, key, manifest);

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

@@ -0,0 +1,3 @@
+import type { Plugin } from '../../types/config.ts';
+declare const plugin: Plugin;
+export default plugin;