1ls 0.1.11 → 0.1.13

package/dist/interactive/builder/constants.d.ts

@@ -0,0 +1,14 @@
+export declare const ARROW_FN_PATTERNS: {
+    readonly SINGLE_PARAM: "x =>";
+    readonly SORT_PARAMS: "(a, b)";
+    readonly REDUCE_PARAMS: "(acc, x)";
+};
+export declare const TEMPLATE_REPLACEMENTS: {
+    readonly SINGLE_PARAM: "x => x";
+    readonly SORT_COMPARE: "(a, b) => a - b";
+    readonly REDUCE_ACC: "(acc, x) => acc";
+};
+export declare const DEFAULT_PARAM_NAMES: {
+    readonly SORT: "a";
+    readonly DEFAULT: "x";
+};

package/dist/interactive/{builder.d.ts → builder/index.d.ts}

@@ -1,4 +1,4 @@
-import type { State } from "./types";
+import type { State } from "../types";
 export declare const enterBuildMode: (state: State) => State;
 export declare const exitBuildMode: (state: State) => State;
 export declare const updateBuildQuery: (state: State, query: string) => State;

package/dist/interactive/builder/types.d.ts

@@ -0,0 +1,4 @@
+import type { State } from "../types";
+export type StateTransition = (state: State) => State;
+export type StateTransitionWithQuery = (state: State, query: string) => State;
+export type StateTransitionWithIndex = (state: State, index: number) => State;

package/dist/interactive/builder/utils.d.ts

@@ -0,0 +1,7 @@
+export declare const needsArrowFn: (template: string) => boolean;
+export declare const getParamName: (template: string) => string;
+export declare const getParamType: (value: unknown) => string;
+export declare const getArraySampleValue: (value: unknown) => unknown;
+export declare const replaceLastOccurrence: (str: string, find: string, replace: string) => string;
+export declare const replaceTemplateWithExpression: (expression: string, template: string, contextExpression: string) => string;
+export declare const buildArrowExpression: (path: string, paramName: string) => string;

package/dist/interactive/methods/constants.d.ts

@@ -0,0 +1,10 @@
+import type { Method } from "./types";
+export declare const ARRAY_METHODS: Method[];
+export declare const STRING_METHODS: Method[];
+export declare const OBJECT_OPERATIONS: Method[];
+export declare const NUMBER_METHODS: Method[];
+export declare const ARRAY_BUILTINS: Method[];
+export declare const OBJECT_BUILTINS: Method[];
+export declare const STRING_BUILTINS: Method[];
+export declare const NUMBER_BUILTINS: Method[];
+export declare const UNIVERSAL_BUILTINS: Method[];

package/dist/interactive/methods/index.d.ts

@@ -0,0 +1,4 @@
+export type { Method } from "./types";
+export { ARRAY_METHODS, STRING_METHODS, OBJECT_OPERATIONS, NUMBER_METHODS, ARRAY_BUILTINS, OBJECT_BUILTINS, STRING_BUILTINS, NUMBER_BUILTINS, UNIVERSAL_BUILTINS, } from "./constants";
+import type { Method } from "./types";
+export declare const getMethodsForType: (type: string) => Method[];

package/dist/interactive/methods/types.d.ts

@@ -0,0 +1,8 @@
+export interface Method {
+    name: string;
+    signature: string;
+    description: string;
+    template?: string;
+    category?: string;
+    isBuiltin?: boolean;
+}

package/dist/interactive/preview/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const MAX_PREVIEW_LINES = 6;
+export declare const MAX_PREVIEW_CHARS = 500;
+export declare const MAX_ARRAY_ITEMS = 5;
+export declare const EVALUATION_TIMEOUT_MS = 50;

package/dist/interactive/preview/index.d.ts

@@ -0,0 +1,5 @@
+import type { PreviewResult } from "./types";
+export type { PreviewResult } from "./types";
+export { MAX_PREVIEW_LINES, MAX_PREVIEW_CHARS, MAX_ARRAY_ITEMS } from "./constants";
+export declare const evaluatePreview: (expression: string, data: unknown) => PreviewResult;
+export declare const formatPreview: (result: PreviewResult) => string;

package/dist/interactive/preview/types.d.ts

