1ls 0.0.1 → 0.0.3

package/README.md

@@ -1,12 +1,12 @@
 # 1ls - One Line Script
 
-A lightweight, fast JSON/YAML/CSV processor with JavaScript syntax. Built with Bun for blazing performance.
+A 0 dependency, lightweight, fast data processor with familiar JavaScript syntax. 
 
 ## Why 1ls?
 
 - **JavaScript Syntax**: Use familiar JavaScript array methods and syntax instead of learning jq's DSL
-- **Multi-format**: Works with JSON, YAML, TOML, CSV, TSV out of the box
-- **Fast**: Built with Bun for exceptional performance
+- **Multi-format**: Works with JSON, JSON5, YAML, TOML, XML, INI, CSV, TSV, ENV, NDJSON, JavaScript, TypeScript, and more
+- **Fast**: Built for speed; no deps, compiled by Bun
 - **Intuitive**: Property access with dot notation, just like JavaScript
 - **Powerful**: Full support for array methods, arrow functions, and object operations
 - **Shortcuts**: Built-in shortcuts for common operations (e.g., `.mp` for `.map`)
@@ -14,12 +14,12 @@ A lightweight, fast JSON/YAML/CSV processor with JavaScript syntax. Built with B
 ## Installation
 
 ```bash
-# Using Bun
-bun install -g 1ls
-
-# Using npm
+# Using npm (or bun)
 npm install -g 1ls
 
+# Using Homebrew (macOS/Linux)
+brew install yowainwright/tap/1ls
+
 # Using curl
 curl -fsSL https://raw.githubusercontent.com/yowainwright/1ls/main/install.sh | bash
 ```
@@ -42,10 +42,94 @@ echo '[1, 2, 3]' | 1ls '.map(x => x * 2)'
 # Chain operations
 echo '[{"name": "Alice", "age": 30}, {"name": "Bob", "age": 25}]' | 1ls '.filter(x => x.age > 26).map(x => x.name)'
 # Output: ["Alice"]
+
+# Interactive mode - explore JSON with fuzzy search
+1ls readFile data.json
+# Opens interactive explorer with fuzzy search, arrow key navigation, and live preview
 ```
 
 ## Examples
 
+### Interactive Mode
+
+Explore JSON interactively with fuzzy search and build expressions with method discovery:
+
+```bash
+# Open interactive explorer from a file (automatic when no expression)
+1ls readFile data.json
+
+# Works with all supported formats
+1ls readFile config.yaml
+1ls readFile config.toml
+
+# For remote data, save to a file first
+curl https://api.github.com/users/github > /tmp/user.json
+1ls readFile /tmp/user.json
+
+# Or use an expression directly (non-interactive)
+1ls readFile data.json '.users.filter(x => x.active)'
+```
+
+#### Mode 1: Path Explorer
+
+Navigate and search JSON paths:
+
+- **Fuzzy search**: Type to filter paths (e.g., "user.name" matches `.users[0].name`, `.user.username`, etc.)
+- **Live preview**: See values as you navigate
+- **Type information**: Shows String, Number, Array, Object, Boolean, or null
+- **↑/↓**: Navigate, **Enter**: Select, **Tab**: Build expression, **Esc/q**: Quit
+
+#### Mode 2: Expression Builder
+
+Build complex expressions with guided method selection:
+
+**Workflow:**
+1. Navigate to a path in Explorer mode → Press **Tab**
+2. Type to fuzzy search methods → **→** to accept
+3. Type to fuzzy search properties → **→** to complete
+4. Repeat to chain methods
+5. Press **Enter** to execute
+
+**Example Session:**
+```
+1. Navigate to .users (Array) → Tab
+2. Type "fil" → → (accepts .filter(x => ...))
+3. Type "act" → → (completes with x.active, back to method selection)
+4. Type "map" → → (accepts .map(x => ...))
+5. Type "name" → → (completes with x.name)
+6. Enter → executes: .users.filter(x => x.active).map(x => x.name)
+```
+
+**Undo mistakes:**
+- Press **←** at any time to undo the last segment
+- Example: `.users.filter(x => x.active).map(x => x.name)` → **←** → `.users.filter(x => x.active)`
+
+**Available Methods by Type:**
+
+**Array**: map, filter, reduce, find, findIndex, some, every, sort, reverse, slice, concat, join, flat, flatMap, length
+
+**String**: toUpperCase, toLowerCase, trim, trimStart, trimEnd, split, replace, replaceAll, substring, slice, startsWith, endsWith, includes, match, length
+
+**Object**: {keys}, {values}, {entries}, {length}
+
+**Number**: toFixed, toString
+
+**Keyboard Shortcuts:**
+- **↑/↓**: Navigate methods/properties
+- **→ or Tab**: Accept/complete method or property (autocomplete-style)
+- **←**: Undo last segment (remove to previous dot)
+- **Enter**: Execute expression
+- **Type**: Fuzzy search methods/properties
+- **Esc**: Go back to Explorer / Quit
+- **q**: Quit (from Explorer)
+
+**Use cases:**
+- Exploring unfamiliar API responses
+- Building filter/map chains interactively
+- Discovering available methods for each type
+- Learning JavaScript array/string methods
+- Prototyping complex data transformations
+
 ### Working with JSON
 
 ```bash
