just-binary 2.9.8

package/dist/commands/query-engine/builtins/object-builtins.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Object-related jq builtins
+ *
+ * Handles object manipulation functions like keys, to_entries, from_entries, etc.
+ */
+import type { EvalContext } from "../evaluator.js";
+import type { AstNode } from "../parser.js";
+import { type QueryValue } from "../value-operations.js";
+type EvalFn = (value: QueryValue, ast: AstNode, ctx: EvalContext) => QueryValue[];
+/**
+ * Handle object builtins that need evaluate function for arguments.
+ * Returns null if the builtin name is not an object builtin handled here.
+ */
+export declare function evalObjectBuiltin(value: QueryValue, name: string, args: AstNode[], ctx: EvalContext, evaluate: EvalFn): QueryValue[] | null;
+export {};

package/dist/commands/query-engine/builtins/path-builtins.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Path-related jq builtins
+ *
+ * Handles path manipulation functions like getpath, setpath, delpaths, paths, etc.
+ */
+import type { EvalContext } from "../evaluator.js";
+import type { AstNode } from "../parser.js";
+import type { QueryValue } from "../value-operations.js";
+type EvalFn = (value: QueryValue, ast: AstNode, ctx: EvalContext) => QueryValue[];
+type IsTruthyFn = (v: QueryValue) => boolean;
+type SetPathFn = (obj: QueryValue, path: (string | number)[], val: QueryValue) => QueryValue;
+type DeletePathFn = (obj: QueryValue, path: (string | number)[]) => QueryValue;
+type ApplyDelFn = (value: QueryValue, expr: AstNode, ctx: EvalContext) => QueryValue;
+type CollectPathsFn = (value: QueryValue, expr: AstNode, ctx: EvalContext, currentPath: (string | number)[], paths: (string | number)[][]) => void;
+/**
+ * Handle path builtins that need evaluate function for arguments.
+ * Returns null if the builtin name is not a path builtin handled here.
+ */
+export declare function evalPathBuiltin(value: QueryValue, name: string, args: AstNode[], ctx: EvalContext, evaluate: EvalFn, isTruthy: IsTruthyFn, setPath: SetPathFn, deletePath: DeletePathFn, applyDel: ApplyDelFn, collectPaths: CollectPathsFn): QueryValue[] | null;
+export {};

package/dist/commands/query-engine/builtins/sql-builtins.d.ts

@@ -0,0 +1,16 @@
+/**
+ * SQL-like jq builtins
+ *
+ * Handles IN, INDEX, and JOIN functions.
+ */
+import type { EvalContext } from "../evaluator.js";
+import type { AstNode } from "../parser.js";
+import type { QueryValue } from "../value-operations.js";
+type EvalFn = (value: QueryValue, ast: AstNode, ctx: EvalContext) => QueryValue[];
+type DeepEqualFn = (a: QueryValue, b: QueryValue) => boolean;
+/**
+ * Handle SQL-like builtins that need evaluate function for arguments.
+ * Returns null if the builtin name is not a SQL builtin handled here.
+ */
+export declare function evalSqlBuiltin(value: QueryValue, name: string, args: AstNode[], ctx: EvalContext, evaluate: EvalFn, deepEqual: DeepEqualFn): QueryValue[] | null;
+export {};

package/dist/commands/query-engine/builtins/string-builtins.d.ts

@@ -0,0 +1,15 @@
+/**
+ * String-related jq builtins
+ *
+ * Handles string manipulation functions like join, split, test, match, gsub, etc.
+ */
+import type { EvalContext } from "../evaluator.js";
+import type { AstNode } from "../parser.js";
+import type { QueryValue } from "../value-operations.js";
+type EvalFn = (value: QueryValue, ast: AstNode, ctx: EvalContext) => QueryValue[];
+/**
+ * Handle string builtins that need evaluate function for arguments.
+ * Returns null if the builtin name is not a string builtin handled here.
+ */
+export declare function evalStringBuiltin(value: QueryValue, name: string, args: AstNode[], ctx: EvalContext, evaluate: EvalFn): QueryValue[] | null;
+export {};