@@ -0,0 +1,6 @@
+export interface PreviewResult {
+    success: boolean;
+    value: unknown;
+    error: string | null;
+    truncated: boolean;
+}

package/dist/interactive/tooltip/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const MAX_TOOLTIP_HINTS = 5;
+export declare const METHOD_TRIGGER_CHAR = ".";
+export declare const METHOD_COMPLETE_CHARS: string[];

package/dist/interactive/tooltip/index.d.ts

@@ -0,0 +1,20 @@
+import type { Method } from "../methods/types";
+import type { FuzzyMatch } from "../types";
+import type { TooltipState, TooltipContext } from "./types";
+export type { TooltipState, TooltipContext } from "./types";
+export { MAX_TOOLTIP_HINTS, METHOD_TRIGGER_CHAR, METHOD_COMPLETE_CHARS } from "./constants";
+export declare const createTooltipState: () => TooltipState;
+export declare const updateTooltipFromQuery: (context: TooltipContext) => TooltipState;
+export declare const selectNextHint: (tooltip: TooltipState) => TooltipState;
+export declare const selectPreviousHint: (tooltip: TooltipState) => TooltipState;
+export declare const getSelectedHint: (tooltip: TooltipState) => Method | null;
+export declare const isMethodComplete: (query: string) => boolean;
+export declare const getPreviewForExpression: (expression: string, data: unknown) => {
+    success: boolean;
+    preview: string;
+};
+export declare const formatMethodHint: (match: FuzzyMatch<Method>) => {
+    signature: string;
+    description: string;
+    isBuiltin: boolean;
+};

package/dist/interactive/tooltip/types.d.ts

@@ -0,0 +1,13 @@
+import type { Method } from "../methods/types";
+import type { FuzzyMatch } from "../types";
+export interface TooltipState {
+    visible: boolean;
+    methodHints: FuzzyMatch<Method>[];
+    partialMethod: string;
+    selectedHintIndex: number;
+}
+export interface TooltipContext {
+    query: string;
+    dataType: string;
+    originalData: unknown;
+}

package/dist/interactive/types.d.ts

