@mojir/lits 1.1.0

package/dist/cli/src/constants/constants.d.ts

@@ -0,0 +1,42 @@
+export declare enum AstNodeType {
+    Number = 201,
+    String = 202,
+    NormalExpression = 203,
+    SpecialExpression = 204,
+    Name = 205,
+    Modifier = 206,
+    ReservedName = 207,
+    Binding = 208,
+    Argument = 209,
+    Partial = 210
+}
+export declare const astNodeTypeName: Map<AstNodeType, string>;
+export declare function isAstNodeType(type: unknown): type is AstNodeType;
+export declare enum TokenType {
+    Bracket = 101,
+    Number = 102,
+    Name = 103,
+    String = 104,
+    ReservedName = 105,
+    Modifier = 106,
+    RegexpShorthand = 107,
+    FnShorthand = 108,
+    CollectionAccessor = 109
+}
+export declare const tokenTypeName: Map<TokenType, string>;
+export declare function isTokenType(type: unknown): type is TokenType;
+export declare enum FunctionType {
+    UserDefined = 301,
+    Partial = 302,
+    Comp = 303,
+    Constantly = 304,
+    Juxt = 305,
+    Complement = 306,
+    EveryPred = 307,
+    SomePred = 308,
+    Fnil = 309,
+    Builtin = 310,
+    NativeJsFunction = 399
+}
+export declare const functionTypeName: Map<FunctionType, string>;
+export declare function isFunctionType(type: unknown): type is FunctionType;

package/dist/cli/src/createReadlineInterface.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+/// <reference types="node" />
+import type { ReadLine, ReadLineOptions } from 'node:readline';
+type Options = Required<Pick<ReadLineOptions, 'completer' | 'historySize' | 'prompt'>>;
+export declare function createReadlineInterface(options: Options): ReadLine;
+export {};

package/dist/cli/src/errors.d.ts

@@ -0,0 +1,26 @@
+import type { Arr } from './interface';
+import type { SourceCodeInfo } from './tokenizer/interface';
+export declare class RecurSignal extends Error {
+    params: Arr;
+    constructor(params: Arr);
+}
+export declare class LitsError extends Error {
+    readonly sourceCodeInfo?: SourceCodeInfo;
+    readonly shortMessage: string;
+    constructor(message: string | Error, sourceCodeInfo?: SourceCodeInfo);
+    getCodeMarker(): string | undefined;
+}
+export declare class NotAFunctionError extends LitsError {
+    constructor(fn: unknown, sourceCodeInfo?: SourceCodeInfo);
+}
+export declare class UserDefinedError extends LitsError {
+    constructor(message: string | Error, sourceCodeInfo?: SourceCodeInfo);
+}
+export declare class AssertionError extends LitsError {
+    constructor(message: string | Error, sourceCodeInfo?: SourceCodeInfo);
+}
+export declare class UndefinedSymbolError extends LitsError {
+    symbol: string;
+    constructor(symbolName: string, sourceCodeInfo?: SourceCodeInfo);
+}
+export declare function isLitsError(error: unknown): error is LitsError;

package/dist/cli/src/evaluator/ContextStack.d.ts

@@ -0,0 +1,21 @@
+import type { ExtraData, NameNode, NativeJsFunction } from '../parser/interface';
+import type { Any } from '../interface';
+import type { LazyValue } from '../Lits/Lits';
+import type { Context, LookUpResult } from './interface';
+export declare class ContextStack {
+    private contexts;
+    globalContext: Context;
+    private values?;
+    private lazyValues?;
+    private nativeJsFunctions?;
+    constructor({ contexts, values: hostValues, lazyValues: lazyHostValues, nativeJsFunctions, }: {
+        contexts: Context[];
+        values?: Record<string, unknown>;
+        lazyValues?: Record<string, LazyValue>;
+        nativeJsFunctions?: Record<string, NativeJsFunction>;
+    });
+    create(context: Context, extraData?: ExtraData): ContextStack;
+    getValue(name: string): unknown;
+    lookUp(node: NameNode): LookUpResult;
+    evaluateName(node: NameNode): Any;
+}

package/dist/cli/src/evaluator/functionExecutors.d.ts

