@jerryan/just-bash 3.5.0

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

@@ -0,0 +1,96 @@
+/**
+ * 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 interface AwkParserLimits {
+    maxSourceLength?: number;
+    maxTokens?: number;
+    maxDepth?: number;
+    maxOperations?: number;
+}
+export declare class AwkParser {
+    tokens: Token[];
+    pos: number;
+    private depth;
+    private operations;
+    private readonly limits;
+    constructor(limits?: AwkParserLimits);
+    parse(input: string): AwkProgram;
+    setPos(newPos: number): void;
+    current(): Token;
+    advance(): Token;
+    useOperation(count?: number): void;
+    withDepth<T>(operation: () => T): T;
+    assertArrayLength(length: number): void;
+    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;
+    /** Parse one statement after reserving host-stack depth. */
+    private parseStatementAtDepth;
+    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 { RuntimeCommand } from "../../types.js";
+export declare const base64Command: RuntimeCommand;
+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 { RuntimeCommand } from "../../types.js";
+export declare const basenameCommand: RuntimeCommand;
+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 { RuntimeCommand } from "../../types.js";
+export declare const bashCommand: RuntimeCommand;
+export declare const shCommand: RuntimeCommand;
+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 { RuntimeCommand } from "../../types.js";
+export declare const catCommand: RuntimeCommand;
+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 { RuntimeCommand } from "../../types.js";
+export declare const chmodCommand: RuntimeCommand;
+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 { RuntimeCommand } from "../../types.js";
+export declare const clearCommand: RuntimeCommand;
+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 { RuntimeCommand } from "../../types.js";
+export declare const column: RuntimeCommand;
+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 { RuntimeCommand } from "../../types.js";
+export declare const commCommand: RuntimeCommand;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/compression/codec-budget.d.ts

@@ -0,0 +1,35 @@
+/** Shared prospective accounting for compression and archive codecs. */
+export interface CodecBudgetOptions {
+    /** Maximum bytes accepted from the compressed/input side of the codec. */
+    maxInputBytes: number;
+    /** Maximum bytes a codec may produce. Must be enforced while producing. */
+    maxOutputBytes: number;
+    /** Optional expansion-ratio guard, applied after `ratioGraceBytes`. */
+    maxExpansionRatio?: number;
+    /** Avoid ratio false positives for tiny, intentionally repetitive inputs. */
+    ratioGraceBytes?: number;
+    /** Maximum bytes of codec work charged across input and output. */
+    maxWorkBytes?: number;
+    signal?: AbortSignal;
+    label?: string;
+}
+/**
+ * A codec must call `acceptInput` before decoding and `acceptOutput` before
+ * retaining every output chunk. This makes the safety check prospective: the
+ * allocation/side effect does not happen when the reservation fails.
+ */
+export declare class CodecBudget {
+    private readonly options;
+    private inputBytes;
+    private outputBytes;
+    private workBytes;
+    private readonly label;
+    constructor(options: CodecBudgetOptions);
+    checkpoint(): void;
+    acceptInput(bytes: number): void;
+    acceptOutput(bytes: number): void;
+    get inputLength(): number;
+    get outputLength(): number;
+    private chargeWork;
+    private addWithinLimit;
+}

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

@@ -0,0 +1,4 @@
+import type { RuntimeCommand } from "../../types.js";
+export declare const cpCommand: RuntimeCommand;
+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 { RuntimeCommand } from "../../types.js";
+export declare const curlCommand: RuntimeCommand;

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