@@ -1,3 +1,7 @@
+export type { Method } from "./methods/types";
+export type { TooltipState } from "./tooltip/types";
+import type { Method } from "./methods/types";
+import type { TooltipState } from "./tooltip/types";
 export interface JsonPath {
     path: string;
     value: unknown;
@@ -20,13 +24,6 @@ export interface ArrowFnContext {
     paramPaths: JsonPath[];
     expression: string;
 }
-export interface Method {
-    name: string;
-    signature: string;
-    description: string;
-    template?: string;
-    category?: string;
-}
 export interface State {
     mode: InteractiveMode;
     paths: JsonPath[];
@@ -37,6 +34,7 @@ export interface State {
     originalData: unknown;
     methodMatches: FuzzyMatch<Method>[];
     propertyMatches: FuzzyMatch<JsonPath>[];
+    tooltip: TooltipState;
 }
 export interface FuzzyMatch<T> {
     item: T;

package/dist/{utils/logger.d.ts → logger.d.ts}

@@ -1,4 +1,13 @@
-import { LogLevelType, LogData } from "./types";
+export declare const LogLevel: {
+    readonly ERROR: 0;
+    readonly WARN: 1;
+    readonly INFO: 2;
+    readonly DEBUG: 3;
+};
+export type LogLevelType = (typeof LogLevel)[keyof typeof LogLevel];
+export interface LogData {
+    [key: string]: unknown;
+}
 export declare class Logger {
     private level;
     private name;

package/dist/navigator/builtins/constants.d.ts

@@ -0,0 +1,62 @@
+export declare const EMPTY_SYMBOL: unique symbol;
+export declare const BUILTIN_FUNCTIONS: {
+    readonly PIPE: "pipe";
+    readonly COMPOSE: "compose";
+    readonly HEAD: "head";
+    readonly LAST: "last";
+    readonly TAIL: "tail";
+    readonly TAKE: "take";
+    readonly DROP: "drop";
+    readonly UNIQ: "uniq";
+    readonly FLATTEN: "flatten";
+    readonly REVERSE: "rev";
+    readonly GROUPBY: "groupBy";
+    readonly SORTBY: "sortBy";
+    readonly CHUNK: "chunk";
+    readonly COMPACT: "compact";
+    readonly PICK: "pick";
+    readonly OMIT: "omit";
+    readonly KEYS: "keys";
+    readonly VALUES: "vals";
+    readonly MERGE: "merge";
+    readonly DEEPMERGE: "deepMerge";
+    readonly FROMPAIRS: "fromPairs";
+    readonly TOPAIRS: "toPairs";
+    readonly SUM: "sum";
+    readonly MEAN: "mean";
+    readonly MIN: "min";
+    readonly MAX: "max";
+    readonly LEN: "len";
+    readonly COUNT: "count";
+    readonly ISEMPTY: "isEmpty";
+    readonly ISNIL: "isNil";
+    readonly IDENTITY: "id";
+    readonly PLUCK: "pluck";
+    readonly TYPE: "type";
+    readonly RANGE: "range";
+    readonly HAS: "has";
+    readonly NTH: "nth";
+    readonly CONTAINS: "contains";
+    readonly ADD: "add";
+    readonly PATH: "path";
+    readonly GETPATH: "getpath";
+    readonly SETPATH: "setpath";
+    readonly RECURSE: "recurse";
+    readonly SPLIT: "split";
+    readonly JOIN: "join";
+    readonly STARTSWITH: "startswith";
+    readonly ENDSWITH: "endswith";
+    readonly LTRIMSTR: "ltrimstr";
+    readonly RTRIMSTR: "rtrimstr";
+    readonly TOSTRING: "tostring";
+    readonly TONUMBER: "tonumber";
+    readonly FLOOR: "floor";
+    readonly CEIL: "ceil";
+    readonly ROUND: "round";
+    readonly ABS: "abs";
+    readonly NOT: "not";
+    readonly SELECT: "select";
+    readonly EMPTY: "empty";
+    readonly ERROR: "error";
+    readonly DEBUG: "debug";
+};

package/dist/navigator/builtins/index.d.ts

@@ -0,0 +1,6 @@
+import type { BuiltinFn } from "./types";
+export { EMPTY_SYMBOL, BUILTIN_FUNCTIONS } from "./constants";
+export type { BuiltinFn, KeyExtractor, Predicate } from "./types";
+export declare const BUILTINS: Record<string, BuiltinFn>;
+export declare const isBuiltin: (name: string) => boolean;
+export declare const executeBuiltin: (name: string, data: unknown, args: unknown[]) => unknown;

package/dist/navigator/builtins/types.d.ts

@@ -0,0 +1,3 @@
+export type BuiltinFn = (data: unknown, args: unknown[]) => unknown;
+export type KeyExtractor = (item: unknown) => unknown;
+export type Predicate = (item: unknown) => boolean;

package/dist/navigator/builtins/utils.d.ts

@@ -0,0 +1,12 @@
+export declare const isArray: (x: unknown) => x is unknown[];
+export declare const isObject: (x: unknown) => x is Record<string, unknown>;
+export declare const isNil: (x: unknown) => x is null | undefined;
+export declare const isString: (x: unknown) => x is string;
+export declare const isNumber: (x: unknown) => x is number;
+export declare const getType: (x: unknown) => string;
+export declare const deepMerge: (target: Record<string, unknown>, source: Record<string, unknown>) => Record<string, unknown>;
+export declare const deepContains: (container: unknown, value: unknown) => boolean;
+export declare const getValueAtPath: (data: unknown, path: (string | number)[]) => unknown;
+export declare const setValueAtPath: (data: unknown, path: (string | number)[], value: unknown) => unknown;
+export declare const collectAllValues: (data: unknown) => unknown[];
+export declare const collectPaths: (val: unknown, currentPath: (string | number)[]) => (string | number)[][];

package/dist/navigator/json/constants.d.ts

@@ -0,0 +1,2 @@
+import type { OperatorFunction } from "../types";
+export declare const OPERATORS: Readonly<Record<string, OperatorFunction>>;

package/dist/navigator/json/index.d.ts

@@ -0,0 +1,22 @@
+import type { ASTNode } from "../../types";
+import type { NavigatorOptions } from "./types";
+export { OPERATORS } from "./constants";
+export type { NavigatorOptions } from "./types";
+export { isOperatorMethod, extractOperator, executeOperator, createParameterContext, getImplicitParameter, isValidObject, getPropertyFromObject, normalizeArrayIndex, getArrayElement, sliceArray, evaluateObjectOperation, isCallableMethod, callMethod, } from "./utils";
+export declare class JsonNavigator {
+    private options;
+    constructor(options?: NavigatorOptions);
+    evaluate(ast: ASTNode, data: unknown): unknown;
+    private evaluatePropertyAccess;
+    private evaluateArg;
+    private evaluateMethodCall;
+    private evaluatePipe;
+    private evaluateRecursiveDescent;
+    private collectAllValues;
+    private evaluateOptionalAccess;
+    private evaluateNullCoalescing;
+    private createFunction;
+    private evaluateFunctionBody;
+    private evaluatePropertyAccessInFunction;
+    private evaluateMethodCallInFunction;
+}

package/dist/navigator/json/types.d.ts

@@ -0,0 +1,3 @@
+export interface NavigatorOptions {
+    strict?: boolean;
+}

package/dist/navigator/json/utils.d.ts

@@ -0,0 +1,14 @@
+import type { EvaluationContext } from "../types";
+export declare const isOperatorMethod: (method: string) => boolean;
+export declare const extractOperator: (method: string) => string;
+export declare const executeOperator: (left: unknown, operator: string, right: unknown) => unknown;
+export declare const createParameterContext: (params: readonly string[], args: readonly unknown[]) => EvaluationContext;
+export declare const getImplicitParameter: (context: EvaluationContext) => unknown;
+export declare const isValidObject: (value: unknown) => value is Record<string, unknown>;
+export declare const getPropertyFromObject: (obj: unknown, property: string) => unknown;
+export declare const normalizeArrayIndex: (index: number, length: number) => number;
+export declare const getArrayElement: (arr: unknown, index: number) => unknown;
+export declare const sliceArray: (arr: unknown, start: number | undefined, end: number | undefined) => unknown;
+export declare const evaluateObjectOperation: (obj: unknown, operation: "keys" | "values" | "entries" | "length") => unknown;
+export declare const isCallableMethod: (target: unknown, method: string) => boolean;
+export declare const callMethod: (target: unknown, method: string, args: readonly unknown[]) => unknown;

package/dist/shortcuts/constants.d.ts

@@ -0,0 +1,15 @@
+import type { ShortcutMapping } from "./types";
+export declare const REGEX_SPECIAL_CHARS: RegExp;
+export declare const IMPLICIT_PROP: {
+    readonly PARAM: "x";
+    readonly METHOD_WITH_ARGS: RegExp;
+    readonly PROPERTY_ACCESS: RegExp;
+    readonly PROPERTY_AT_START: RegExp;
+    readonly PROPERTY_AFTER_OPERATOR: RegExp;
+    readonly EXPAND_AT_START: RegExp;
+    readonly EXPAND_AFTER_OPERATOR: RegExp;
+    readonly ARROW_FUNC: RegExp;
+    readonly PARAM_DOT_TEMPLATE: "(?<![a-zA-Z0-9_])PARAM\\.";
+};
+export declare const BUILTIN_SHORTCUTS: ShortcutMapping[];
+export declare const SHORTCUTS: ShortcutMapping[];

package/dist/shortcuts/index.d.ts

@@ -0,0 +1,9 @@
+export type { ShortcutMapping } from "./types";
+export { BUILTIN_SHORTCUTS, SHORTCUTS } from "./constants";
+export declare const escapeRegExp: (str: string) => string;
+export declare const expandShortcuts: (expression: string) => string;
+export declare const shortenExpression: (expression: string) => string;
+export declare const getShortcutHelp: () => string;
+export declare const isShortcut: (method: string) => boolean;
+export declare const getFullMethod: (shortMethod: string) => string | undefined;
+export declare const getShortMethod: (fullMethod: string) => string | undefined;

package/dist/shortcuts/types.d.ts

@@ -0,0 +1,6 @@
+export interface ShortcutMapping {
+    short: string;
+    full: string;
+    description: string;
+    type: "array" | "object" | "string" | "any" | "builtin";
+}

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-import { DataFormat } from "./utils/types";
+import { DataFormat } from "./formats/types";
 export type OutputFormat = "json" | "yaml" | "csv" | "table";
 export interface FileOperationOptions {
     find?: string;
@@ -30,9 +30,13 @@ export interface CliOptions extends FileOperationOptions, ShorthandOptions, Form
     help?: boolean;
     version?: boolean;
     interactive?: boolean;
+    strict?: boolean;
+    slurp?: boolean;
+    nullInput?: boolean;
 }
 export declare enum TokenType {
     DOT = "DOT",
+    DOUBLE_DOT = "DOUBLE_DOT",
     IDENTIFIER = "IDENTIFIER",
     LEFT_BRACKET = "LEFT_BRACKET",
     RIGHT_BRACKET = "RIGHT_BRACKET",
@@ -46,6 +50,8 @@ export declare enum TokenType {
     COMMA = "COMMA",
     ARROW = "ARROW",
     OPERATOR = "OPERATOR",
+    QUESTION = "QUESTION",
+    DOUBLE_QUESTION = "DOUBLE_QUESTION",
     EOF = "EOF"
 }
 export interface Token {
@@ -53,7 +59,7 @@ export interface Token {
     value: string;
     position: number;
 }
-export type ASTNode = PropertyAccessNode | IndexAccessNode | SliceAccessNode | MethodCallNode | ObjectOperationNode | ArraySpreadNode | LiteralNode | ArrowFunctionNode | RootNode;
+export type ASTNode = PropertyAccessNode | IndexAccessNode | SliceAccessNode | MethodCallNode | ObjectOperationNode | ArraySpreadNode | LiteralNode | ArrowFunctionNode | RootNode | RecursiveDescentNode | OptionalAccessNode | NullCoalescingNode;
 export interface PropertyAccessNode {
     type: "PropertyAccess";
     property: string;
@@ -99,3 +105,17 @@ export interface RootNode {
     type: "Root";
     expression?: ASTNode;
 }
+export interface RecursiveDescentNode {
+    type: "RecursiveDescent";
+    object?: ASTNode;
+}
+export interface OptionalAccessNode {
+    type: "OptionalAccess";
+    expression: ASTNode;
+    object?: ASTNode;
+}
+export interface NullCoalescingNode {
+    type: "NullCoalescing";
+    left: ASTNode;
+    right: ASTNode;
+}

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const VERSION = "0.1.13";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "1ls",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "1 line script - Lightweight JSON CLI with JavaScript syntax",
   "type": "module",
   "main": "dist/index.js",
@@ -29,8 +29,8 @@
   "scripts": {
     "dev": "turbo dev --filter=1ls-app",
     "dev:cli": "bun run ./src/cli/index.ts",
-    "build": "rm -rf dist bin && bun build ./src/cli/index.ts --outdir dist --target bun --minify && bun build ./src/browser/index.ts --outdir dist/browser --target browser --minify --format esm && tsc --emitDeclarationOnly --outDir dist && cp -r src/completions dist/",
-    "build:binary:all": "rm -rf dist bin && mkdir -p bin && bun build ./src/cli/index.ts --compile --minify --target=bun-darwin-arm64 --outfile bin/1ls-darwin-arm64 && bun build ./src/cli/index.ts --compile --minify --target=bun-darwin-x64 --outfile bin/1ls-darwin-x64 && bun build ./src/cli/index.ts --compile --minify --target=bun-linux-x64 --outfile bin/1ls-linux-x64 && bun build ./src/cli/index.ts --compile --minify --target=bun-linux-arm64 --outfile bin/1ls-linux-arm64",
+    "build": "bun scripts/sync-version.ts && rm -rf dist bin && bun build ./src/cli/index.ts --outdir dist --target bun --minify && bun build ./src/browser/index.ts --outdir dist/browser --target browser --minify --format esm && tsc --emitDeclarationOnly --outDir dist && cp -r src/completions dist/",
+    "build:binary:all": "bun scripts/sync-version.ts && rm -rf dist bin && mkdir -p bin && bun build ./src/cli/index.ts --compile --minify --target=bun-darwin-arm64 --outfile bin/1ls-darwin-arm64 && bun build ./src/cli/index.ts --compile --minify --target=bun-darwin-x64 --outfile bin/1ls-darwin-x64 && bun build ./src/cli/index.ts --compile --minify --target=bun-linux-x64 --outfile bin/1ls-linux-x64 && bun build ./src/cli/index.ts --compile --minify --target=bun-linux-arm64 --outfile bin/1ls-linux-arm64",
     "build:qjs": "bash scripts/build-qjs.sh",
     "build:qjs:bundle": "mkdir -p dist/qjs && bun build ./src/browser/index.ts --outfile dist/qjs/core.js --target browser --minify --format esm",
     "clean": "rm -rf dist bin",
@@ -38,6 +38,8 @@
     "test": "bun test",
     "test:coverage": "bun test --coverage --coverage-reporter=lcov",
     "test:integration": "bun test test/integration/",
+    "test:bench": "docker build -f test/benchmarks/Dockerfile -t 1ls-bench . && docker run --rm 1ls-bench",
+    "test:bench:update": "bash test/benchmarks/update.sh",
     "lint": "bunx oxlint src/",
     "typecheck": "tsc --noEmit",
     "release": "release-it",

package/dist/formats/yaml.d.ts

@@ -1,3 +0,0 @@
-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/interactive/methods.d.ts

@@ -1,12 +0,0 @@
-export interface Method {
-    name: string;
-    signature: string;
-    description: string;
-    template?: string;
-    category?: string;
-}
-export declare const ARRAY_METHODS: Method[];
-export declare const STRING_METHODS: Method[];
-export declare const OBJECT_OPERATIONS: Method[];
-export declare const NUMBER_METHODS: Method[];
-export declare const getMethodsForType: (type: string) => Method[];

package/dist/navigator/json.d.ts

@@ -1,26 +0,0 @@
-import { ASTNode } from "../types";
-import { EvaluationContext, OperatorFunction } from "./types";
-export declare const OPERATORS: Readonly<Record<string, OperatorFunction>>;
-export declare function isOperatorMethod(method: string): boolean;
-export declare function extractOperator(method: string): string;
-export declare function executeOperator(left: unknown, operator: string, right: unknown): unknown;
-export declare function createParameterContext(params: readonly string[], args: readonly unknown[]): EvaluationContext;
-export declare function getImplicitParameter(context: EvaluationContext): unknown;
-export declare function isValidObject(value: unknown): value is Record<string, unknown>;
-export declare function getPropertyFromObject(obj: unknown, property: string): unknown;
-export declare function normalizeArrayIndex(index: number, length: number): number;
-export declare function getArrayElement(arr: unknown, index: number): unknown;
-export declare function sliceArray(arr: unknown, start: number | undefined, end: number | undefined): unknown;
-export declare function evaluateObjectOperation(obj: unknown, operation: "keys" | "values" | "entries" | "length"): unknown;
-export declare function isCallableMethod(target: unknown, method: string): boolean;
-export declare function callMethod(target: unknown, method: string, args: readonly unknown[]): unknown;
-export declare class JsonNavigator {
-    evaluate(ast: ASTNode, data: unknown): unknown;
-    private evaluatePropertyAccess;
-    private evaluateArg;
-    private evaluateMethodCall;
-    private createFunction;
-    private evaluateFunctionBody;
-    private evaluatePropertyAccessInFunction;
-    private evaluateMethodCallInFunction;
-}

package/dist/utils/constants.d.ts

@@ -1,12 +0,0 @@
-export declare const SUPPORTED_CODE_EXTENSIONS: readonly [".ts", ".js", ".tsx", ".jsx"];
-export declare const SUPPORTED_DATA_EXTENSIONS: readonly [".json", ".yml", ".yaml"];
-export declare const SUPPORTED_TEXT_EXTENSIONS: readonly [".md", ".txt"];
-export declare const DEFAULT_SEARCH_EXTENSIONS: readonly [".ts", ".js", ".tsx", ".jsx", ".json", ".yml", ".yaml", ".md", ".txt"];
-export declare const OPERATOR_METHOD_PREFIX = "__operator_";
-export declare const OPERATOR_METHOD_SUFFIX = "__";
-export declare const APP_VERSION = "1.0.0";
-export declare const APP_NAME = "1ls";
-export declare const VALID_OUTPUT_FORMATS: readonly ["json", "yaml", "csv", "table"];
-export declare const VALID_INPUT_FORMATS: readonly ["json", "yaml", "toml", "csv", "tsv", "lines", "text"];
-export declare const VALID_OBJECT_OPERATIONS: readonly ["keys", "values", "entries", "length"];
-export declare const REGEX_SPECIAL_CHARS: RegExp;

package/dist/utils/file.d.ts

@@ -1,27 +0,0 @@
-import { stat } from "node:fs/promises";
-import type { FileInfo, ListOptions, GrepOptions, GrepResult } from "./types";
-export declare function readFile(path: string): Promise<unknown>;
-export declare function readFile(path: string, parseJson: true): Promise<unknown>;
-export declare function readFile(path: string, parseJson: false): Promise<string>;
-export declare function serializeContent(content: unknown): string;
-export declare function writeFile(path: string, content: unknown): Promise<void>;
-export declare function createFileInfo(path: string, stats: Awaited<ReturnType<typeof stat>>): FileInfo;
-export declare function getFileInfo(path: string): Promise<FileInfo>;
-export declare function isHiddenFile(entry: string): boolean;
-export declare function shouldIncludeHiddenFile(entry: string, includeHidden: boolean): boolean;
-export declare function matchesExtensionFilter(ext: string, extensions: string[] | undefined): boolean;
-export declare function matchesPatternFilter(name: string, pattern: RegExp | undefined): boolean;
-export declare function shouldIncludeFile(info: FileInfo, extensions: string[] | undefined, pattern: RegExp | undefined): boolean;
-export declare function isWithinDepthLimit(depth: number, maxDepth: number | undefined): boolean;
-export declare function processDirectoryEntry(currentDir: string, entry: string, depth: number, options: ListOptions): Promise<FileInfo[]>;
-export declare function walkDirectory(currentDir: string, depth: number, options: ListOptions): Promise<FileInfo[]>;
-export declare function listFiles(dir: string, options?: ListOptions): Promise<FileInfo[]>;
-export declare function createRegexFromPattern(pattern: string | RegExp, ignoreCase: boolean): RegExp;
-export declare function createGrepResult(filePath: string, lineNumber: number, matchIndex: number, lineContent: string, lines: readonly string[], contextSize: number | undefined): GrepResult;
-export declare function logVerboseError(filePath: string, error: unknown, verbose: boolean): void;
-export declare function extractMatchesFromLine(line: string, lineIndex: number, regex: RegExp, filePath: string, allLines: readonly string[], contextSize: number | undefined): GrepResult[];
-export declare function shouldStopSearching(currentCount: number, maxMatches: number | undefined): boolean;
-export declare function searchFileContent(filePath: string, regex: RegExp, options: GrepOptions): Promise<GrepResult[]>;
-export declare function searchInDirectory(path: string, regex: RegExp, options: GrepOptions): Promise<GrepResult[]>;
-export declare function grep(pattern: string, path: string, options?: GrepOptions): Promise<GrepResult[]>;
-export declare function grep(pattern: RegExp, path: string, options?: GrepOptions): Promise<GrepResult[]>;

package/dist/utils/index.d.ts

@@ -1,7 +0,0 @@
-export declare function escapeRegExp(str: string): string;
-export * from "./constants";
-export * from "./file";
-export * from "./logger";
-export * from "./shortcuts";
-export * from "./stream";
-export * from "./types";

package/dist/utils/shortcuts.d.ts

@@ -1,8 +0,0 @@
-import type { ShortcutMapping } from "./types";
-export declare const SHORTCUTS: ShortcutMapping[];
-export declare function expandShortcuts(expression: string): string;
-export declare function shortenExpression(expression: string): string;
-export declare function getShortcutHelp(): string;
-export declare function isShortcut(method: string): boolean;
-export declare function getFullMethod(shortMethod: string): string | undefined;
-export declare function getShortMethod(fullMethod: string): string | undefined;