@@ -0,0 +1,11 @@
+import type { Any, Arr } from '../interface';
+import type { LitsFunctionType } from '../parser/interface';
+import type { SourceCodeInfo } from '../tokenizer/interface';
+import type { EvaluateAstNode, ExecuteFunction } from './interface';
+import type { ContextStack } from './ContextStack';
+type FunctionExecutors = Record<LitsFunctionType, (fn: any, params: Arr, sourceCodeInfo: SourceCodeInfo | undefined, contextStack: ContextStack, helpers: {
+    evaluateAstNode: EvaluateAstNode;
+    executeFunction: ExecuteFunction;
+}) => Any>;
+export declare const functionExecutors: FunctionExecutors;
+export {};

package/dist/cli/src/evaluator/index.d.ts

@@ -0,0 +1,5 @@
+import type { Ast, AstNode } from '../parser/interface';
+import type { Any } from '../interface';
+import type { ContextStack } from './ContextStack';
+export declare function evaluate(ast: Ast, contextStack: ContextStack): Any;
+export declare function evaluateAstNode(node: AstNode, contextStack: ContextStack): Any;

package/dist/cli/src/evaluator/interface.d.ts

@@ -0,0 +1,12 @@
+import type { Any, Arr } from '../interface';
+import type { AstNode, BuiltinFunction } from '../parser/interface';
+import type { SourceCodeInfo } from '../tokenizer/interface';
+import type { ContextStack } from './ContextStack';
+export interface ContextEntry {
+    value: Any;
+}
+export type Context = Record<string, ContextEntry>;
+export type EvaluateAstNode = (node: AstNode, contextStack: ContextStack) => Any;
+export type ExecuteFunction = (fn: Any, params: Arr, contextStack: ContextStack, sourceCodeInfo?: SourceCodeInfo) => Any;
+export type LookUpResult = ContextEntry | BuiltinFunction | 'specialExpression' | null;
+export declare function isContextEntry(value: unknown): value is ContextEntry;

package/dist/cli/src/index.d.ts

@@ -0,0 +1,12 @@
+export { AstNodeType, TokenType, FunctionType } from './constants/constants';
+export { isBuiltinFunction, isLitsFunction, asLitsFunction, assertLitsFunction, isUserDefinedFunction, asUserDefinedFunction, assertUserDefinedFunction, isNativeJsFunction, asNativeJsFunction, assertNativeJsFunction, } from './typeGuards/litsFunction';
+export { type LitsFunction, type NativeJsFunction, type ExtraData } from './parser/interface';
+export type { Context } from './evaluator/interface';
+export type { Ast } from './parser/interface';
+export type { Token, SourceCodeInfo } from './tokenizer/interface';
+export { normalExpressionKeys, specialExpressionKeys } from './builtin';
+export { reservedNames } from './reservedNames';
+export { Lits } from './Lits/Lits';
+export { type LitsError, isLitsError } from './errors';
+export type { LitsParams, LitsRuntimeInfo, LazyValue } from './Lits/Lits';
+export { createNativeJsFunction } from './utils';

package/dist/cli/src/interface.d.ts

@@ -0,0 +1,8 @@
+import type { RegularExpression } from './parser/interface';
+import type { LitsFunction } from '.';
+export type Arr = unknown[];
+export type Seq = string | Arr;
+export type Obj = Record<string, unknown>;
+export type Coll = Seq | Obj;
+export type Any = Coll | string | number | boolean | null | LitsFunction | RegularExpression;
+export type UnknownRecord = Record<string, unknown>;

package/dist/cli/src/parser/index.d.ts

@@ -0,0 +1,3 @@
+import type { TokenStream } from '../tokenizer/interface';
+import type { Ast } from './interface';
+export declare function parse(tokenStream: TokenStream): Ast;

package/dist/cli/src/parser/interface.d.ts

