@mojir/lits 2.2.2-alpha.6 → 2.2.2

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

@@ -0,0 +1,133 @@
+import type { JsFunction } from '../Lits/Lits';
+import type { SpecialExpressionType } from '../builtin';
+import type { Arity } from '../builtin/interface';
+import type { specialExpressionTypes } from '../builtin/specialExpressionTypes';
+import type { FunctionType, NodeType, NodeTypes } from '../constants/constants';
+import type { Context } from '../evaluator/interface';
+import type { Any, Arr, Coll } from '../interface';
+import type { ReservedSymbol } from '../tokenizer/reservedNames';
+import type { SourceCodeInfo, Token } from '../tokenizer/token';
+import type { FUNCTION_SYMBOL, REGEXP_SYMBOL } from '../utils/symbols';
+export interface ParseState {
+    position: number;
+}
+export type EvaluatedFunction = [BindingTarget[], Node[], Context];
+interface GenericLitsFunction {
+    [FUNCTION_SYMBOL]: true;
+    sourceCodeInfo?: SourceCodeInfo;
+    functionType: FunctionType;
+    arity: Arity;
+}
+export interface RegularExpression {
+    [REGEXP_SYMBOL]: true;
+    sourceCodeInfo?: SourceCodeInfo;
+    s: string;
+    f: string;
+}
+export interface NativeJsFunction extends GenericLitsFunction {
+    functionType: 'NativeJsFunction';
+    name: string | undefined;
+    nativeFn: JsFunction;
+    docString: string;
+}
+export declare function isJsFunction(fn: unknown): fn is JsFunction;
+export declare function assertJsFunction(fn: unknown): asserts fn is JsFunction;
+export interface NativeJsModule {
+    [key: string]: NativeJsFunction | NativeJsModule;
+}
+export interface UserDefinedFunction extends GenericLitsFunction {
+    functionType: 'UserDefined';
+    name: string | undefined;
+    evaluatedfunction: EvaluatedFunction;
+    docString: string;
+}
+export interface PartialFunction extends GenericLitsFunction {
+    functionType: 'Partial';
+    function: FunctionLike;
+    params: Arr;
+    placeholders: number[];
+}
+export interface CompFunction extends GenericLitsFunction {
+    functionType: 'Comp';
+    params: Arr;
+}
+export interface ConstantlyFunction extends GenericLitsFunction {
+    functionType: 'Constantly';
+    value: Any;
+}
+export interface JuxtFunction extends GenericLitsFunction {
+    functionType: 'Juxt';
+    params: Arr;
+}
+export interface ComplementFunction extends GenericLitsFunction {
+    functionType: 'Complement';
+    function: FunctionLike;
+}
+export interface EveryPredFunction extends GenericLitsFunction {
+    functionType: 'EveryPred';
+    params: Arr;
+}
+export interface SomePredFunction extends GenericLitsFunction {
+    functionType: 'SomePred';
+    params: Arr;
+}
+export interface FNullFunction extends GenericLitsFunction {
+    functionType: 'Fnull';
+    function: FunctionLike;
+    params: Arr;
+}
+export interface NormalBuiltinFunction extends GenericLitsFunction {
+    functionType: 'Builtin';
+    normalBuiltinSymbolType: number;
+    name: string;
+}
+export interface SpecialBuiltinFunction extends GenericLitsFunction {
+    functionType: 'SpecialBuiltin';
+    specialBuiltinSymbolType: typeof specialExpressionTypes['&&'] | typeof specialExpressionTypes['||'] | typeof specialExpressionTypes['array'] | typeof specialExpressionTypes['object'] | typeof specialExpressionTypes['defined?'] | typeof specialExpressionTypes['recur'] | typeof specialExpressionTypes['throw'] | typeof specialExpressionTypes['??'];
+}
+export interface ModuleFunction extends GenericLitsFunction {
+    functionType: 'Module';
+    moduleName: string;
+    functionName: string;
+}
+export type LitsFunction = NativeJsFunction | UserDefinedFunction | NormalBuiltinFunction | SpecialBuiltinFunction | ModuleFunction | PartialFunction | CompFunction | ConstantlyFunction | JuxtFunction | ComplementFunction | EveryPredFunction | SomePredFunction | FNullFunction;
+export type LitsFunctionType = LitsFunction['functionType'];
+export type FunctionLike = LitsFunction | Coll | number;
+export type DebugData = {
+    token: Token;
+    nameToken?: Token;
+};
+export type Node<T extends NodeType = NodeType, Payload = unknown> = [T, Payload] | [T, Payload, SourceCodeInfo];
+export type ExpressionNode = NormalExpressionNode | SpecialExpressionNode | NumberNode | StringNode;
+export type SpreadNode = Node<typeof NodeTypes.Spread, Node>;
+export type NumberNode = Node<typeof NodeTypes.Number, number>;
+export type StringNode = Node<typeof NodeTypes.String, string>;
+export type UserDefinedSymbolNode = Node<typeof NodeTypes.UserDefinedSymbol, string>;
+export type NormalBuiltinSymbolNode = Node<typeof NodeTypes.NormalBuiltinSymbol, number>;
+export type SpecialBuiltinSymbolNode = Node<typeof NodeTypes.SpecialBuiltinSymbol, SpecialExpressionType>;
+export type SymbolNode = UserDefinedSymbolNode | NormalBuiltinSymbolNode | SpecialBuiltinSymbolNode;
+export type ReservedSymbolNode = Node<typeof NodeTypes.ReservedSymbol, ReservedSymbol>;
+export type SpecialExpressionNode<T extends [SpecialExpressionType, ...unknown[]] = [SpecialExpressionType, ...unknown[]]> = Node<typeof NodeTypes.SpecialExpression, T>;
+export type NormalExpressionNodeWithName = Node<typeof NodeTypes.NormalExpression, [NormalBuiltinSymbolNode | UserDefinedSymbolNode, Node[]]>;
+export type NormalExpressionNodeExpression = Node<typeof NodeTypes.NormalExpression, [Node, Node[]]>;
+export type NormalExpressionNode = NormalExpressionNodeWithName | NormalExpressionNodeExpression;
+export declare const bindingTargetTypes: {
+    readonly symbol: 11;
+    readonly rest: 12;
+    readonly object: 13;
+    readonly array: 14;
+};
+export type BindingTargetType = typeof bindingTargetTypes[keyof typeof bindingTargetTypes];
+type GenericTarget<T extends BindingTargetType, Payload extends unknown[]> = [T, Payload] | [T, Payload, SourceCodeInfo];
+export type SymbolBindingTarget = GenericTarget<typeof bindingTargetTypes.symbol, [SymbolNode, Node | undefined]>;
+export type RestBindingTarget = GenericTarget<typeof bindingTargetTypes.rest, [string, Node | undefined]>;
+export type ObjectBindingTarget = GenericTarget<typeof bindingTargetTypes.object, [Record<string, BindingTarget>, Node | undefined]>;
+export type ArrayBindingTarget = GenericTarget<typeof bindingTargetTypes.array, [(BindingTarget | null)[], Node | undefined]>;
+export type BindingTarget = SymbolBindingTarget | RestBindingTarget | ObjectBindingTarget | ArrayBindingTarget;
+export type BindingNode = Node<typeof NodeTypes.Binding, [BindingTarget, Node]>;
+type AstBody = Node[];
+export interface Ast {
+    body: AstBody;
+    hasDebugData: boolean;
+}
+export {};

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

