just-binary 2.9.8

package/dist/commands/rg/rg-options.d.ts

@@ -0,0 +1,61 @@
+/**
+ * RgOptions interface and default values
+ */
+export interface RgOptions {
+    ignoreCase: boolean;
+    caseSensitive: boolean;
+    smartCase: boolean;
+    fixedStrings: boolean;
+    wordRegexp: boolean;
+    lineRegexp: boolean;
+    invertMatch: boolean;
+    multiline: boolean;
+    multilineDotall: boolean;
+    patterns: string[];
+    patternFiles: string[];
+    count: boolean;
+    countMatches: boolean;
+    files: boolean;
+    filesWithMatches: boolean;
+    filesWithoutMatch: boolean;
+    stats: boolean;
+    onlyMatching: boolean;
+    maxCount: number;
+    lineNumber: boolean;
+    noFilename: boolean;
+    withFilename: boolean;
+    nullSeparator: boolean;
+    byteOffset: boolean;
+    column: boolean;
+    vimgrep: boolean;
+    replace: string | null;
+    afterContext: number;
+    beforeContext: number;
+    contextSeparator: string;
+    quiet: boolean;
+    heading: boolean;
+    passthru: boolean;
+    includeZero: boolean;
+    sort: "path" | "none";
+    json: boolean;
+    globs: string[];
+    iglobs: string[];
+    globCaseInsensitive: boolean;
+    types: string[];
+    typesNot: string[];
+    typeAdd: string[];
+    typeClear: string[];
+    hidden: boolean;
+    noIgnore: boolean;
+    noIgnoreDot: boolean;
+    noIgnoreVcs: boolean;
+    ignoreFiles: string[];
+    maxDepth: number;
+    maxFilesize: number;
+    followSymlinks: boolean;
+    searchZip: boolean;
+    searchBinary: boolean;
+    preprocessor: string | null;
+    preprocessorGlobs: string[];
+}
+export declare function createDefaultOptions(): RgOptions;

package/dist/commands/rg/rg-parser.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Argument parsing for rg command - Declarative approach
+ */
+import type { ExecResult } from "../../types.js";
+import { type RgOptions } from "./rg-options.js";
+export interface ParseResult {
+    success: true;
+    options: RgOptions;
+    paths: string[];
+    explicitLineNumbers: boolean;
+}
+export interface ParseError {
+    success: false;
+    error: ExecResult;
+}
+export type ParseArgsResult = ParseResult | ParseError;
+/**
+ * Parse rg command arguments
+ */
+export declare function parseArgs(args: string[]): ParseArgsResult;

package/dist/commands/rg/rg-search.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Core search logic for rg command
+ */
+import type { CommandContext, ExecResult } from "../../types.js";
+import type { RgOptions } from "./rg-options.js";
+export interface SearchContext {
+    ctx: CommandContext;
+    options: RgOptions;
+    paths: string[];
+    explicitLineNumbers: boolean;
+}
+/**
+ * Execute the search with parsed options
+ */
+export declare function executeSearch(searchCtx: SearchContext): Promise<ExecResult>;

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

@@ -0,0 +1,14 @@
+/**
+ * rg - ripgrep-like recursive search
+ *
+ * Fast recursive search with smart defaults:
+ * - Recursive by default (unlike grep)
+ * - Respects .gitignore
+ * - Skips hidden files by default
+ * - Skips binary files by default
+ * - Smart case sensitivity (case-insensitive unless pattern has uppercase)
+ */
+import type { Command } from "../../types.js";
+export declare const rgCommand: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/rm/rm.d.ts

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

package/dist/commands/rmdir/rmdir.d.ts

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

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

@@ -0,0 +1,10 @@
+/**
+ * Shared search engine for grep and rg commands
+ *
+ * Provides core text searching functionality:
+ * - Line-by-line content matching
+ * - Context lines (before/after)
+ * - Regex building for different modes (basic, extended, fixed, perl)
+ */
+export { type SearchOptions, type SearchResult, searchContent, } from "./matcher.js";
+export { buildRegex, convertReplacement, type RegexMode, type RegexOptions, type RegexResult, } from "./regex.js";