@@ -0,0 +1,160 @@
+import type { SpecialExpressionName } from '../builtin/interface';
+import type { Condition } from '../builtin/specialExpressions/cond';
+import type { LoopBindingNode } from '../builtin/specialExpressions/loops';
+import type { Arity, FunctionOverload } from '../builtin/utils';
+import type { Context } from '../evaluator/interface';
+import type { Any, Arr } from '../interface';
+import type { ReservedName } from '../reservedNames';
+import type { SourceCodeInfo, Token, TokenStream } from '../tokenizer/interface';
+import type { FUNCTION_SYMBOL, REGEXP_SYMBOL } from '../utils/symbols';
+import type { AstNodeType, FunctionType } from '../constants/constants';
+import type { JsFunction, LazyValue } from '../Lits/Lits';
+export interface EvaluatedFunctionArguments {
+    mandatoryArguments: string[];
+    restArgument?: string;
+}
+export interface EvaluatedFunctionOverload {
+    as: EvaluatedFunctionArguments;
+    b: AstNode[];
+    a: Arity;
+    f: Context;
+}
+export type ExtraData = Record<string, LazyValue>;
+interface GenericLitsFunction {
+    [FUNCTION_SYMBOL]: true;
+    sourceCodeInfo?: SourceCodeInfo;
+    t: FunctionType;
+}
+export interface RegularExpression {
+    [REGEXP_SYMBOL]: true;
+    sourceCodeInfo?: SourceCodeInfo;
+    s: string;
+    f: string;
+}
+export interface NativeJsFunction extends GenericLitsFunction {
+    t: FunctionType.NativeJsFunction;
+    n: string | undefined;
+    f: JsFunction;
+}
+export interface UserDefinedFunction extends GenericLitsFunction {
+    t: FunctionType.UserDefined;
+    n: string | undefined;
+    o: EvaluatedFunctionOverload[];
+    x?: ExtraData;
+}
+export interface PartialFunction extends GenericLitsFunction {
+    t: FunctionType.Partial;
+    f: Any;
+    p: Arr;
+}
+export interface CompFunction extends GenericLitsFunction {
+    t: FunctionType.Comp;
+    f: Arr;
+}
+export interface ConstantlyFunction extends GenericLitsFunction {
+    t: FunctionType.Constantly;
+    v: Any;
+}
+export interface JuxtFunction extends GenericLitsFunction {
+    t: FunctionType.Juxt;
+    f: Arr;
+}
+export interface ComplementFunction extends GenericLitsFunction {
+    t: FunctionType.Complement;
+    f: Any;
+}
+export interface EveryPredFunction extends GenericLitsFunction {
+    t: FunctionType.EveryPred;
+    f: Arr;
+}
+export interface SomePredFunction extends GenericLitsFunction {
+    t: FunctionType.SomePred;
+    f: Arr;
+}
+export interface FNilFunction extends GenericLitsFunction {
+    t: FunctionType.Fnil;
+    f: Any;
+    p: Arr;
+}
+export interface BuiltinFunction extends GenericLitsFunction {
+    t: FunctionType.Builtin;
+    n: string;
+}
+export type LitsFunction = NativeJsFunction | UserDefinedFunction | BuiltinFunction | PartialFunction | CompFunction | ConstantlyFunction | JuxtFunction | ComplementFunction | EveryPredFunction | SomePredFunction | FNilFunction;
+export type LitsFunctionType = LitsFunction['t'];
+export type ModifierName = '&' | '&let' | '&when' | '&while';
+interface GenericNode {
+    t: AstNodeType;
+    tkn?: Token;
+}
+export type ExpressionNode = NormalExpressionNode | SpecialExpressionNode | NumberNode | StringNode;
+export type ParseBinding = (tokens: TokenStream, position: number) => [number, BindingNode];
+export type ParseBindings = (tokens: TokenStream, position: number) => [number, BindingNode[]];
+export type ParseArgument = (tokens: TokenStream, position: number) => [number, ArgumentNode | ModifierNode];
+export type ParseExpression = (tokens: TokenStream, position: number) => [number, ExpressionNode];
+export type ParseTokens = (tokens: TokenStream, position: number) => [number, AstNode[]];
+export type ParseToken = (tokens: TokenStream, position: number) => [number, AstNode];
+export interface NumberNode extends GenericNode {
+    t: AstNodeType.Number;
+    v: number;
+}
+export interface StringNode extends GenericNode {
+    t: AstNodeType.String;
+    v: string;
+}
+export interface NameNode extends GenericNode {
+    t: AstNodeType.Name;
+    v: string;
+}
+export interface ModifierNode extends GenericNode {
+    t: AstNodeType.Modifier;
+    v: ModifierName;
+}
+export interface ReservedNameNode extends GenericNode {
+    t: AstNodeType.ReservedName;
+    v: ReservedName;
+}
+interface NormalExpressionNodeBase extends GenericNode {
+    t: AstNodeType.NormalExpression;
+    p: AstNode[];
+}
+export interface NormalExpressionNodeWithName extends NormalExpressionNodeBase {
+    n: string;
+    e?: ExpressionNode;
+}
+interface NormalExpressionNodeExpression extends NormalExpressionNodeBase {
+    n?: never;
+    e: ExpressionNode;
+}
+export type NormalExpressionNode = NormalExpressionNodeWithName | NormalExpressionNodeExpression;
+export interface BindingNode extends GenericNode {
+    t: AstNodeType.Binding;
+    n: string;
+    v: AstNode;
+}
+export interface ArgumentNode extends GenericNode {
+    t: AstNodeType.Argument;
+    n: string;
+    d?: AstNode;
+}
+export interface SpecialExpressionNode extends GenericNode {
+    t: AstNodeType.SpecialExpression;
+    n: SpecialExpressionName;
+    p: AstNode[];
+    b?: BindingNode;
+    bs?: BindingNode[];
+    c?: Condition[];
+    f?: AstNode;
+    o?: FunctionOverload[];
+    l?: LoopBindingNode[];
+    m?: AstNode;
+    te?: AstNode;
+    e?: NameNode;
+    ce?: AstNode;
+}
+export type AstNode = NumberNode | StringNode | ReservedNameNode | NameNode | NormalExpressionNode | ModifierNode | SpecialExpressionNode;
+type AstBody = AstNode[];
+export interface Ast {
+    b: AstBody;
+}
+export {};