@@ -110,11 +194,34 @@ John,30
 Jane,25' | 1ls '.map(x => x.name)'
 # Output: ["John", "Jane"]
 
+# ENV file input
+echo 'DATABASE_URL=postgres://localhost/db
+PORT=3000
+DEBUG=true' | 1ls '.PORT'
+# Output: 3000
+
+# NDJSON (Newline-Delimited JSON) - great for logs
+echo '{"level":"error","msg":"Failed"}
+{"level":"info","msg":"Started"}
+{"level":"error","msg":"Timeout"}' | 1ls '.filter(x => x.level === "error")'
+# Output: [{"level":"error","msg":"Failed"}, {"level":"error","msg":"Timeout"}]
+
 # Specify input format explicitly
 cat data.yaml | 1ls --input-format yaml '.users[0].name'
 cat data.csv | 1ls --input-format csv '.filter(x => x.age > 25)'
+cat app.env | 1ls --input-format env '.DATABASE_URL'
+cat logs.ndjson | 1ls --input-format ndjson '.filter(x => x.level === "error")'
 ```
 
+**Supported Formats:**
+- JSON, JSON5 (JSON with comments/trailing commas)
+- YAML, TOML, XML, INI
+- CSV, TSV
+- ENV files (.env)
+- NDJSON (Newline-Delimited JSON for logs)
+- JavaScript, TypeScript (with `export default`)
+- Plain text, line-by-line
+
 ### File Operations
 
 ```bash
@@ -157,6 +264,7 @@ echo '["a", "b"]' | 1ls '.jn(",")'           # Short for .join()
 |--------|-------|-------------|
 | `--help` | `-h` | Show help |
 | `--version` | `-v` | Show version |
+| `--interactive` | | Interactive fuzzy search explorer |
 | `--raw` | `-r` | Output raw strings, not JSON |
 | `--pretty` | `-p` | Pretty print output |
 | `--compact` | `-c` | Compact output |
@@ -294,6 +402,26 @@ done
 - Efficient streaming for large files
 - Native binary compilation
 
+## Development
+
+```bash
+# Clone the repository
+git clone https://github.com/yowainwright/1ls.git
+cd 1ls
+
+# Install dependencies
+bun install
+
+# Run tests
+bun test
+
+# Build
+bun run build
+
+# Build binaries
+bun run build:binary:all
+```
+
 ## Contributing
 
 Contributions are welcome! Please check out the [Contributing Guide](CONTRIBUTING.md).