package/dist/commands/query-engine/builtins/type-builtins.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Type-related jq builtins
+ *
+ * Handles type checking and type filtering functions like type, numbers, strings, etc.
+ */
+import type { QueryValue } from "../value-operations.js";
+/**
+ * Handle type builtins.
+ * Returns null if the builtin name is not a type builtin handled here.
+ */
+export declare function evalTypeBuiltin(value: QueryValue, name: string): QueryValue[] | null;

package/dist/commands/query-engine/evaluator.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Query expression evaluator
+ *
+ * Evaluates a parsed query AST against any value.
+ * Used by jq, yq, and other query-based commands.
+ */
+import type { FeatureCoverageWriter } from "../../types.js";
+import type { AstNode } from "./parser.js";
+import { type QueryValue } from "./value-operations.js";
+export type { QueryValue } from "./value-operations.js";
+export interface QueryExecutionLimits {
+    maxIterations?: number;
+    maxDepth?: number;
+}
+export interface EvalContext {
+    vars: Map<string, QueryValue>;
+    limits: Required<Pick<QueryExecutionLimits, "maxIterations">> & QueryExecutionLimits;
+    env?: Map<string, string>;
+    /** Original document root for parent/root navigation */
+    root?: QueryValue;
+    /** Current path from root for parent navigation */
+    currentPath?: (string | number)[];
+    funcs?: Map<string, {
+        params: string[];
+        body: AstNode;
+        closure?: Map<string, unknown>;
+    }>;
+    labels?: Set<string>;
+    /** Feature coverage writer for fuzzing instrumentation */
+    coverage?: FeatureCoverageWriter;
+}
+export interface EvaluateOptions {
+    limits?: QueryExecutionLimits;
+    env?: Map<string, string>;
+    coverage?: FeatureCoverageWriter;
+}
+export declare function evaluate(value: QueryValue, ast: AstNode, ctxOrOptions?: EvalContext | EvaluateOptions): QueryValue[];

package/dist/commands/query-engine/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Shared query engine for jq-style filtering
+ *
+ * Provides parser and evaluator for jq-style queries that can be used
+ * with any data format (JSON, YAML, XML, etc.).
+ */
+export * from "./evaluator.js";
+export * from "./parser.js";

package/dist/commands/query-engine/parser-types.d.ts