package/dist/cli/src/parser/parsers.d.ts

@@ -0,0 +1,4 @@
+import type { TokenStream } from '../tokenizer/interface';
+import type { AstNode, NumberNode } from './interface';
+export declare function parseNumber(tokenStream: TokenStream, position: number): [number, NumberNode];
+export declare function parseToken(tokenStream: TokenStream, position: number): [number, AstNode];

package/dist/cli/src/reservedNames.d.ts

@@ -0,0 +1,7 @@
+import type { Any } from './interface';
+export type ReservedName = 'true' | 'false' | 'nil' | 'null' | 'undefined' | '===' | '!==' | '&&' | '||';
+export declare const reservedNamesRecord: Record<ReservedName, {
+    value: Any;
+    forbidden?: true;
+}>;
+export declare const reservedNames: ReservedName[];

package/dist/cli/src/testFramework/index.d.ts

@@ -0,0 +1,14 @@
+export interface RunTestParams {
+    testPath: string;
+    testNamePattern?: RegExp;
+}
+export interface TestResult {
+    /**
+     * Test report
+     * http://testanything.org/
+     */
+    tap: string;
+    success: boolean;
+}
+export declare function runTest({ testPath: filePath, testNamePattern }: RunTestParams): TestResult;
+export declare function getErrorYaml(error: unknown): string;

package/dist/cli/src/tokenizer/index.d.ts

@@ -0,0 +1,2 @@
+import type { TokenStream, TokenizeParams } from './interface';
+export declare function tokenize(input: string, params: TokenizeParams): TokenStream;

package/dist/cli/src/tokenizer/interface.d.ts

@@ -0,0 +1,25 @@
+import type { TokenType } from '../constants/constants';
+export interface SourceCodeInfo {
+    position?: {
+        line: number;
+        column: number;
+    };
+    code?: string;
+    filePath?: string;
+}
+export interface Token {
+    t: TokenType;
+    v: string;
+    o?: Record<string, boolean>;
+    sourceCodeInfo?: SourceCodeInfo;
+}
+export type TokenDescriptor = [length: number, token: Token | undefined];
+export type Tokenizer = (input: string, position: number, sourceCodeInfo?: SourceCodeInfo) => TokenDescriptor;
+export interface TokenStream {
+    tokens: Token[];
+    filePath?: string;
+}
+export interface TokenizeParams {
+    debug: boolean;
+    filePath?: string;
+}

package/dist/cli/src/tokenizer/sugar/applyCollectionAccessor.d.ts

@@ -0,0 +1,2 @@
+import type { SugarFunction } from '.';
+export declare const applyCollectionAccessors: SugarFunction;

