@rslint/core 0.5.3 → 0.6.0

package/dist/cli.js

@@ -1,44 +1,998 @@
-import path from 'node:path';
-import fs from 'node:fs';
-import { execFileSync } from 'node:child_process';
-import { loadConfigFile, normalizeConfig } from './config-loader.js';
-import { parseArgs, classifyArgs, isJSConfigFile } from './utils/args.js';
-import { discoverConfigs, filterConfigsByParentIgnores, } from './utils/config-discovery.js';
-/**
- * Pass-through execution of the Go binary with stdio inherited.
- */
-function execBinary(binPath, argv) {
+import node_path from "node:path";
+import node_fs from "node:fs";
+import { parseArgs } from "node:util";
+import picomatch from "picomatch";
+import fs_0, * as __rspack_external_fs from "fs";
+import path_0, { basename, dirname, normalize, posix, relative as external_path_relative, resolve, sep } from "path";
+import { fileURLToPath } from "url";
+import { createRequire } from "module";
+import { loadConfigFile, collectPluginMeta, normalizeConfig } from "./config-loader.js";
+function isJSConfigFile(filePath) {
+    return /\.(ts|mts|js|mjs)$/.test(filePath);
+}
+function args_parseArgs(argv) {
+    const { values, tokens } = parseArgs({
+        args: argv,
+        strict: false,
+        tokens: true,
+        options: {
+            config: {
+                type: 'string'
+            },
+            init: {
+                type: 'boolean'
+            },
+            singleThreaded: {
+                type: 'boolean'
+            },
+            format: {
+                type: 'string'
+            },
+            'max-warnings': {
+                type: 'string'
+            },
+            rule: {
+                type: 'string',
+                multiple: true
+            },
+            trace: {
+                type: 'string'
+            },
+            cpuprof: {
+                type: 'string'
+            },
+            'start-time': {
+                type: 'string'
+            }
+        }
+    });
+    const flags = [];
+    const positionalsBefore = [];
+    const positionalsAfter = [];
+    let seenTerminator = false;
+    for (const token of tokens)if ('option' === token.kind) {
+        if ('config' === token.name || 'init' === token.name || 'start-time' === token.name) continue;
+        flags.push(token.rawName);
+        if (null != token.value) flags.push(token.value);
+    } else if ('option-terminator' === token.kind) seenTerminator = true;
+    else if ('positional' === token.kind) if (seenTerminator) positionalsAfter.push(token.value);
+    else positionalsBefore.push(token.value);
+    const positionals = [
+        ...positionalsBefore,
+        ...positionalsAfter
+    ];
+    const rest = seenTerminator ? [
+        ...flags,
+        ...positionalsBefore,
+        '--',
+        ...positionalsAfter
+    ] : [
+        ...flags,
+        ...positionalsBefore
+    ];
+    return {
+        config: values.config ?? null,
+        init: values.init ?? false,
+        singleThreaded: values.singleThreaded ?? false,
+        rest,
+        positionals
+    };
+}
+function classifyArgs(positionals, cwd) {
+    const files = [];
+    const dirs = [];
+    for (const arg of positionals){
+        const resolved = node_path.resolve(cwd, arg);
+        try {
+            const real = node_fs.realpathSync(resolved);
+            if (node_fs.statSync(real).isDirectory()) dirs.push(real);
+            else files.push(real);
+        } catch  {
+            files.push(resolved);
+        }
+    }
+    return {
+        files,
+        dirs
+    };
+}
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+function cleanPath(path) {
+    let normalized = normalize(path);
+    if (normalized.length > 1 && normalized[normalized.length - 1] === sep) normalized = normalized.substring(0, normalized.length - 1);
+    return normalized;
+}
+const SLASHES_REGEX = /[\\/]/g;
+function convertSlashes(path, separator) {
+    return path.replace(SLASHES_REGEX, separator);
+}
+const WINDOWS_ROOT_DIR_REGEX = /^[a-z]:[\\/]$/i;
+function isRootDirectory(path) {
+    return "/" === path || WINDOWS_ROOT_DIR_REGEX.test(path);
+}
+function normalizePath(path, options) {
+    const { resolvePaths, normalizePath: normalizePath$1, pathSeparator } = options;
+    const pathNeedsCleaning = "win32" === process.platform && path.includes("/") || path.startsWith(".");
+    if (resolvePaths) path = resolve(path);
+    if (normalizePath$1 || pathNeedsCleaning) path = cleanPath(path);
+    if ("." === path) return "";
+    const needsSeperator = path[path.length - 1] !== pathSeparator;
+    return convertSlashes(needsSeperator ? path + pathSeparator : path, pathSeparator);
+}
+function joinPathWithBasePath(filename, directoryPath) {
+    return directoryPath + filename;
+}
+function joinPathWithRelativePath(root, options) {
+    return function(filename, directoryPath) {
+        const sameRoot = directoryPath.startsWith(root);
+        if (sameRoot) return directoryPath.slice(root.length) + filename;
+        return convertSlashes(external_path_relative(root, directoryPath), options.pathSeparator) + options.pathSeparator + filename;
+    };
+}
+function joinPath(filename) {
+    return filename;
+}
+function joinDirectoryPath(filename, directoryPath, separator) {
+    return directoryPath + filename + separator;
+}
+function build$7(root, options) {
+    const { relativePaths, includeBasePath } = options;
+    return relativePaths && root ? joinPathWithRelativePath(root, options) : includeBasePath ? joinPathWithBasePath : joinPath;
+}
+function pushDirectoryWithRelativePath(root) {
+    return function(directoryPath, paths) {
+        paths.push(directoryPath.substring(root.length) || ".");
+    };
+}
+function pushDirectoryFilterWithRelativePath(root) {
+    return function(directoryPath, paths, filters) {
+        const relativePath = directoryPath.substring(root.length) || ".";
+        if (filters.every((filter)=>filter(relativePath, true))) paths.push(relativePath);
+    };
+}
+const pushDirectory = (directoryPath, paths)=>{
+    paths.push(directoryPath || ".");
+};
+const pushDirectoryFilter = (directoryPath, paths, filters)=>{
+    const path = directoryPath || ".";
+    if (filters.every((filter)=>filter(path, true))) paths.push(path);
+};
+const empty$2 = ()=>{};
+function build$6(root, options) {
+    const { includeDirs, filters, relativePaths } = options;
+    if (!includeDirs) return empty$2;
+    if (relativePaths) return filters && filters.length ? pushDirectoryFilterWithRelativePath(root) : pushDirectoryWithRelativePath(root);
+    return filters && filters.length ? pushDirectoryFilter : pushDirectory;
+}
+const pushFileFilterAndCount = (filename, _paths, counts, filters)=>{
+    if (filters.every((filter)=>filter(filename, false))) counts.files++;
+};
+const pushFileFilter = (filename, paths, _counts, filters)=>{
+    if (filters.every((filter)=>filter(filename, false))) paths.push(filename);
+};
+const pushFileCount = (_filename, _paths, counts, _filters)=>{
+    counts.files++;
+};
+const pushFile = (filename, paths)=>{
+    paths.push(filename);
+};
+const empty$1 = ()=>{};
+function build$5(options) {
+    const { excludeFiles, filters, onlyCounts } = options;
+    if (excludeFiles) return empty$1;
+    if (filters && filters.length) return onlyCounts ? pushFileFilterAndCount : pushFileFilter;
+    if (onlyCounts) return pushFileCount;
+    return pushFile;
+}
+const getArray = (paths)=>paths;
+const getArrayGroup = ()=>[
+        ""
+    ].slice(0, 0);
+function build$4(options) {
+    return options.group ? getArrayGroup : getArray;
+}
+const groupFiles = (groups, directory, files)=>{
+    groups.push({
+        directory,
+        files,
+        dir: directory
+    });
+};
+const empty = ()=>{};
+function build$3(options) {
+    return options.group ? groupFiles : empty;
+}
+const resolveSymlinksAsync = function(path, state, callback$1) {
+    const { queue, fs, options: { suppressErrors } } = state;
+    queue.enqueue();
+    fs.realpath(path, (error, resolvedPath)=>{
+        if (error) return queue.dequeue(suppressErrors ? null : error, state);
+        fs.stat(resolvedPath, (error$1, stat)=>{
+            if (error$1) return queue.dequeue(suppressErrors ? null : error$1, state);
+            if (stat.isDirectory() && isRecursive(path, resolvedPath, state)) return queue.dequeue(null, state);
+            callback$1(stat, resolvedPath);
+            queue.dequeue(null, state);
+        });
+    });
+};
+const resolveSymlinks = function(path, state, callback$1) {
+    const { queue, fs, options: { suppressErrors } } = state;
+    queue.enqueue();
+    try {
+        const resolvedPath = fs.realpathSync(path);
+        const stat = fs.statSync(resolvedPath);
+        if (stat.isDirectory() && isRecursive(path, resolvedPath, state)) return;
+        callback$1(stat, resolvedPath);
+    } catch (e) {
+        if (!suppressErrors) throw e;
+    }
+};
+function build$2(options, isSynchronous) {
+    if (!options.resolveSymlinks || options.excludeSymlinks) return null;
+    return isSynchronous ? resolveSymlinks : resolveSymlinksAsync;
+}
+function isRecursive(path, resolved, state) {
+    if (state.options.useRealPaths) return isRecursiveUsingRealPaths(resolved, state);
+    let parent = dirname(path);
+    let depth = 1;
+    while(parent !== state.root && depth < 2){
+        const resolvedPath = state.symlinks.get(parent);
+        const isSameRoot = !!resolvedPath && (resolvedPath === resolved || resolvedPath.startsWith(resolved) || resolved.startsWith(resolvedPath));
+        if (isSameRoot) depth++;
+        else parent = dirname(parent);
+    }
+    state.symlinks.set(path, resolved);
+    return depth > 1;
+}
+function isRecursiveUsingRealPaths(resolved, state) {
+    return state.visited.includes(resolved + state.options.pathSeparator);
+}
+const onlyCountsSync = (state)=>state.counts;
+const groupsSync = (state)=>state.groups;
+const defaultSync = (state)=>state.paths;
+const limitFilesSync = (state)=>state.paths.slice(0, state.options.maxFiles);
+const onlyCountsAsync = (state, error, callback$1)=>{
+    report(error, callback$1, state.counts, state.options.suppressErrors);
+    return null;
+};
+const defaultAsync = (state, error, callback$1)=>{
+    report(error, callback$1, state.paths, state.options.suppressErrors);
+    return null;
+};
+const limitFilesAsync = (state, error, callback$1)=>{
+    report(error, callback$1, state.paths.slice(0, state.options.maxFiles), state.options.suppressErrors);
+    return null;
+};
+const groupsAsync = (state, error, callback$1)=>{
+    report(error, callback$1, state.groups, state.options.suppressErrors);
+    return null;
+};
+function report(error, callback$1, output, suppressErrors) {
+    callback$1(error && !suppressErrors ? error : null, output);
+}
+function build$1(options, isSynchronous) {
+    const { onlyCounts, group, maxFiles } = options;
+    if (onlyCounts) return isSynchronous ? onlyCountsSync : onlyCountsAsync;
+    if (group) return isSynchronous ? groupsSync : groupsAsync;
+    if (maxFiles) return isSynchronous ? limitFilesSync : limitFilesAsync;
+    return isSynchronous ? defaultSync : defaultAsync;
+}
+const readdirOpts = {
+    withFileTypes: true
+};
+const walkAsync = (state, crawlPath, directoryPath, currentDepth, callback$1)=>{
+    state.queue.enqueue();
+    if (currentDepth < 0) return state.queue.dequeue(null, state);
+    const { fs } = state;
+    state.visited.push(crawlPath);
+    state.counts.directories++;
+    fs.readdir(crawlPath || ".", readdirOpts, (error, entries = [])=>{
+        callback$1(entries, directoryPath, currentDepth);
+        state.queue.dequeue(state.options.suppressErrors ? null : error, state);
+    });
+};
+const walkSync = (state, crawlPath, directoryPath, currentDepth, callback$1)=>{
+    const { fs } = state;
+    if (currentDepth < 0) return;
+    state.visited.push(crawlPath);
+    state.counts.directories++;
+    let entries = [];
     try {
-        execFileSync(binPath, argv, { stdio: 'inherit' });
-        return 0;
-    }
-    catch (error) {
-        if (isExecError(error))
-            return error.status;
-        process.stderr.write(`Failed to execute ${binPath}: ${String(error)}\n`);
-        return 1;
-    }
-}
-function isExecError(error) {
-    return (typeof error === 'object' &&
-        error !== null &&
-        'status' in error &&
-        typeof error.status === 'number');
-}
-/**
- * Load multiple JS configs and pipe to Go binary via stdin.
- * Tolerates individual config load failures — skips broken configs with a
- * warning and continues with the remaining configs.
- */
-async function runWithJSConfigs(binPath, configs, goArgs, cwd) {
+        entries = fs.readdirSync(crawlPath || ".", readdirOpts);
+    } catch (e) {
+        if (!state.options.suppressErrors) throw e;
+    }
+    callback$1(entries, directoryPath, currentDepth);
+};
+function build(isSynchronous) {
+    return isSynchronous ? walkSync : walkAsync;
+}
+var Queue = class {
+    count = 0;
+    constructor(onQueueEmpty){
+        this.onQueueEmpty = onQueueEmpty;
+    }
+    enqueue() {
+        this.count++;
+        return this.count;
+    }
+    dequeue(error, output) {
+        if (this.onQueueEmpty && (--this.count <= 0 || error)) {
+            this.onQueueEmpty(error, output);
+            if (error) {
+                output.controller.abort();
+                this.onQueueEmpty = void 0;
+            }
+        }
+    }
+};
+var Counter = class {
+    _files = 0;
+    _directories = 0;
+    set files(num) {
+        this._files = num;
+    }
+    get files() {
+        return this._files;
+    }
+    set directories(num) {
+        this._directories = num;
+    }
+    get directories() {
+        return this._directories;
+    }
+    get dirs() {
+        return this._directories;
+    }
+};
+var Aborter = class {
+    aborted = false;
+    abort() {
+        this.aborted = true;
+    }
+};
+var Walker = class {
+    root;
+    isSynchronous;
+    state;
+    joinPath;
+    pushDirectory;
+    pushFile;
+    getArray;
+    groupFiles;
+    resolveSymlink;
+    walkDirectory;
+    callbackInvoker;
+    constructor(root, options, callback$1){
+        this.isSynchronous = !callback$1;
+        this.callbackInvoker = build$1(options, this.isSynchronous);
+        this.root = normalizePath(root, options);
+        this.state = {
+            root: isRootDirectory(this.root) ? this.root : this.root.slice(0, -1),
+            paths: [
+                ""
+            ].slice(0, 0),
+            groups: [],
+            counts: new Counter(),
+            options,
+            queue: new Queue((error, state)=>this.callbackInvoker(state, error, callback$1)),
+            symlinks: /* @__PURE__ */ new Map(),
+            visited: [
+                ""
+            ].slice(0, 0),
+            controller: new Aborter(),
+            fs: options.fs || __rspack_external_fs
+        };
+        this.joinPath = build$7(this.root, options);
+        this.pushDirectory = build$6(this.root, options);
+        this.pushFile = build$5(options);
+        this.getArray = build$4(options);
+        this.groupFiles = build$3(options);
+        this.resolveSymlink = build$2(options, this.isSynchronous);
+        this.walkDirectory = build(this.isSynchronous);
+    }
+    start() {
+        this.pushDirectory(this.root, this.state.paths, this.state.options.filters);
+        this.walkDirectory(this.state, this.root, this.root, this.state.options.maxDepth, this.walk);
+        return this.isSynchronous ? this.callbackInvoker(this.state, null) : null;
+    }
+    walk = (entries, directoryPath, depth)=>{
+        const { paths, options: { filters, resolveSymlinks: resolveSymlinks$1, excludeSymlinks, exclude, maxFiles, signal, useRealPaths, pathSeparator }, controller } = this.state;
+        if (controller.aborted || signal && signal.aborted || maxFiles && paths.length > maxFiles) return;
+        const files = this.getArray(this.state.paths);
+        for(let i = 0; i < entries.length; ++i){
+            const entry = entries[i];
+            if (entry.isFile() || entry.isSymbolicLink() && !resolveSymlinks$1 && !excludeSymlinks) {
+                const filename = this.joinPath(entry.name, directoryPath);
+                this.pushFile(filename, files, this.state.counts, filters);
+            } else if (entry.isDirectory()) {
+                let path = joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);
+                if (exclude && exclude(entry.name, path)) continue;
+                this.pushDirectory(path, paths, filters);
+                this.walkDirectory(this.state, path, path, depth - 1, this.walk);
+            } else if (this.resolveSymlink && entry.isSymbolicLink()) {
+                let path = joinPathWithBasePath(entry.name, directoryPath);
+                this.resolveSymlink(path, this.state, (stat, resolvedPath)=>{
+                    if (stat.isDirectory()) {
+                        resolvedPath = normalizePath(resolvedPath, this.state.options);
+                        if (exclude && exclude(entry.name, useRealPaths ? resolvedPath : path + pathSeparator)) return;
+                        this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path + pathSeparator, depth - 1, this.walk);
+                    } else {
+                        resolvedPath = useRealPaths ? resolvedPath : path;
+                        const filename = basename(resolvedPath);
+                        const directoryPath$1 = normalizePath(dirname(resolvedPath), this.state.options);
+                        resolvedPath = this.joinPath(filename, directoryPath$1);
+                        this.pushFile(resolvedPath, files, this.state.counts, filters);
+                    }
+                });
+            }
+        }
+        this.groupFiles(this.state.groups, directoryPath, files);
+    };
+};
+function promise(root, options) {
+    return new Promise((resolve$1, reject)=>{
+        callback(root, options, (err, output)=>{
+            if (err) return reject(err);
+            resolve$1(output);
+        });
+    });
+}
+function callback(root, options, callback$1) {
+    let walker = new Walker(root, options, callback$1);
+    walker.start();
+}
+function sync(root, options) {
+    const walker = new Walker(root, options);
+    return walker.start();
+}
+var APIBuilder = class {
+    constructor(root, options){
+        this.root = root;
+        this.options = options;
+    }
+    withPromise() {
+        return promise(this.root, this.options);
+    }
+    withCallback(cb) {
+        callback(this.root, this.options, cb);
+    }
+    sync() {
+        return sync(this.root, this.options);
+    }
+};
+let pm = null;
+try {
+    __require.resolve("picomatch");
+    pm = __require("picomatch");
+} catch  {}
+var Builder = class {
+    globCache = {};
+    options = {
+        maxDepth: 1 / 0,
+        suppressErrors: true,
+        pathSeparator: sep,
+        filters: []
+    };
+    globFunction;
+    constructor(options){
+        this.options = {
+            ...this.options,
+            ...options
+        };
+        this.globFunction = this.options.globFunction;
+    }
+    group() {
+        this.options.group = true;
+        return this;
+    }
+    withPathSeparator(separator) {
+        this.options.pathSeparator = separator;
+        return this;
+    }
+    withBasePath() {
+        this.options.includeBasePath = true;
+        return this;
+    }
+    withRelativePaths() {
+        this.options.relativePaths = true;
+        return this;
+    }
+    withDirs() {
+        this.options.includeDirs = true;
+        return this;
+    }
+    withMaxDepth(depth) {
+        this.options.maxDepth = depth;
+        return this;
+    }
+    withMaxFiles(limit) {
+        this.options.maxFiles = limit;
+        return this;
+    }
+    withFullPaths() {
+        this.options.resolvePaths = true;
+        this.options.includeBasePath = true;
+        return this;
+    }
+    withErrors() {
+        this.options.suppressErrors = false;
+        return this;
+    }
+    withSymlinks({ resolvePaths = true } = {}) {
+        this.options.resolveSymlinks = true;
+        this.options.useRealPaths = resolvePaths;
+        return this.withFullPaths();
+    }
+    withAbortSignal(signal) {
+        this.options.signal = signal;
+        return this;
+    }
+    normalize() {
+        this.options.normalizePath = true;
+        return this;
+    }
+    filter(predicate) {
+        this.options.filters.push(predicate);
+        return this;
+    }
+    onlyDirs() {
+        this.options.excludeFiles = true;
+        this.options.includeDirs = true;
+        return this;
+    }
+    exclude(predicate) {
+        this.options.exclude = predicate;
+        return this;
+    }
+    onlyCounts() {
+        this.options.onlyCounts = true;
+        return this;
+    }
+    crawl(root) {
+        return new APIBuilder(root || ".", this.options);
+    }
+    withGlobFunction(fn) {
+        this.globFunction = fn;
+        return this;
+    }
+    crawlWithOptions(root, options) {
+        this.options = {
+            ...this.options,
+            ...options
+        };
+        return new APIBuilder(root || ".", this.options);
+    }
+    glob(...patterns) {
+        if (this.globFunction) return this.globWithOptions(patterns);
+        return this.globWithOptions(patterns, {
+            dot: true
+        });
+    }
+    globWithOptions(patterns, ...options) {
+        const globFn = this.globFunction || pm;
+        if (!globFn) throw new Error("Please specify a glob function to use glob matching.");
+        var isMatch = this.globCache[patterns.join("\0")];
+        if (!isMatch) {
+            isMatch = globFn(patterns, ...options);
+            this.globCache[patterns.join("\0")] = isMatch;
+        }
+        this.options.filters.push((path)=>isMatch(path));
+        return this;
+    }
+};
+const isReadonlyArray = Array.isArray;
+const isWin = "win32" === process.platform;
+const ONLY_PARENT_DIRECTORIES = /^(\/?\.\.)+$/;
+function getPartialMatcher(patterns, options = {}) {
+    const patternsCount = patterns.length;
+    const patternsParts = Array(patternsCount);
+    const matchers = Array(patternsCount);
+    const globstarEnabled = !options.noglobstar;
+    for(let i = 0; i < patternsCount; i++){
+        const parts = splitPattern(patterns[i]);
+        patternsParts[i] = parts;
+        const partsCount = parts.length;
+        const partMatchers = Array(partsCount);
+        for(let j = 0; j < partsCount; j++)partMatchers[j] = picomatch(parts[j], options);
+        matchers[i] = partMatchers;
+    }
+    return (input)=>{
+        const inputParts = input.split("/");
+        if (".." === inputParts[0] && ONLY_PARENT_DIRECTORIES.test(input)) return true;
+        for(let i = 0; i < patterns.length; i++){
+            const patternParts = patternsParts[i];
+            const matcher = matchers[i];
+            const inputPatternCount = inputParts.length;
+            const minParts = Math.min(inputPatternCount, patternParts.length);
+            let j = 0;
+            while(j < minParts){
+                const part = patternParts[j];
+                if (part.includes("/")) return true;
+                const match = matcher[j](inputParts[j]);
+                if (!match) break;
+                if (globstarEnabled && "**" === part) return true;
+                j++;
+            }
+            if (j === inputPatternCount) return true;
+        }
+        return false;
+    };
+}
+const WIN32_ROOT_DIR = /^[A-Z]:\/$/i;
+const isRoot = isWin ? (p)=>WIN32_ROOT_DIR.test(p) : (p)=>"/" === p;
+function buildFormat(cwd, root, absolute) {
+    if (cwd === root || root.startsWith(`${cwd}/`)) {
+        if (absolute) {
+            const start = isRoot(cwd) ? cwd.length : cwd.length + 1;
+            return (p, isDir)=>p.slice(start, isDir ? -1 : void 0) || ".";
+        }
+        const prefix = root.slice(cwd.length + 1);
+        if (prefix) return (p, isDir)=>{
+            if ("." === p) return prefix;
+            const result = `${prefix}/${p}`;
+            return isDir ? result.slice(0, -1) : result;
+        };
+        return (p, isDir)=>isDir && "." !== p ? p.slice(0, -1) : p;
+    }
+    if (absolute) return (p)=>posix.relative(cwd, p) || ".";
+    return (p)=>posix.relative(cwd, `${root}/${p}`) || ".";
+}
+function buildRelative(cwd, root) {
+    if (root.startsWith(`${cwd}/`)) {
+        const prefix = root.slice(cwd.length + 1);
+        return (p)=>`${prefix}/${p}`;
+    }
+    return (p)=>{
+        const result = posix.relative(cwd, `${root}/${p}`);
+        if (p.endsWith("/") && "" !== result) return `${result}/`;
+        return result || ".";
+    };
+}
+const splitPatternOptions = {
+    parts: true
+};
+function splitPattern(path$1) {
+    var _result$parts;
+    const result = picomatch.scan(path$1, splitPatternOptions);
+    return (null == (_result$parts = result.parts) ? void 0 : _result$parts.length) ? result.parts : [
+        path$1
+    ];
+}
+const POSIX_UNESCAPED_GLOB_SYMBOLS = /(?<!\\)([()[\]{}*?|]|^!|[!+@](?=\()|\\(?![()[\]{}!*+?@|]))/g;
+const WIN32_UNESCAPED_GLOB_SYMBOLS = /(?<!\\)([()[\]{}]|^!|[!+@](?=\())/g;
+const escapePosixPath = (path$1)=>path$1.replace(POSIX_UNESCAPED_GLOB_SYMBOLS, "\\$&");
+const escapeWin32Path = (path$1)=>path$1.replace(WIN32_UNESCAPED_GLOB_SYMBOLS, "\\$&");
+const escapePath = isWin ? escapeWin32Path : escapePosixPath;
+function isDynamicPattern(pattern, options) {
+    if ((null == options ? void 0 : options.caseSensitiveMatch) === false) return true;
+    const scan = picomatch.scan(pattern);
+    return scan.isGlob || scan.negated;
+}
+function log(...tasks) {
+    console.log(`[tinyglobby ${/* @__PURE__ */ new Date().toLocaleTimeString("es")}]`, ...tasks);
+}
+const PARENT_DIRECTORY = /^(\/?\.\.)+/;
+const ESCAPING_BACKSLASHES = /\\(?=[()[\]{}!*+?@|])/g;
+const BACKSLASHES = /\\/g;
+function normalizePattern(pattern, expandDirectories, cwd, props, isIgnore) {
+    let result = pattern;
+    if (pattern.endsWith("/")) result = pattern.slice(0, -1);
+    if (!result.endsWith("*") && expandDirectories) result += "/**";
+    const escapedCwd = escapePath(cwd);
+    result = path_0.isAbsolute(result.replace(ESCAPING_BACKSLASHES, "")) ? posix.relative(escapedCwd, result) : posix.normalize(result);
+    const parentDirectoryMatch = PARENT_DIRECTORY.exec(result);
+    const parts = splitPattern(result);
+    if (null == parentDirectoryMatch ? void 0 : parentDirectoryMatch[0]) {
+        const n = (parentDirectoryMatch[0].length + 1) / 3;
+        let i = 0;
+        const cwdParts = escapedCwd.split("/");
+        while(i < n && parts[i + n] === cwdParts[cwdParts.length + i - n]){
+            result = result.slice(0, (n - i - 1) * 3) + result.slice((n - i) * 3 + parts[i + n].length + 1) || ".";
+            i++;
+        }
+        const potentialRoot = posix.join(cwd, parentDirectoryMatch[0].slice(3 * i));
+        if (!potentialRoot.startsWith(".") && props.root.length > potentialRoot.length) {
+            props.root = potentialRoot;
+            props.depthOffset = -n + i;
+        }
+    }
+    if (!isIgnore && props.depthOffset >= 0) {
+        null != props.commonPath || (props.commonPath = parts);
+        const newCommonPath = [];
+        const length = Math.min(props.commonPath.length, parts.length);
+        for(let i = 0; i < length; i++){
+            const part = parts[i];
+            if ("**" === part && !parts[i + 1]) {
+                newCommonPath.pop();
+                break;
+            }
+            if (part !== props.commonPath[i] || isDynamicPattern(part) || i === parts.length - 1) break;
+            newCommonPath.push(part);
+        }
+        props.depthOffset = newCommonPath.length;
+        props.commonPath = newCommonPath;
+        props.root = newCommonPath.length > 0 ? posix.join(cwd, ...newCommonPath) : cwd;
+    }
+    return result;
+}
+function processPatterns({ patterns = [
+    "**/*"
+], ignore = [], expandDirectories = true }, cwd, props) {
+    if ("string" == typeof patterns) patterns = [
+        patterns
+    ];
+    if ("string" == typeof ignore) ignore = [
+        ignore
+    ];
+    const matchPatterns = [];
+    const ignorePatterns = [];
+    for (const pattern of ignore)if (pattern) {
+        if ("!" !== pattern[0] || "(" === pattern[1]) ignorePatterns.push(normalizePattern(pattern, expandDirectories, cwd, props, true));
+    }
+    for (const pattern of patterns)if (pattern) {
+        if ("!" !== pattern[0] || "(" === pattern[1]) matchPatterns.push(normalizePattern(pattern, expandDirectories, cwd, props, false));
+        else if ("!" !== pattern[1] || "(" === pattern[2]) ignorePatterns.push(normalizePattern(pattern.slice(1), expandDirectories, cwd, props, true));
+    }
+    return {
+        match: matchPatterns,
+        ignore: ignorePatterns
+    };
+}
+function formatPaths(paths, relative) {
+    for(let i = paths.length - 1; i >= 0; i--){
+        const path$1 = paths[i];
+        paths[i] = relative(path$1);
+    }
+    return paths;
+}
+function normalizeCwd(cwd) {
+    if (!cwd) return process.cwd().replace(BACKSLASHES, "/");
+    if (cwd instanceof URL) return fileURLToPath(cwd).replace(BACKSLASHES, "/");
+    return path_0.resolve(cwd).replace(BACKSLASHES, "/");
+}
+function getCrawler(patterns, inputOptions = {}) {
+    const options = process.env.TINYGLOBBY_DEBUG ? {
+        ...inputOptions,
+        debug: true
+    } : inputOptions;
+    const cwd = normalizeCwd(options.cwd);
+    if (options.debug) log("globbing with:", {
+        patterns,
+        options,
+        cwd
+    });
+    if (Array.isArray(patterns) && 0 === patterns.length) return [
+        {
+            sync: ()=>[],
+            withPromise: async ()=>[]
+        },
+        false
+    ];
+    const props = {
+        root: cwd,
+        commonPath: null,
+        depthOffset: 0
+    };
+    const processed = processPatterns({
+        ...options,
+        patterns
+    }, cwd, props);
+    if (options.debug) log("internal processing patterns:", processed);
+    const matchOptions = {
+        dot: options.dot,
+        nobrace: false === options.braceExpansion,
+        nocase: false === options.caseSensitiveMatch,
+        noextglob: false === options.extglob,
+        noglobstar: false === options.globstar,
+        posix: true
+    };
+    const matcher = picomatch(processed.match, {
+        ...matchOptions,
+        ignore: processed.ignore
+    });
+    const ignore = picomatch(processed.ignore, matchOptions);
+    const partialMatcher = getPartialMatcher(processed.match, matchOptions);
+    const format = buildFormat(cwd, props.root, options.absolute);
+    const formatExclude = options.absolute ? format : buildFormat(cwd, props.root, true);
+    const fdirOptions = {
+        filters: [
+            options.debug ? (p, isDirectory)=>{
+                const path$1 = format(p, isDirectory);
+                const matches = matcher(path$1);
+                if (matches) log(`matched ${path$1}`);
+                return matches;
+            } : (p, isDirectory)=>matcher(format(p, isDirectory))
+        ],
+        exclude: options.debug ? (_, p)=>{
+            const relativePath = formatExclude(p, true);
+            const skipped = "." !== relativePath && !partialMatcher(relativePath) || ignore(relativePath);
+            skipped ? log(`skipped ${p}`) : log(`crawling ${p}`);
+            return skipped;
+        } : (_, p)=>{
+            const relativePath = formatExclude(p, true);
+            return "." !== relativePath && !partialMatcher(relativePath) || ignore(relativePath);
+        },
+        fs: options.fs ? {
+            readdir: options.fs.readdir || fs_0.readdir,
+            readdirSync: options.fs.readdirSync || fs_0.readdirSync,
+            realpath: options.fs.realpath || fs_0.realpath,
+            realpathSync: options.fs.realpathSync || fs_0.realpathSync,
+            stat: options.fs.stat || fs_0.stat,
+            statSync: options.fs.statSync || fs_0.statSync
+        } : void 0,
+        pathSeparator: "/",
+        relativePaths: true,
+        resolveSymlinks: true,
+        signal: options.signal
+    };
+    if (void 0 !== options.deep) fdirOptions.maxDepth = Math.round(options.deep - props.depthOffset);
+    if (options.absolute) {
+        fdirOptions.relativePaths = false;
+        fdirOptions.resolvePaths = true;
+        fdirOptions.includeBasePath = true;
+    }
+    if (false === options.followSymbolicLinks) {
+        fdirOptions.resolveSymlinks = false;
+        fdirOptions.excludeSymlinks = true;
+    }
+    if (options.onlyDirectories) {
+        fdirOptions.excludeFiles = true;
+        fdirOptions.includeDirs = true;
+    } else if (false === options.onlyFiles) fdirOptions.includeDirs = true;
+    props.root = props.root.replace(BACKSLASHES, "");
+    const root = props.root;
+    if (options.debug) log("internal properties:", props);
+    const relative = cwd !== root && !options.absolute && buildRelative(cwd, props.root);
+    return [
+        new Builder(fdirOptions).crawl(root),
+        relative
+    ];
+}
+function globSync(patternsOrOptions, options) {
+    if (patternsOrOptions && (null == options ? void 0 : options.patterns)) throw new Error("Cannot pass patterns as both an argument and an option");
+    const isModern = isReadonlyArray(patternsOrOptions) || "string" == typeof patternsOrOptions;
+    const opts = isModern ? options : patternsOrOptions;
+    const patterns = isModern ? patternsOrOptions : patternsOrOptions.patterns;
+    const [crawler, relative] = getCrawler(patterns, opts);
+    if (!relative) return crawler.sync();
+    return formatPaths(crawler.sync(), relative);
+}
+const JS_CONFIG_FILES = [
+    'rslint.config.js',
+    'rslint.config.mjs',
+    'rslint.config.ts',
+    'rslint.config.mts'
+];
+function findJSConfig(cwd) {
+    for (const name of JS_CONFIG_FILES){
+        const p = node_path.join(cwd, name);
+        if (node_fs.existsSync(p)) return p;
+    }
+    return null;
+}
+function findJSConfigUp(startDir) {
+    let dir = node_path.resolve(startDir);
+    while(true){
+        const found = findJSConfig(dir);
+        if (found) return found;
+        const parent = node_path.dirname(dir);
+        if (parent === dir) return null;
+        dir = parent;
+    }
+}
+function findJSConfigsInDir(startDir) {
+    const resolved = node_path.resolve(startDir);
+    return globSync([
+        '**/rslint.config.{js,mjs,ts,mts}'
+    ], {
+        cwd: resolved,
+        absolute: true,
+        dot: true,
+        ignore: [
+            '**/node_modules/**',
+            '**/.git/**'
+        ]
+    }).map((p)=>node_path.normalize(p));
+}
+function discoverConfigs(files, dirs, cwd, explicitConfig) {
+    const configs = new Map();
+    const addConfig = (configPath)=>{
+        if (!configs.has(configPath)) configs.set(configPath, node_path.dirname(configPath));
+    };
+    if (explicitConfig) {
+        const resolved = node_path.resolve(cwd, explicitConfig);
+        addConfig(resolved);
+        return configs;
+    }
+    const startDirs = new Set();
+    const scanDirs = [];
+    if (0 === files.length && 0 === dirs.length) {
+        startDirs.add(cwd);
+        scanDirs.push(cwd);
+    }
+    for (const file of files)startDirs.add(node_path.dirname(file));
+    for (const dir of dirs){
+        startDirs.add(dir);
+        scanDirs.push(dir);
+    }
+    for (const startDir of startDirs){
+        const configPath = findJSConfigUp(startDir);
+        if (configPath) addConfig(configPath);
+    }
+    for (const dir of scanDirs)for (const configPath of findJSConfigsInDir(dir))addConfig(configPath);
+    return configs;
+}
+function isGlobalIgnoreEntry(entry) {
+    const ignores = entry.ignores;
+    if (!Array.isArray(ignores) || 0 === ignores.length) return false;
+    return null == entry.files && null == entry.rules && (null == entry.plugins || (Array.isArray(entry.plugins) ? 0 === entry.plugins.length : 0 === Object.keys(entry.plugins).length)) && null == entry.languageOptions && null == entry.settings;
+}
+function getGlobalIgnores(entries) {
+    const patterns = [];
+    for (const entry of entries)if (isGlobalIgnoreEntry(entry)) for (const pattern of entry.ignores)patterns.push(pattern);
+    return patterns;
+}
+function isDirIgnoredByPatterns(dirPath, patterns, parentConfigDir) {
+    const relDir = node_path.relative(parentConfigDir, dirPath);
+    if (!relDir || relDir.startsWith('..')) return false;
+    const normalizedRelDir = relDir.split(node_path.sep).join('/');
+    for (const pattern of patterns){
+        if (!pattern || pattern.startsWith('!')) continue;
+        if (pattern.endsWith('/**/*') || pattern.endsWith('/*') && !pattern.endsWith('/**')) continue;
+        const isMatch = picomatch(pattern, {
+            dot: true
+        });
+        if (isMatch(normalizedRelDir) || isMatch(normalizedRelDir + '/') || isMatch(normalizedRelDir + '/x')) return true;
+        const segments = normalizedRelDir.split('/');
+        for(let i = 1; i < segments.length; i++){
+            const partial = segments.slice(0, i).join('/');
+            if (isMatch(partial) || isMatch(partial + '/') || isMatch(partial + '/x')) return true;
+        }
+    }
+    return false;
+}
+function filterConfigsByParentIgnores(configEntries) {
+    if (configEntries.length <= 1) return configEntries;
+    const resolvedDirs = new Map();
+    for (const entry of configEntries){
+        let dir = entry.configDirectory.replace(/[/\\]+$/, '');
+        try {
+            dir = node_fs.realpathSync(dir);
+        } catch  {}
+        resolvedDirs.set(entry, dir);
+    }
+    const sorted = [
+        ...configEntries
+    ].sort((a, b)=>(resolvedDirs.get(a)?.length ?? 0) - (resolvedDirs.get(b)?.length ?? 0));
+    const result = [];
+    for (const config of sorted){
+        let ignored = false;
+        const configDir = resolvedDirs.get(config);
+        for (const parent of result){
+            const parentDir = resolvedDirs.get(parent);
+            if (!configDir.startsWith(parentDir + node_path.sep) && configDir !== parentDir) continue;
+            const globalIgnores = getGlobalIgnores(parent.entries);
+            if (0 !== globalIgnores.length) {
+                if (isDirIgnoredByPatterns(configDir, globalIgnores, parentDir)) {
+                    ignored = true;
+                    break;
+                }
+            }
+        }
+        if (!ignored) result.push(config);
+    }
+    return result;
+}
+async function runWithJSConfigs(binPath, configs, goArgs, cwd, singleThreaded) {
     const configEntries = [];
-    const isSingleConfig = configs.size === 1;
-    for (const [configPath, configDir] of configs) {
+    const dirToPath = new Map();
+    const isSingleConfig = 1 === configs.size;
+    for (const [configPath, configDir] of configs){
         let rawConfig;
         try {
             rawConfig = await loadConfigFile(configPath);
-        }
-        catch (err) {
+        } catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
             if (isSingleConfig) {
                 process.stderr.write(`Error: failed to load config ${configPath}: ${msg}\n`);
@@ -50,8 +1004,7 @@ async function runWithJSConfigs(binPath, configs, goArgs, cwd) {
         let entries;
         try {
             entries = normalizeConfig(rawConfig);
-        }
-        catch (err) {
+        } catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
             if (isSingleConfig) {
                 process.stderr.write(`Error: invalid config in ${configPath}: ${msg}\n`);
@@ -60,73 +1013,78 @@ async function runWithJSConfigs(binPath, configs, goArgs, cwd) {
             process.stderr.write(`Warning: skipping config ${configPath}: ${msg}\n`);
             continue;
         }
-        configEntries.push({ configDirectory: configDir, entries });
-    }
-    // All configs failed to load — fall back to Go binary (JSON config path)
-    if (configEntries.length === 0) {
-        return execBinary(binPath, goArgs);
-    }
-    // Filter out nested configs whose directory is covered by a parent config's
-    // global ignores. This aligns with ESLint v10 behavior: when walking the
-    // directory tree, global ignores prevent entering directories, so nested
-    // configs in ignored directories are never discovered.
-    const filteredEntries = filterConfigsByParentIgnores(configEntries);
-    const payload = JSON.stringify({ configs: filteredEntries });
-    try {
-        execFileSync(binPath, ['--config-stdin', ...goArgs], {
-            input: payload,
-            stdio: ['pipe', 'inherit', 'inherit'],
-            cwd,
+        configEntries.push({
+            configDirectory: configDir,
+            entries
         });
-        return 0;
-    }
-    catch (error) {
-        if (isExecError(error))
-            return error.status;
-        process.stderr.write(`Failed to execute ${binPath}: ${String(error)}\n`);
-        return 1;
+        dirToPath.set(configDir, configPath);
     }
+    const { runEngine } = await import("./0~engine.js");
+    if (0 === configEntries.length) return runEngine({
+        binPath,
+        goArgs,
+        configs: [],
+        cwd
+    });
+    const filteredEntries = filterConfigsByParentIgnores(configEntries);
+    const { eslintPluginEntries, pluginConfigs } = collectPluginMeta(filteredEntries.map((ce)=>({
+            configPath: dirToPath.get(ce.configDirectory) ?? '',
+            configDirectory: ce.configDirectory,
+            entries: ce.entries
+        })));
+    return runEngine({
+        binPath,
+        goArgs,
+        configs: filteredEntries,
+        cwd,
+        eslintPluginEntries,
+        pluginConfigs,
+        runtime: {
+            singleThreaded
+        }
+    });
 }
-export async function run(binPath, argv, startTime) {
+async function run(binPath, argv, startTime) {
     const cwd = process.cwd();
-    const args = parseArgs(argv);
-    // --init: pass through to Go
+    const args = args_parseArgs(argv);
     if (args.init) {
-        return execBinary(binPath, ['--init']);
+        const { runEngine } = await import("./0~engine.js");
+        return runEngine({
+            binPath,
+            goArgs: [
+                '--init'
+            ],
+            configs: [],
+            cwd
+        });
     }
-    // Validate explicit --config flag
     if (args.config) {
-        const configPath = path.resolve(cwd, args.config);
-        if (!fs.existsSync(configPath)) {
+        const configPath = node_path.resolve(cwd, args.config);
+        if (!node_fs.existsSync(configPath)) {
             process.stderr.write(`Error: config file not found: ${configPath}\n`);
             return 1;
         }
     }
-    // Build Go args: start-time flag BEFORE positional args, because Go's
-    // flag.Parse stops at the first positional argument. If --start-time comes
-    // after positionals, it gets treated as a file path.
-    const goArgs = [`--start-time=${startTime}`, ...args.rest];
-    // Classify positional arguments into files and directories
+    const goArgs = [
+        `--start-time=${startTime}`,
+        ...args.rest
+    ];
     const { files, dirs } = classifyArgs(args.positionals, cwd);
-    // Discover JS/TS configs
     const configs = discoverConfigs(files, dirs, cwd, args.config);
-    // Check if any discovered config is a JS/TS config.
-    // NOTE: If any JS config is found (even in subdirectories), the entire flow
-    // switches to the JS config path. A root JSON config (rslint.json) will be
-    // bypassed in this case. This is a known limitation of mixing JSON and JS
-    // config formats. JSON config is deprecated — projects should migrate to JS.
     const jsConfigs = new Map();
-    for (const [configPath, configDir] of configs) {
-        if (isJSConfigFile(configPath)) {
-            jsConfigs.set(configPath, configDir);
-        }
-    }
-    if (jsConfigs.size > 0) {
-        return runWithJSConfigs(binPath, jsConfigs, goArgs, cwd);
-    }
-    // Fall back to Go binary (handles JSON config + deprecation warning)
-    const jsonGoArgs = args.config
-        ? ['--config', args.config, ...goArgs]
-        : goArgs;
-    return execBinary(binPath, jsonGoArgs);
+    for (const [configPath, configDir] of configs)if (isJSConfigFile(configPath)) jsConfigs.set(configPath, configDir);
+    if (jsConfigs.size > 0) return runWithJSConfigs(binPath, jsConfigs, goArgs, cwd, args.singleThreaded);
+    const jsonGoArgs = args.config ? [
+        '--config',
+        args.config,
+        ...goArgs
+    ] : goArgs;
+    const { runEngine } = await import("./0~engine.js");
+    return runEngine({
+        binPath,
+        goArgs: jsonGoArgs,
+        configs: [],
+        cwd
+    });
 }
+export { run };