@@ -0,0 +1,2 @@
+export declare const polishSymbolCharacterClass = "[\\w@%^?=!$<>+*/:&|~-]";
+export declare const polishSymbolFirstCharacterClass = "[a-zA-Z_@%^?=!$<>+*/&|~-]";

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

@@ -0,0 +1,4 @@
+import type { TokenStream } from './tokenize';
+export declare function minifyTokenStream(tokenStream: TokenStream, { removeWhiteSpace }: {
+    removeWhiteSpace: boolean;
+}): TokenStream;

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

@@ -0,0 +1,12 @@
+declare const binaryOperators: readonly ["^", "*", "/", "%", "+", "-", "<<", ">>", ">>>", "++", "<", "<=", "≤", ">", ">=", "≥", "==", "!=", "≠", "&", "xor", "|", "&&", "||", "??", "|>"];
+declare const symbolicOperators: readonly ["^", "*", "/", "%", "+", "-", "<<", ">>", ">>>", "++", "<", "<=", "≤", ">", ">=", "≥", "==", "!=", "≠", "&", "xor", "|", "&&", "||", "??", "|>", "?", ":", "->", "...", ".", ",", "=", ":", ";"];
+export declare function isFunctionOperator(operator: string): boolean;
+export type SymbolicBinaryOperator = typeof binaryOperators[number];
+export type SymbolicOperator = typeof symbolicOperators[number];
+export declare function isBinaryOperator(operator: string): operator is SymbolicBinaryOperator;
+export declare function assertBinaryOperator(operator: string): asserts operator is SymbolicBinaryOperator;
+export declare function asBinaryOperator(operator: string): SymbolicBinaryOperator;
+export declare function isSymbolicOperator(operator: string): operator is SymbolicOperator;
+export declare function assertSymbolicOperator(operator: string): asserts operator is SymbolicOperator;
+export declare function asSymbolicOperator(operator: string): SymbolicOperator;
+export {};

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

