just-binary 2.9.8

package/dist/commands/awk/parser2.d.ts

@@ -0,0 +1,81 @@
+/**
+ * AWK Parser
+ *
+ * Recursive descent parser that builds an AST from tokens.
+ */
+import type { AwkExpr, AwkProgram } from "./ast.js";
+import { type Token, TokenType } from "./lexer.js";
+export declare class AwkParser {
+    tokens: Token[];
+    pos: number;
+    parse(input: string): AwkProgram;
+    setPos(newPos: number): void;
+    current(): Token;
+    advance(): Token;
+    match(...types: TokenType[]): boolean;
+    check(type: TokenType): boolean;
+    expect(type: TokenType, message?: string): Token;
+    skipNewlines(): void;
+    private skipTerminators;
+    private parseProgram;
+    private parseFunction;
+    private parseRule;
+    private parseBlock;
+    private parseStatement;
+    private parseIf;
+    private parseWhile;
+    private parseDoWhile;
+    private parseFor;
+    parseExpression(): AwkExpr;
+    private parseAssignment;
+    parseTernary(): AwkExpr;
+    /**
+     * Parse command pipe getline: "cmd" | getline [var]
+     * This has lower precedence than logical OR but higher than ternary.
+     */
+    private parsePipeGetline;
+    private parseOr;
+    /**
+     * Continue parsing a logical OR/AND expression from a given left-hand side.
+     * Used when we've already parsed part of an expression (e.g., a regex in pattern context).
+     */
+    private parseLogicalOrRest;
+    /**
+     * Continue parsing a logical AND expression from a given left-hand side.
+     */
+    private parseLogicalAndRest;
+    private parseAnd;
+    private parseIn;
+    private parseConcatenation;
+    private parseMatch;
+    private parseComparison;
+    private canStartExpression;
+    /**
+     * Check if the current token terminates a concatenation.
+     * These are tokens that indicate we've reached a higher-level operator
+     * or end of expression.
+     */
+    private isConcatTerminator;
+    parseAddSub(): AwkExpr;
+    private parseMulDiv;
+    private parseUnary;
+    private parsePower;
+    private parsePostfix;
+    /**
+     * Parse a field index expression. This is like parseUnary but does NOT allow
+     * postfix operators, so that $i++ parses as ($i)++ rather than $(i++).
+     * Allows: $1, $i, $++i, $--i, $(expr), $-1
+     * Does NOT consume postfix ++ or -- (those apply to the field, not the index)
+     */
+    private parseFieldIndex;
+    /**
+     * Parse power expression for field index (no postfix on base)
+     */
+    private parseFieldIndexPower;
+    /**
+     * Parse primary expression for field index - like parsePrimary but returns
+     * without checking for postfix operators
+     */
+    private parseFieldIndexPrimary;
+    parsePrimary(): AwkExpr;
+}

package/dist/commands/base64/base64.d.ts

@@ -0,0 +1,7 @@
+/**
+ * base64 - Encode or decode base64
+ */
+import type { Command } from "../../types.js";
+export declare const base64Command: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/basename/basename.d.ts

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

package/dist/commands/bash/bash.d.ts

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

package/dist/commands/browser-excluded.d.ts

@@ -0,0 +1,16 @@
+/**
+ * List of commands that are not available in browser environments.
+ *
+ * These commands are excluded from the browser bundle because they:
+ * - Use Node.js-specific APIs that don't have browser equivalents
+ * - Have dependencies that don't work in browsers
+ *
+ * When a user tries to use one of these commands in a browser environment,
+ * they should get a helpful error message explaining why the command
+ * is not available.
+ */
+export declare const BROWSER_EXCLUDED_COMMANDS: readonly string[];
+/**
+ * Check if a command is browser-excluded
+ */
+export declare function isBrowserExcludedCommand(commandName: string): boolean;

package/dist/commands/cat/cat.d.ts

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

package/dist/commands/chmod/chmod.d.ts

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

package/dist/commands/clear/clear.d.ts

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

package/dist/commands/column/column.d.ts

@@ -0,0 +1,11 @@
+/**
+ * column - columnate lists
+ *
+ * Usage: column [OPTION]... [FILE]...
+ *
+ * Columnate input. Fill rows first by default, or create a table with -t.
+ */
+import type { Command } from "../../types.js";
+export declare const column: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/comm/comm.d.ts

@@ -0,0 +1,12 @@
+/**
+ * comm - compare two sorted files line by line
+ *
+ * Outputs three columns:
+ * - Column 1: lines only in FILE1
+ * - Column 2: lines only in FILE2
+ * - Column 3: lines in both files
+ */
+import type { Command } from "../../types.js";
+export declare const commCommand: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/cp/cp.d.ts

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

package/dist/commands/curl/curl.d.ts