package/dist/cli/src/tokenizer/sugar/index.d.ts

@@ -0,0 +1,3 @@
+import type { TokenStream } from '../interface';
+export type SugarFunction = (tokenStream: TokenStream) => TokenStream;
+export declare function getSugar(): SugarFunction[];

package/dist/cli/src/tokenizer/tokenizers.d.ts

@@ -0,0 +1,19 @@
+import type { Tokenizer } from './interface';
+export declare const nameCharacters = "[@%0-9a-zA-Z\u00E0\u00E1\u00E2\u00E3\u0103\u00E4\u0101\u00E5\u00E6\u0107\u010D\u00E7\u00E8\u00E9\u00EA\u0115\u00EB\u0113\u00EC\u00ED\u00EE\u012D\u00EF\u00F0\u0142\u00F1\u00F2\u00F3\u00F4\u00F5\u00F6\u0151\u00F8\u0161\u00F9\u00FA\u00FB\u00FC\u0171\u00FD\u00FF\u00FE\u00C0\u00C1\u00C2\u00C3\u0102\u00C4\u0100\u00C5\u00C6\u0106\u010C\u00C7\u00C8\u00C9\u00CA\u0114\u00CB\u0112\u00CC\u00CD\u00CE\u012C\u00CF\u00D0\u0141\u00D1\u00D2\u00D3\u00D4\u00D5\u00D6\u0150\u00D8\u0160\u00D9\u00DA\u00DB\u00DC\u0170\u00DD\u00DE\u00DF_^?=!$%<>+*/-]";
+export declare const skipWhiteSpace: Tokenizer;
+export declare const skipComment: Tokenizer;
+export declare const tokenizeLeftParen: Tokenizer;
+export declare const tokenizeRightParen: Tokenizer;
+export declare const tokenizeLeftBracket: Tokenizer;
+export declare const tokenizeRightBracket: Tokenizer;
+export declare const tokenizeLeftCurly: Tokenizer;
+export declare const tokenizeRightCurly: Tokenizer;
+export declare const tokenizeString: Tokenizer;
+export declare const tokenizeCollectionAccessor: Tokenizer;
+export declare const tokenizeSymbolString: Tokenizer;
+export declare const tokenizeRegexpShorthand: Tokenizer;
+export declare const tokenizeFnShorthand: Tokenizer;
+export declare const tokenizeNumber: Tokenizer;
+export declare const tokenizeReservedName: Tokenizer;
+export declare const tokenizeName: Tokenizer;
+export declare const tokenizeModifier: Tokenizer;

package/dist/cli/src/typeGuards/array.d.ts

@@ -0,0 +1,9 @@
+import type { SourceCodeInfo } from '../tokenizer/interface';
+export declare function asArray(value: unknown, sourceCodeInfo?: SourceCodeInfo): unknown[];
+export declare function assertArray(value: unknown, sourceCodeInfo?: SourceCodeInfo): asserts value is unknown[];
+export declare function isStringArray(value: unknown): value is string[];
+export declare function asStringArray(value: unknown, sourceCodeInfo?: SourceCodeInfo): string[];
+export declare function assertStringArray(value: unknown, sourceCodeInfo?: SourceCodeInfo): asserts value is string[];
+export declare function isCharArray(value: unknown): value is string[];
+export declare function asCharArray(value: unknown, sourceCodeInfo?: SourceCodeInfo): string[];
+export declare function assertCharArray(value: unknown, sourceCodeInfo?: SourceCodeInfo): asserts value is string[];

package/dist/cli/src/typeGuards/astNode.d.ts