@@ -0,0 +1,66 @@
+export declare const numberReservedSymbolRecord: {
+    readonly E: number;
+    readonly '-E': number;
+    readonly ε: number;
+    readonly '-\u03B5': number;
+    readonly PI: number;
+    readonly '-PI': number;
+    readonly π: number;
+    readonly '-\u03C0': number;
+    readonly PHI: number;
+    readonly '-PHI': number;
+    readonly φ: number;
+    readonly '-\u03C6': number;
+    readonly POSITIVE_INFINITY: number;
+    readonly '\u221E': number;
+    readonly NEGATIVE_INFINITY: number;
+    readonly '-\u221E': number;
+    readonly MAX_SAFE_INTEGER: number;
+    readonly MIN_SAFE_INTEGER: number;
+    readonly MAX_VALUE: number;
+    readonly MIN_VALUE: number;
+    readonly NaN: number;
+};
+export declare const reservedSymbolRecord: {
+    readonly E: number;
+    readonly '-E': number;
+    readonly ε: number;
+    readonly '-\u03B5': number;
+    readonly PI: number;
+    readonly '-PI': number;
+    readonly π: number;
+    readonly '-\u03C0': number;
+    readonly PHI: number;
+    readonly '-PHI': number;
+    readonly φ: number;
+    readonly '-\u03C6': number;
+    readonly POSITIVE_INFINITY: number;
+    readonly '\u221E': number;
+    readonly NEGATIVE_INFINITY: number;
+    readonly '-\u221E': number;
+    readonly MAX_SAFE_INTEGER: number;
+    readonly MIN_SAFE_INTEGER: number;
+    readonly MAX_VALUE: number;
+    readonly MIN_VALUE: number;
+    readonly NaN: number;
+    readonly true: true;
+    readonly false: false;
+    readonly null: null;
+    readonly do: null;
+    readonly else: null;
+    readonly case: null;
+    readonly each: null;
+    readonly in: null;
+    readonly when: null;
+    readonly while: null;
+    readonly catch: null;
+    readonly function: null;
+    readonly export: null;
+    readonly as: null;
+    readonly then: null;
+    readonly end: null;
+    readonly _: null;
+};
+export type ReservedSymbol = keyof typeof reservedSymbolRecord;
+export declare function isReservedSymbol(symbol: string): symbol is keyof typeof reservedSymbolRecord;
+export declare function isNumberReservedSymbol(symbol: string): symbol is keyof typeof numberReservedSymbolRecord;

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

