just-binary 2.9.8

package/dist/commands/split/split.d.ts

@@ -0,0 +1,12 @@
+/**
+ * split - split a file into pieces
+ *
+ * Usage: split [OPTION]... [FILE [PREFIX]]
+ *
+ * Output pieces of FILE to PREFIXaa, PREFIXab, ...;
+ * default size is 1000 lines, and default PREFIX is 'x'.
+ */
+import type { Command } from "../../types.js";
+export declare const split: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/sqlite3/formatters.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Output formatters for sqlite3 command
+ */
+export type OutputMode = "list" | "csv" | "json" | "line" | "column" | "table" | "markdown" | "tabs" | "box" | "quote" | "html" | "ascii";
+export interface FormatOptions {
+    mode: OutputMode;
+    header: boolean;
+    separator: string;
+    nullValue: string;
+    newline: string;
+}
+/**
+ * Format query results according to the specified options
+ */
+export declare function formatOutput(columns: string[], rows: unknown[][], options: FormatOptions): string;

package/dist/commands/sqlite3/sqlite3.d.ts

@@ -0,0 +1,16 @@
+/**
+ * sqlite3 - SQLite database CLI
+ *
+ * Wraps sql.js (WASM) to provide SQLite database access through the virtual filesystem.
+ * Databases are loaded from buffers and written back after modifications.
+ *
+ * Queries run in a worker thread with a timeout to prevent runaway queries
+ * (e.g., infinite recursive CTEs) from blocking execution.
+ *
+ * Security: sql.js is fully sandboxed - it cannot access the real filesystem,
+ * making ATTACH DATABASE and VACUUM INTO safe (they only operate on virtual buffers).
+ */
+import type { Command } from "../../types.js";
+export declare const sqlite3Command: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/sqlite3/worker.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Worker thread for sqlite3 query execution.
+ *
+ * This isolates potentially long-running queries so they can be
+ * terminated if they exceed the timeout.
+ *
+ * Uses sql.js (WASM-based SQLite) which is fully sandboxed and cannot
+ * access the real filesystem.
+ *
+ * Security: Uses phased defense-in-depth:
+ * 1. Init phase: sql.js WASM loads without restrictions
+ * 2. Defense phase: Activate full blocking after sql.js init
+ * 3. Execute phase: User SQL runs with all dangerous globals blocked
+ */
+import { type WorkerDefenseStats } from "../../security/index.js";
+export interface WorkerInput {
+    dbBuffer: Uint8Array | null;
+    sql: string;
+    options: {
+        bail: boolean;
+        echo: boolean;
+    };
+}
+export interface WorkerSuccess {
+    success: true;
+    results: StatementResult[];
+    hasModifications: boolean;
+    dbBuffer: Uint8Array | null;
+    /** Defense-in-depth stats if enabled */
+    defenseStats?: WorkerDefenseStats;
+}
+export interface StatementResult {
+    type: "data" | "error";
+    columns?: string[];
+    rows?: unknown[][];
+    error?: string;
+}
+export interface WorkerError {
+    success: false;
+    error: string;
+    /** Defense-in-depth stats if enabled */
+    defenseStats?: WorkerDefenseStats;
+}
+export type WorkerOutput = WorkerSuccess | WorkerError;

package/dist/commands/stat/stat.d.ts

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

package/dist/commands/strings/strings.d.ts

@@ -0,0 +1,12 @@
+/**
+ * strings - print the sequences of printable characters in files
+ *
+ * Usage: strings [OPTION]... [FILE]...
+ *
+ * For each FILE, print the printable character sequences that are at least
+ * MIN characters long. If no FILE is specified, standard input is read.
+ */
+import type { Command } from "../../types.js";
+export declare const strings: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/tac/tac.d.ts

@@ -0,0 +1,11 @@
+/**
+ * tac - concatenate and print files in reverse
+ *
+ * Usage: tac [OPTION]... [FILE]...
+ *
+ * Writes each FILE to standard output, last line first.
+ */
+import type { Command } from "../../types.js";
+export declare const tac: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/tail/tail.d.ts

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