@@ -0,0 +1,171 @@
+/**
+ * Query expression parser types
+ *
+ * AST node types and token types for jq-style filter expressions.
+ */
+export type TokenType = "DOT" | "PIPE" | "COMMA" | "COLON" | "SEMICOLON" | "LPAREN" | "RPAREN" | "LBRACKET" | "RBRACKET" | "LBRACE" | "RBRACE" | "QUESTION" | "PLUS" | "MINUS" | "STAR" | "SLASH" | "PERCENT" | "EQ" | "NE" | "LT" | "LE" | "GT" | "GE" | "AND" | "OR" | "NOT" | "ALT" | "ASSIGN" | "UPDATE_ADD" | "UPDATE_SUB" | "UPDATE_MUL" | "UPDATE_DIV" | "UPDATE_MOD" | "UPDATE_ALT" | "UPDATE_PIPE" | "IDENT" | "NUMBER" | "STRING" | "IF" | "THEN" | "ELIF" | "ELSE" | "END" | "AS" | "TRY" | "CATCH" | "TRUE" | "FALSE" | "NULL" | "REDUCE" | "FOREACH" | "LABEL" | "BREAK" | "DEF" | "DOTDOT" | "EOF";
+export interface Token {
+    type: TokenType;
+    value?: string | number;
+    pos: number;
+}
+export type AstNode = IdentityNode | FieldNode | IndexNode | SliceNode | IterateNode | PipeNode | CommaNode | LiteralNode | ArrayNode | ObjectNode | ParenNode | BinaryOpNode | UnaryOpNode | CondNode | TryNode | CallNode | VarBindNode | VarRefNode | RecurseNode | OptionalNode | StringInterpNode | UpdateOpNode | ReduceNode | ForeachNode | LabelNode | BreakNode | DefNode;
+export interface IdentityNode {
+    type: "Identity";
+}
+export interface FieldNode {
+    type: "Field";
+    name: string;
+    base?: AstNode;
+}
+export interface IndexNode {
+    type: "Index";
+    index: AstNode;
+    base?: AstNode;
+}
+export interface SliceNode {
+    type: "Slice";
+    start?: AstNode;
+    end?: AstNode;
+    base?: AstNode;
+}
+export interface IterateNode {
+    type: "Iterate";
+    base?: AstNode;
+}
+export interface PipeNode {
+    type: "Pipe";
+    left: AstNode;
+    right: AstNode;
+}
+export interface CommaNode {
+    type: "Comma";
+    left: AstNode;
+    right: AstNode;
+}
+export interface LiteralNode {
+    type: "Literal";
+    value: unknown;
+}
+export interface ArrayNode {
+    type: "Array";
+    elements?: AstNode;
+}
+export interface ObjectNode {
+    type: "Object";
+    entries: {
+        key: AstNode | string;
+        value: AstNode;
+    }[];
+}
+export interface ParenNode {
+    type: "Paren";
+    expr: AstNode;
+}
+export interface BinaryOpNode {
+    type: "BinaryOp";
+    op: "+" | "-" | "*" | "/" | "%" | "==" | "!=" | "<" | "<=" | ">" | ">=" | "and" | "or" | "//";
+    left: AstNode;
+    right: AstNode;
+}
+export interface UnaryOpNode {
+    type: "UnaryOp";
+    op: "-" | "not";
+    operand: AstNode;
+}
+export interface CondNode {
+    type: "Cond";
+    cond: AstNode;
+    then: AstNode;
+    elifs: {
+        cond: AstNode;
+        then: AstNode;
+    }[];
+    else?: AstNode;
+}
+export interface TryNode {
+    type: "Try";
+    body: AstNode;
+    catch?: AstNode;
+}
+export interface CallNode {
+    type: "Call";
+    name: string;
+    args: AstNode[];
+}
+export interface VarBindNode {
+    type: "VarBind";
+    name: string;
+    value: AstNode;
+    body: AstNode;
+    pattern?: DestructurePattern;
+    alternatives?: DestructurePattern[];
+}
+export type DestructurePattern = {
+    type: "var";
+    name: string;
+} | {
+    type: "array";
+    elements: DestructurePattern[];
+} | {
+    type: "object";
+    fields: {
+        key: string | AstNode;
+        pattern: DestructurePattern;
+        keyVar?: string;
+    }[];
+};
+export interface VarRefNode {
+    type: "VarRef";
+    name: string;
+}
+export interface RecurseNode {
+    type: "Recurse";
+}
+export interface OptionalNode {
+    type: "Optional";
+    expr: AstNode;
+}
+export interface StringInterpNode {
+    type: "StringInterp";
+    parts: (string | AstNode)[];
+}
+export interface UpdateOpNode {
+    type: "UpdateOp";
+    op: "+=" | "-=" | "*=" | "/=" | "%=" | "//=" | "=" | "|=";
+    path: AstNode;
+    value: AstNode;
+}
+export interface ReduceNode {
+    type: "Reduce";
+    expr: AstNode;
+    varName: string;
+    pattern?: DestructurePattern;
+    init: AstNode;
+    update: AstNode;
+}
+export interface ForeachNode {
+    type: "Foreach";
+    expr: AstNode;
+    varName: string;
+    pattern?: DestructurePattern;
+    init: AstNode;
+    update: AstNode;
+    extract?: AstNode;
+}
+export interface LabelNode {
+    type: "Label";
+    name: string;
+    body: AstNode;
+}
+export interface BreakNode {
+    type: "Break";
+    name: string;
+}
+export interface DefNode {
+    type: "Def";
+    name: string;
+    params: string[];
+    funcBody: AstNode;
+    body: AstNode;
+}

package/dist/commands/query-engine/parser.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Query expression parser
+ *
+ * Tokenizes and parses jq-style filter expressions into an AST.
+ * Used by jq, yq, and other query-based commands.
+ */
+export type { ArrayNode, AstNode, BinaryOpNode, BreakNode, CallNode, CommaNode, CondNode, DefNode, DestructurePattern, FieldNode, ForeachNode, IdentityNode, IndexNode, IterateNode, LabelNode, LiteralNode, ObjectNode, OptionalNode, ParenNode, PipeNode, RecurseNode, ReduceNode, SliceNode, StringInterpNode, Token, TokenType, TryNode, UnaryOpNode, UpdateOpNode, VarBindNode, VarRefNode, } from "./parser-types.js";
+import type { AstNode } from "./parser-types.js";
+export declare function parse(input: string): AstNode;