@@ -0,0 +1,86 @@
+import type { ReservedSymbol } from './reservedNames';
+import { type SymbolicBinaryOperator, type SymbolicOperator } from './operators';
+export declare const tokenTypes: readonly ["LBrace", "LBracket", "RBrace", "RBracket", "LParen", "RParen", "BasePrefixedNumber", "DocString", "Error", "MultiLineComment", "Number", "Operator", "RegexpShorthand", "ReservedSymbol", "SingleLineComment", "Shebang", "string", "Symbol", "Whitespace"];
+export type TokenType = typeof tokenTypes[number];
+declare const modifierNames: readonly ["&rest", "&let", "&when", "&while"];
+export type ModifierName = typeof modifierNames[number];
+type GenericToken<T extends TokenType, V extends string = string> = [T, V] | [T, V, SourceCodeInfo];
+export type ErrorToken = ['Error', string, SourceCodeInfo | undefined, string];
+export type LBraceToken = GenericToken<'LBrace', '{'>;
+export type LBracketToken = GenericToken<'LBracket', '['>;
+export type LParenToken = GenericToken<'LParen', '('>;
+export type RBraceToken = GenericToken<'RBrace', '}'>;
+export type RBracketToken = GenericToken<'RBracket', ']'>;
+export type RParenToken = GenericToken<'RParen', ')'>;
+export type BasePrefixedNumberToken = GenericToken<'BasePrefixedNumber'>;
+export type MultiLineCommentToken = GenericToken<'MultiLineComment'>;
+export type NumberToken = GenericToken<'Number'>;
+export type OperatorToken<T extends SymbolicOperator = SymbolicOperator> = GenericToken<'Operator', T>;
+export type RegexpShorthandToken = GenericToken<'RegexpShorthand'>;
+export type ReservedSymbolToken<T extends ReservedSymbol = ReservedSymbol> = GenericToken<'ReservedSymbol', T>;
+export type SingleLineCommentToken = GenericToken<'SingleLineComment'>;
+export type ShebangToken = GenericToken<'Shebang'>;
+export type StringToken = GenericToken<'string'>;
+export type DocStringToken = GenericToken<'DocString'>;
+export type SymbolToken<T extends string = string> = GenericToken<'Symbol', T>;
+export type WhitespaceToken = GenericToken<'Whitespace'>;
+export type Token = LBraceToken | LBracketToken | LParenToken | RBraceToken | RBracketToken | RParenToken | BasePrefixedNumberToken | DocStringToken | ErrorToken | MultiLineCommentToken | NumberToken | OperatorToken | RegexpShorthandToken | ReservedSymbolToken | SingleLineCommentToken | ShebangToken | StringToken | SymbolToken | WhitespaceToken;
+export type TokenDescriptor<T extends Token> = [length: number, token?: T];
+export interface SourceCodeInfo {
+    position: {
+        line: number;
+        column: number;
+    };
+    code: string;
+    filePath?: string;
+}
+export declare function isSymbolToken<T extends string>(token: Token | undefined | undefined, symbolName?: T): token is SymbolToken<T>;
+export declare function assertSymbolToken<T extends string>(token: Token | undefined | undefined, symbolName?: T): asserts token is SymbolToken<T>;
+export declare function asSymbolToken<T extends string>(token: Token | undefined | undefined, symbolName?: T): SymbolToken<T>;
+export declare function isReservedSymbolToken<T extends ReservedSymbol>(token: Token | undefined | undefined, symbolName?: T): token is ReservedSymbolToken<T>;
+export declare function assertReservedSymbolToken<T extends ReservedSymbol>(token: Token | undefined | undefined, symbolName?: T): asserts token is ReservedSymbolToken<T>;
+export declare function asReservedSymbolToken<T extends ReservedSymbol>(token: Token | undefined | undefined, symbolName?: T): ReservedSymbolToken<T>;
+export declare function isShebangToken(token: Token | undefined): token is SingleLineCommentToken;
+export declare function isSingleLineCommentToken(token: Token | undefined): token is SingleLineCommentToken;
+export declare function isMultiLineCommentToken(token: Token | undefined): token is MultiLineCommentToken;
+export declare function isOperatorToken<T extends SymbolicOperator>(token: Token | undefined | undefined, operatorName?: T): token is OperatorToken<T>;
+export declare function assertOperatorToken<T extends SymbolicOperator>(token: Token | undefined | undefined, operatorName?: T): asserts token is OperatorToken<T>;
+export declare function asOperatorToken<T extends SymbolicOperator>(token: Token | undefined | undefined, operatorName?: T): OperatorToken<T>;
+export declare function isWhitespaceToken(token: Token | undefined): token is WhitespaceToken;
+export declare function assertWhitespaceToken(token: Token | undefined): asserts token is WhitespaceToken;
+export declare function asWhitespaceToken(token: Token | undefined): WhitespaceToken;
+export declare function isNumberToken(token: Token | undefined): token is NumberToken;
+export declare function assertNumberToken(token: Token | undefined): asserts token is NumberToken;
+export declare function asNumberToken(token: Token | undefined): NumberToken;
+export declare function isBasePrefixedNumberToken(token: Token | undefined): token is BasePrefixedNumberToken;
+export declare function assertBasePrefixedNumberToken(token: Token | undefined): asserts token is BasePrefixedNumberToken;
+export declare function asBasePrefixedNumberToken(token: Token | undefined): BasePrefixedNumberToken;
+export declare function isLParenToken(token: Token | undefined): token is LParenToken;
+export declare function assertLParenToken(token: Token | undefined): asserts token is LParenToken;
+export declare function asLParenToken(token: Token | undefined): LParenToken;
+export declare function isRParenToken(token: Token | undefined): token is RParenToken;
+export declare function assertRParenToken(token: Token | undefined): asserts token is RParenToken;
+export declare function asRParenToken(token: Token | undefined): RParenToken;
+export declare function isLBracketToken(token: Token | undefined): token is LBracketToken;
+export declare function assertLBracketToken(token: Token | undefined): asserts token is LBracketToken;
+export declare function asLBracketToken(token: Token | undefined): LBracketToken;
+export declare function isRBracketToken(token: Token | undefined): token is RBracketToken;
+export declare function assertRBracketToken(token: Token | undefined): asserts token is RBracketToken;
+export declare function asRBracketToken(token: Token | undefined): RBracketToken;
+export declare function isLBraceToken(token: Token | undefined): token is LBraceToken;
+export declare function assertLBraceToken(token: Token | undefined): asserts token is LBraceToken;
+export declare function asLBraceToken(token: Token | undefined): LBraceToken;
+export declare function isRBraceToken(token: Token | undefined): token is RBraceToken;
+export declare function assertRBraceToken(token: Token | undefined): asserts token is RBraceToken;
+export declare function asRBraceToken(token: Token | undefined): RBraceToken;
+export declare function isStringToken(token: Token | undefined): token is StringToken;
+export declare function assertStringToken(token: Token | undefined): asserts token is StringToken;
+export declare function asStringToken(token: Token | undefined): StringToken;
+export declare function isDocStringToken(token: Token | undefined): token is DocStringToken;
+export declare function isRegexpShorthandToken(token: Token | undefined): token is RegexpShorthandToken;
+export declare function assertRegexpShorthandToken(token: Token | undefined): asserts token is RegexpShorthandToken;
+export declare function asRegexpShorthandToken(token: Token | undefined): RegexpShorthandToken;
+export declare function isA_BinaryOperatorToken(token: Token | undefined): token is OperatorToken<SymbolicBinaryOperator>;
+export declare function assertA_BinaryOperatorToken(token: Token | undefined): asserts token is OperatorToken<SymbolicBinaryOperator>;
+export declare function asA_BinaryOperatorToken(token: Token | undefined): OperatorToken<SymbolicBinaryOperator>;
+export {};

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