package/dist/commands/tar/archive.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Tar archive utilities using modern-tar
+ *
+ * Provides helpers for creating and extracting tar archives
+ * with optional gzip, bzip2, and xz compression.
+ */
+import { type ParsedTarEntryWithData, type TarEntry, type TarHeader } from "modern-tar";
+export type { TarEntry, TarHeader, ParsedTarEntryWithData };
+/**
+ * Entry for creating a tar archive
+ */
+export interface TarCreateEntry {
+    name: string;
+    content?: Uint8Array | string;
+    mode?: number;
+    mtime?: Date;
+    isDirectory?: boolean;
+    isSymlink?: boolean;
+    linkTarget?: string;
+    uid?: number;
+    gid?: number;
+}
+/**
+ * Create a tar archive from entries
+ */
+export declare function createArchive(entries: TarCreateEntry[]): Promise<Uint8Array>;
+/**
+ * Create a gzip-compressed tar archive from entries
+ */
+export declare function createCompressedArchive(entries: TarCreateEntry[]): Promise<Uint8Array>;
+/**
+ * Parsed tar entry for extraction
+ */
+export interface ParsedEntry {
+    name: string;
+    mode: number;
+    uid: number;
+    gid: number;
+    size: number;
+    mtime: Date;
+    type: "file" | "directory" | "symlink" | "hardlink" | "other";
+    linkTarget?: string;
+    content: Uint8Array;
+}
+/**
+ * Parse a tar archive and return entries
+ */
+export declare function parseArchive(data: Uint8Array): Promise<{
+    entries: ParsedEntry[];
+    error?: string;
+}>;
+/**
+ * Parse a gzip-compressed tar archive
+ */
+export declare function parseCompressedArchive(data: Uint8Array): Promise<{
+    entries: ParsedEntry[];
+    error?: string;
+}>;
+/**
+ * Check if data is gzip compressed (magic bytes 0x1f 0x8b)
+ */
+export declare function isGzipCompressed(data: Uint8Array): boolean;
+/**
+ * Check if data is bzip2 compressed (magic bytes "BZh")
+ */
+export declare function isBzip2Compressed(data: Uint8Array): boolean;
+/**
+ * Check if data is xz compressed (magic bytes 0xFD 0x37 0x7A 0x58 0x5A 0x00)
+ */
+export declare function isXzCompressed(data: Uint8Array): boolean;
+/**
+ * Create a bzip2-compressed tar archive from entries
+ */
+export declare function createBzip2CompressedArchive(entries: TarCreateEntry[]): Promise<Uint8Array>;
+/**
+ * Create an xz-compressed tar archive from entries
+ */
+export declare function createXzCompressedArchive(entries: TarCreateEntry[]): Promise<Uint8Array>;
+/**
+ * Parse a bzip2-compressed tar archive
+ */
+export declare function parseBzip2CompressedArchive(data: Uint8Array): Promise<{
+    entries: ParsedEntry[];
+    error?: string;
+}>;
+/**
+ * Parse an xz-compressed tar archive
+ */
+export declare function parseXzCompressedArchive(data: Uint8Array): Promise<{
+    entries: ParsedEntry[];
+    error?: string;
+}>;
+/**
+ * Check if data is zstd compressed (magic number 0x28 0xB5 0x2F 0xFD)
+ */
+export declare function isZstdCompressed(data: Uint8Array): boolean;
+/**
+ * Create a zstd-compressed tar archive from entries
+ */
+export declare function createZstdCompressedArchive(entries: TarCreateEntry[]): Promise<Uint8Array>;
+/**
+ * Parse a zstd-compressed tar archive
+ */
+export declare function parseZstdCompressedArchive(data: Uint8Array): Promise<{
+    entries: ParsedEntry[];
+    error?: string;
+}>;

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

@@ -0,0 +1,36 @@
+/**
+ * Option parsing for tar command
+ */
+import type { ExecResult } from "../../types.js";
+export interface TarOptions {
+    create: boolean;
+    append: boolean;
+    update: boolean;
+    extract: boolean;
+    list: boolean;
+    file: string;
+    autoCompress: boolean;
+    gzip: boolean;
+    bzip2: boolean;
+    xz: boolean;
+    zstd: boolean;
+    verbose: boolean;
+    toStdout: boolean;
+    keepOldFiles: boolean;
+    touch: boolean;
+    directory: string;
+    preserve: boolean;
+    strip: number;
+    exclude: string[];
+    filesFrom: string;
+    excludeFrom: string;
+    wildcards: boolean;
+}
+export declare function parseOptions(args: string[]): {
+    ok: true;
+    options: TarOptions;
+    files: string[];
+} | {
+    ok: false;
+    error: ExecResult;
+};