@@ -309,17 +437,14 @@ MIT © Jeff Wainwright
 | Syntax | JavaScript | DSL | JavaScript |
 | Performance | ⚡ Fast (Bun) | ⚡ Fast | 🚀 Good |
 | Learning Curve | Easy | Steep | Easy |
-| Multi-format | ✅ | ❌ | ❌ |
-| Shortcuts | ✅ | ❌ | ❌ |
-| Arrow Functions | ✅ | ❌ | ✅ |
-| File Operations | ✅ | ❌ | ❌ |
+| Multi-format | ✓ | x | x |
+| Interactive Mode | ✓ | x | ✓ |
+| Shortcuts | ✓ | x | x |
+| Arrow Functions | ✓ | x | ✓ |
+| File Operations | ✓ | x | x |
 
 ## Troubleshooting
 
-### Installation Issues
-- Ensure Bun is installed: `curl -fsSL https://bun.sh/install | bash`
-- Check PATH includes Bun location
-
 ### Expression Errors
 - Wrap expressions in quotes to prevent shell interpretation
 - Use single quotes for expressions containing dollar signs
@@ -332,4 +457,4 @@ MIT © Jeff Wainwright
 
 - [GitHub Repository](https://github.com/yowainwright/1ls)
 - [Documentation](https://1ls.dev)
-- [Issue Tracker](https://github.com/yowainwright/1ls/issues)
+- [Issue Tracker](https://github.com/yowainwright/1ls/issues)

package/dist/cli/constants.d.ts

@@ -0,0 +1,3 @@
+import { DataFormat } from "../utils/types";
+export declare const VALID_OUTPUT_FORMATS: readonly ["json", "yaml", "csv", "table"];
+export declare const VALID_INPUT_FORMATS: DataFormat[];

package/dist/completions/1ls.bash

@@ -0,0 +1,63 @@
+#!/bin/bash
+# Bash completion for 1ls
+
+_1ls_complete() {
+    local cur prev opts
+    COMPREPLY=()
+    cur="${COMP_WORDS[COMP_CWORD]}"
+    prev="${COMP_WORDS[COMP_CWORD-1]}"
+
+    # Main options
+    opts="--help --version --raw --pretty --compact --type --format --list --grep --find --recursive --ignore-case --line-numbers --ext --max-depth --shortcuts --shorten --expand readFile"
+
+    # Format options
+    format_opts="json yaml csv table"
+
+    # Common JSON path starters
+    json_paths=". .[] .{keys} .{values} .{entries}"
+
+    # Common shorthand methods
+    shortcuts=".mp .flt .rd .fnd .sm .evr .srt .rvs .jn .kys .vls .ents .lc .uc .trm"
+
+    case "${prev}" in
+        --format)
+            COMPREPLY=( $(compgen -W "${format_opts}" -- ${cur}) )
+            return 0
+            ;;
+        --list|--find|readFile)
+            # File/directory completion
+            COMPREPLY=( $(compgen -f -- ${cur}) )
+            return 0
+            ;;
+        --ext)
+            # Common extensions
+            COMPREPLY=( $(compgen -W "js ts tsx jsx json md txt yml yaml xml html css" -- ${cur}) )
+            return 0
+            ;;
+        --shorten|--expand)
+            # JSON expressions
+            COMPREPLY=( $(compgen -W "${json_paths}" -- ${cur}) )
+            return 0
+            ;;
+        *)
+            ;;
+    esac
+
+    # If current word starts with -, show options
+    if [[ ${cur} == -* ]]; then
+        COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
+        return 0
+    fi
+
+    # If current word starts with ., suggest JSON paths and shortcuts
+    if [[ ${cur} == .* ]]; then
+        all_paths="${json_paths} ${shortcuts}"
+        COMPREPLY=( $(compgen -W "${all_paths}" -- ${cur}) )
+        return 0
+    fi
+
+    # Default to options
+    COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
+}
+
+complete -F _1ls_complete 1ls