@@ -0,0 +1,8 @@
+import type { FilePathParams } from '../Lits/Lits';
+import type { Token } from './token';
+export interface TokenStream {
+    tokens: Token[];
+    hasDebugData: boolean;
+    filePath?: string;
+}
+export declare function tokenize(input: string, debug: boolean, filePath: FilePathParams['filePath']): TokenStream;

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

@@ -1,19 +1,14 @@
-import type { Tokenizer } from './interface';
-export declare const tokenizeNewLine: Tokenizer;
-export declare const tokenizeComment: Tokenizer;
-export declare const skipWhiteSpace: 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;
+import type { BasePrefixedNumberToken, DocStringToken, ErrorToken, LBraceToken, LBracketToken, LParenToken, MultiLineCommentToken, NumberToken, OperatorToken, RBraceToken, RBracketToken, RParenToken, RegexpShorthandToken, ReservedSymbolToken, SingleLineCommentToken, StringToken, SymbolToken, Token, TokenDescriptor, WhitespaceToken } from './token';
+export type Tokenizer<T extends Token> = (input: string, position: number) => TokenDescriptor<T | ErrorToken>;
+export declare const NO_MATCH: TokenDescriptor<never>;
+export declare const tokenizeDocString: Tokenizer<DocStringToken>;
+export declare const tokenizeWhitespace: Tokenizer<WhitespaceToken>;
+export declare const tokenizeNumber: Tokenizer<NumberToken>;
+export declare const tokenizeBasePrefixedNumber: Tokenizer<BasePrefixedNumberToken>;
+export declare const tokenizeSymbol: Tokenizer<SymbolToken>;
+export declare const tokenizeReservedSymbolToken: Tokenizer<ReservedSymbolToken>;
+export declare const tokenizeOperator: Tokenizer<OperatorToken>;
+export declare const tokenizeMultiLineComment: Tokenizer<MultiLineCommentToken>;
+export declare const tokenizeShebang: Tokenizer<SingleLineCommentToken>;
+export declare const tokenizeSingleLineComment: Tokenizer<SingleLineCommentToken>;
+export declare const tokenizers: [Tokenizer<WhitespaceToken>, Tokenizer<MultiLineCommentToken>, Tokenizer<SingleLineCommentToken>, Tokenizer<ReservedSymbolToken>, Tokenizer<LParenToken>, Tokenizer<RParenToken>, Tokenizer<LBracketToken>, Tokenizer<RBracketToken>, Tokenizer<LBraceToken>, Tokenizer<RBraceToken>, Tokenizer<DocStringToken>, Tokenizer<StringToken>, Tokenizer<RegexpShorthandToken>, Tokenizer<BasePrefixedNumberToken>, Tokenizer<NumberToken>, Tokenizer<OperatorToken>, Tokenizer<SymbolToken>];

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