package/dist/commands/search-engine/matcher.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Core content matching logic for search commands
+ */
+import type { UserRegex } from "../../regex/index.js";
+export interface SearchOptions {
+    /** Select non-matching lines */
+    invertMatch?: boolean;
+    /** Print line number with output lines */
+    showLineNumbers?: boolean;
+    /** Print only a count of matching lines */
+    countOnly?: boolean;
+    /** Count individual matches instead of lines (--count-matches) */
+    countMatches?: boolean;
+    /** Filename prefix for output (empty string for no prefix) */
+    filename?: string;
+    /** Show only the matching parts of lines */
+    onlyMatching?: boolean;
+    /** Print NUM lines of leading context */
+    beforeContext?: number;
+    /** Print NUM lines of trailing context */
+    afterContext?: number;
+    /** Stop after NUM matches (0 = unlimited) */
+    maxCount?: number;
+    /** Separator between context groups (default: --) */
+    contextSeparator?: string;
+    /** Show column number of first match */
+    showColumn?: boolean;
+    /** Output each match separately (vimgrep format) */
+    vimgrep?: boolean;
+    /** Show byte offset of each match */
+    showByteOffset?: boolean;
+    /** Replace matched text with this string */
+    replace?: string | null;
+    /** Print all lines (matches use :, non-matches use -) */
+    passthru?: boolean;
+    /** Enable multiline matching (patterns can span lines) */
+    multiline?: boolean;
+    /** If \K was used, this is the capture group index containing the "real" match */
+    kResetGroup?: number;
+}
+export interface SearchResult {
+    /** The formatted output string */
+    output: string;
+    /** Whether any matches were found */
+    matched: boolean;
+    /** Number of matches found */
+    matchCount: number;
+}
+/**
+ * Search content for regex matches and format output
+ *
+ * Handles:
+ * - Count only mode (-c)
+ * - Line numbers (-n)
+ * - Invert match (-v)
+ * - Only matching (-o)
+ * - Context lines (-A, -B, -C)
+ * - Max count (-m)
+ */
+export declare function searchContent(content: string, regex: UserRegex, options?: SearchOptions): SearchResult;

package/dist/commands/search-engine/regex.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Regex building utilities for search commands
+ */
+import { type UserRegex } from "../../regex/index.js";
+export type RegexMode = "basic" | "extended" | "fixed" | "perl";
+export interface RegexOptions {
+    mode: RegexMode;
+    ignoreCase?: boolean;
+    wholeWord?: boolean;
+    lineRegexp?: boolean;
+    multiline?: boolean;
+    /** Makes . match newlines in multiline mode (ripgrep --multiline-dotall) */
+    multilineDotall?: boolean;
+}
+export interface RegexResult {
+    regex: UserRegex;
+    /** If \K was used, this is the 1-based index of the capture group containing the "real" match */
+    kResetGroup?: number;
+}
+/**
+ * Build a JavaScript RegExp from a pattern with the specified mode
+ */
+export declare function buildRegex(pattern: string, options: RegexOptions): RegexResult;
+/**
+ * Convert replacement string syntax to JavaScript's String.replace format
+ *
+ * Conversions:
+ * - $0 and ${0} -> $& (full match)
+ * - $name -> $<name> (named capture groups)
+ * - ${name} -> $<name> (braced named capture groups)
+ * - Preserves $1, $2, etc. for numbered groups
+ */
+export declare function convertReplacement(replacement: string): string;

package/dist/commands/sed/executor.d.ts

@@ -0,0 +1,7 @@
+import type { SedCommand, SedExecutionLimits, SedState } from "./types.js";
+export declare function createInitialState(totalLines: number, filename?: string, rangeStates?: Map<string, import("./types.js").RangeState>): SedState;
+export interface ExecuteContext {
+    lines: string[];
+    currentLineIndex: number;
+}
+export declare function executeCommands(commands: SedCommand[], state: SedState, ctx?: ExecuteContext, limits?: SedExecutionLimits): number;

package/dist/commands/sed/lexer.d.ts