package/dist/completions/1ls.zsh

@@ -0,0 +1,79 @@
+#compdef 1ls
+# Zsh completion for 1ls
+
+_1ls() {
+    local -a opts format_opts shortcuts json_paths
+
+    # Main options
+    opts=(
+        '--help[Show help]'
+        '--version[Show version]'
+        '--raw[Raw output (no formatting)]'
+        '--pretty[Pretty print JSON]'
+        '--compact[Compact JSON]'
+        '--type[Show value type info]'
+        '--format[Output format]:format:(json yaml csv table)'
+        '--list[List files in directory]:directory:_files -/'
+        '--grep[Search for pattern]:pattern:'
+        '--find[Path to search in]:path:_files'
+        '--recursive[Recursive search]'
+        '--ignore-case[Case insensitive search]'
+        '--line-numbers[Show line numbers]'
+        '--ext[Filter by extensions]:extensions:'
+        '--max-depth[Maximum recursion depth]:depth:'
+        '--shortcuts[Show all available shortcuts]'
+        '--shorten[Convert expression to shorthand]:expression:'
+        '--expand[Convert shorthand to full form]:expression:'
+        'readFile[Read from file]:file:_files'
+    )
+
+    # Common shorthand methods
+    shortcuts=(
+        '.mp:map - Transform each element'
+        '.flt:filter - Filter elements'
+        '.rd:reduce - Reduce to single value'
+        '.fnd:find - Find first match'
+        '.sm:some - Test if any match'
+        '.evr:every - Test if all match'
+        '.srt:sort - Sort elements'
+        '.rvs:reverse - Reverse order'
+        '.jn:join - Join to string'
+        '.kys:keys - Get object keys'
+        '.vls:values - Get object values'
+        '.ents:entries - Get object entries'
+        '.lc:toLowerCase - Convert to lowercase'
+        '.uc:toUpperCase - Convert to uppercase'
+        '.trm:trim - Remove whitespace'
+    )
+
+    # JSON path examples
+    json_paths=(
+        '.:Root object'
+        '.[]:All array elements'
+        '.{keys}:Object keys'
+        '.{values}:Object values'
+        '.{entries}:Object entries'
+    )
+
+    # Check context and provide appropriate completions
+    local curcontext="$curcontext" state line
+    typeset -A opt_args
+
+    _arguments -C \
+        "${opts[@]}" \
+        '*:: :->args'
+
+    case $state in
+        args)
+            # If typing starts with ., offer shortcuts and paths
+            if [[ $words[$CURRENT] == .* ]]; then
+                _describe -t shortcuts 'shortcuts' shortcuts
+                _describe -t paths 'json paths' json_paths
+            else
+                _arguments "${opts[@]}"
+            fi
+            ;;
+    esac
+}
+
+_1ls "$@"

package/dist/completions/install-completions.sh