@@ -1,2 +1,2 @@
-import type { TokenStream } from '../tokenizer/interface';
-export declare function transformTokens(tokenStram: TokenStream, transformer: (name: string) => string): TokenStream;
+import type { TokenStream } from '../tokenizer/tokenize';
+export declare function transformSymbolTokens(tokenStram: TokenStream, transformer: (symbol: string) => string): TokenStream;

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

@@ -0,0 +1,16 @@
+import type { Any } from '../interface';
+import type { SourceCodeInfo } from '../tokenizer/token';
+export declare function annotate<T>(value: T): T;
+export declare function isVector(vector: unknown): vector is number[];
+export declare function assertVector(vector: unknown, sourceCodeInfo: SourceCodeInfo | undefined): asserts vector is number[];
+export declare function is2dVector(vector: unknown): vector is [number, number];
+export declare function assert2dVector(vector: unknown, sourceCodeInfo: SourceCodeInfo | undefined): asserts vector is [number, number];
+export declare function is3dVector(vector: unknown): vector is [number, number, number];
+export declare function assert3dVector(vector: unknown, sourceCodeInfo: SourceCodeInfo | undefined): asserts vector is [number, number, number];
+export declare function assertNonEmptyVector(vector: unknown, sourceCodeInfo: SourceCodeInfo | undefined): asserts vector is number[];
+export declare function isGrid(grid: unknown): grid is unknown[][];
+export declare function assertGrid(grid: unknown, sourceCodeInfo: SourceCodeInfo | undefined): asserts grid is Any[][];
+export declare function isMatrix(matrix: unknown): matrix is number[][];
+export declare function assertMatrix(matrix: unknown, sourceCodeInfo: SourceCodeInfo | undefined): asserts matrix is number[][];
+export declare function assertSquareMatrix(matrix: unknown, sourceCodeInfo: SourceCodeInfo | undefined): asserts matrix is number[][];
+export declare function isSquareMatrix(matrix: unknown): matrix is number[][];

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