@@ -0,0 +1,86 @@
+/**
+ * SED Lexer
+ *
+ * Tokenizes sed scripts into a stream of tokens.
+ * Sed has context-sensitive tokenization - the meaning of characters
+ * depends heavily on what command is being parsed.
+ */
+export declare enum SedTokenType {
+    NUMBER = "NUMBER",
+    DOLLAR = "DOLLAR",// $ - last line
+    PATTERN = "PATTERN",// /regex/
+    STEP = "STEP",// first~step
+    RELATIVE_OFFSET = "RELATIVE_OFFSET",// +N (GNU extension: ,+N range)
+    LBRACE = "LBRACE",// {
+    RBRACE = "RBRACE",// }
+    SEMICOLON = "SEMICOLON",// ;
+    NEWLINE = "NEWLINE",
+    COMMA = "COMMA",// , - address range separator
+    NEGATION = "NEGATION",// ! - negate address
+    COMMAND = "COMMAND",// p, d, h, H, g, G, x, n, N, P, D, q, Q, z, =, l, F, v
+    SUBSTITUTE = "SUBSTITUTE",// s/pattern/replacement/flags
+    TRANSLITERATE = "TRANSLITERATE",// y/source/dest/
+    LABEL_DEF = "LABEL_DEF",// :name
+    BRANCH = "BRANCH",// b [label]
+    BRANCH_ON_SUBST = "BRANCH_ON_SUBST",// t [label]
+    BRANCH_ON_NO_SUBST = "BRANCH_ON_NO_SUBST",// T [label]
+    TEXT_CMD = "TEXT_CMD",// a\, i\, c\ with text
+    FILE_READ = "FILE_READ",// r filename
+    FILE_READ_LINE = "FILE_READ_LINE",// R filename
+    FILE_WRITE = "FILE_WRITE",// w filename
+    FILE_WRITE_LINE = "FILE_WRITE_LINE",// W filename
+    EXECUTE = "EXECUTE",// e [command]
+    VERSION = "VERSION",// v [version]
+    EOF = "EOF",
+    ERROR = "ERROR"
+}
+export interface SedToken {
+    type: SedTokenType;
+    value: string | number;
+    pattern?: string;
+    replacement?: string;
+    flags?: string;
+    source?: string;
+    dest?: string;
+    text?: string;
+    label?: string;
+    filename?: string;
+    command?: string;
+    first?: number;
+    step?: number;
+    offset?: number;
+    line: number;
+    column: number;
+}
+export declare class SedLexer {
+    private input;
+    private pos;
+    private line;
+    private column;
+    constructor(input: string);
+    tokenize(): SedToken[];
+    private makeToken;
+    private peek;
+    private advance;
+    /**
+     * Read an escaped string until the delimiter is reached.
+     * Handles escape sequences: \n -> newline, \t -> tab, \X -> X
+     * Returns null if newline is encountered before delimiter.
+     */
+    private readEscapedString;
+    private skipWhitespace;
+    private nextToken;
+    private readNumber;
+    private readRelativeOffset;
+    private readPattern;
+    private readLabelDef;
+    private readCommand;
+    private readSubstitute;
+    private readTransliterate;
+    private readTextCommand;
+    private readBranch;
+    private readVersion;
+    private readFileCommand;
+    private readExecute;
+    private isDigit;
+}

package/dist/commands/sed/parser.d.ts

@@ -0,0 +1,18 @@
+import type { SedCommand } from "./types.js";
+/**
+ * Parse multiple sed scripts into a list of commands.
+ * This is the main entry point for parsing sed scripts.
+ *
+ * Also detects #n or #r special comments at the start of the first script:
+ * - #n enables silent mode (equivalent to -n flag)
+ * - #r enables extended regex mode (equivalent to -r/-E flag)
+ *
+ * Handles backslash continuation across -e arguments:
+ * - If a script ends with \, the next script is treated as continuation
+ */
+export declare function parseMultipleScripts(scripts: string[], extendedRegex?: boolean): {
+    commands: SedCommand[];
+    error?: string;
+    silentMode?: boolean;
+    extendedRegexMode?: boolean;
+};

package/dist/commands/sed/sed-regex.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Regex conversion utilities for sed command
+ */
+/**
+ * Convert Basic Regular Expression (BRE) to Extended Regular Expression (ERE).
+ * In BRE: +, ?, |, (, ) are literal; \+, \?, \|, \(, \) are special
+ * In ERE: +, ?, |, (, ) are special; \+, \?, \|, \(, \) are literal
+ * Also converts POSIX character classes to JavaScript equivalents.
+ */
+export declare function breToEre(pattern: string): string;
+/**
+ * Normalize regex patterns for JavaScript RegExp.
+ * Converts GNU sed extensions to JavaScript-compatible syntax.
+ *
+ * Handles:
+ * - {,n} → {0,n} (GNU extension: "0 to n times")
+ */
+export declare function normalizeForJs(pattern: string): string;
+/**
+ * Escape pattern space for the `l` (list) command.
+ * Shows non-printable characters as escape sequences and ends with $.
+ */
+export declare function escapeForList(input: string): string;

package/dist/commands/sed/sed.d.ts

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

package/dist/commands/sed/types.d.ts

