@mojir/lits 1.3.0 → 2.0.2

package/dist/cli/reference/api.d.ts

@@ -10,7 +10,7 @@ export declare const api: {
     readonly regularExpression: readonly ["regexp", "match", "replace"];
     readonly specialExpressions: readonly ["and", "or", "def", "defs", "let", "if-let", "when-let", "when-first", "fn", "defn", "defns", "try", "throw", "if", "if-not", "cond", "when", "when-not", "comment", "do", "recur", "loop", "time!", "doseq", "for", "declared?", "??"];
     readonly string: readonly ["subs", "string-repeat", "str", "number", "number-to-string", "lower-case", "upper-case", "trim", "trim-left", "trim-right", "pad-left", "pad-right", "split", "template", "to-char-code", "from-char-code", "encode-base64", "decode-base64", "encode-uri-component", "decode-uri-component", "join"];
-    readonly bitwise: readonly ["bit-shift-left", "bit-shift-right", "bit-not", "bit-and", "bit-and-not", "bit-or", "bit-xor", "bit-flip", "bit-clear", "bit-set", "bit-test"];
+    readonly bitwise: readonly ["bit-shift-left", "bit-shift-right", "unsigned-bit-shift-right", "bit-not", "bit-and", "bit-and-not", "bit-or", "bit-xor", "bit-flip", "bit-clear", "bit-set", "bit-test"];
     readonly assert: readonly ["assert", "assert=", "assert-not=", "assert-equal", "assert-not-equal", "assert>", "assert<", "assert>=", "assert<=", "assert-true", "assert-false", "assert-truthy", "assert-falsy", "assert-nil", "assert-throws", "assert-throws-error", "assert-not-throws"];
     readonly shorthand: ["_short_regexp", "_short_fn", "_short_string", "_short_dot", "_short_hash"];
     readonly datatype: ["_type_number", "_type_string", "_type_object", "_type_array", "_type_boolean", "_type_function", "_type_integer", "_type_any", "_type_nil", "_type_collection", "_type_sequence", "_type_regexp", "_type_never"];
@@ -31,7 +31,7 @@ export type AssertApiName = typeof api.assert[number];
 export type FunctionName = CollectionApiName | ArrayApiName | SequenceApiName | MathApiName | FunctionalApiName | MiscApiName | ObjectApiName | PredicateApiName | RegularExpressionApiName | SpecialExpressionsApiName | StringApiName | BitwiseApiName | AssertApiName;
 export type ShorthandName = typeof api.shorthand[number];
 export type DatatypeName = typeof api.datatype[number];
-declare const apiNames: readonly ["count", "get", "get-in", "contains?", "has?", "has-some?", "has-every?", "assoc", "assoc-in", "concat", "not-empty", "every?", "not-every?", "any?", "not-any?", "update", "update-in", "array", "range", "repeat", "flatten", "mapcat", "nth", "push", "pop", "unshift", "shift", "slice", "reductions", "reduce", "reduce-right", "map", "filter", "position", "index-of", "some", "reverse", "first", "second", "last", "rest", "nthrest", "next", "nthnext", "cons", "take", "take-last", "take-while", "drop", "drop-last", "drop-while", "sort", "sort-by", "random-sample!", "rand-nth!", "shuffle!", "distinct", "remove", "remove-at", "split-at", "split-with", "frequencies", "group-by", "partition", "partition-all", "partition-by", "+", "-", "*", "/", "mod", "rem", "quot", "inc", "dec", "sqrt", "cbrt", "pow", "exp", "round", "trunc", "floor", "ceil", "min", "max", "abs", "sign", "positive-infinity", "negative-infinity", "max-safe-integer", "min-safe-integer", "max-value", "min-value", "epsilon", "nan", "e", "pi", "log", "log2", "log10", "rand!", "rand-int!", "sin", "cos", "tan", "asin", "acos", "atan", "sinh", "cosh", "tanh", "asinh", "acosh", "atanh", "apply", "identity", "partial", "comp", "constantly", "juxt", "complement", "every-pred", "some-pred", "fnil", "not=", "=", "<", ">", "<=", ">=", "not", "write!", "inst-ms!", "iso-date-time->inst-ms", "inst-ms->iso-date-time", "boolean", "compare", "lits-version!", "uuid!", "equal?", "json-parse", "json-stringify", "dissoc", "object", "keys", "vals", "entries", "find", "merge", "merge-with", "zipmap", "select-keys", "boolean?", "nil?", "number?", "string?", "function?", "integer?", "array?", "object?", "coll?", "seq?", "regexp?", "zero?", "pos?", "neg?", "even?", "odd?", "finite?", "nan?", "negative-infinity?", "positive-infinity?", "false?", "true?", "empty?", "not-empty?", "regexp", "match", "replace", "and", "or", "def", "defs", "let", "if-let", "when-let", "when-first", "fn", "defn", "defns", "try", "throw", "if", "if-not", "cond", "when", "when-not", "comment", "do", "recur", "loop", "time!", "doseq", "for", "declared?", "??", "subs", "string-repeat", "str", "number", "number-to-string", "lower-case", "upper-case", "trim", "trim-left", "trim-right", "pad-left", "pad-right", "split", "template", "to-char-code", "from-char-code", "encode-base64", "decode-base64", "encode-uri-component", "decode-uri-component", "join", "bit-shift-left", "bit-shift-right", "bit-not", "bit-and", "bit-and-not", "bit-or", "bit-xor", "bit-flip", "bit-clear", "bit-set", "bit-test", "assert", "assert=", "assert-not=", "assert-equal", "assert-not-equal", "assert>", "assert<", "assert>=", "assert<=", "assert-true", "assert-false", "assert-truthy", "assert-falsy", "assert-nil", "assert-throws", "assert-throws-error", "assert-not-throws", "_short_regexp", "_short_fn", "_short_string", "_short_dot", "_short_hash", "_type_number", "_type_string", "_type_object", "_type_array", "_type_boolean", "_type_function", "_type_integer", "_type_any", "_type_nil", "_type_collection", "_type_sequence", "_type_regexp", "_type_never"];
+declare const apiNames: readonly ["count", "get", "get-in", "contains?", "has?", "has-some?", "has-every?", "assoc", "assoc-in", "concat", "not-empty", "every?", "not-every?", "any?", "not-any?", "update", "update-in", "array", "range", "repeat", "flatten", "mapcat", "nth", "push", "pop", "unshift", "shift", "slice", "reductions", "reduce", "reduce-right", "map", "filter", "position", "index-of", "some", "reverse", "first", "second", "last", "rest", "nthrest", "next", "nthnext", "cons", "take", "take-last", "take-while", "drop", "drop-last", "drop-while", "sort", "sort-by", "random-sample!", "rand-nth!", "shuffle!", "distinct", "remove", "remove-at", "split-at", "split-with", "frequencies", "group-by", "partition", "partition-all", "partition-by", "+", "-", "*", "/", "mod", "rem", "quot", "inc", "dec", "sqrt", "cbrt", "pow", "exp", "round", "trunc", "floor", "ceil", "min", "max", "abs", "sign", "positive-infinity", "negative-infinity", "max-safe-integer", "min-safe-integer", "max-value", "min-value", "epsilon", "nan", "e", "pi", "log", "log2", "log10", "rand!", "rand-int!", "sin", "cos", "tan", "asin", "acos", "atan", "sinh", "cosh", "tanh", "asinh", "acosh", "atanh", "apply", "identity", "partial", "comp", "constantly", "juxt", "complement", "every-pred", "some-pred", "fnil", "not=", "=", "<", ">", "<=", ">=", "not", "write!", "inst-ms!", "iso-date-time->inst-ms", "inst-ms->iso-date-time", "boolean", "compare", "lits-version!", "uuid!", "equal?", "json-parse", "json-stringify", "dissoc", "object", "keys", "vals", "entries", "find", "merge", "merge-with", "zipmap", "select-keys", "boolean?", "nil?", "number?", "string?", "function?", "integer?", "array?", "object?", "coll?", "seq?", "regexp?", "zero?", "pos?", "neg?", "even?", "odd?", "finite?", "nan?", "negative-infinity?", "positive-infinity?", "false?", "true?", "empty?", "not-empty?", "regexp", "match", "replace", "and", "or", "def", "defs", "let", "if-let", "when-let", "when-first", "fn", "defn", "defns", "try", "throw", "if", "if-not", "cond", "when", "when-not", "comment", "do", "recur", "loop", "time!", "doseq", "for", "declared?", "??", "subs", "string-repeat", "str", "number", "number-to-string", "lower-case", "upper-case", "trim", "trim-left", "trim-right", "pad-left", "pad-right", "split", "template", "to-char-code", "from-char-code", "encode-base64", "decode-base64", "encode-uri-component", "decode-uri-component", "join", "bit-shift-left", "bit-shift-right", "unsigned-bit-shift-right", "bit-not", "bit-and", "bit-and-not", "bit-or", "bit-xor", "bit-flip", "bit-clear", "bit-set", "bit-test", "assert", "assert=", "assert-not=", "assert-equal", "assert-not-equal", "assert>", "assert<", "assert>=", "assert<=", "assert-true", "assert-false", "assert-truthy", "assert-falsy", "assert-nil", "assert-throws", "assert-throws-error", "assert-not-throws", "_short_regexp", "_short_fn", "_short_string", "_short_dot", "_short_hash", "_type_number", "_type_string", "_type_object", "_type_array", "_type_boolean", "_type_function", "_type_integer", "_type_any", "_type_nil", "_type_collection", "_type_sequence", "_type_regexp", "_type_never"];
 export type ApiName = typeof apiNames[number];
 export declare function isApiName(arg: string): arg is ApiName;
 export declare const categoryRecord: {

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

@@ -15,7 +15,6 @@ export interface LazyValue {
 }
 export interface JsFunction {
     fn: (...args: any[]) => unknown;
-    [key: string]: unknown;
 }
 export interface LitsParams {
     globalContext?: Context;
@@ -25,16 +24,19 @@ export interface LitsParams {
     jsFunctions?: Record<string, JsFunction>;
     filePath?: string;
     debug?: boolean;
+    algebraic?: boolean;
 }
 interface LitsConfig {
     initialCache?: Record<string, Ast>;
     astCacheSize?: number | null;
     debug?: boolean;
+    algebraic?: boolean;
 }
 export declare class Lits {
     private astCache;
     private astCacheSize;
     private debug;
+    private algebraic;
     constructor(config?: LitsConfig);
     getRuntimeInfo(): LitsRuntimeInfo;
     run(program: string, params?: LitsParams): unknown;
@@ -43,6 +45,8 @@ export declare class Lits {
     tokenize(program: string, tokenizeParams?: TokenizeParams): TokenStream;
     parse(tokenStream: TokenStream): Ast;
     evaluate(ast: Ast, params: LitsParams): Any;
+    transform(tokenStream: TokenStream, transformer: (name: string) => string): TokenStream;
+    untokenize(tokenStream: TokenStream): string;
     apply(fn: LitsFunction, fnParams: unknown[], params?: LitsParams): Any;
     private generateAst;
 }

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

@@ -2,7 +2,7 @@ import type { LitsParams } from '../Lits/Lits';
 import type { Builtin } from '../builtin/interface';
 import { type ContextStack } from '../evaluator/ContextStack';
 import type { Ast, AstNode } from '../parser/interface';
-import type { Token } from '../tokenizer/interface';
+import type { Token } from '../tokenizer/tokens';
 export interface UnresolvedIdentifier {
     symbol: string;
     token: Token | undefined;

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

@@ -31,7 +31,7 @@ declare const specialExpressions: {
 export type SpecialExpressionName = keyof typeof specialExpressions;
 export type BuiltinSpecialExpressions = typeof specialExpressions;
 export type BuiltinSpecialExpression = typeof specialExpressions[SpecialExpressionName];
-export type SpecialExpressionNode = ReturnType<typeof specialExpressions[SpecialExpressionName]['parse']>[1];
+export type SpecialExpressionNode = ReturnType<typeof specialExpressions[SpecialExpressionName]['parse']>;
 export declare const builtin: Builtin;
 export declare const normalExpressionKeys: string[];
 export declare const specialExpressionKeys: string[];

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

@@ -2,8 +2,9 @@ import type { FindUnresolvedIdentifiers, UnresolvedIdentifiers } from '../analyz
 import type { ContextStack } from '../evaluator/ContextStack';
 import type { EvaluateAstNode, ExecuteFunction } from '../evaluator/interface';
 import type { Any, Arr } from '../interface';
-import type { NormalExpressionNode, ParseArgument, ParseBinding, ParseBindings, ParseExpression, ParseToken, ParseTokensUntilClosingBracket } from '../parser/interface';
-import type { SourceCodeInfo, Token, TokenStream } from '../tokenizer/interface';
+import type { NormalExpressionNode, ParseArgument, ParseBinding, ParseBindings, ParseExpression, ParseState, ParseToken, ParseTokensUntilClosingBracket } from '../parser/interface';
+import type { SourceCodeInfo, TokenStream } from '../tokenizer/interface';
+import type { Token } from '../tokenizer/tokens';
 import type { BuiltinSpecialExpressions, SpecialExpressionNode } from '.';
 export type NormalExpressionEvaluator<T> = (params: Arr, sourceCodeInfo: SourceCodeInfo | undefined, contextStack: ContextStack, { executeFunction }: {
     executeFunction: ExecuteFunction;
@@ -27,7 +28,7 @@ interface EvaluateHelpers {
     builtin: Builtin;
 }
 export interface BuiltinSpecialExpression<T, N extends SpecialExpressionNode> {
-    parse: (tokenStream: TokenStream, position: number, firstToken: Token, parsers: ParserHelpers) => [number, N];
+    parse: (tokenStream: TokenStream, parseState: ParseState, firstToken: Token, parsers: ParserHelpers) => N;
     evaluate: (node: N, contextStack: ContextStack, helpers: EvaluateHelpers) => T;
     findUnresolvedIdentifiers: (node: N, contextStack: ContextStack, params: {
         findUnresolvedIdentifiers: FindUnresolvedIdentifiers;

package/dist/cli/src/builtin/specialExpressions/functions.d.ts

@@ -1,8 +1,8 @@
-import type { AstNode, CommonSpecialExpressionNode, LitsFunction, NameNode } from '../../parser/interface';
+import type { AstNode, CommonSpecialExpressionNode, LitsFunction, SymbolNode } from '../../parser/interface';
 import type { BuiltinSpecialExpression } from '../interface';
 import type { FunctionOverload } from '../utils';
 export interface DefnNode extends CommonSpecialExpressionNode<'defn'> {
-    f: NameNode;
+    f: SymbolNode;
     o: FunctionOverload[];
 }
 export interface DefnsNode extends CommonSpecialExpressionNode<'defns'> {

package/dist/cli/src/builtin/specialExpressions/if-let.d.ts

@@ -1,10 +1,7 @@
 import type { Any } from '../../interface';
-import type { BindingNode, CommonSpecialExpressionNode, NormalExpressionNode } from '../../parser/interface';
+import type { BindingNode, CommonSpecialExpressionNode } from '../../parser/interface';
 import type { BuiltinSpecialExpression } from '../interface';
 export interface IfLetNode extends CommonSpecialExpressionNode<'if-let'> {
     b: BindingNode;
-    debugData: CommonSpecialExpressionNode<'let'>['debugData'] & ({
-        bindingArray: NormalExpressionNode;
-    } | undefined);
 }
 export declare const ifLetSpecialExpression: BuiltinSpecialExpression<Any, IfLetNode>;

package/dist/cli/src/builtin/specialExpressions/let.d.ts

@@ -1,10 +1,7 @@
 import type { Any } from '../../interface';
-import type { BindingNode, CommonSpecialExpressionNode, NormalExpressionNode } from '../../parser/interface';
+import type { BindingNode, CommonSpecialExpressionNode } from '../../parser/interface';
 import type { BuiltinSpecialExpression } from '../interface';
 export interface LetNode extends CommonSpecialExpressionNode<'let'> {
     bs: BindingNode[];
-    debugData: CommonSpecialExpressionNode<'let'>['debugData'] & ({
-        bindingArray: NormalExpressionNode;
-    } | undefined);
 }
 export declare const letSpecialExpression: BuiltinSpecialExpression<Any, LetNode>;

package/dist/cli/src/builtin/specialExpressions/try.d.ts

@@ -1,8 +1,8 @@
 import type { Any } from '../../interface';
-import type { AstNode, CommonSpecialExpressionNode, NameNode } from '../../parser/interface';
+import type { AstNode, CommonSpecialExpressionNode, SymbolNode } from '../../parser/interface';
 import type { BuiltinSpecialExpression } from '../interface';
 export interface TryNode extends CommonSpecialExpressionNode<'try'> {
-    e: NameNode;
+    e: SymbolNode;
     ce: AstNode;
 }
 export declare const trySpecialExpression: BuiltinSpecialExpression<Any, TryNode>;

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

@@ -3,9 +3,9 @@ export declare enum AstNodeType {
     String = 202,
     NormalExpression = 203,
     SpecialExpression = 204,
-    Name = 205,
+    Symbol = 205,
     Modifier = 206,
-    ReservedName = 207,
+    ReservedSymbol = 207,
     Binding = 208,
     Argument = 209,
     Partial = 210,
@@ -13,21 +13,6 @@ export declare enum AstNodeType {
 }
 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,
-    Comment = 110,
-    NewLine = 111
-}
-export declare const tokenTypeName: Map<TokenType, string>;
-export declare function isTokenType(type: unknown): type is TokenType;
 export declare enum FunctionType {
     UserDefined = 301,
     Partial = 302,

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

@@ -7,7 +7,7 @@ export declare class RecurSignal extends Error {
 export declare class LitsError extends Error {
     readonly sourceCodeInfo?: SourceCodeInfo;
     readonly shortMessage: string;
-    constructor(message: string | Error, sourceCodeInfo?: SourceCodeInfo);
+    constructor(message: string | Error, sourceCodeInfo: SourceCodeInfo | undefined);
     getCodeMarker(): string | undefined;
 }
 export declare class NotAFunctionError extends LitsError {

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

@@ -1,4 +1,4 @@
-import type { ExtraData, NameNode, NativeJsFunction } from '../parser/interface';
+import type { ExtraData, NativeJsFunction, SymbolNode } from '../parser/interface';
 import type { Any } from '../interface';
 import type { LazyValue, LitsParams } from '../Lits/Lits';
 import type { Context, LookUpResult } from './interface';
@@ -18,7 +18,7 @@ export declare class ContextStackImpl {
     create(context: Context, extraData?: ExtraData): ContextStack;
     clone(): ContextStack;
     getValue(name: string): unknown;
-    lookUp(node: NameNode): LookUpResult;
-    evaluateName(node: NameNode): Any;
+    lookUp(node: SymbolNode): LookUpResult;
+    evaluateName(node: SymbolNode): Any;
 }
 export declare function createContextStack(params?: LitsParams): ContextStack;

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

@@ -0,0 +1,4 @@
+export declare const polishIdentifierCharacterClass = "[\\w@%^?=!$<>+*/:-]";
+export declare const polishIdentifierFirstCharacterClass = "[a-zA-Z_@%^?=!$<>+*/-]";
+export declare const algebraicIdentifierCharacterClass = "[\\w$:]";
+export declare const algebraicIdentifierFirstCharacterClass = "[a-zA-Z_$]";

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

@@ -1,12 +1,18 @@
-export { AstNodeType, TokenType, FunctionType } from './constants/constants';
+export { AstNodeType, FunctionType } from './constants/constants';
 export { isBuiltinFunction, isLitsFunction, asLitsFunction, assertLitsFunction, isUserDefinedFunction, asUserDefinedFunction, assertUserDefinedFunction, isNativeJsFunction, asNativeJsFunction, assertNativeJsFunction, } from './typeGuards/litsFunction';
-export type { LitsFunction, NativeJsFunction, ExtraData, Ast } from './parser/interface';
+export { type LitsFunction, type NativeJsFunction, type ExtraData } from './parser/interface';
 export type { Context } from './evaluator/interface';
-export type { Token, SourceCodeInfo } from './tokenizer/interface';
-export type { UnresolvedIdentifier } from './analyze';
+export type { Ast } from './parser/interface';
+export type { SourceCodeInfo } from './tokenizer/interface';
+export type { Token } from './tokenizer/tokens';
 export { normalExpressionKeys, specialExpressionKeys } from './builtin';
-export { reservedNames } from './reservedNames';
+export { polishReservedNames } from './tokenizer/polish/polishReservedNames';
 export { Lits } from './Lits/Lits';
 export { type LitsError, isLitsError } from './errors';
-export type { LitsParams, LitsRuntimeInfo, LazyValue } from './Lits/Lits';
+export type { LitsParams, LitsRuntimeInfo, LazyValue, JsFunction } from './Lits/Lits';
 export { createNativeJsFunction } from './utils';
+export { apiReference, isDatatypeReference, isFunctionReference, isNormalExpressionArgument, isShorthandReference, isSpecialExpressionArgument, isTypedValue } from '../reference';
+export type { Argument, CommonReference, DatatypeReference, FunctionReference, Reference, ShorthandReference } from '../reference';
+export type { ApiName, FunctionName, ShorthandName, DatatypeName } from '../reference/api';
+export { isApiName, isDataType } from '../reference/api';
+export { polishIdentifierCharacterClass as identifierCharacterClass, polishIdentifierFirstCharacterClass as identifierFirstCharacterClass } from './identifier';

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

@@ -0,0 +1,17 @@
+import type { TokenStream } from '../tokenizer/interface';
+import type { AstNode, ParseState } from './interface';
+export declare class AlgebraicParser {
+    private readonly tokenStream;
+    private parseState;
+    constructor(tokenStream: TokenStream, parseState: ParseState);
+    private advance;
+    parse(): AstNode;
+    private parseExpression;
+    private parseOperand;
+    private parseObject;
+    private parseArray;
+    private parseFunctionCall;
+    parseLamdaFunction(): AstNode | null;
+    private isAtEnd;
+    private peek;
+}

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

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

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

@@ -0,0 +1,6 @@
+import type { TokenStream } from '../tokenizer/interface';
+import type { NumberNode, ParseState, ReservedSymbolNode, StringNode, SymbolNode } from './interface';
+export declare function parseSymbol(tokenStream: TokenStream, parseState: ParseState): SymbolNode;
+export declare function parseReservedSymbol(tokenStream: TokenStream, parseState: ParseState): ReservedSymbolNode;
+export declare function parseNumber(tokenStream: TokenStream, parseState: ParseState): NumberNode;
+export declare function parseString(tokenStream: TokenStream, parseState: ParseState): StringNode;

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

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

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

@@ -4,9 +4,16 @@ import type { Arity } from '../builtin/utils';
 import type { AstNodeType, FunctionType } from '../constants/constants';
 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 { PolishReservedName } from '../tokenizer/polish/polishReservedNames';
+import type { SourceCodeInfo, TokenStream } from '../tokenizer/interface';
 import type { FUNCTION_SYMBOL, REGEXP_SYMBOL } from '../utils/symbols';
+import type { Token } from '../tokenizer/tokens';
+import type { ModifierName } from '../tokenizer/polish/polishTokens';
+export interface ParseState {
+    position: number;
+    algebraic: boolean;
+    parseToken: ParseToken;
+}
 export interface EvaluatedFunctionArguments {
     mandatoryArguments: string[];
     restArgument?: string;
@@ -80,24 +87,23 @@ export interface BuiltinFunction extends GenericLitsFunction {
 }
 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';
+export type DebugData = {
+    token: Token;
+    nameToken?: Token;
+};
 export interface GenericNode {
     t: AstNodeType;
     p: AstNode[];
     n: string | undefined;
-    debugData: {
-        token: Token;
-        lastToken: Token;
-        nameToken?: Token;
-    } | undefined;
+    token: Token | undefined;
 }
 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 ParseTokensUntilClosingBracket = (tokens: TokenStream, position: number) => [number, AstNode[]];
-export type ParseToken = (tokens: TokenStream, position: number) => [number, AstNode];
+export type ParseBinding = (tokens: TokenStream, parseState: ParseState) => BindingNode;
+export type ParseBindings = (tokens: TokenStream, parseState: ParseState) => BindingNode[];
+export type ParseArgument = (tokens: TokenStream, parseState: ParseState) => ArgumentNode | ModifierNode;
+export type ParseExpression = (tokens: TokenStream, parseState: ParseState) => ExpressionNode;
+export type ParseTokensUntilClosingBracket = (tokens: TokenStream, parseState: ParseState) => AstNode[];
+export type ParseToken = (tokens: TokenStream, parseState: ParseState) => AstNode;
 export interface NumberNode extends GenericNode {
     t: AstNodeType.Number;
     v: number;
@@ -106,17 +112,17 @@ export interface StringNode extends GenericNode {
     t: AstNodeType.String;
     v: string;
 }
-export interface NameNode extends GenericNode {
-    t: AstNodeType.Name;
+export interface SymbolNode extends GenericNode {
+    t: AstNodeType.Symbol;
     v: string;
 }
 export interface ModifierNode extends GenericNode {
     t: AstNodeType.Modifier;
     v: ModifierName;
 }
-export interface ReservedNameNode extends GenericNode {
-    t: AstNodeType.ReservedName;
-    v: ReservedName;
+export interface ReservedSymbolNode extends GenericNode {
+    t: AstNodeType.ReservedSymbol;
+    v: PolishReservedName;
 }
 interface CommonNormalExpressionNode extends GenericNode {
     t: AstNodeType.NormalExpression;
@@ -146,7 +152,7 @@ export interface CommentNode extends GenericNode {
     t: AstNodeType.Comment;
     v: string;
 }
-export type AstNode = NumberNode | StringNode | ReservedNameNode | NameNode | CommentNode | NormalExpressionNode | ModifierNode | SpecialExpressionNode;
+export type AstNode = NumberNode | StringNode | ReservedSymbolNode | SymbolNode | CommentNode | NormalExpressionNode | ModifierNode | SpecialExpressionNode;
 type AstBody = AstNode[];
 export interface Ast {
     b: AstBody;

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

@@ -7,5 +7,5 @@ export type RemoveOptions = typeof removeOptions;
 export declare function removeCommenNodes(ast: Ast): void;
 declare function recursivelyRemoveCommentNodes(astNode: AstNode): void;
 declare function removeCommenNodesFromArray(astNodes: AstNode[]): void;
-export declare function withoutCommentNodes(astNodes: AstNode[]): (import("../parser/interface").NumberNode | import("../parser/interface").StringNode | import("../parser/interface").ReservedNameNode | import("../parser/interface").NameNode | import("../parser/interface").NormalExpressionNode | import("../parser/interface").ModifierNode | import("../builtin/specialExpressions/and").AndNode | import("../builtin/specialExpressions/comment").CommentExpressionNode | import("../builtin/specialExpressions/cond").CondNode | import("../builtin/specialExpressions/def").DefNode | import("../builtin/specialExpressions/functions").DefnNode | import("../builtin/specialExpressions/functions").DefnsNode | import("../builtin/specialExpressions/defs").DefsNode | import("../builtin/specialExpressions/do").DoNode | import("../builtin/specialExpressions/loops").DoSeqNode | import("../builtin/specialExpressions/loops").ForNode | import("../builtin/specialExpressions/functions").FnNode | import("../builtin/specialExpressions/if").IfNode | import("../builtin/specialExpressions/if-let").IfLetNode | import("../builtin/specialExpressions/if-not").IfNotNode | import("../builtin/specialExpressions/let").LetNode | import("../builtin/specialExpressions/loop").LoopNode | import("../builtin/specialExpressions/or").OrNode | import("../builtin/specialExpressions/recur").RecurNode | import("../builtin/specialExpressions/throw").ThrowNode | import("../builtin/specialExpressions/time").TimeNode | import("../builtin/specialExpressions/try").TryNode | import("../builtin/specialExpressions/when").WhenNode | import("../builtin/specialExpressions/when-first").WhenFirstNode | import("../builtin/specialExpressions/when-let").WhenLetNode | import("../builtin/specialExpressions/when-not").WhenNotNode | import("../builtin/specialExpressions/declared").DeclaredNode | import("../builtin/specialExpressions/qq").QqNode)[];
+export declare function withoutCommentNodes(astNodes: AstNode[]): (import("../parser/interface").NumberNode | import("../parser/interface").StringNode | import("../parser/interface").ReservedSymbolNode | import("../parser/interface").SymbolNode | import("../parser/interface").NormalExpressionNode | import("../parser/interface").ModifierNode | import("../builtin").SpecialExpressionNode)[];
 export {};

package/dist/cli/src/tokenizer/algebraic/algebraicReservedNames.d.ts

@@ -0,0 +1,8 @@
+import type { Any } from '../../interface';
+export declare const algebraicReservedNamesRecord: Record<string, {
+    value: Any;
+    forbidden?: true;
+}>;
+type AlgebraicReservedName = keyof typeof algebraicReservedNamesRecord;
+export declare const algebraicReservedNames: AlgebraicReservedName[];
+export {};

package/dist/cli/src/tokenizer/algebraic/algebraicTokenizers.d.ts

@@ -0,0 +1,10 @@
+import type { Tokenizer } from '../interface';
+import type { A_MultiLineCommentToken, A_NumberToken, A_OperatorToken, A_ReservedSymbolToken, A_SingleLineCommentToken, A_SymbolToken, A_WhitespaceToken } from './algebraicTokens';
+export declare const tokenizeA_Whitespace: Tokenizer<A_WhitespaceToken>;
+export declare const tokenizeA_Number: Tokenizer<A_NumberToken>;
+export declare const tokenizeA_ReservedSymbolToken: Tokenizer<A_ReservedSymbolToken>;
+export declare const tokenizeA_Symbol: Tokenizer<A_SymbolToken>;
+export declare const tokenizeA_Operator: Tokenizer<A_OperatorToken>;
+export declare const tokenizeA_MultiLineComment: Tokenizer<A_MultiLineCommentToken>;
+export declare const tokenizeA_SingleLineComment: Tokenizer<A_SingleLineCommentToken>;
+export declare const algebraicTokenizers: [Tokenizer<A_WhitespaceToken>, Tokenizer<A_MultiLineCommentToken>, Tokenizer<A_SingleLineCommentToken>, Tokenizer<import("../common/commonTokens").PolishNotationToken>, Tokenizer<import("../common/commonTokens").AlgebraicNotationToken>, Tokenizer<import("../common/commonTokens").EndNotationToken>, Tokenizer<import("../common/commonTokens").LParenToken>, Tokenizer<import("../common/commonTokens").RParenToken>, Tokenizer<import("../common/commonTokens").LBracketToken>, Tokenizer<import("../common/commonTokens").RBracketToken>, Tokenizer<import("../common/commonTokens").LBraceToken>, Tokenizer<import("../common/commonTokens").RBraceToken>, Tokenizer<import("../common/commonTokens").StringToken>, Tokenizer<A_NumberToken>, Tokenizer<A_OperatorToken>, Tokenizer<A_ReservedSymbolToken>, Tokenizer<A_SymbolToken>];

package/dist/cli/src/tokenizer/algebraic/algebraicTokens.d.ts

@@ -0,0 +1,47 @@
+import type { CommonSimpleToken, CommonValueToken, CommonValueTokenType } from '../common/commonTokens';
+import type { Token } from '../tokens';
+import { type TokenDebugData } from '../utils';
+export declare const algebraicSimpleTokenTypes: readonly ["LBrace", "LBracket", "LParen", "RBrace", "RBracket", "RParen", "AlgNotation", "PolNotation", "EndNotation"];
+export declare const algebraicOnlyValueTokenTypes: ["A_Whitespace", "A_Operator", "A_Symbol", "A_ReservedSymbol", "A_SingleLineComment", "A_MultiLineComment", "A_Number"];
+export declare const algebraicValueTokenTypes: readonly ["String", "A_Whitespace", "A_Operator", "A_Symbol", "A_ReservedSymbol", "A_SingleLineComment", "A_MultiLineComment", "A_Number"];
+export declare const algebraicTokenTypes: readonly ["LBrace", "LBracket", "LParen", "RBrace", "RBracket", "RParen", "AlgNotation", "PolNotation", "EndNotation", "String", "A_Whitespace", "A_Operator", "A_Symbol", "A_ReservedSymbol", "A_SingleLineComment", "A_MultiLineComment", "A_Number"];
+export declare const AlgebraicOperators: readonly ["!", "~", "=", ",", "=>", "...", ".", "**", "*", "/", "%", "+", "-", "<<", ">>", ">>>", "<", "<=", ">", ">=", "==", "!=", "&", "^", "|", "&&", "||", "??"];
+export type AlgebraicOperator = typeof AlgebraicOperators[number];
+export declare function isAlgebraicOperator(operator: string): operator is AlgebraicOperator;
+export declare function assertAlgebraicOperator(operator: string): asserts operator is AlgebraicOperator;
+export declare function asAlgebraicOperator(operator: string): AlgebraicOperator;
+export type AlgebraicSimpleTokenType = typeof algebraicSimpleTokenTypes[number];
+export type AlgebraicValueTokenType = typeof algebraicValueTokenTypes[number];
+export type AlgebraicTokenType = typeof algebraicTokenTypes[number];
+type GenericAlgebraicValueToken<T extends Exclude<AlgebraicValueTokenType, CommonValueTokenType>, V extends string = string> = [T, V] | [T, V, TokenDebugData];
+export type A_WhitespaceToken = GenericAlgebraicValueToken<'A_Whitespace'>;
+export type A_NumberToken = GenericAlgebraicValueToken<'A_Number'>;
+export type A_OperatorToken<T extends AlgebraicOperator = AlgebraicOperator> = GenericAlgebraicValueToken<'A_Operator', T>;
+export type A_SymbolToken = GenericAlgebraicValueToken<'A_Symbol'>;
+export type A_ReservedSymbolToken = GenericAlgebraicValueToken<'A_ReservedSymbol'>;
+export type A_SingleLineCommentToken = GenericAlgebraicValueToken<'A_SingleLineComment'>;
+export type A_MultiLineCommentToken = GenericAlgebraicValueToken<'A_MultiLineComment'>;
+export type AlgebraicOnlyValueToken = A_WhitespaceToken | A_NumberToken | A_OperatorToken | A_SymbolToken | A_ReservedSymbolToken | A_SingleLineCommentToken | A_MultiLineCommentToken;
+export type AlgebraicToken = AlgebraicOnlyValueToken | CommonSimpleToken | CommonValueToken;
+export declare function isA_SymbolToken(token?: Token): token is A_SymbolToken;
+export declare function assertA_SymbolToken(token?: Token): asserts token is A_SymbolToken;
+export declare function asA_SymbolToken(token?: Token): A_SymbolToken;
+export declare function isA_ReservedSymbolToken(token?: Token): token is A_ReservedSymbolToken;
+export declare function assertA_ReservedSymbolToken(token?: Token): asserts token is A_ReservedSymbolToken;
+export declare function asA_ReservedSymbolToken(token?: Token): A_ReservedSymbolToken;
+export declare function isA_CommentToken(token?: Token): token is A_SingleLineCommentToken;
+export declare function assertA_CommentToken(token?: Token): asserts token is A_SingleLineCommentToken;
+export declare function asA_CommentToken(token?: Token): A_SingleLineCommentToken;
+export declare function isA_MultiLineCommentToken(token?: Token): token is A_MultiLineCommentToken;
+export declare function assertA_MultiLineCommentToken(token?: Token): asserts token is A_MultiLineCommentToken;
+export declare function asA_MultiLineCommentToken(token?: Token): A_MultiLineCommentToken;
+export declare function isA_OperatorToken<T extends AlgebraicOperator>(token?: Token, operatorName?: T): token is A_OperatorToken<T>;
+export declare function assertA_OperatorToken<T extends AlgebraicOperator>(token?: Token, operatorName?: T): asserts token is A_OperatorToken<T>;
+export declare function asA_OperatorToken<T extends AlgebraicOperator>(token?: Token, operatorName?: T): A_OperatorToken<T>;
+export declare function isA_WhitespaceToken(token?: Token): token is A_WhitespaceToken;
+export declare function assertA_WhitespaceToken(token?: Token): asserts token is A_WhitespaceToken;
+export declare function asA_WhitespaceToken(token?: Token): A_WhitespaceToken;
+export declare function isA_NumberToken(token?: Token): token is A_NumberToken;
+export declare function assertA_NumberToken(token?: Token): asserts token is A_NumberToken;
+export declare function asA_NumberToken(token?: Token): A_NumberToken;
+export {};

package/dist/cli/src/tokenizer/common/commonTokenizers.d.ts

@@ -0,0 +1,8 @@
+import type { TokenDescriptor, Tokenizer } from '../interface';
+import type { SimpleToken } from '../tokens';
+import type { AlgebraicNotationToken, EndNotationToken, LBraceToken, LBracketToken, LParenToken, PolishNotationToken, RBraceToken, RBracketToken, RParenToken, StringToken } from './commonTokens';
+export declare const NO_MATCH: TokenDescriptor<never>;
+export declare function isNoMatch(tokenDescriptor: TokenDescriptor<any>): tokenDescriptor is TokenDescriptor<never>;
+export declare const tokenizeString: Tokenizer<StringToken>;
+export declare function tokenizeSimpleToken<T extends SimpleToken>(type: T[0], value: string, input: string, position: number): TokenDescriptor<T>;
+export declare const commonTokenizers: readonly [Tokenizer<PolishNotationToken>, Tokenizer<AlgebraicNotationToken>, Tokenizer<EndNotationToken>, Tokenizer<LParenToken>, Tokenizer<RParenToken>, Tokenizer<LBracketToken>, Tokenizer<RBracketToken>, Tokenizer<LBraceToken>, Tokenizer<RBraceToken>, Tokenizer<StringToken>];

package/dist/cli/src/tokenizer/common/commonTokens.d.ts

@@ -0,0 +1,51 @@
+import { type TokenDebugData } from '../utils';
+import type { Token } from '../tokens';
+export declare const commonSimpleTokenTypes: readonly ["LBrace", "LBracket", "LParen", "RBrace", "RBracket", "RParen", "AlgNotation", "PolNotation", "EndNotation"];
+export declare const commomValueTokenTypes: readonly ["String"];
+export type CommonSimpleTokenType = typeof commonSimpleTokenTypes[number];
+export type CommonValueTokenType = typeof commomValueTokenTypes[number];
+type GenericCommonSimpleToken<T extends CommonSimpleTokenType> = [T] | [T, TokenDebugData];
+type GenericCommonValueToken<T extends CommonValueTokenType, V extends string = string> = [T, V] | [T, V, TokenDebugData];
+export type LParenToken = GenericCommonSimpleToken<'LParen'>;
+export type RParenToken = GenericCommonSimpleToken<'RParen'>;
+export type LBracketToken = GenericCommonSimpleToken<'LBracket'>;
+export type RBracketToken = GenericCommonSimpleToken<'RBracket'>;
+export type LBraceToken = GenericCommonSimpleToken<'LBrace'>;
+export type RBraceToken = GenericCommonSimpleToken<'RBrace'>;
+export type AlgebraicNotationToken = GenericCommonSimpleToken<'AlgNotation'>;
+export type PolishNotationToken = GenericCommonSimpleToken<'PolNotation'>;
+export type EndNotationToken = GenericCommonSimpleToken<'EndNotation'>;
+export type StringToken = GenericCommonValueToken<'String'>;
+export type CommonSimpleToken = LParenToken | RParenToken | LBracketToken | RBracketToken | LBraceToken | RBraceToken | AlgebraicNotationToken | PolishNotationToken | EndNotationToken;
+export type CommonValueToken = StringToken;
+export declare function isLParenToken(token?: Token): token is LParenToken;
+export declare function assertLParenToken(token?: Token): asserts token is LParenToken;
+export declare function asLParenToken(token?: Token): LParenToken;
+export declare function isRParenToken(token?: Token): token is RParenToken;
+export declare function assertRParenToken(token?: Token): asserts token is RParenToken;
+export declare function asRParenToken(token?: Token): RParenToken;
+export declare function isLBracketToken(token?: Token): token is LBracketToken;
+export declare function assertLBracketToken(token?: Token): asserts token is LBracketToken;
+export declare function asLBracketToken(token?: Token): LBracketToken;
+export declare function isRBracketToken(token?: Token): token is RBracketToken;
+export declare function assertRBracketToken(token?: Token): asserts token is RBracketToken;
+export declare function asRBracketToken(token?: Token): RBracketToken;
+export declare function isLBraceToken(token?: Token): token is LBraceToken;
+export declare function assertLBraceToken(token?: Token): asserts token is LBraceToken;
+export declare function asLBraceToken(token?: Token): LBraceToken;
+export declare function isRBraceToken(token?: Token): token is RBraceToken;
+export declare function assertRBraceToken(token?: Token): asserts token is RBraceToken;
+export declare function asRBraceToken(token?: Token): RBraceToken;
+export declare function isStringToken(token?: Token): token is StringToken;
+export declare function assertStringToken(token?: Token): asserts token is StringToken;
+export declare function asStringToken(token?: Token): StringToken;
+export declare function isAlgebraicNotationToken(token?: Token): token is AlgebraicNotationToken;
+export declare function assertAlgebraicNotationToken(token?: Token): asserts token is AlgebraicNotationToken;
+export declare function asAlgebraicNotationToken(token?: Token): AlgebraicNotationToken;
+export declare function isPolishNotationToken(token?: Token): token is PolishNotationToken;
+export declare function assertPolishNotationToken(token?: Token): asserts token is PolishNotationToken;
+export declare function asPolishNotationToken(token?: Token): PolishNotationToken;
+export declare function isEndNotationToken(token?: Token): token is EndNotationToken;
+export declare function assertEndNotationToken(token?: Token): asserts token is EndNotationToken;
+export declare function asEndNotationToken(token?: Token): EndNotationToken;
+export {};

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

@@ -1,9 +1,2 @@
-import { TokenType } from '../constants/constants';
-import type { MetaToken, Token, TokenStream, TokenizeParams } from './interface';
+import type { TokenStream, TokenizeParams } from './interface';
 export declare function tokenize(input: string, params: TokenizeParams): TokenStream;
-export declare function isMetaToken(token?: Token): token is MetaToken;
-export declare function assertMetaToken(token?: Token): asserts token is MetaToken;
-export declare function isCommentToken(token?: Token): token is Token<TokenType.Comment>;
-export declare function assertCommentToken(token?: Token): asserts token is Token<TokenType.Comment>;
-export declare function isNewLineToken(token?: Token): token is Token<TokenType.NewLine>;
-export declare function assertNewLineToken(token?: Token): asserts token is Token<TokenType.NewLine>;

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

@@ -1,4 +1,4 @@
-import type { TokenType } from '../constants/constants';
+import type { Token } from './tokens';
 export interface SourceCodeInfo {
     position?: {
         line: number;
@@ -7,29 +7,16 @@ export interface SourceCodeInfo {
     code?: string;
     filePath?: string;
 }
-export type MetaToken = Token<TokenType.NewLine> | Token<TokenType.Comment>;
-export interface MetaTokens {
-    leadingMetaTokens: MetaToken[];
-    inlineCommentToken: Token<TokenType.Comment> | null;
-}
-export interface TokenDebugData {
-    sourceCodeInfo: SourceCodeInfo;
-    metaTokens: MetaTokens;
-}
-export interface Token<T extends TokenType = TokenType> {
-    t: T;
-    v: string;
-    o?: Record<string, boolean>;
-    debugData: TokenDebugData | undefined;
-}
-export type TokenDescriptor = [length: number, token: Token | undefined];
-export type Tokenizer = (input: string, position: number, debugData?: TokenDebugData) => TokenDescriptor;
+export type TokenDescriptor<T extends Token> = [length: number, token?: T];
+export type Tokenizer<T extends Token> = (input: string, position: number) => TokenDescriptor<T>;
 export interface TokenStream {
     tokens: Token[];
     hasDebugData: boolean;
+    algebraic: boolean;
     filePath?: string;
 }
 export interface TokenizeParams {
     debug?: boolean;
     filePath?: string;
+    algebraic?: boolean;
 }

package/dist/cli/src/tokenizer/polish/polishReservedNames.d.ts

@@ -0,0 +1,7 @@
+import type { Any } from '../../interface';
+export declare const polishReservedNamesRecord: Record<string, {
+    value: Any;
+    forbidden?: true;
+}>;
+export type PolishReservedName = keyof typeof polishReservedNamesRecord;
+export declare const polishReservedNames: PolishReservedName[];