@@ -0,0 +1,17 @@
+import type { AstNode, ExpressionNode, NameNode, NormalExpressionNode, NormalExpressionNodeWithName } from '../parser/interface';
+import type { SourceCodeInfo } from '../tokenizer/interface';
+export declare function isAstNode(value: unknown): value is AstNode;
+export declare function asAstNode(value: unknown, sourceCodeInfo?: SourceCodeInfo): AstNode;
+export declare function assertAstNode(value: unknown, sourceCodeInfo?: SourceCodeInfo): asserts value is AstNode;
+export declare function isNameNode(value: unknown): value is NameNode;
+export declare function asNameNode(value: unknown, sourceCodeInfo?: SourceCodeInfo): NameNode;
+export declare function assertNameNode(value: unknown, sourceCodeInfo?: SourceCodeInfo): asserts value is NameNode;
+export declare function isNormalExpressionNode(value: unknown): value is NormalExpressionNode;
+export declare function asNormalExpressionNode(value: unknown, sourceCodeInfo?: SourceCodeInfo): NormalExpressionNode;
+export declare function assertNormalExpressionNode(value: unknown, sourceCodeInfo?: SourceCodeInfo): asserts value is NormalExpressionNode;
+export declare function isNormalExpressionNodeWithName(value: unknown): value is NormalExpressionNodeWithName;
+export declare function asNormalExpressionNodeWithName(value: unknown, sourceCodeInfo?: SourceCodeInfo): NormalExpressionNodeWithName;
+export declare function assertNormalExpressionNodeWithName(value: unknown, sourceCodeInfo?: SourceCodeInfo): asserts value is NormalExpressionNodeWithName;
+export declare function isExpressionNode(value: unknown): value is ExpressionNode;
+export declare function asExpressionNode(value: unknown, sourceCodeInfo?: SourceCodeInfo): ExpressionNode;
+export declare function assertExpressionNode(value: unknown, sourceCodeInfo?: SourceCodeInfo): asserts value is ExpressionNode;

package/dist/cli/src/typeGuards/index.d.ts

@@ -0,0 +1,15 @@
+import type { UnknownRecord } from '../interface';
+import type { NormalExpressionNode, SpecialExpressionNode } from '../parser/interface';
+import type { SourceCodeInfo } from '../tokenizer/interface';
+export declare function assertEventNumberOfParams(node: NormalExpressionNode): void;
+export declare function isNonUndefined<T>(value: T | undefined): value is T;
+export declare function asNonUndefined<T>(value: T | undefined, sourceCodeInfo?: SourceCodeInfo): T;
+export declare function assertNonUndefined<T>(value: T | undefined, sourceCodeInfo?: SourceCodeInfo): asserts value is T;
+export declare function assertUnreachable(_: never): never;
+export declare function isUnknownRecord(value: unknown): value is Record<string, unknown>;
+export declare function assertUnknownRecord(value: unknown, sourceCodeInfo?: SourceCodeInfo): asserts value is UnknownRecord;
+export declare function asUnknownRecord(value: unknown, sourceCodeInfo?: SourceCodeInfo): UnknownRecord;
+export declare function assertNumberOfParams(count: number | {
+    min?: number;
+    max?: number;
+}, node: NormalExpressionNode | SpecialExpressionNode): void;

package/dist/cli/src/typeGuards/lits.d.ts

@@ -0,0 +1,21 @@
+import type { Any, Coll, Obj, Seq } from '../interface';
+import type { RegularExpression } from '../parser/interface';
+import type { SourceCodeInfo } from '../tokenizer/interface';
+export declare function isAny(value: unknown): value is Any;
+export declare function asAny(value: unknown, sourceCodeInfo?: SourceCodeInfo): Any;
+export declare function assertAny(value: unknown, sourceCodeInfo?: SourceCodeInfo): asserts value is Any;
+export declare function isSeq(value: unknown): value is Seq;
+export declare function asSeq(value: unknown, sourceCodeInfo?: SourceCodeInfo): Seq;
+export declare function assertSeq(value: unknown, sourceCodeInfo?: SourceCodeInfo): asserts value is Seq;
+export declare function isObj(value: unknown): value is Obj;
+export declare function asObj(value: unknown, sourceCodeInfo?: SourceCodeInfo): Obj;
+export declare function assertObj(value: unknown, sourceCodeInfo?: SourceCodeInfo): asserts value is Obj;
+export declare function isColl(value: unknown): value is Coll;
+export declare function asColl(value: unknown, sourceCodeInfo?: SourceCodeInfo): Coll;
+export declare function assertColl(value: unknown, sourceCodeInfo?: SourceCodeInfo): asserts value is Coll;
+export declare function isRegularExpression(regexp: unknown): regexp is RegularExpression;
+export declare function asRegularExpression(value: unknown, sourceCodeInfo?: SourceCodeInfo): RegularExpression;
+export declare function assertRegularExpression(value: unknown, sourceCodeInfo?: SourceCodeInfo): asserts value is RegularExpression;
+export declare function isStringOrRegularExpression(value: unknown): value is string | RegularExpression;
+export declare function asStringOrRegularExpression(value: unknown, sourceCodeInfo?: SourceCodeInfo): string | RegularExpression;
+export declare function assertStringOrRegularExpression(value: unknown, sourceCodeInfo?: SourceCodeInfo): asserts value is string | RegularExpression;