@@ -0,0 +1,219 @@
+import type { FeatureCoverageWriter } from "../../types.js";
+export interface StepAddress {
+    first: number;
+    step: number;
+}
+export interface RelativeOffset {
+    offset: number;
+}
+export type SedAddress = number | "$" | {
+    pattern: string;
+} | StepAddress | RelativeOffset;
+export interface AddressRange {
+    start?: SedAddress;
+    end?: SedAddress;
+    negated?: boolean;
+}
+export type SedCommandType = "substitute" | "print" | "printFirstLine" | "delete" | "deleteFirstLine" | "append" | "insert" | "change" | "hold" | "holdAppend" | "get" | "getAppend" | "exchange" | "next" | "nextAppend" | "quit" | "quitSilent" | "transliterate" | "lineNumber" | "branch" | "branchOnSubst" | "branchOnNoSubst" | "label" | "zap" | "group" | "list" | "printFilename" | "version" | "readFile" | "readFileLine" | "writeFile" | "writeFirstLine" | "execute";
+export interface SubstituteCommand {
+    type: "substitute";
+    address?: AddressRange;
+    pattern: string;
+    replacement: string;
+    global: boolean;
+    ignoreCase: boolean;
+    printOnMatch: boolean;
+    nthOccurrence?: number;
+    extendedRegex?: boolean;
+}
+export interface PrintCommand {
+    type: "print";
+    address?: AddressRange;
+}
+export interface DeleteCommand {
+    type: "delete";
+    address?: AddressRange;
+}
+export interface AppendCommand {
+    type: "append";
+    address?: AddressRange;
+    text: string;
+}
+export interface InsertCommand {
+    type: "insert";
+    address?: AddressRange;
+    text: string;
+}
+export interface ChangeCommand {
+    type: "change";
+    address?: AddressRange;
+    text: string;
+}
+export interface HoldCommand {
+    type: "hold";
+    address?: AddressRange;
+}
+export interface HoldAppendCommand {
+    type: "holdAppend";
+    address?: AddressRange;
+}
+export interface GetCommand {
+    type: "get";
+    address?: AddressRange;
+}
+export interface GetAppendCommand {
+    type: "getAppend";
+    address?: AddressRange;
+}
+export interface ExchangeCommand {
+    type: "exchange";
+    address?: AddressRange;
+}
+export interface NextCommand {
+    type: "next";
+    address?: AddressRange;
+}
+export interface QuitCommand {
+    type: "quit";
+    address?: AddressRange;
+    exitCode?: number;
+}
+export interface QuitSilentCommand {
+    type: "quitSilent";
+    address?: AddressRange;
+    exitCode?: number;
+}
+export interface NextAppendCommand {
+    type: "nextAppend";
+    address?: AddressRange;
+}
+export interface TransliterateCommand {
+    type: "transliterate";
+    address?: AddressRange;
+    source: string;
+    dest: string;
+}
+export interface LineNumberCommand {
+    type: "lineNumber";
+    address?: AddressRange;
+}
+export interface BranchCommand {
+    type: "branch";
+    address?: AddressRange;
+    label?: string;
+}
+export interface BranchOnSubstCommand {
+    type: "branchOnSubst";
+    address?: AddressRange;
+    label?: string;
+}
+export interface LabelCommand {
+    type: "label";
+    name: string;
+}
+export interface BranchOnNoSubstCommand {
+    type: "branchOnNoSubst";
+    address?: AddressRange;
+    label?: string;
+}
+export interface PrintFirstLineCommand {
+    type: "printFirstLine";
+    address?: AddressRange;
+}
+export interface DeleteFirstLineCommand {
+    type: "deleteFirstLine";
+    address?: AddressRange;
+}
+export interface ZapCommand {
+    type: "zap";
+    address?: AddressRange;
+}
+export interface GroupCommand {
+    type: "group";
+    address?: AddressRange;
+    commands: SedCommand[];
+}
+export interface ListCommand {
+    type: "list";
+    address?: AddressRange;
+}
+export interface PrintFilenameCommand {
+    type: "printFilename";
+    address?: AddressRange;
+}
+export interface VersionCommand {
+    type: "version";
+    address?: AddressRange;
+    minVersion?: string;
+}
+export interface ReadFileCommand {
+    type: "readFile";
+    address?: AddressRange;
+    filename: string;
+}
+export interface ReadFileLineCommand {
+    type: "readFileLine";
+    address?: AddressRange;
+    filename: string;
+}
+export interface WriteFileCommand {
+    type: "writeFile";
+    address?: AddressRange;
+    filename: string;
+}
+export interface WriteFirstLineCommand {
+    type: "writeFirstLine";
+    address?: AddressRange;
+    filename: string;
+}
+export interface ExecuteCommand {
+    type: "execute";
+    address?: AddressRange;
+    command?: string;
+}
+export type SedCommand = SubstituteCommand | PrintCommand | PrintFirstLineCommand | DeleteCommand | DeleteFirstLineCommand | AppendCommand | InsertCommand | ChangeCommand | HoldCommand | HoldAppendCommand | GetCommand | GetAppendCommand | ExchangeCommand | NextCommand | QuitCommand | QuitSilentCommand | NextAppendCommand | TransliterateCommand | LineNumberCommand | BranchCommand | BranchOnSubstCommand | BranchOnNoSubstCommand | LabelCommand | ZapCommand | GroupCommand | ListCommand | PrintFilenameCommand | VersionCommand | ReadFileCommand | ReadFileLineCommand | WriteFileCommand | WriteFirstLineCommand | ExecuteCommand;
+export interface SedState {
+    patternSpace: string;
+    holdSpace: string;
+    lineNumber: number;
+    totalLines: number;
+    deleted: boolean;
+    printed: boolean;
+    quit: boolean;
+    quitSilent: boolean;
+    exitCode?: number;
+    errorMessage?: string;
+    appendBuffer: string[];
+    changedText?: string;
+    substitutionMade: boolean;
+    lineNumberOutput: string[];
+    nCommandOutput: string[];
+    restartCycle: boolean;
+    inDRestartedCycle: boolean;
+    currentFilename?: string;
+    pendingFileReads: Array<{
+        filename: string;
+        wholeFile: boolean;
+    }>;
+    pendingFileWrites: Array<{
+        filename: string;
+        content: string;
+    }>;
+    pendingExecute?: {
+        command: string;
+        replacePattern: boolean;
+    };
+    rangeStates: Map<string, RangeState>;
+    lastPattern?: string;
+    branchRequest?: string;
+    linesConsumedInCycle: number;
+    coverage?: FeatureCoverageWriter;
+}
+export interface RangeState {
+    active: boolean;
+    startLine?: number;
+    completed?: boolean;
+}
+export interface SedExecutionLimits {
+    maxIterations: number;
+}