@@ -0,0 +1,52 @@
+#!/bin/bash
+
+echo "Installing 1ls shell completions..."
+
+# Detect shell
+if [ -n "$BASH_VERSION" ]; then
+    SHELL_NAME="bash"
+elif [ -n "$ZSH_VERSION" ]; then
+    SHELL_NAME="zsh"
+else
+    echo "Unsupported shell. Only bash and zsh are supported."
+    exit 1
+fi
+
+# Get the directory of this script
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+
+if [ "$SHELL_NAME" = "bash" ]; then
+    # Bash installation
+    if [ -d "$HOME/.bash_completion.d" ]; then
+        cp "$SCRIPT_DIR/1ls.bash" "$HOME/.bash_completion.d/"
+        echo "Installed to ~/.bash_completion.d/"
+        echo "Add this to your ~/.bashrc if not already present:"
+        echo "  source ~/.bash_completion.d/1ls.bash"
+    elif [ -f "$HOME/.bashrc" ]; then
+        echo "" >> "$HOME/.bashrc"
+        echo "# 1ls completions" >> "$HOME/.bashrc"
+        echo "source $SCRIPT_DIR/1ls.bash" >> "$HOME/.bashrc"
+        echo "Added to ~/.bashrc"
+    else
+        echo "Could not find suitable location for bash completions"
+        echo "Please manually source: $SCRIPT_DIR/1ls.bash"
+    fi
+elif [ "$SHELL_NAME" = "zsh" ]; then
+    # Zsh installation
+    if [ -d "$HOME/.zsh/completions" ]; then
+        cp "$SCRIPT_DIR/1ls.zsh" "$HOME/.zsh/completions/_1ls"
+        echo "Installed to ~/.zsh/completions/"
+    elif [ -d "/usr/local/share/zsh/site-functions" ]; then
+        cp "$SCRIPT_DIR/1ls.zsh" "/usr/local/share/zsh/site-functions/_1ls"
+        echo "Installed to /usr/local/share/zsh/site-functions/"
+    else
+        mkdir -p "$HOME/.zsh/completions"
+        cp "$SCRIPT_DIR/1ls.zsh" "$HOME/.zsh/completions/_1ls"
+        echo "Installed to ~/.zsh/completions/"
+        echo "Add this to your ~/.zshrc if not already present:"
+        echo "  fpath=(~/.zsh/completions \$fpath)"
+        echo "  autoload -U compinit && compinit"
+    fi
+fi
+
+echo "Reload your shell or run 'source ~/.${SHELL_NAME}rc' to enable completions"

package/dist/expression/constants.d.ts

@@ -0,0 +1 @@
+export declare const BOOLEAN_LITERALS: readonly ["true", "false", "null"];

package/dist/expression/index.d.ts

@@ -0,0 +1,43 @@
+import { Token, ASTNode, PropertyAccessNode, IndexAccessNode, SliceAccessNode, MethodCallNode, ObjectOperationNode, ObjectOperationType, ArraySpreadNode, ArrowFunctionNode, RootNode } from "../types";
+export declare function createErrorMessage(token: Token, message: string): string;
+export declare function createPropertyAccessNode(property: string, object?: ASTNode): PropertyAccessNode;
+export declare function createIndexAccessNode(index: number, object?: ASTNode): IndexAccessNode;
+export declare function createSliceAccessNode(start: number | undefined, end: number | undefined, object?: ASTNode): SliceAccessNode;
+export declare function createMethodCallNode(method: string, args: ASTNode[], object?: ASTNode): MethodCallNode;
+export declare function createObjectOperationNode(operation: ObjectOperationType, object?: ASTNode): ObjectOperationNode;
+export declare function createArraySpreadNode(object?: ASTNode): ArraySpreadNode;
+export declare function createArrowFunctionNode(params: string[], body: ASTNode): ArrowFunctionNode;
+export declare function createRootNode(expression?: ASTNode): RootNode;
+export declare const VALID_OBJECT_OPERATIONS: readonly ObjectOperationType[];
+export declare function isValidObjectOperation(value: string): value is ObjectOperationType;
+export declare class ExpressionParser {
+    private tokens;
+    private position;
+    private current;
+    constructor(tokens: readonly Token[]);
+    parse(): RootNode;
+    private parseExpression;
+    private parsePrimary;
+    private parsePrimaryNode;
+    private parseAccessChain;
+    private parseBracketAccess;
+    private parseNumericIndexOrSlice;
+    private parseSliceFromColon;
+    private parseArrayAccess;
+    private parseObjectOperation;
+    private parseIdentifierOrFunction;
+    private parseArrowFunction;
+    private parseFunctionBody;
+    private parseBinaryExpression;
+    private parseFunctionTerm;
+    private parseIdentifierChain;
+    private parseMethodCall;
+    private parseMethodArguments;
+    private parseMethodArgument;
+    private parseFunctionParams;
+    private parsePostfix;
+    private parsePostfixDot;
+    private parseNumber;
+    private advance;
+    private expect;
+}