package/dist/cli/src/typeGuards/litsFunction.d.ts

@@ -0,0 +1,12 @@
+import type { BuiltinFunction, LitsFunction, NativeJsFunction, UserDefinedFunction } from '../parser/interface';
+import type { SourceCodeInfo } from '../tokenizer/interface';
+export declare function isLitsFunction(value: unknown): value is LitsFunction;
+export declare function asLitsFunction(value: unknown, sourceCodeInfo?: SourceCodeInfo): LitsFunction;
+export declare function assertLitsFunction(value: unknown, sourceCodeInfo?: SourceCodeInfo): asserts value is LitsFunction;
+export declare function isUserDefinedFunction(value: unknown): value is UserDefinedFunction;
+export declare function asUserDefinedFunction(value: unknown, sourceCodeInfo?: SourceCodeInfo): UserDefinedFunction;
+export declare function assertUserDefinedFunction(value: unknown, sourceCodeInfo?: SourceCodeInfo): asserts value is UserDefinedFunction;
+export declare function isNativeJsFunction(value: unknown): value is NativeJsFunction;
+export declare function asNativeJsFunction(value: unknown, sourceCodeInfo?: SourceCodeInfo): NativeJsFunction;
+export declare function assertNativeJsFunction(value: unknown, sourceCodeInfo?: SourceCodeInfo): asserts value is NativeJsFunction;
+export declare function isBuiltinFunction(value: unknown): value is BuiltinFunction;

package/dist/cli/src/typeGuards/number.d.ts

@@ -0,0 +1,66 @@
+import type { SourceCodeInfo } from '../tokenizer/interface';
+type SignOptions = {
+    positive?: true;
+    negative?: never;
+    nonPositive?: never;
+    nonNegative?: never;
+    zero?: never;
+    nonZero?: never;
+} | {
+    positive?: never;
+    negative?: true;
+    nonPositive?: never;
+    nonNegative?: never;
+    zero?: never;
+    nonZero?: never;
+} | {
+    positive?: never;
+    negative?: never;
+    nonPositive?: true;
+    nonNegative?: never;
+    zero?: never;
+    nonZero?: never;
+} | {
+    positive?: never;
+    negative?: never;
+    nonPositive?: never;
+    nonNegative?: true;
+    zero?: never;
+    nonZero?: never;
+} | {
+    positive?: never;
+    negative?: never;
+    nonPositive?: never;
+    nonNegative?: never;
+    zero?: true;
+    nonZero?: never;
+} | {
+    positive?: never;
+    negative?: never;
+    nonPositive?: never;
+    nonNegative?: never;
+    zero?: never;
+    nonZero?: true;
+};
+type GtOptions = {
+    gt?: number;
+    gte?: never;
+} | {
+    gt?: never;
+    gte?: number;
+};
+type LtOptions = {
+    lt?: number;
+    lte?: never;
+} | {
+    lt?: never;
+    lte?: number;
+};
+type NumberOptions = {
+    integer?: true;
+    finite?: true;
+} & SignOptions & GtOptions & LtOptions;
+export declare function isNumber(value: unknown, options?: NumberOptions): value is number;
+export declare function assertNumber(value: unknown, sourceCodeInfo?: SourceCodeInfo, options?: NumberOptions): asserts value is number;
+export declare function asNumber(value: unknown, sourceCodeInfo: SourceCodeInfo | undefined, options?: NumberOptions): number;
+export {};

package/dist/cli/src/typeGuards/string.d.ts