@@ -0,0 +1,8 @@
+/**
+ * curl - Transfer data from or to a server
+ *
+ * This is a simplified implementation of curl that uses the secure fetch wrapper.
+ * Network access must be explicitly configured via BashEnvOptions.network.
+ */
+import type { Command } from "../../types.js";
+export declare const curlCommand: Command;

package/dist/commands/curl/form.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Form data handling for curl command
+ */
+import type { FormField } from "./types.js";
+/**
+ * URL-encode form data in curl's --data-urlencode format
+ * Supports: name=content, =content, name@file, @file
+ */
+export declare function encodeFormData(input: string): string;
+/**
+ * Parse -F/--form field specification
+ * Supports: name=value, name=@file, name=<file, name=value;type=mime
+ */
+export declare function parseFormField(spec: string): FormField | null;
+/**
+ * Generate multipart form data body and boundary
+ */
+export declare function generateMultipartBody(fields: FormField[], fileContents: Map<string, string>): {
+    body: string;
+    boundary: string;
+};

package/dist/commands/curl/help.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Help text for curl command
+ */
+export declare const curlHelp: {
+    name: string;
+    summary: string;
+    usage: string;
+    options: string[];
+};

package/dist/commands/curl/parse.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Option parsing for curl command
+ */
+import type { ExecResult } from "../../types.js";
+import type { CurlOptions } from "./types.js";
+/**
+ * Parse curl command line arguments
+ */
+export declare function parseOptions(args: string[]): CurlOptions | ExecResult;

package/dist/commands/curl/response-formatting.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Utility functions for curl command
+ */
+/**
+ * Format response headers for output
+ */
+export declare function formatHeaders(headers: Record<string, string>): string;
+/**
+ * Extract filename from URL for -O option
+ */
+export declare function extractFilename(url: string): string;
+/**
+ * Apply write-out format string replacements
+ */
+export declare function applyWriteOut(format: string, result: {
+    status: number;
+    headers: Record<string, string>;
+    url: string;
+    bodyLength: number;
+}): string;

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

@@ -0,0 +1,31 @@
+/**
+ * Types for curl command
+ */
+export interface FormField {
+    name: string;
+    value: string;
+    filename?: string;
+    contentType?: string;
+}
+export interface CurlOptions {
+    method: string;
+    headers: Record<string, string>;
+    data?: string;
+    dataBinary: boolean;
+    formFields: FormField[];
+    user?: string;
+    uploadFile?: string;
+    cookieJar?: string;
+    outputFile?: string;
+    useRemoteName: boolean;
+    headOnly: boolean;
+    includeHeaders: boolean;
+    silent: boolean;
+    showError: boolean;
+    failSilently: boolean;
+    followRedirects: boolean;
+    writeOut?: string;
+    verbose: boolean;
+    timeoutMs?: number;
+    url?: string;
+}

package/dist/commands/cut/cut.d.ts

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

package/dist/commands/date/date.d.ts

@@ -0,0 +1,7 @@
+/**
+ * date - Display the current date and time
+ */
+import type { Command } from "../../types.js";
+export declare const dateCommand: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/diff/diff.d.ts

@@ -0,0 +1,7 @@
+/**
+ * diff - Compare files line by line
+ */
+import type { Command } from "../../types.js";
+export declare const diffCommand: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/dirname/dirname.d.ts

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

package/dist/commands/du/du.d.ts

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

package/dist/commands/echo/echo.d.ts

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

package/dist/commands/env/env.d.ts

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

package/dist/commands/expand/expand.d.ts

@@ -0,0 +1,12 @@
+/**
+ * expand - convert tabs to spaces
+ *
+ * Usage: expand [OPTION]... [FILE]...
+ *
+ * Convert TABs in each FILE to spaces, writing to standard output.
+ * If no FILE is specified, standard input is read.
+ */
+import type { Command } from "../../types.js";
+export declare const expand: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/expand/unexpand.d.ts

@@ -0,0 +1,12 @@
+/**
+ * unexpand - convert spaces to tabs
+ *
+ * Usage: unexpand [OPTION]... [FILE]...
+ *
+ * Convert blanks in each FILE to TABs, writing to standard output.
+ * If no FILE is specified, standard input is read.
+ */
+import type { Command } from "../../types.js";
+export declare const unexpand: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/expr/expr.d.ts

@@ -0,0 +1,9 @@
+import type { Command } from "../../types.js";
+/**
+ * expr - evaluate expressions
+ *
+ * Basic implementation supporting arithmetic operations and string operations.
+ */
+export declare const exprCommand: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/file/file.d.ts

@@ -0,0 +1,9 @@
+/**
+ * file - determine file type
+ *
+ * Uses the file-type npm package for magic byte detection.
+ */
+import type { Command } from "../../types.js";
+export declare const fileCommand: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/find/find.d.ts

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