package/dist/commands/tar/tar.d.ts

@@ -0,0 +1,10 @@
+/**
+ * tar - manipulate tape archives
+ *
+ * Supports creating, extracting, and listing tar archives
+ * with optional gzip, bzip2, and xz compression.
+ */
+import type { Command } from "../../types.js";
+export declare const tarCommand: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/tee/tee.d.ts

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

package/dist/commands/time/time.d.ts

@@ -0,0 +1,27 @@
+import type { Command } from "../../types.js";
+/**
+ * time - time command execution
+ *
+ * Usage: time [-f FORMAT] [-o FILE] [-a] [-v] [-p] command [arguments...]
+ *
+ * Times the execution of a command and outputs timing statistics.
+ *
+ * Options:
+ *   -f FORMAT    Use FORMAT for output (GNU time format specifiers)
+ *   -o FILE      Write timing output to FILE
+ *   -a           Append to output file (with -o)
+ *   -v           Verbose output
+ *   -p           POSIX portable output format
+ *
+ * Format specifiers:
+ *   %e    Elapsed real time in seconds
+ *   %M    Maximum resident set size (KB)
+ *   %S    System CPU time (seconds)
+ *   %U    User CPU time (seconds)
+ *
+ * Note: In this JavaScript implementation, user/system CPU time and memory
+ * metrics are not available, so %M, %S, %U output 0.
+ */
+export declare const timeCommand: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/timeout/timeout.d.ts

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

package/dist/commands/touch/touch.d.ts

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

package/dist/commands/tr/tr.d.ts

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

package/dist/commands/tree/tree.d.ts

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

package/dist/commands/true/true.d.ts

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

package/dist/commands/uniq/uniq.d.ts

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

package/dist/commands/wc/wc.d.ts

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

package/dist/commands/which/which.d.ts

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

package/dist/commands/whoami/whoami.d.ts

@@ -0,0 +1,11 @@
+/**
+ * whoami - print effective user name
+ *
+ * Usage: whoami
+ *
+ * In sandboxed environment, always returns "user".
+ */
+import type { Command } from "../../types.js";
+export declare const whoami: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/xan/aggregation.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Aggregation functions for xan command
+ */
+import { type EvaluateOptions } from "../query-engine/index.js";
+import { type CsvData, type CsvRow } from "./csv.js";
+/** Aggregation specification from parsed expression */
+export interface AggSpec {
+    func: string;
+    expr: string;
+    alias: string;
+}
+/**
+ * Parse aggregation expression: "func(expr) as alias" or "func(expr)"
+ * Handles nested parentheses in expressions like sum(add(a, b))
+ */
+export declare function parseAggExpr(expr: string): AggSpec[];
+/** Compute aggregation on data */
+export declare function computeAgg(data: CsvData, spec: AggSpec, evalOptions?: EvaluateOptions): number | string | boolean | null;
+/** Build aggregation result row */
+export declare function buildAggRow(data: CsvData, specs: AggSpec[], evalOptions?: EvaluateOptions): CsvRow;

package/dist/commands/xan/column-selection.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Shared utilities for xan subcommands
+ */
+import type { AstNode } from "../query-engine/parser.js";
+/**
+ * Parse a moonblade expression and transform to jq AST
+ */
+export declare function parseMoonbladeExpr(expr: string): AstNode;
+/**
+ * Parse column specification which can include:
+ * - Column names (e.g., "name,email")
+ * - Column indices (e.g., "0,2")
+ * - Numeric ranges (e.g., "0-2" means columns 0, 1, 2)
+ * - Column name ranges (e.g., "name:email" means columns from name to email)
+ * - Glob patterns (e.g., "vec_*", "*_count")
+ * - Negation (e.g., "!name" excludes column)
+ * Returns an array of column names
+ */
+export declare function parseColumnSpec(spec: string, headers: string[]): string[];