package/dist/expression/utils.d.ts

@@ -0,0 +1,5 @@
+import { LiteralNode } from "../types";
+import { BOOLEAN_LITERALS } from "./constants";
+export declare const isBooleanLiteral: (value: string) => value is (typeof BOOLEAN_LITERALS)[number];
+export declare const createLiteralNode: (value: string | number | boolean | null) => LiteralNode;
+export declare const tryParseLiteralIdentifier: (identifier: string) => LiteralNode | undefined;

package/dist/formats/constants.d.ts

@@ -0,0 +1,51 @@
+export declare const CSV: {
+    readonly NUMBER: RegExp;
+};
+export declare const YAML: {
+    readonly INTEGER: RegExp;
+    readonly FLOAT: RegExp;
+};
+export declare const TOML: {
+    readonly INTEGER: RegExp;
+    readonly FLOAT: RegExp;
+};
+export declare const XML: {
+    readonly NUMBER: RegExp;
+    readonly ATTRIBUTES: RegExp;
+    readonly SELF_CLOSING: RegExp;
+    readonly OPEN_TAG: RegExp;
+    readonly NESTED_TAGS: RegExp;
+    readonly COMPLETE_TAGS: RegExp;
+    readonly XML_DECLARATION: RegExp;
+};
+export declare const INI: {
+    readonly NUMBER: RegExp;
+};
+export declare const JSON5: {
+    readonly TRAILING_COMMA: RegExp;
+    readonly UNQUOTED_KEY: RegExp;
+};
+export declare const JS: {
+    readonly EXPORT: RegExp;
+};
+export declare const TS: {
+    readonly TYPE_ANNOTATION: RegExp;
+    readonly INTERFACE: RegExp;
+    readonly TYPE_ALIAS: RegExp;
+    readonly GENERIC: RegExp;
+    readonly EXPORT: RegExp;
+};
+export declare const DETECTION: {
+    readonly JSON5_FEATURES: RegExp;
+    readonly SECTION_HEADER: RegExp;
+    readonly TOML_SECTION: RegExp;
+    readonly TOML_QUOTED_VALUES: RegExp;
+    readonly TOML_SYNTAX: RegExp;
+    readonly INI_SYNTAX: RegExp;
+    readonly JS_EXPORT: RegExp;
+    readonly TS_TYPE_ANNOTATION: RegExp;
+    readonly TS_INTERFACE: RegExp;
+    readonly TS_TYPE_ALIAS: RegExp;
+    readonly ENV_FEATURES: RegExp;
+    readonly NDJSON_FEATURES: RegExp;
+};

package/dist/formats/csv.d.ts

@@ -0,0 +1,4 @@
+export declare function parseCSVLine(line: string, delimiter: string): string[];
+export declare function parseCSVValue(value: string): unknown;
+export declare function parseCSV(input: string, delimiter?: string): unknown[];
+export declare function parseTSV(input: string): unknown[];

package/dist/formats/env.d.ts

@@ -0,0 +1,2 @@
+export declare function parseENVValue(value: string): unknown;
+export declare function parseENV(input: string): Record<string, unknown>;

package/dist/formats/index.d.ts

@@ -0,0 +1,4 @@
+import type { DataFormat } from "../utils/types";
+export declare function parseLines(input: string): string[];
+export declare function parseInput(input: string, format?: DataFormat): Promise<unknown>;
+export declare function detectFormat(input: string): DataFormat;

package/dist/formats/ini.d.ts

@@ -0,0 +1,2 @@
+export declare function parseINIValue(value: string): unknown;
+export declare function parseINI(input: string): Record<string, unknown>;

package/dist/formats/javascript.d.ts

@@ -0,0 +1,2 @@
+export declare function stripJSComments(input: string): string;
+export declare function parseJavaScript(input: string): unknown;