package/dist/commands/find/matcher.d.ts

@@ -0,0 +1,69 @@
+import type { EvalContext, EvalResult, Expression } from "./types.js";
+/**
+ * Evaluate a find expression and return both match result and prune flag.
+ * The prune flag is set when -prune is evaluated and returns true.
+ */
+export declare function evaluateExpressionWithPrune(expr: Expression, ctx: EvalContext): EvalResult;
+/**
+ * Check if an expression needs full stat metadata (size, mtime, mode)
+ * vs just type info (isFile/isDirectory) which can come from dirent
+ */
+export declare function expressionNeedsStatMetadata(expr: Expression | null): boolean;
+/**
+ * Check if an expression uses -empty (needs directory entry count)
+ */
+export declare function expressionNeedsEmptyCheck(expr: Expression | null): boolean;
+/**
+ * Analyze a path expression for pruning opportunities.
+ * For patterns like "*\/pulls\/*.json", we can skip descending into "pulls" subdirectories
+ * since files must be directly inside "pulls".
+ */
+export interface PathPruningHint {
+    /** If set, when in a directory with this name, don't descend into subdirs */
+    terminalDirName: string | null;
+    /** If set, files must have this extension (e.g., ".json") */
+    requiredExtension: string | null;
+}
+/**
+ * Extract path pruning hints from an expression tree.
+ * Returns hints that can be used to skip unnecessary directory traversal.
+ */
+export declare function extractPathPruningHints(expr: Expression | null): PathPruningHint;
+export declare function collectNewerRefs(expr: Expression | null): string[];
+/**
+ * Context for early prune evaluation (before readdir).
+ * Only includes info available without reading directory contents or stat.
+ */
+export interface EarlyEvalContext {
+    name: string;
+    relativePath: string;
+    isFile: boolean;
+    isDirectory: boolean;
+}
+/**
+ * Check if an expression is "simple" - only uses name/path/regex/type/prune/print.
+ * Simple expressions can be evaluated without creating EvalContext objects.
+ */
+export declare function isSimpleExpression(expr: Expression | null): boolean;
+/**
+ * Fast-path evaluator for simple expressions.
+ * Avoids creating EvalContext objects by taking arguments directly.
+ * Only use this when isSimpleExpression() returns true.
+ */
+export declare function evaluateSimpleExpression(expr: Expression, name: string, relativePath: string, isFile: boolean, isDirectory: boolean): EvalResult;
+/**
+ * Check if an expression contains -prune and can potentially be evaluated
+ * early (before readdir) to avoid unnecessary I/O.
+ */
+export declare function expressionHasPrune(expr: Expression | null): boolean;
+/**
+ * Evaluate an expression for early prune detection.
+ * Returns { shouldPrune: true } if we should skip reading this directory.
+ * Returns { shouldPrune: false } if we can't determine or shouldn't prune.
+ *
+ * This is used to avoid reading directory contents when we know we'll prune.
+ * For expressions that need stat info, we conservatively return false.
+ */
+export declare function evaluateForEarlyPrune(expr: Expression | null, ctx: EarlyEvalContext): {
+    shouldPrune: boolean;
+};

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

@@ -0,0 +1,2 @@
+import type { ParseResult } from "./types.js";
+export declare function parseExpressions(args: string[], startIndex: number): ParseResult;

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

@@ -0,0 +1,88 @@
+export type Expression = {
+    type: "name";
+    pattern: string;
+    ignoreCase?: boolean;
+} | {
+    type: "path";
+    pattern: string;
+    ignoreCase?: boolean;
+} | {
+    type: "regex";
+    pattern: string;
+    ignoreCase?: boolean;
+} | {
+    type: "type";
+    fileType: "f" | "d";
+} | {
+    type: "empty";
+} | {
+    type: "mtime";
+    days: number;
+    comparison: "exact" | "more" | "less";
+} | {
+    type: "newer";
+    refPath: string;
+} | {
+    type: "size";
+    value: number;
+    unit: SizeUnit;
+    comparison: "exact" | "more" | "less";
+} | {
+    type: "perm";
+    mode: number;
+    matchType: "exact" | "all" | "any";
+} | {
+    type: "prune";
+} | {
+    type: "print";
+} | {
+    type: "not";
+    expr: Expression;
+} | {
+    type: "and";
+    left: Expression;
+    right: Expression;
+} | {
+    type: "or";
+    left: Expression;
+    right: Expression;
+};
+export type SizeUnit = "c" | "k" | "M" | "G" | "b";
+export type FindAction = {
+    type: "exec";
+    command: string[];
+    batchMode: boolean;
+} | {
+    type: "print";
+} | {
+    type: "print0";
+} | {
+    type: "printf";
+    format: string;
+} | {
+    type: "delete";
+};
+export interface EvalContext {
+    name: string;
+    relativePath: string;
+    isFile: boolean;
+    isDirectory: boolean;
+    isEmpty: boolean;
+    mtime: number;
+    size: number;
+    mode: number;
+    newerRefTimes: Map<string, number>;
+    depth?: number;
+    startingPoint?: string;
+}
+export interface EvalResult {
+    matches: boolean;
+    pruned: boolean;
+    printed: boolean;
+}
+export interface ParseResult {
+    expr: Expression | null;
+    pathIndex: number;
+    error?: string;
+    actions: FindAction[];
+}