package/dist/commands/query-engine/path-operations.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Query Path Utilities
+ *
+ * Utility functions for path-based operations on query values.
+ */
+import type { QueryValue } from "./value-operations.js";
+/**
+ * Set a value at a given path within a query value.
+ * Creates intermediate arrays/objects as needed.
+ */
+export declare function setPath(value: QueryValue, path: (string | number)[], newVal: QueryValue): QueryValue;
+/**
+ * Delete a value at a given path within a query value.
+ */
+export declare function deletePath(value: QueryValue, path: (string | number)[]): QueryValue;

package/dist/commands/query-engine/safe-object.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Safe Object Utilities
+ *
+ * Defense-in-depth against JavaScript prototype pollution attacks.
+ * These utilities prevent malicious JSON from accessing or modifying
+ * the JavaScript prototype chain via keys like "__proto__", "constructor", etc.
+ */
+/**
+ * Check if a key is safe to use for object property access/assignment.
+ * Returns true if the key is safe, false if it could cause prototype pollution.
+ */
+export declare function isSafeKey(key: string): boolean;
+/**
+ * Check if a key is safe using the extended dangerous keys list.
+ * More paranoid version that blocks additional Object.prototype methods.
+ */
+export declare function isSafeKeyStrict(key: string): boolean;
+/**
+ * Safely get a property from an object using hasOwnProperty check.
+ * Returns undefined if the key is dangerous or doesn't exist as own property.
+ */
+export declare function safeGet<T>(obj: Record<string, T>, key: string): T | undefined;
+/**
+ * Safely set a property on an object.
+ * Silently ignores dangerous keys to prevent prototype pollution.
+ */
+export declare function safeSet<T>(obj: Record<string, T>, key: string, value: T): void;
+/**
+ * Safely delete a property from an object.
+ * Ignores dangerous keys.
+ */
+export declare function safeDelete<T>(obj: Record<string, T>, key: string): void;
+/**
+ * Create a safe object from entries, filtering out dangerous keys.
+ */
+export declare function safeFromEntries<T>(entries: Iterable<[string, T]>): Record<string, T>;
+/**
+ * Safely spread/assign properties from source to target.
+ * Only copies own properties and filters dangerous keys.
+ */
+export declare function safeAssign<T>(target: Record<string, T>, source: Record<string, T>): Record<string, T>;
+/**
+ * Create a shallow copy of an object, filtering dangerous keys.
+ */
+export declare function safeCopy<T extends Record<string, unknown>>(obj: T): T;
+/**
+ * Check if object has own property safely (not inherited from prototype).
+ */
+export declare function safeHasOwn(obj: object, key: string): boolean;
+/**
+ * Create a null-prototype shallow copy of an object.
+ * This prevents prototype chain lookups without filtering any keys.
+ */
+export declare function nullPrototypeCopy<T extends object>(obj: T): T & Record<string, unknown>;
+/**
+ * Merge multiple objects into a new null-prototype object.
+ * This prevents prototype chain lookups without filtering any keys.
+ */
+export declare function nullPrototypeMerge<T extends object>(...objs: T[]): T & Record<string, unknown>;