@@ -0,0 +1,15 @@
+import type { SourceCodeInfo } from '../tokenizer/interface';
+type StringAssertionOptions = {
+    nonEmpty?: true;
+    char?: never;
+} | {
+    nonEmpty?: never;
+    char?: true;
+};
+export declare function isString(value: unknown, options?: StringAssertionOptions): value is string;
+export declare function assertString(value: unknown, sourceCodeInfo: SourceCodeInfo | undefined, options?: StringAssertionOptions): asserts value is string;
+export declare function asString(value: unknown, sourceCodeInfo: SourceCodeInfo | undefined, options?: StringAssertionOptions): string;
+export declare function isStringOrNumber(value: unknown): value is string | number;
+export declare function asStringOrNumber(value: unknown, sourceCodeInfo?: SourceCodeInfo): string | number;
+export declare function assertStringOrNumber(value: unknown, sourceCodeInfo?: SourceCodeInfo): asserts value is string | number;
+export {};

package/dist/cli/src/typeGuards/token.d.ts

@@ -0,0 +1,13 @@
+import { type TokenType } from '../constants/constants';
+import type { Token } from '../tokenizer/interface';
+type TokenAssertionOptions = {
+    type: TokenType;
+    value?: string;
+} | {
+    type?: never;
+    value?: never;
+};
+export declare function isToken(value: unknown, options?: TokenAssertionOptions): value is Token;
+export declare function assertToken(value: unknown, filePath: string | undefined, options?: TokenAssertionOptions): asserts value is Token;
+export declare function asToken(value: unknown, filePath: string | undefined, options?: TokenAssertionOptions): Token;
+export {};

package/dist/cli/src/utils/debug/debugTools.d.ts

@@ -0,0 +1,3 @@
+import type { SourceCodeInfo } from '../../tokenizer/interface';
+export declare function valueToString(value: unknown): string;
+export declare function getCodeMarker(sourceCodeInfo: SourceCodeInfo): string;

package/dist/cli/src/utils/debug/getSourceCodeInfo.d.ts

@@ -0,0 +1,2 @@
+import type { SourceCodeInfo } from '../../tokenizer/interface';
+export declare function getSourceCodeInfo(anyValue: any, sourceCodeInfo?: SourceCodeInfo): SourceCodeInfo | undefined;

package/dist/cli/src/utils/getAssertionError.d.ts

@@ -0,0 +1,3 @@
+import { LitsError } from '../errors';
+import type { SourceCodeInfo } from '../tokenizer/interface';
+export declare function getAssertionError(typeName: string, value: unknown, sourceCodeInfo?: SourceCodeInfo): LitsError;

package/dist/cli/src/utils/index.d.ts

@@ -0,0 +1,10 @@
+import type { Any, Coll } from '../interface';
+import type { NativeJsFunction } from '../parser/interface';
+import type { SourceCodeInfo } from '../tokenizer/interface';
+export declare function collHasKey(coll: unknown, key: string | number): boolean;
+export declare function compare(a: unknown, b: unknown): number;
+export declare function deepEqual(a: Any, b: Any, sourceCodeInfo?: SourceCodeInfo): boolean;
+export declare function toNonNegativeInteger(num: number): number;
+export declare function toAny(value: unknown): Any;
+export declare function cloneColl<T extends Coll>(value: T): T;
+export declare function createNativeJsFunction(fn: (...args: any[]) => unknown, name?: string): NativeJsFunction;

package/dist/cli/src/utils/symbols.d.ts

@@ -0,0 +1,2 @@
+export declare const FUNCTION_SYMBOL = "__fn";
+export declare const REGEXP_SYMBOL = "__re";

package/dist/common/clojureDocs.d.ts

@@ -0,0 +1 @@
+export declare function getClojureDocsLink(functionName: string, clojureDocs?: string | null): string | null;

package/dist/common/createFormatter.d.ts

@@ -0,0 +1,6 @@
+import type { FormatterRule } from '../cli/src/cliFormatterRules';
+export type TextFormatter = (text: string) => string;
+export declare function createFormatter(rules: FormatterRule[], options?: {
+    prefix?: string;
+    suffix?: string;
+}): TextFormatter;

package/dist/common/utils.d.ts

@@ -0,0 +1,3 @@
+export declare function throttle<T extends (...args: any[]) => void>(func: T): (this: any, ...args: Parameters<T>) => void;
+export declare function stringifyValue(value: unknown, html: boolean): string;
+export declare function findAllOccurrences(input: string, pattern: RegExp): Set<string>;