package/dist/commands/flag-coverage.d.ts

@@ -0,0 +1,2 @@
+import type { FeatureCoverageWriter } from "../types.js";
+export declare function emitFlagCoverage(coverage: FeatureCoverageWriter, cmdName: string, args: readonly string[]): void;

package/dist/commands/fold/fold.d.ts

@@ -0,0 +1,12 @@
+/**
+ * fold - wrap each input line to fit in specified width
+ *
+ * Usage: fold [OPTION]... [FILE]...
+ *
+ * Wrap input lines in each FILE, writing to standard output.
+ * If no FILE is specified, standard input is read.
+ */
+import type { Command } from "../../types.js";
+export declare const fold: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/fuzz-flags-types.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Type definitions for command fuzz flag metadata.
+ * Used by fuzzing generators to automatically create flag combinations.
+ */
+export interface FuzzFlag {
+    flag: string;
+    type: "boolean" | "value";
+    valueHint?: "number" | "path" | "string" | "pattern" | "format" | "delimiter";
+}
+export interface CommandFuzzInfo {
+    name: string;
+    flags: FuzzFlag[];
+    stdinType?: "text" | "json" | "binary" | "none";
+    needsFiles?: boolean;
+    needsArgs?: boolean;
+    minArgs?: number;
+}

package/dist/commands/fuzz-flags.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Central aggregator for command fuzz flag metadata.
+ * Imports flagsForFuzzing from every command file and provides a lookup Map.
+ */
+import type { CommandFuzzInfo } from "./fuzz-flags-types.js";
+/** Get all command fuzz info entries */
+export declare function getAllCommandFuzzInfo(): CommandFuzzInfo[];
+export type { CommandFuzzInfo };

package/dist/commands/grep/grep.d.ts

@@ -0,0 +1,8 @@
+import type { Command } from "../../types.js";
+export declare const grepCommand: Command;
+export declare const fgrepCommand: Command;
+export declare const egrepCommand: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;
+export declare const fgrepFlagsForFuzzing: CommandFuzzInfo;
+export declare const egrepFlagsForFuzzing: CommandFuzzInfo;

package/dist/commands/gzip/gzip.d.ts

@@ -0,0 +1,13 @@
+/**
+ * gzip - compress or expand files
+ *
+ * Also provides gunzip (decompress) and zcat (decompress to stdout) commands.
+ */
+import type { Command } from "../../types.js";
+export declare const gzipCommand: Command;
+export declare const gunzipCommand: Command;
+export declare const zcatCommand: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;
+export declare const gunzipFlagsForFuzzing: CommandFuzzInfo;
+export declare const zcatFlagsForFuzzing: CommandFuzzInfo;

package/dist/commands/head/head-tail-shared.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Shared utilities for head and tail commands.
+ */
+import type { CommandContext, ExecResult } from "../../types.js";
+export interface HeadTailOptions {
+    lines: number;
+    bytes: number | null;
+    quiet: boolean;
+    verbose: boolean;
+    files: string[];
+    /** tail-specific: start from line N instead of last N lines */
+    fromLine?: boolean;
+}
+export type HeadTailParseResult = {
+    ok: true;
+    options: HeadTailOptions;
+} | {
+    ok: false;
+    error: ExecResult;
+};
+/**
+ * Parse head/tail command arguments.
+ * Both commands share most options, with tail having additional +N syntax.
+ */
+export declare function parseHeadTailArgs(args: string[], cmdName: "head" | "tail"): HeadTailParseResult;
+/**
+ * Process files for head/tail commands.
+ * Handles stdin, multiple files, headers, and error handling.
+ */
+export declare function processHeadTailFiles(ctx: CommandContext, options: HeadTailOptions, cmdName: "head" | "tail", contentProcessor: (content: string) => string): Promise<ExecResult>;
+/**
+ * Get the first N lines or bytes from content.
+ */
+export declare function getHead(content: string, lines: number, bytes: number | null): string;
+/**
+ * Get the last N lines or bytes from content.
+ */
+export declare function getTail(content: string, lines: number, bytes: number | null, fromLine: boolean): string;