@rslint/core 0.6.3 → 0.6.4

package/dist/cli.js

@@ -1,12 +1,8 @@
 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";
+import { filterConfigsByParentIgnores, discoverConfigs } from "./207.js";
 function isJSConfigFile(filePath) {
     return /\.(ts|mts|js|mjs)$/.test(filePath);
 }
@@ -96,895 +92,6 @@ function classifyArgs(positionals, cwd) {
         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 {
-        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
-    ];
-}
-async function glob(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.withPromise();
-    return formatPaths(await crawler.withPromise(), 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;
-    }
-}
-async function findJSConfigsInDir(startDir) {
-    const resolved = node_path.resolve(startDir);
-    const matches = await glob([
-        '**/rslint.config.{js,mjs,ts,mts}'
-    ], {
-        cwd: resolved,
-        absolute: true,
-        dot: true,
-        ignore: [
-            '**/node_modules/**',
-            '**/.git/**'
-        ]
-    });
-    return matches.map((p)=>node_path.normalize(p));
-}
-async 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 (await 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 dirToPath = new Map();