package/dist/commands/seq/seq.d.ts

@@ -0,0 +1,16 @@
+import type { Command } from "../../types.js";
+/**
+ * seq - print a sequence of numbers
+ *
+ * Usage:
+ *   seq LAST           - print numbers from 1 to LAST
+ *   seq FIRST LAST     - print numbers from FIRST to LAST
+ *   seq FIRST INCR LAST - print numbers from FIRST to LAST by INCR
+ *
+ * Options:
+ *   -s STRING  use STRING to separate numbers (default: newline)
+ *   -w         equalize width by padding with leading zeros
+ */
+export declare const seqCommand: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/sleep/sleep.d.ts

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

package/dist/commands/sort/comparator.d.ts

@@ -0,0 +1,9 @@
+import type { SortOptions } from "./types.js";
+/**
+ * Create a comparison function for sorting
+ */
+export declare function createComparator(options: SortOptions): (a: string, b: string) => number;
+/**
+ * Filter unique lines based on key values or whole line
+ */
+export declare function filterUnique(lines: string[], options: SortOptions): string[];

package/dist/commands/sort/parser.d.ts

@@ -0,0 +1,11 @@
+import type { KeySpec } from "./types.js";
+/**
+ * Parse a key specification like:
+ * - "1" - field 1
+ * - "1,2" - fields 1 through 2
+ * - "1.3" - field 1 starting at char 3
+ * - "1.3,2.5" - field 1 char 3 through field 2 char 5
+ * - "1n" - field 1, numeric
+ * - "1,2nr" - fields 1-2, numeric and reverse
+ */
+export declare function parseKeySpec(spec: string): KeySpec | null;

package/dist/commands/sort/sort.d.ts

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

package/dist/commands/sort/types.d.ts

@@ -0,0 +1,30 @@
+export interface KeySpec {
+    startField: number;
+    startChar?: number;
+    endField?: number;
+    endChar?: number;
+    numeric?: boolean;
+    reverse?: boolean;
+    ignoreCase?: boolean;
+    ignoreLeading?: boolean;
+    humanNumeric?: boolean;
+    versionSort?: boolean;
+    dictionaryOrder?: boolean;
+    monthSort?: boolean;
+}
+export interface SortOptions {
+    reverse: boolean;
+    numeric: boolean;
+    unique: boolean;
+    ignoreCase: boolean;
+    humanNumeric: boolean;
+    versionSort: boolean;
+    dictionaryOrder: boolean;
+    monthSort: boolean;
+    ignoreLeadingBlanks: boolean;
+    stable: boolean;
+    checkOnly: boolean;
+    outputFile: string | null;
+    keys: KeySpec[];
+    fieldDelimiter: string | null;
+}