package/dist/commands/xan/csv.d.ts

@@ -0,0 +1,37 @@
+/**
+ * CSV parsing and formatting utilities for xan command
+ */
+import type { CommandContext, ExecResult } from "../../types.js";
+export interface CsvRow {
+    [key: string]: string | number | boolean | null;
+}
+export type CsvData = CsvRow[];
+/**
+ * Create a null-prototype CsvRow to prevent prototype pollution.
+ * User-controlled CSV column names could match dangerous keys like
+ * __proto__, constructor, or prototype. Using a null-prototype object
+ * ensures these don't access the prototype chain.
+ */
+export declare function createSafeRow(): CsvRow;
+/**
+ * Set a property on a CsvRow.
+ * Since CsvRow uses null-prototype, this is safe from prototype pollution.
+ */
+export declare function safeSetRow(row: CsvRow, key: string, value: string | number | boolean | null): void;
+/**
+ * Convert a plain object row to a safe null-prototype row.
+ */
+export declare function toSafeRow(plainRow: Record<string, unknown>): CsvRow;
+/** Parse CSV input string to array of row objects */
+export declare function parseCsv(input: string): {
+    headers: string[];
+    data: CsvData;
+};
+/** Format array of row objects back to CSV string */
+export declare function formatCsv(headers: string[], data: CsvData): string;
+/** Read CSV input from file or stdin */
+export declare function readCsvInput(args: string[], ctx: CommandContext): Promise<{
+    headers: string[];
+    data: CsvData;
+    error?: ExecResult;
+}>;