@@ -0,0 +1,23 @@
+/**
+ * Form data handling for curl command
+ */
+import type { FormField } from "./types.js";
+export declare function encodeCurlData(value: string): string;
+/**
+ * URL-encode form data in curl's --data-urlencode format
+ * Supports: name=content, =content, content. The `@file` / `name@file` forms
+ * are detected in parseOptions and deferred to execute time (see resolveData).
+ */
+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
+ */
+/**
+ * Status line + headers + trailing blank line, matching `-i` / `-D` layout.
+ */
+export declare function formatHeaderBlock(status: number, statusText: string, 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,70 @@
+/**
+ * Types for curl command
+ */
+export interface FormField {
+    name: string;
+    value: string;
+    filename?: string;
+    contentType?: string;
+}
+/**
+ * A single `-d`/`--data`/`--data-binary`/`--data-raw`/`--data-urlencode`
+ * occurrence. Parts accumulate in command-line order and are joined with `&`
+ * at execute time, matching real curl's behavior of combining repeated data
+ * flags. Exactly one of `value` / `file` is set per part.
+ */
+export interface DataPart {
+    /**
+     * Inline value already in its final wire form: raw for `-d`/`--data`/
+     * `--data-raw`/`--data-binary`, URL-encoded for inline `--data-urlencode`.
+     * Undefined when the part is file-backed.
+     */
+    value?: string;
+    /** File-backed payload (`@file` forms), read at execute time. */
+    file?: DataPartFile;
+}
+export interface DataPartFile {
+    /** Path to read; resolved against ctx.cwd at execute time. */
+    path: string;
+    /**
+     * `ascii` (`-d`/`--data` @file): CR and LF are stripped after reading.
+     * `binary` (`--data-binary` @file): file bytes are sent verbatim.
+     * `urlencode` (`--data-urlencode` @file/name@file): contents are
+     * URL-encoded after reading.
+     */
+    mode: "ascii" | "binary" | "urlencode";
+    /**
+     * `--data-urlencode name@file` emits a `name=` prefix before the encoded
+     * file contents. Undefined for the bare `@file` form.
+     */
+    name?: string;
+}
+export interface CurlOptions {
+    method: string;
+    headers: Headers;
+    dataParts: DataPart[];
+    dataBinary: boolean;
+    getMode: boolean;
+    formFields: FormField[];
+    user?: string;
+    uploadFile?: string;
+    cookieJar?: string;
+    outputFile?: string;
+    /**
+     * `-D` / `--dump-header` destination. `"-"` writes headers to stdout;
+     * any other string is a VFS path. Undefined when the flag was not given.
+     */
+    dumpHeader?: string;
+    useRemoteName: boolean;
+    headOnly: boolean;
+    includeHeaders: boolean;
+    silent: boolean;
+    showError: boolean;
+    failSilently: boolean;
+    followRedirects: boolean;
+    writeOut?: string;
+    verbose: boolean;
+    timeoutMs?: number;
+    maxRedirects?: number;
+    url?: string;
+}

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

@@ -0,0 +1,4 @@
+import type { RuntimeCommand } from "../../types.js";
+export declare const cutCommand: RuntimeCommand;
+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 { RuntimeCommand } from "../../types.js";
+export declare const dateCommand: RuntimeCommand;
+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 { RuntimeCommand } from "../../types.js";
+export declare const diffCommand: RuntimeCommand;
+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 { RuntimeCommand } from "../../types.js";
+export declare const dirnameCommand: RuntimeCommand;
+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 { RuntimeCommand } from "../../types.js";
+export declare const duCommand: RuntimeCommand;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/duration.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Parse a duration string (e.g. "5s", "1m", "2h", "1d") to milliseconds.
+ * Returns null if the string is not a valid duration.
+ */
+export declare function parseDuration(arg: string): number | null;

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

@@ -0,0 +1,4 @@
+import type { RuntimeCommand } from "../../types.js";
+export declare const echoCommand: RuntimeCommand;
+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 { RuntimeCommand } from "../../types.js";
+export declare const envCommand: RuntimeCommand;
+export declare const printenvCommand: RuntimeCommand;
+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 { RuntimeCommand } from "../../types.js";
+export declare const expand: RuntimeCommand;
+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 { RuntimeCommand } from "../../types.js";
+export declare const unexpand: RuntimeCommand;
+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 { RuntimeCommand } from "../../types.js";
+/**
+ * expr - evaluate expressions
+ *
+ * Basic implementation supporting arithmetic operations and string operations.
+ */
+export declare const exprCommand: RuntimeCommand;
+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 { RuntimeCommand } from "../../types.js";
+export declare const fileCommand: RuntimeCommand;
+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 { RuntimeCommand } from "../../types.js";
+export declare const findCommand: RuntimeCommand;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

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

@@ -0,0 +1,53 @@
+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;
+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,89 @@
+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: "action";
+    action: FindAction;
+} | {
+    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;
+    actions?: FindAction[];
+}
+export interface ParseResult {
+    expr: Expression | null;
+    pathIndex: number;
+    error?: string;
+}

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 { RuntimeCommand } from "../../types.js";
+export declare const fold: RuntimeCommand;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/format-mode.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Format a numeric file mode as a symbolic permission string (e.g. "drwxr-xr-x").
+ */
+export declare function formatMode(mode: number, isDirectory: boolean): string;