@@ -1,4 +1,4 @@
-import type { SourceCodeInfo } from '../tokenizer/interface';
+import type { SourceCodeInfo } from '../tokenizer/token';
 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[];

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

@@ -1,17 +1,20 @@
-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;
+import type { ExpressionNode, Node, NormalBuiltinSymbolNode, NormalExpressionNode, NormalExpressionNodeWithName, SpecialBuiltinSymbolNode, SpreadNode, SymbolNode, UserDefinedSymbolNode } from '../parser/types';
+import type { SourceCodeInfo } from '../tokenizer/token';
+export declare function isSymbolNode(node: Node): node is SymbolNode;
+export declare function asSymbolNode(node: Node, sourceCodeInfo?: SourceCodeInfo): SymbolNode;
+export declare function assertSymbolNode(node: Node, sourceCodeInfo?: SourceCodeInfo): asserts node is SymbolNode;
+export declare function isUserDefinedSymbolNode(node: Node): node is UserDefinedSymbolNode;
+export declare function asUserDefinedSymbolNode(node: Node, sourceCodeInfo?: SourceCodeInfo): UserDefinedSymbolNode;
+export declare function assertUserDefinedSymbolNode(node: Node, sourceCodeInfo?: SourceCodeInfo): asserts node is UserDefinedSymbolNode;
+export declare function isNormalBuiltinSymbolNode(node: Node): node is NormalBuiltinSymbolNode;
+export declare function isSpecialBuiltinSymbolNode(node: Node): node is SpecialBuiltinSymbolNode;
+export declare function isNormalExpressionNode(node: Node): node is NormalExpressionNode;
+export declare function asNormalExpressionNode(node: Node, sourceCodeInfo?: SourceCodeInfo): NormalExpressionNode;
+export declare function assertNormalExpressionNode(node: Node, sourceCodeInfo?: SourceCodeInfo): asserts node is NormalExpressionNode;
+export declare function isNormalExpressionNodeWithName(node: Node): node is NormalExpressionNodeWithName;
+export declare function asNormalExpressionNodeWithName(node: Node, sourceCodeInfo?: SourceCodeInfo): NormalExpressionNodeWithName;
+export declare function assertNormalExpressionNodeWithName(node: Node, sourceCodeInfo?: SourceCodeInfo): asserts node is NormalExpressionNodeWithName;
+export declare function isExpressionNode(node: Node): node is ExpressionNode;
+export declare function asExpressionNode(node: Node, sourceCodeInfo?: SourceCodeInfo): ExpressionNode;
+export declare function assertExpressionNode(node: Node, sourceCodeInfo?: SourceCodeInfo): asserts node is ExpressionNode;
+export declare function isSpreadNode(node: Node): node is SpreadNode;

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

@@ -1,17 +1,8 @@
 import type { UnknownRecord } from '../interface';
-import type { GenericNode } from '../parser/interface';
-import type { SourceCodeInfo } from '../tokenizer/interface';
-type Count = number | {
-    min?: number;
-    max?: number;
-};
-export declare function assertEvenNumberOfParams(node: GenericNode): void;
-export declare function assertNumberOfParams(count: Count, node: GenericNode): void;
+import type { SourceCodeInfo } from '../tokenizer/token';
 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 {};

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

@@ -1,6 +1,6 @@
 import type { Any, Coll, Obj, Seq } from '../interface';
-import type { RegularExpression } from '../parser/interface';
-import type { SourceCodeInfo } from '../tokenizer/interface';
+import type { FunctionLike, RegularExpression } from '../parser/types';
+import type { SourceCodeInfo } from '../tokenizer/token';
 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;