package/dist/commands/xan/moonblade-parser.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Moonblade expression parser for xan
+ *
+ * Parses moonblade expressions (xan's expression language) and transforms
+ * them to jq AST for evaluation by the shared query engine.
+ *
+ * Grammar based on xan's grammar.pest
+ */
+export type MoonbladeExpr = {
+    type: "int";
+    value: number;
+} | {
+    type: "float";
+    value: number;
+} | {
+    type: "string";
+    value: string;
+} | {
+    type: "bool";
+    value: boolean;
+} | {
+    type: "null";
+} | {
+    type: "identifier";
+    name: string;
+    unsure: boolean;
+} | {
+    type: "underscore";
+} | {
+    type: "func";
+    name: string;
+    args: Array<{
+        name?: string;
+        expr: MoonbladeExpr;
+    }>;
+} | {
+    type: "list";
+    elements: MoonbladeExpr[];
+} | {
+    type: "map";
+    entries: Array<{
+        key: string;
+        value: MoonbladeExpr;
+    }>;
+} | {
+    type: "regex";
+    pattern: string;
+    caseInsensitive: boolean;
+} | {
+    type: "slice";
+    start?: MoonbladeExpr;
+    end?: MoonbladeExpr;
+} | {
+    type: "lambda";
+    params: string[];
+    body: MoonbladeExpr;
+} | {
+    type: "lambdaBinding";
+    name: string;
+} | {
+    type: "pipeline";
+    exprs: MoonbladeExpr[];
+};
+export interface NamedExpr {
+    expr: MoonbladeExpr;
+    name: string | string[];
+}
+export interface Aggregation {
+    aggName: string;
+    funcName: string;
+    args: MoonbladeExpr[];
+}
+/**
+ * Parse named expressions like: "expr1, expr2 as name, expr3 as (a, b)"
+ */
+export declare function parseNamedExpressions(input: string): NamedExpr[];
+/**
+ * Parse a moonblade expression string into AST
+ */
+export declare function parseMoonblade(input: string): MoonbladeExpr;

package/dist/commands/xan/moonblade-to-jq.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Transform moonblade AST to jq AST
+ *
+ * This module converts moonblade expressions (xan's expression language)
+ * to jq AST for evaluation by the shared query engine.
+ */
+import type { AstNode } from "../query-engine/parser.js";
+import type { MoonbladeExpr } from "./moonblade-parser.js";
+/**
+ * Transform moonblade AST to jq AST
+ */
+export declare function moonbladeToJq(expr: MoonbladeExpr, rowContext?: boolean): AstNode;

package/dist/commands/xan/moonblade-tokenizer.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Moonblade expression tokenizer
+ */
+export type TokenType = "int" | "float" | "string" | "regex" | "ident" | "true" | "false" | "null" | "(" | ")" | "[" | "]" | "{" | "}" | "," | ":" | ";" | "=>" | "+" | "-" | "*" | "/" | "//" | "%" | "**" | "++" | "==" | "!=" | "<" | "<=" | ">" | ">=" | "eq" | "ne" | "lt" | "le" | "gt" | "ge" | "&&" | "||" | "and" | "or" | "!" | "." | "|" | "in" | "not in" | "as" | "=" | "_" | "eof";
+export interface Token {
+    type: TokenType;
+    value: string;
+    pos: number;
+}
+export declare class Tokenizer {
+    private input;
+    private pos;
+    private tokens;
+    constructor(input: string);
+    tokenize(): Token[];
+    private skipWhitespace;
+    private nextToken;
+    private match;
+    private isIdentStart;
+    private isIdentChar;
+    private readNumber;
+    private readString;
+    private readRegex;
+    private readIdentifier;
+}

package/dist/commands/xan/subcommands.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Barrel file for xan subcommand handlers
+ *
+ * This file re-exports all subcommands from their individual modules
+ * for cleaner organization and easier maintenance.
+ */
+export { cmdAgg, cmdFrequency, cmdGroupby, cmdStats } from "./xan-agg.js";
+export { cmdDrop, cmdEnum, cmdRename, cmdSelect } from "./xan-columns.js";
+export { cmdCount, cmdHead, cmdHeaders, cmdReverse, cmdSlice, cmdTail, } from "./xan-core.js";
+export { cmdFixlengths, cmdFrom, cmdPartition, cmdShuffle, cmdSplit, cmdTo, cmdTranspose, } from "./xan-data.js";
+export { cmdDedup, cmdFilter, cmdSort, cmdTop } from "./xan-filter.js";
+export { cmdMap, cmdTransform } from "./xan-map.js";
+export { cmdExplode, cmdImplode, cmdJoin, cmdMerge, cmdPivot, } from "./xan-reshape.js";
+export { cmdBehead, cmdCat, cmdFlatmap, cmdFmt, cmdSample, cmdSearch, } from "./xan-simple.js";
+export { cmdFlatten, cmdView } from "./xan-view.js";

package/dist/commands/xan/xan-agg.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Aggregation commands: agg, groupby, frequency, stats
+ */
+import type { CommandContext, ExecResult } from "../../types.js";
+export declare function cmdAgg(args: string[], ctx: CommandContext): Promise<ExecResult>;
+export declare function cmdGroupby(args: string[], ctx: CommandContext): Promise<ExecResult>;
+export declare function cmdFrequency(args: string[], ctx: CommandContext): Promise<ExecResult>;
+export declare function cmdStats(args: string[], ctx: CommandContext): Promise<ExecResult>;

package/dist/commands/xan/xan-columns.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Column operation commands: select, drop, rename, enum
+ */
+import type { CommandContext, ExecResult } from "../../types.js";
+export declare function cmdSelect(args: string[], ctx: CommandContext): Promise<ExecResult>;
+export declare function cmdDrop(args: string[], ctx: CommandContext): Promise<ExecResult>;
+export declare function cmdRename(args: string[], ctx: CommandContext): Promise<ExecResult>;
+export declare function cmdEnum(args: string[], ctx: CommandContext): Promise<ExecResult>;

package/dist/commands/xan/xan-core.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Core xan commands: headers, count, head, tail, slice, reverse
+ */
+import type { CommandContext, ExecResult } from "../../types.js";
+export declare function cmdHeaders(args: string[], ctx: CommandContext): Promise<ExecResult>;
+export declare function cmdCount(args: string[], ctx: CommandContext): Promise<ExecResult>;
+export declare function cmdHead(args: string[], ctx: CommandContext): Promise<ExecResult>;
+export declare function cmdTail(args: string[], ctx: CommandContext): Promise<ExecResult>;
+export declare function cmdSlice(args: string[], ctx: CommandContext): Promise<ExecResult>;
+export declare function cmdReverse(args: string[], ctx: CommandContext): Promise<ExecResult>;