package/dist/commands/query-engine/value-operations.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Query Value Utilities
+ *
+ * Utility functions for working with jq/query values.
+ */
+export type QueryValue = unknown;
+/**
+ * Check if a value is truthy in jq semantics.
+ * In jq: false and null are falsy, everything else is truthy.
+ */
+export declare function isTruthy(v: QueryValue): boolean;
+/**
+ * Deep equality check for query values.
+ */
+export declare function deepEqual(a: QueryValue, b: QueryValue): boolean;
+/**
+ * Compare two values for sorting.
+ * Returns negative if a < b, positive if a > b, 0 if equal.
+ */
+export declare function compare(a: QueryValue, b: QueryValue): number;
+/**
+ * Deep merge two objects.
+ * Values from b override values from a, except nested objects are merged recursively.
+ * Filters out dangerous keys (__proto__, constructor, prototype) to prevent prototype pollution.
+ * Uses null-prototype objects to prevent prototype pollution via inherited properties.
+ */
+export declare function deepMerge(a: Record<string, unknown>, b: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Calculate the nesting depth of a value (array or object).
+ */
+export declare function getValueDepth(value: QueryValue, maxCheck?: number): number;
+/**
+ * Compare two values using jq's comparison semantics.
+ * jq sorts by type first (null < bool < number < string < array < object),
+ * then by value within type.
+ */
+export declare function compareJq(a: QueryValue, b: QueryValue): number;
+/**
+ * Check if value a contains value b using jq's containment semantics.
+ */
+export declare function containsDeep(a: QueryValue, b: QueryValue): boolean;

package/dist/commands/readlink/readlink.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from "../../types.js";
+export declare const readlinkCommand: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/registry.d.ts

@@ -0,0 +1,45 @@
+import type { Command } from "../types.js";
+/** All available built-in command names (excludes network commands) */
+export type CommandName = "echo" | "cat" | "printf" | "ls" | "mkdir" | "rmdir" | "touch" | "rm" | "cp" | "mv" | "ln" | "chmod" | "pwd" | "readlink" | "head" | "tail" | "wc" | "stat" | "grep" | "fgrep" | "egrep" | "rg" | "sed" | "awk" | "sort" | "uniq" | "comm" | "cut" | "paste" | "tr" | "rev" | "nl" | "fold" | "expand" | "unexpand" | "strings" | "split" | "column" | "join" | "tee" | "find" | "basename" | "dirname" | "tree" | "du" | "env" | "printenv" | "alias" | "unalias" | "history" | "xargs" | "true" | "false" | "clear" | "bash" | "sh" | "jq" | "base64" | "diff" | "date" | "sleep" | "timeout" | "seq" | "expr" | "md5sum" | "sha1sum" | "sha256sum" | "file" | "html-to-markdown" | "help" | "which" | "tac" | "hostname" | "od" | "gzip" | "gunzip" | "zcat" | "tar" | "yq" | "xan" | "sqlite3" | "time" | "whoami";
+/** Network command names (only available when network is configured) */
+export type NetworkCommandName = "curl";
+/** Python command names (only available when python is explicitly enabled) */
+export type PythonCommandName = "python3" | "python";
+/** All command names including network and python commands */
+export type AllCommandName = CommandName | NetworkCommandName | PythonCommandName;
+/**
+ * Gets all available command names (excludes network commands)
+ */
+export declare function getCommandNames(): string[];
+/**
+ * Gets all network command names
+ */
+export declare function getNetworkCommandNames(): string[];
+/**
+ * Creates all lazy commands for registration (excludes network commands)
+ * @param filter Optional array of command names to include. If not provided, all commands are created.
+ */
+export declare function createLazyCommands(filter?: CommandName[]): Command[];
+/**
+ * Creates network commands for registration (curl, etc.)
+ * These are only registered when network is explicitly configured.
+ */
+export declare function createNetworkCommands(): Command[];
+/**
+ * Gets all python command names
+ */
+export declare function getPythonCommandNames(): string[];
+/**
+ * Creates python commands for registration (python3, python).
+ * These are only registered when python is explicitly enabled.
+ * Note: Python introduces additional security surface (arbitrary code execution).
+ */
+export declare function createPythonCommands(): Command[];
+/**
+ * Clears the command cache (for testing)
+ */
+export declare function clearCommandCache(): void;
+/**
+ * Gets the number of loaded commands (for testing)
+ */
+export declare function getLoadedCommandCount(): number;

package/dist/commands/rev/rev.d.ts

@@ -0,0 +1,13 @@
+/**
+ * rev - reverse lines characterwise
+ *
+ * Usage: rev [file ...]
+ *
+ * Copies the specified files to standard output, reversing the order
+ * of characters in every line. If no files are specified, standard
+ * input is read.
+ */
+import type { Command } from "../../types.js";
+export declare const rev: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/rg/file-types.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Built-in file type definitions for rg
+ *
+ * Maps type names to file extensions and glob patterns.
+ * Based on ripgrep's default type definitions.
+ */
+export interface FileType {
+    extensions: string[];
+    globs: string[];
+}
+/**
+ * Mutable file type registry for runtime type modifications
+ * Supports --type-add and --type-clear flags
+ */
+export declare class FileTypeRegistry {
+    private types;
+    constructor();
+    /**
+     * Add a type definition
+     * Format: "name:pattern" where pattern can be:
+     * - "*.ext" - glob pattern
+     * - "include:other" - include patterns from another type
+     */
+    addType(spec: string): void;
+    /**
+     * Clear all patterns from a type
+     */
+    clearType(name: string): void;
+    /**
+     * Get a type by name
+     */
+    getType(name: string): FileType | undefined;
+    /**
+     * Get all type names
+     */
+    getAllTypes(): Map<string, FileType>;
+    /**
+     * Check if a filename matches any of the specified types
+     */
+    matchesType(filename: string, typeNames: string[]): boolean;
+    /**
+     * Check if a filename matches any recognized type
+     */
+    private matchesAnyType;
+}
+/**
+ * Format type list for --type-list output
+ */
+export declare function formatTypeList(): string;

package/dist/commands/rg/gitignore.d.ts

@@ -0,0 +1,98 @@
+/**
+ * .gitignore parser for rg
+ *
+ * Handles:
+ * - Simple patterns (*.log, node_modules/)
+ * - Negation patterns (!important.log)
+ * - Directory-only patterns (build/)
+ * - Rooted patterns (/root-only)
+ * - Double-star patterns (for matching across directories)
+ */
+import type { IFileSystem } from "../../fs/interface.js";
+export declare class GitignoreParser {
+    private patterns;
+    private basePath;
+    constructor(basePath?: string);
+    /**
+     * Parse .gitignore content and add patterns
+     */
+    parse(content: string): void;
+    /**
+     * Convert a gitignore pattern to a regex
+     */
+    private patternToRegex;
+    /**
+     * Check if a path should be ignored
+     *
+     * @param relativePath Path relative to the gitignore location
+     * @param isDirectory Whether the path is a directory
+     * @returns true if the path should be ignored
+     */
+    matches(relativePath: string, isDirectory: boolean): boolean;
+    /**
+     * Check if a path is explicitly whitelisted by a negation pattern
+     *
+     * @param relativePath Path relative to the gitignore location
+     * @param isDirectory Whether the path is a directory
+     * @returns true if the path is whitelisted by a negation pattern
+     */
+    isWhitelisted(relativePath: string, isDirectory: boolean): boolean;
+    /**
+     * Get the base path for this gitignore
+     */
+    getBasePath(): string;
+}
+/**
+ * Hierarchical gitignore manager
+ *
+ * Loads .gitignore and .ignore files from the root down to the current directory,
+ * applying patterns in order (child patterns override parent patterns).
+ */
+export declare class GitignoreManager {
+    private parsers;
+    private fs;
+    private skipDotIgnore;
+    private skipVcsIgnore;
+    private loadedDirs;
+    constructor(fs: IFileSystem, _rootPath: string, skipDotIgnore?: boolean, skipVcsIgnore?: boolean);
+    /**
+     * Load all .gitignore and .ignore files from root to the specified path
+     */
+    load(targetPath: string): Promise<void>;
+    /**
+     * Load ignore files for a directory during traversal.
+     * Only loads if the directory hasn't been loaded before.
+     */
+    loadForDirectory(dir: string): Promise<void>;
+    /**
+     * Add patterns from raw content at the specified base path.
+     * Used for --ignore-file flag.
+     */
+    addPatternsFromContent(content: string, basePath: string): void;
+    /**
+     * Check if a path should be ignored
+     *
+     * @param absolutePath Absolute path to check
+     * @param isDirectory Whether the path is a directory
+     * @returns true if the path should be ignored
+     */
+    matches(absolutePath: string, isDirectory: boolean): boolean;
+    /**
+     * Check if a path is explicitly whitelisted by a negation pattern.
+     * Used to include hidden files that have negation patterns like "!.foo"
+     *
+     * @param absolutePath Absolute path to check
+     * @param isDirectory Whether the path is a directory
+     * @returns true if the path is whitelisted by a negation pattern
+     */
+    isWhitelisted(absolutePath: string, isDirectory: boolean): boolean;
+    /**
+     * Quick check for common ignored directories
+     * Used for early pruning during traversal
+     */
+    static isCommonIgnored(name: string): boolean;
+}
+/**
+ * Load gitignore files for a search starting at the given path
+ */
+export declare function loadGitignores(fs: IFileSystem, startPath: string, skipDotIgnore?: boolean, skipVcsIgnore?: boolean, customIgnoreFiles?: string[]): Promise<GitignoreManager>;