package/dist/formats/json5.d.ts

@@ -0,0 +1,3 @@
+export declare function stripJSON5Comments(input: string): string;
+export declare function normalizeJSON5(input: string): string;
+export declare function parseJSON5(input: string): unknown;

package/dist/formats/ndjson.d.ts

@@ -0,0 +1 @@
+export declare function parseNDJSON(input: string): unknown[];

package/dist/formats/protobuf.d.ts

@@ -0,0 +1,2 @@
+export declare function parseProtobuf(_input: string): unknown;
+export declare function parseProtobufJSON(input: string): unknown;

package/dist/formats/toml.d.ts

@@ -0,0 +1,2 @@
+export declare function parseTOMLValue(value: string): unknown;
+export declare function parseTOML(input: string): unknown;

package/dist/formats/types.d.ts

@@ -0,0 +1,41 @@
+export interface CSVOptions {
+    delimiter: string;
+}
+export interface TOMLTable {
+    [key: string]: unknown;
+}
+export interface YAMLParseContext {
+    stack: unknown[];
+    indentStack: number[];
+    currentList: unknown[] | null;
+    listIndent: number;
+}
+export interface XMLAttributes {
+    _attributes?: Record<string, unknown>;
+    _text?: unknown;
+    [key: string]: unknown;
+}
+export interface ParseState {
+    result: string[];
+    inString: boolean;
+    delimiter: string;
+    skip: number;
+}
+export interface XMLParseState {
+    buffer: string[];
+    depth: number;
+    skip: number;
+}
+export interface XMLElementState {
+    elements: string[];
+    buffer: string[];
+    depth: number;
+    skip: number;
+}
+export interface INIParseState {
+    result: Record<string, unknown>;
+    currentSection: string;
+}
+export interface ENVParseState {
+    result: Record<string, unknown>;
+}

package/dist/formats/typescript.d.ts

@@ -0,0 +1 @@
+export declare function parseTypeScript(input: string): unknown;

package/dist/formats/utils.d.ts

@@ -0,0 +1,11 @@
+export declare const TRUTHY_VALUES: readonly ["true", "yes", "on"];
+export declare const FALSY_VALUES: readonly ["false", "no", "off"];
+export declare const NULL_VALUES: readonly ["null", "~", ""];
+export declare const isTruthyValue: (value: string) => value is (typeof TRUTHY_VALUES)[number];
+export declare const isFalsyValue: (value: string) => value is (typeof FALSY_VALUES)[number];
+export declare const isNullValue: (value: string) => value is (typeof NULL_VALUES)[number];
+export declare const parseBooleanValue: (value: string) => boolean | undefined;
+export declare const parseNullValue: (value: string) => null | undefined;
+export declare const tryParseNumber: (value: string) => number | undefined;
+export declare const countQuotes: (line: string, endPos: number) => number;
+export declare const isQuoteBalanced: (quoteCount: number) => boolean;

package/dist/formats/xml.d.ts

@@ -0,0 +1,5 @@
+export declare function parseXMLValue(value: string): unknown;
+export declare function parseXMLAttributes(attrString: string): Record<string, unknown>;
+export declare function parseXMLElement(xml: string): unknown;
+export declare function parseXMLChildren(content: string): Record<string, unknown>;
+export declare function parseXML(input: string): unknown;

package/dist/formats/yaml.d.ts

@@ -0,0 +1,3 @@
+export declare function parseYAMLValue(value: string): unknown;
+export declare function findPreviousKey(lines: string[], currentIndex: number): string | null;
+export declare function parseYAML(input: string): unknown;

package/dist/formatter/output.d.ts

@@ -2,7 +2,7 @@ import { CliOptions } from "../types";
 export declare class Formatter {
     private options;
     constructor(options: CliOptions);
-    format(data: any): string;
+    format(data: unknown): string;
     private formatRaw;
     private formatJson;
     private formatWithType;