@rslint/core 0.6.4 → 0.7.0

package/dist/519.js

@@ -0,0 +1,601 @@
+import node_path from "node:path";
+import { createRequire } from "node:module";
+import { pathToFileURL } from "node:url";
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import picomatch from "picomatch";
+const NATIVE_PLUGINS = [
+    "@typescript-eslint",
+    'import',
+    'jest',
+    'jsx-a11y',
+    'promise',
+    'react',
+    'react-hooks',
+    'unicorn'
+];
+const NATIVE_PLUGIN_DECL_ALIASES = [
+    'eslint-plugin-import',
+    'eslint-plugin-jest',
+    'eslint-plugin-jsx-a11y',
+    'eslint-plugin-promise',
+    'eslint-plugin-react-hooks',
+    'eslint-plugin-unicorn'
+];
+const NATIVE_PLUGIN_RESERVED_NAMES = new Set([
+    ...NATIVE_PLUGINS,
+    ...NATIVE_PLUGIN_DECL_ALIASES
+]);
+function defineConfig(config) {
+    return config;
+}
+function define_config_globalIgnores(ignorePatterns) {
+    if (!Array.isArray(ignorePatterns)) throw new TypeError('ignorePatterns must be an array');
+    if (0 === ignorePatterns.length) throw new TypeError('ignorePatterns must contain at least one pattern');
+    return {
+        ignores: ignorePatterns
+    };
+}
+function selectPluginSource(entry) {
+    if (null == entry || 'object' != typeof entry) return null;
+    const e = entry;
+    if (null != e.plugins && 'object' == typeof e.plugins && !Array.isArray(e.plugins)) return e.plugins;
+    return null;
+}
+function unwrapPluginModule(mod) {
+    if (null == mod || 'object' != typeof mod) return null;
+    const m = mod;
+    if (null != m.default && 'object' == typeof m.default) return m.default;
+    return mod;
+}
+let freshConfigLoadNonce = 0;
+function isRecord(value) {
+    return null !== value && 'object' == typeof value && !Array.isArray(value);
+}
+async function loadConfigFile(configPath) {
+    const ext = node_path.extname(configPath);
+    if ('.ts' === ext || '.mts' === ext || '.cts' === ext) {
+        const useNative = Boolean(process.features.typescript);
+        if (useNative) {
+            const mod = await import(pathToFileURL(configPath).href);
+            return mod.default ?? mod;
+        }
+        const jiti = await loadJiti(configPath);
+        if (jiti) {
+            const resolved = await jiti.import(configPath);
+            return extractDefault(resolved);
+        }
+        throw new Error(`Failed to load TypeScript config file: ${configPath}\nTo load .ts/.mts/.cts config files, either:\n  1. Use Node.js >= 22.6 (with native TypeScript support)\n  2. Install jiti as a dependency: npm install -D jiti`);
+    }
+    const mod = await import(pathToFileURL(configPath).href);
+    return mod.default ?? mod;
+}
+async function loadConfigFileFresh(configPath) {
+    const ext = node_path.extname(configPath);
+    const requireFromConfig = createRequire(pathToFileURL(configPath));
+    const evictCommonJSCache = ()=>{
+        try {
+            Reflect.deleteProperty(requireFromConfig.cache, requireFromConfig.resolve(configPath));
+        } catch  {}
+    };
+    evictCommonJSCache();
+    if (('.ts' === ext || '.mts' === ext || '.cts' === ext) && !process.features.typescript) return loadConfigFile(configPath);
+    return importConfigFresh(configPath);
+}
+async function importConfigFresh(configPath) {
+    const url = pathToFileURL(configPath);
+    url.searchParams.set('rslint', String(freshConfigLoadNonce++));
+    const mod = await import(url.href);
+    return mod.default ?? mod;
+}
+async function loadJiti(configPath) {
+    try {
+        const { createJiti } = await import("jiti");
+        return createJiti(node_path.dirname(configPath), {
+            interopDefault: true
+        });
+    } catch  {
+        return null;
+    }
+}
+function extractDefault(mod) {
+    if ('object' == typeof mod && null !== mod && 'default' in mod) return mod.default;
+    return mod;
+}
+function normalizeConfig(config) {
+    if (!Array.isArray(config)) throw new Error(`rslint config must export an array (flat config format), got ${typeof config}`);
+    for(let index = 0; index < config.length; index++)if (!Object.prototype.hasOwnProperty.call(config, index)) throw new Error(`[rslint] Config entry at index ${index}: unexpected undefined config`);
+    return config.map((rawEntry, index)=>{
+        if (null === rawEntry) throw new Error(`[rslint] Config entry at index ${index}: unexpected null config`);
+        if (Array.isArray(rawEntry)) throw new Error(`[rslint] Config entry at index ${index}: unexpected array`);
+        if (!isRecord(rawEntry)) throw new Error(`[rslint] Config entry at index ${index} must be an object, got ${typeof rawEntry}`);
+        const entry = rawEntry;
+        const hasFiles = Object.prototype.hasOwnProperty.call(entry, 'files');
+        if (hasFiles && !Array.isArray(entry.files)) throw new Error(`[rslint] Config entry at index ${index}: "files" must be an array, got ${typeof entry.files}`);
+        if (hasFiles && Array.isArray(entry.files) && 0 === entry.files.length) throw new Error(`[rslint] Config entry at index ${index}: "files" must be a non-empty array`);
+        if (hasFiles && Array.isArray(entry.files) && entry.files.some((pattern)=>'string' != typeof pattern && (!Array.isArray(pattern) || pattern.some((nestedPattern)=>'string' != typeof nestedPattern)))) throw new Error(`[rslint] Config entry at index ${index}: "files" must contain only strings or arrays of strings`);
+        const hasIgnores = Object.prototype.hasOwnProperty.call(entry, 'ignores');
+        if (hasIgnores && !Array.isArray(entry.ignores)) throw new Error(`[rslint] Config entry at index ${index}: "ignores" must be an array, got ${typeof entry.ignores}`);
+        if (Array.isArray(entry.ignores) && entry.ignores.some((pattern)=>'string' != typeof pattern)) throw new Error(`[rslint] Config entry at index ${index}: "ignores" must contain only strings`);
+        for (const key of [
+            'rules',
+            'languageOptions',
+            'settings'
+        ])if (Object.prototype.hasOwnProperty.call(entry, key) && (null === entry[key] || 'object' != typeof entry[key] || Array.isArray(entry[key]))) throw new Error(`[rslint] Config entry at index ${index}: "${key}" must be an object`);
+        if (isRecord(entry.rules)) validateRules(entry.rules, index);
+        const languageOptions = isRecord(entry.languageOptions) ? entry.languageOptions : void 0;
+        if (languageOptions && Object.prototype.hasOwnProperty.call(languageOptions, 'globals')) validateGlobals(languageOptions.globals, index);
+        const hasPlugins = Object.prototype.hasOwnProperty.call(entry, 'plugins');
+        if (hasPlugins && (null === entry.plugins || 'object' != typeof entry.plugins)) throw new Error(`[rslint] Config entry at index ${index}: "plugins" must be an object or an array of strings`);
+        if (Array.isArray(entry.plugins) && entry.plugins.some((plugin)=>'string' != typeof plugin)) throw new Error(`[rslint] Config entry at index ${index}: "plugins" must contain only strings`);
+        if (Object.prototype.hasOwnProperty.call(entry, 'name') && 'string' != typeof entry.name) throw new Error(`[rslint] Config entry at index ${index}: "name" must be a string`);
+        const pluginSource = selectPluginSource(entry);
+        const eslintPluginMeta = {};
+        const pluginPrefixes = [];
+        if (null != pluginSource) for (const prefix of Object.keys(pluginSource)){
+            if (NATIVE_PLUGIN_RESERVED_NAMES.has(prefix)) throw new Error(`[rslint] Config entry at index ${index}: plugins prefix "${prefix}" collides with the built-in plugin of the same name; choose a different prefix.`);
+            const plugin = unwrapPluginModule(pluginSource[prefix]);
+            const pluginRules = plugin?.rules;
+            if (null == pluginRules || 'object' != typeof pluginRules) throw new Error(`[rslint] Config entry at index ${index}: plugins["${prefix}"] must expose a "rules" object.`);
+            eslintPluginMeta[prefix] = {
+                ruleNames: Object.keys(pluginRules).sort()
+            };
+            pluginPrefixes.push(prefix);
+        }
+        const stringPlugins = Array.isArray(entry.plugins) ? entry.plugins.filter((p)=>'string' == typeof p) : [];
+        const plugins = [
+            ...new Set([
+                ...stringPlugins,
+                ...pluginPrefixes
+            ])
+        ];
+        const authoredNonGlobalKey = Object.keys(entry).some((key)=>'name' !== key && 'ignores' !== key);
+        const serializesNonGlobalKey = hasFiles || void 0 !== entry.languageOptions || void 0 !== entry.rules || hasPlugins || void 0 !== entry.settings;
+        const needsNonGlobalShapeMarker = authoredNonGlobalKey && !serializesNonGlobalKey;
+        return {
+            ...void 0 !== entry.name ? {
+                name: entry.name
+            } : {},
+            ...hasFiles ? {
+                files: entry.files
+            } : {},
+            ...void 0 !== entry.ignores ? {
+                ignores: entry.ignores
+            } : {},
+            ...void 0 !== entry.languageOptions ? {
+                languageOptions: entry.languageOptions
+            } : {},
+            ...void 0 !== entry.rules ? {
+                rules: entry.rules
+            } : {},
+            ...hasPlugins ? {
+                plugins
+            } : {},
+            ...void 0 !== entry.settings ? {
+                settings: entry.settings
+            } : needsNonGlobalShapeMarker ? {
+                settings: {}
+            } : {},
+            ...pluginPrefixes.length > 0 ? {
+                eslintPlugins: eslintPluginMeta
+            } : {}
+        };
+    });
+}
+const GLOBAL_ACCESS_VALUES = new Set([
+    true,
+    'true',
+    'writable',
+    'writeable',
+    false,
+    'false',
+    'readonly',
+    'readable',
+    null,
+    'off'
+]);
+const RULE_SEVERITIES = new Set([
+    'off',
+    'warn',
+    'error',
+    0,
+    1,
+    2
+]);
+function validateRules(rules, entryIndex) {
+    for (const [name, value] of Object.entries(rules)){
+        const severity = Array.isArray(value) ? value[0] : value;
+        if (Array.isArray(value) && 0 === value.length || !RULE_SEVERITIES.has(severity)) throw new Error(`[rslint] Config entry at index ${entryIndex}: rule "${name}" must use severity 'off', 'warn', 'error', 0, 1, or 2`);
+    }
+}
+function validateGlobals(value, entryIndex) {
+    if (null === value || 'object' != typeof value || Array.isArray(value)) throw new Error(`[rslint] Config entry at index ${entryIndex}: "languageOptions.globals" must be an object`);
+    for (const [name, access] of Object.entries(value)){
+        if (name !== name.trim()) throw new Error(`[rslint] Config entry at index ${entryIndex}: global "${name}" has leading or trailing whitespace`);
+        if (!GLOBAL_ACCESS_VALUES.has(access)) throw new Error(`[rslint] Config entry at index ${entryIndex}: global "${name}" must be "readonly", "writable", or "off"`);
+    }
+}
+function collectPluginMeta(configs) {
+    const isPluginMetaMap = (v)=>null !== v && 'object' == typeof v;
+    const byPrefix = new Map();
+    const pluginConfigs = [];
+    for (const c of configs){
+        let hasPlugins = false;
+        for (const entry of c.entries){
+            if (null === entry || 'object' != typeof entry || !('eslintPlugins' in entry)) continue;
+            const ep = entry.eslintPlugins;
+            if (isPluginMetaMap(ep)) for (const [prefix, meta] of Object.entries(ep)){
+                hasPlugins = true;
+                const existing = byPrefix.get(prefix);
+                if (existing) {
+                    for (const name of meta.ruleNames)if (!existing.includes(name)) existing.push(name);
+                } else byPrefix.set(prefix, [
+                    ...meta.ruleNames
+                ]);
+            }
+        }
+        if (hasPlugins) pluginConfigs.push({
+            configPath: c.configPath,
+            configDirectory: c.configDirectory
+        });
+    }
+    const eslintPluginEntries = [
+        ...byPrefix.entries()
+    ].map(([prefix, ruleNames])=>({
+            prefix,
+            ruleNames
+        }));
+    return {
+        eslintPluginEntries,
+        pluginConfigs
+    };
+}
+class ConfigSourceChangedError extends Error {
+    code = 'CONFIG_CHANGED_DURING_LOAD';
+    constructor(configPath, phase = 'load'){
+        super('load' === phase ? `config changed while it was being loaded: ${configPath}` : `config changed while its plugin host was being prepared: ${configPath}`);
+        this.name = 'ConfigSourceChangedError';
+    }
+}
+function assertNotAborted(signal) {
+    if (!signal?.aborted) return;
+    if (signal.reason instanceof Error) throw signal.reason;
+    throw new Error('config module operation was aborted');
+}
+function protocolError(message) {
+    return new Error(`config module protocol: ${message}`);
+}
+function isConfigEntry(value) {
+    return null !== value && 'object' == typeof value && !Array.isArray(value);
+}
+function normalizeCandidate(candidate) {
+    if (!candidate || 'object' != typeof candidate) throw protocolError('candidate must be an object');
+    if ('string' != typeof candidate.id || 0 === candidate.id.length) throw protocolError('candidate id must be a non-empty string');
+    if ('string' != typeof candidate.configPath || !node_path.isAbsolute(candidate.configPath)) throw protocolError(`candidate ${JSON.stringify(candidate.id)} configPath must be absolute`);
+    if ('string' != typeof candidate.configDirectory || !node_path.isAbsolute(candidate.configDirectory)) throw protocolError(`candidate ${JSON.stringify(candidate.id)} configDirectory must be absolute`);
+    return {
+        id: candidate.id,
+        configPath: node_path.normalize(candidate.configPath),
+        configDirectory: candidate.configDirectory
+    };
+}
+function cloneEntries(entriesJSON) {
+    const entries = JSON.parse(entriesJSON);
+    if (!Array.isArray(entries) || !entries.every(isConfigEntry)) throw protocolError('stored config entries are malformed');
+    return entries;
+}
+function clonePluginEntries(entries) {
+    return entries.map(({ prefix, ruleNames })=>({
+            prefix,
+            ruleNames: [
+                ...ruleNames
+            ]
+        }));
+}
+function cloneStoredResult(result) {
+    if ('loaded' === result.status) return {
+        id: result.id,
+        status: 'loaded',
+        entries: cloneEntries(result.entriesJSON)
+    };
+    return {
+        id: result.id,
+        status: 'failed',
+        error: {
+            ...result.error
+        }
+    };
+}
+function errorPayload(error, fallbackCode) {
+    const message = error instanceof Error ? error.message : String(error);
+    let code = fallbackCode;
+    if (null !== error && 'object' == typeof error && 'code' in error) {
+        const candidateCode = error.code;
+        if ('string' == typeof candidateCode && candidateCode.length > 0) code = candidateCode;
+    }
+    return {
+        message,
+        ...code ? {
+            code
+        } : {}
+    };
+}
+class ConfigModuleHost {
+    #loadCached;
+    #loadFresh;
+    #readSource;
+    #sessions = new Map();
+    constructor(options = {}){
+        this.#loadCached = options.loadCached ?? loadConfigFile;
+        this.#loadFresh = options.loadFresh ?? loadConfigFileFresh;
+        this.#readSource = options.readSource ?? readFile;
+    }
+    async loadConfigs(request, signal) {
+        this.#validateRequest(request);
+        const candidates = request.candidates.map(normalizeCandidate);
+        const session = this.#getOrCreateSession(request.transactionId, request.loadMode, true === request.singleThreaded);
+        return this.#enqueue(session, async ()=>{
+            assertNotAborted(signal);
+            this.#validateCandidateBatch(session, candidates);
+            const newCandidates = candidates.filter(({ id })=>!session.candidatesById.has(id));
+            let loaded;
+            if (request.singleThreaded) {
+                loaded = [];
+                for (const candidate of newCandidates)loaded.push(await this.#loadCandidate(candidate, session.loadMode));
+            } else loaded = await Promise.all(newCandidates.map(async (candidate)=>{
+                const result = await this.#loadCandidate(candidate, session.loadMode);
+                return result;
+            }));
+            assertNotAborted(signal);
+            for(let index = 0; index < newCandidates.length; index++){
+                const candidate = newCandidates[index];
+                const result = loaded[index];
+                session.candidatesById.set(candidate.id, {
+                    candidate,
+                    result
+                });
+                session.idByConfigPath.set(candidate.configPath, candidate.id);
+            }
+            return {
+                transactionId: request.transactionId,
+                results: candidates.map(({ id })=>{
+                    const stored = session.candidatesById.get(id);
+                    if (!stored) throw protocolError(`candidate ${JSON.stringify(id)} was not loaded`);
+                    return cloneStoredResult(stored.result);
+                })
+            };
+        });
+    }
+    async #summarizeEffectiveConfigs(transactionId, effectiveConfigIds, signal) {
+        const session = this.#sessions.get(transactionId);
+        if (!session) throw protocolError(`unknown transaction ${JSON.stringify(transactionId)}`);
+        return this.#enqueue(session, async ()=>{
+            assertNotAborted(signal);
+            const stored = this.#effectiveCandidates(session, effectiveConfigIds);
+            await this.#verifyFingerprints(stored, 'load', signal);
+            const configs = stored.map(({ candidate, result })=>({
+                    id: candidate.id,
+                    configPath: candidate.configPath,
+                    configDirectory: candidate.configDirectory,
+                    entries: cloneEntries(result.entriesJSON),
+                    sourceFingerprint: result.sourceFingerprint
+                }));
+            const { eslintPluginEntries, pluginConfigs } = collectPluginMeta(configs);
+            return {
+                transactionId,
+                configs,
+                eslintPluginEntries: clonePluginEntries(eslintPluginEntries),
+                pluginConfigs: pluginConfigs.map((descriptor)=>({
+                        ...descriptor
+                    }))
+            };
+        });
+    }
+    async activateConfigs(request, signal, prepare) {
+        this.#validateActivationRequest(request);
+        const plan = await this.#summarizeEffectiveConfigs(request.transactionId, request.effectiveConfigIds, signal);
+        const response = {
+            transactionId: plan.transactionId,
+            eslintPluginEntries: clonePluginEntries(plan.eslintPluginEntries)
+        };
+        assertNotAborted(signal);
+        await prepare?.(plan);
+        assertNotAborted(signal);
+        await this.#verifyEffectiveConfigs(request, signal);
+        return response;
+    }
+    async #verifyEffectiveConfigs(request, signal) {
+        this.#validateActivationRequest(request);
+        const session = this.#sessions.get(request.transactionId);
+        if (!session) throw protocolError(`unknown transaction ${JSON.stringify(request.transactionId)}`);
+        await this.#enqueue(session, async ()=>{
+            assertNotAborted(signal);
+            const stored = this.#effectiveCandidates(session, request.effectiveConfigIds);
+            await this.#verifyFingerprints(stored, 'plugin-prepare', signal);
+        });
+    }
+    deleteSession(transactionId) {
+        return this.#sessions.delete(transactionId);
+    }
+    #validateRequest(request) {
+        if (!request || 'object' != typeof request) throw protocolError('load request must be an object');
+        if (1 !== request.protocolVersion) throw protocolError(`unsupported version ${String(request.protocolVersion)}; expected 1`);
+        if ('string' != typeof request.transactionId || 0 === request.transactionId.length) throw protocolError('transactionId must be a non-empty string');
+        if ('cached' !== request.loadMode && 'fresh' !== request.loadMode) throw protocolError(`unsupported loadMode ${String(request.loadMode)}`);
+        if (void 0 !== request.singleThreaded && 'boolean' != typeof request.singleThreaded) throw protocolError('singleThreaded must be a boolean when provided');
+        if (!Array.isArray(request.candidates)) throw protocolError('candidates must be an array');
+    }
+    #validateActivationRequest(request) {
+        if (!request || 'object' != typeof request) throw protocolError('activation request must be an object');
+        if (1 !== request.protocolVersion) throw protocolError(`unsupported version ${String(request.protocolVersion)}; expected 1`);
+        if ('string' != typeof request.transactionId || 0 === request.transactionId.length) throw protocolError('transactionId must be a non-empty string');
+        if (!Array.isArray(request.effectiveConfigIds)) throw protocolError('effectiveConfigIds must be an array');
+    }
+    #getOrCreateSession(transactionId, loadMode, singleThreaded) {
+        const existing = this.#sessions.get(transactionId);
+        if (existing) {
+            if (existing.loadMode !== loadMode) throw protocolError(`transaction ${JSON.stringify(transactionId)} cannot change loadMode from ${existing.loadMode} to ${loadMode}`);
+            if (existing.singleThreaded !== singleThreaded) throw protocolError(`transaction ${JSON.stringify(transactionId)} cannot change singleThreaded mode`);
+            return existing;
+        }
+        const session = {
+            loadMode,
+            singleThreaded,
+            candidatesById: new Map(),
+            idByConfigPath: new Map(),
+            operation: Promise.resolve()
+        };
+        this.#sessions.set(transactionId, session);
+        return session;
+    }
+    #validateCandidateBatch(session, candidates) {
+        const ids = new Set();
+        const paths = new Map();
+        for (const candidate of candidates){
+            if (ids.has(candidate.id)) throw protocolError(`candidate batch contains duplicate id ${JSON.stringify(candidate.id)}`);
+            ids.add(candidate.id);
+            const batchOwner = paths.get(candidate.configPath);
+            if (batchOwner && batchOwner !== candidate.id) throw protocolError(`candidate IDs ${JSON.stringify(batchOwner)} and ${JSON.stringify(candidate.id)} use the same configPath`);
+            paths.set(candidate.configPath, candidate.id);
+            const existing = session.candidatesById.get(candidate.id);
+            if (existing && (existing.candidate.configPath !== candidate.configPath || existing.candidate.configDirectory !== candidate.configDirectory)) throw protocolError(`candidate id ${JSON.stringify(candidate.id)} changed path or directory within one transaction`);
+            const pathOwner = session.idByConfigPath.get(candidate.configPath);
+            if (pathOwner && pathOwner !== candidate.id) throw protocolError(`candidate IDs ${JSON.stringify(pathOwner)} and ${JSON.stringify(candidate.id)} use the same configPath`);
+        }
+    }
+    #effectiveCandidates(session, effectiveConfigIds) {
+        const seen = new Set();
+        return effectiveConfigIds.map((id)=>{
+            if (seen.has(id)) throw protocolError(`effective config list contains duplicate id ${JSON.stringify(id)}`);
+            seen.add(id);
+            const candidate = session.candidatesById.get(id);
+            if (!candidate) throw protocolError(`unknown effective config id ${JSON.stringify(id)}`);
+            if ('loaded' !== candidate.result.status) throw protocolError(`effective config ${JSON.stringify(id)} did not load successfully`);
+            return {
+                candidate: candidate.candidate,
+                result: candidate.result
+            };
+        });
+    }
+    async #verifyFingerprints(stored, phase, signal) {
+        const currentFingerprints = await Promise.all(stored.map(async ({ candidate })=>{
+            const fingerprint = await this.#fingerprint(candidate.configPath);
+            return fingerprint;
+        }));
+        assertNotAborted(signal);
+        for(let index = 0; index < stored.length; index++)if (currentFingerprints[index] !== stored[index].result.sourceFingerprint) throw new ConfigSourceChangedError(stored[index].candidate.configPath, phase);
+    }
+    async #loadCandidate(candidate, loadMode) {
+        let failureCode = 'load';
+        try {
+            const sourceFingerprint = await this.#fingerprint(candidate.configPath);
+            const rawConfig = await ('fresh' === loadMode ? this.#loadFresh(candidate.configPath) : this.#loadCached(candidate.configPath));
+            failureCode = 'invalid';
+            const normalized = normalizeConfig(rawConfig);
+            const entriesJSON = JSON.stringify(normalized);
+            const afterFingerprint = await this.#fingerprint(candidate.configPath);
+            if (sourceFingerprint !== afterFingerprint) throw new ConfigSourceChangedError(candidate.configPath);
+            return {
+                id: candidate.id,
+                status: 'loaded',
+                entriesJSON,
+                sourceFingerprint: afterFingerprint
+            };
+        } catch (error) {
+            return {
+                id: candidate.id,
+                status: 'failed',
+                error: errorPayload(error, failureCode)
+            };
+        }
+    }
+    async #fingerprint(configPath) {
+        const contents = await this.#readSource(configPath);
+        return `${contents.byteLength}:${createHash('sha256').update(contents).digest('hex')}`;
+    }
+    async #enqueue(session, operation) {
+        const result = session.operation.then(operation, operation);
+        session.operation = result.then(()=>void 0, ()=>void 0);
+        const value = await result;
+        return value;
+    }
+}
+function isGlobalIgnoreEntry(entry) {
+    if (null === entry || 'object' != typeof entry || Array.isArray(entry)) return false;
+    const ignores = 'ignores' in entry ? entry.ignores : void 0;
+    if (!Array.isArray(ignores) || 0 === ignores.length || ignores.some((pattern)=>'string' != typeof pattern)) return false;
+    return Object.keys(entry).every((key)=>'ignores' === key || 'name' === key);
+}
+function getGlobalIgnores(entries) {
+    const patterns = [];
+    for (const entry of entries)if (isGlobalIgnoreEntry(entry)) patterns.push(...entry.ignores);
+    return patterns;
+}
+function normalizeGlobPattern(pattern) {
+    const normalized = node_path.posix.normalize(pattern.replaceAll('\\', '/'));
+    return '.' === normalized ? '' : normalized.replace(/^\.\//, '');
+}
+function isDirIgnoredByPatterns(dirPath, patterns, parentConfigDir) {
+    const relDir = node_path.relative(parentConfigDir, dirPath);
+    if (!isRelativeChildPath(relDir)) return false;
+    const segments = relDir.split(node_path.sep).filter(Boolean);
+    let current = '';
+    for (const segment of segments){
+        current = current ? `${current}/${segment}` : segment;
+        let ignored = false;
+        for (const rawPattern of patterns){
+            if (!rawPattern) continue;
+            const negated = rawPattern.startsWith('!');
+            if (negated !== ignored) continue;
+            const pattern = normalizeGlobPattern(negated ? rawPattern.slice(1) : rawPattern);
+            if (!pattern) continue;
+            const isMatch = picomatch(pattern, {
+                dot: true
+            });
+            if (isMatch(current) || isMatch(`${current}/`)) ignored = !negated;
+        }
+        if (ignored) return true;
+    }
+    return false;
+}
+function isRelativeChildPath(relPath) {
+    return '' !== relPath && '..' !== relPath && !relPath.startsWith(`..${node_path.sep}`) && !node_path.isAbsolute(relPath);
+}
+function isSameOrChildDirectory(parentDir, childDir) {
+    const parent = node_path.normalize(parentDir);
+    const child = node_path.normalize(childDir);
+    if (parent === child) return true;
+    const prefix = parent.endsWith(node_path.sep) ? parent : `${parent}${node_path.sep}`;
+    return child.startsWith(prefix);
+}
+function normalizeConfigDirectory(configDirectory) {
+    let dir = configDirectory;
+    const root = node_path.parse(dir).root;
+    while(dir.length > root.length && /[/\\]$/.test(dir))dir = dir.slice(0, -1);
+    return node_path.normalize(dir);
+}
+function filterConfigsByParentIgnores(configEntries, forceIncludeConfigDirectories = new Set()) {
+    if (configEntries.length <= 1) return configEntries;
+    const forceIncludedDirs = new Set([
+        ...forceIncludeConfigDirectories
+    ].map(normalizeConfigDirectory));
+    const normalizedEntries = configEntries.map((config)=>({
+            config,
+            directory: normalizeConfigDirectory(config.configDirectory)
+        })).sort((a, b)=>a.directory.length - b.directory.length);
+    const result = [];
+    for (const entry of normalizedEntries){
+        let ignored = false;
+        let nearestParent;
+        for (const parent of result)if (isSameOrChildDirectory(parent.directory, entry.directory)) {
+            if (void 0 === nearestParent || parent.directory.length > nearestParent.directory.length) nearestParent = parent;
+        }
+        if (void 0 !== nearestParent) {
+            const globalIgnores = getGlobalIgnores(nearestParent.config.entries);
+            ignored = globalIgnores.length > 0 && isDirIgnoredByPatterns(entry.directory, globalIgnores, nearestParent.directory);
+        }
+        if (!ignored || forceIncludedDirs.has(entry.directory)) result.push(entry);
+    }
+    return result.map(({ config })=>config);
+}
+export { ConfigModuleHost, collectPluginMeta, defineConfig, define_config_globalIgnores as globalIgnores, filterConfigsByParentIgnores, loadConfigFile, loadConfigFileFresh, normalizeConfig };

package/dist/770.js

@@ -0,0 +1,18 @@
+import { createRequire } from "node:module";
+const resolve_binary_require = createRequire(import.meta.url);
+function resolveRslintBinary() {
+    const arch = process.arch;
+    const tuples = 'linux' === process.platform ? [
+        `linux-${arch}-gnu`,
+        `linux-${arch}-musl`
+    ] : 'win32' === process.platform ? [
+        `win32-${arch}-msvc`
+    ] : [
+        `${process.platform}-${arch}`
+    ];
+    for (const tuple of tuples)try {
+        return resolve_binary_require.resolve(`@rslint/native-${tuple}/bin`);
+    } catch  {}
+    throw new Error(`rslint: no native binary for ${process.platform}-${arch} (looked for @rslint/native-{${tuples.join(',')}})`);
+}
+export { resolveRslintBinary };

package/dist/cli.d.ts

@@ -1,3 +1,13 @@
 export declare function run(binPath: string, argv: string[], startTime: number): Promise<number>;
 
+export declare function runCLI({ argv, }?: RunCLIOptions): Promise<void>;
+
+export declare type RunCLIOptions = {
+    /**
+     * The command-line arguments to parse, matching the shape of Node.js `process.argv`
+     * @default process.argv
+     */
+    argv?: string[];
+};
+
 export { }