@@ -19,3 +19,6 @@ export declare function assertRegularExpression(value: unknown, sourceCodeInfo?:
 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;
+export declare function isFunctionLike(value: unknown): value is FunctionLike;
+export declare function asFunctionLike(value: unknown, sourceCodeInfo?: SourceCodeInfo): FunctionLike;
+export declare function assertFunctionLike(value: unknown, sourceCodeInfo?: SourceCodeInfo): asserts value is FunctionLike;

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

@@ -1,5 +1,5 @@
-import type { BuiltinFunction, LitsFunction, NativeJsFunction, UserDefinedFunction } from '../parser/interface';
-import type { SourceCodeInfo } from '../tokenizer/interface';
+import type { LitsFunction, NativeJsFunction, NormalBuiltinFunction, UserDefinedFunction } from '../parser/types';
+import type { SourceCodeInfo } from '../tokenizer/token';
 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;
@@ -9,4 +9,4 @@ export declare function assertUserDefinedFunction(value: unknown, sourceCodeInfo
 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;
+export declare function isBuiltinFunction(value: unknown): value is NormalBuiltinFunction;

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

@@ -1,4 +1,4 @@
-import type { SourceCodeInfo } from '../tokenizer/interface';
+import type { SourceCodeInfo } from '../tokenizer/token';
 type SignOptions = {
     positive?: true;
     negative?: never;

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

@@ -1,4 +1,4 @@
-import type { SourceCodeInfo } from '../tokenizer/interface';
+import type { SourceCodeInfo } from '../tokenizer/token';
 type StringAssertionOptions = {
     nonEmpty?: true;
     char?: never;

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

@@ -1,2 +1,2 @@
-import type { TokenStream } from '../tokenizer/interface';
+import type { TokenStream } from '../tokenizer/tokenize';
 export declare function untokenize(tokenStream: TokenStream): string;

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

@@ -0,0 +1,10 @@
+import type { Arity } from '../builtin/interface';
+import type { FunctionLike } from '../parser/types';
+import type { SourceCodeInfo } from '../tokenizer/token';
+export declare function arityAccepts(arity: Arity, nbrOfParams: number): boolean;
+export declare function arityAcceptsMin(arity: Arity, nbrOfParams: number): boolean;
+export declare function getCommonArityFromFunctions(params: FunctionLike[]): Arity | null;
+export declare function getArityFromFunction(param: FunctionLike): Arity;
+export declare function assertNumberOfParams(arity: Arity, length: number, sourceCodeInfo: SourceCodeInfo | undefined): void;
+export declare function canBeOperator(count: Arity): boolean;
+export declare function toFixedArity(arity: number): Arity;

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

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

@@ -0,0 +1,2 @@
+import type { SourceCodeInfo } from '../../tokenizer/token';
+export declare function getCodeMarker(sourceCodeInfo: SourceCodeInfo): string;

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

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

package/dist/cli/src/utils/docString/generateDocString.d.ts

@@ -0,0 +1,2 @@
+import type { FunctionReference } from '../../../reference';
+export declare function generateDocString(reference: FunctionReference): string;

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

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

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

@@ -1,11 +1,14 @@
 import type { Any, Coll } from '../interface';
-import type { NativeJsFunction } from '../parser/interface';
-import type { SourceCodeInfo } from '../tokenizer/interface';
+import type { SourceCodeInfo } from '../tokenizer/token';
 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 compare<T extends string | number>(a: T, b: T, sourceCodeInfo: SourceCodeInfo | undefined): number;
+export declare function deepEqual(a: unknown, b: unknown, 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;
-export declare function arrayToPairs<T>(arr: T[]): T[][];
+export declare function joinSets<T>(...results: Set<T>[]): Set<T>;
+export declare function addToSet<T>(target: Set<T>, source: Set<T>): void;
+export declare const EPSILON = 1e-10;
+export declare function approxEqual(a: number, b: number, epsilon?: number): boolean;
+export declare function approxZero(value: number): boolean;
+export declare function smartTrim(str: string, minIndent?: number): string;