@mojir/lits 2.0.22 → 2.1.0

package/dist/src/parser/{interface.d.ts → types.d.ts}

@@ -1,33 +1,23 @@
-import type { JsFunction, LazyValue } from '../Lits/Lits';
+import type { JsFunction } from '../Lits/Lits';
 import type { SpecialExpressionName, SpecialExpressionNode } from '../builtin';
-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 { PolishReservedName } from '../tokenizer/polish/polishReservedNames';
-import type { SourceCodeInfo, TokenStream } from '../tokenizer/interface';
+import type { TokenStream } from '../tokenizer/tokenize';
+import type { ModifierName, SourceCodeInfo, Token } from '../tokenizer/token';
 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;
-    parseToken: ParseToken;
 }
-export interface EvaluatedFunctionArguments {
-    mandatoryArguments: string[];
-    restArgument?: string;
+export interface EvaluatedFunction {
+    arguments: BindingTarget[];
+    body: AstNode[];
+    context: Context;
 }
-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;
+    functionType: FunctionType;
 }
 export interface RegularExpression {
     [REGEXP_SYMBOL]: true;
@@ -36,65 +26,62 @@ export interface RegularExpression {
     f: string;
 }
 export interface NativeJsFunction extends GenericLitsFunction {
-    t: FunctionType.NativeJsFunction;
-    n: string | undefined;
-    f: JsFunction;
+    functionType: 'NativeJsFunction';
+    name: string | undefined;
+    nativeFn: JsFunction;
 }
 export interface UserDefinedFunction extends GenericLitsFunction {
-    t: FunctionType.UserDefined;
-    n: string | undefined;
-    o: EvaluatedFunctionOverload[];
-    x?: ExtraData;
+    functionType: 'UserDefined';
+    name: string | undefined;
+    evaluatedfunction: EvaluatedFunction;
 }
 export interface PartialFunction extends GenericLitsFunction {
-    t: FunctionType.Partial;
-    f: Any;
-    p: Arr;
+    functionType: 'Partial';
+    function: Any;
+    params: Arr;
 }
 export interface CompFunction extends GenericLitsFunction {
-    t: FunctionType.Comp;
-    f: Arr;
+    functionType: 'Comp';
+    params: Arr;
 }
 export interface ConstantlyFunction extends GenericLitsFunction {
-    t: FunctionType.Constantly;
-    v: Any;
+    functionType: 'Constantly';
+    value: Any;
 }
 export interface JuxtFunction extends GenericLitsFunction {
-    t: FunctionType.Juxt;
-    f: Arr;
+    functionType: 'Juxt';
+    params: Arr;
 }
 export interface ComplementFunction extends GenericLitsFunction {
-    t: FunctionType.Complement;
-    f: Any;
+    functionType: 'Complement';
+    function: Any;
 }
 export interface EveryPredFunction extends GenericLitsFunction {
-    t: FunctionType.EveryPred;
-    f: Arr;
+    functionType: 'EveryPred';
+    params: Arr;
 }
 export interface SomePredFunction extends GenericLitsFunction {
-    t: FunctionType.SomePred;
-    f: Arr;
+    functionType: 'SomePred';
+    params: Arr;
 }
-export interface FNilFunction extends GenericLitsFunction {
-    t: FunctionType.Fnil;
-    f: Any;
-    p: Arr;
+export interface FNullFunction extends GenericLitsFunction {
+    functionType: 'Fnull';
+    function: Any;
+    params: Arr;
 }
 export interface BuiltinFunction extends GenericLitsFunction {
-    t: FunctionType.Builtin;
+    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 LitsFunction = NativeJsFunction | UserDefinedFunction | BuiltinFunction | PartialFunction | CompFunction | ConstantlyFunction | JuxtFunction | ComplementFunction | EveryPredFunction | SomePredFunction | FNullFunction;
+export type LitsFunctionType = LitsFunction['functionType'];
 export type DebugData = {
     token: Token;
     nameToken?: Token;
 };
 export interface GenericNode {
-    t: AstNodeType;
-    p: AstNode[];
-    n: string | undefined;
-    token: Token | undefined;
+    type: AstNodeType;
+    sourceCodeInfo?: SourceCodeInfo | undefined;
 }
 export type ExpressionNode = NormalExpressionNode | SpecialExpressionNode | NumberNode | StringNode;
 export type ParseBinding = (tokens: TokenStream, parseState: ParseState) => BindingNode;
@@ -103,58 +90,85 @@ export type ParseArgument = (tokens: TokenStream, parseState: ParseState) => Arg
 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 SpreadNode extends GenericNode {
+    type: 'Spread';
+    value: AstNode;
+}
 export interface NumberNode extends GenericNode {
-    t: AstNodeType.Number;
-    v: number;
+    type: 'Number';
+    value: number;
 }
 export interface StringNode extends GenericNode {
-    t: AstNodeType.String;
-    v: string;
+    type: 'String';
+    value: string;
 }
 export interface SymbolNode extends GenericNode {
-    t: AstNodeType.Symbol;
-    v: string;
+    type: 'Symbol';
+    value: string;
 }
 export interface ModifierNode extends GenericNode {
-    t: AstNodeType.Modifier;
-    v: ModifierName;
+    type: 'Modifier';
+    value: ModifierName;
 }
 export interface ReservedSymbolNode extends GenericNode {
-    t: AstNodeType.ReservedSymbol;
-    v: PolishReservedName;
+    type: 'ReservedSymbol';
+    value: string;
 }
 interface CommonNormalExpressionNode extends GenericNode {
-    t: AstNodeType.NormalExpression;
+    type: 'NormalExpression';
+    params: AstNode[];
 }
 export interface CommonSpecialExpressionNode<T extends SpecialExpressionName> extends GenericNode {
-    t: AstNodeType.SpecialExpression;
-    n: T;
+    type: 'SpecialExpression';
+    name: T;
+    params: AstNode[];
 }
 export interface NormalExpressionNodeWithName extends CommonNormalExpressionNode {
-    n: string;
+    name: string;
 }
 interface NormalExpressionNodeExpression extends CommonNormalExpressionNode {
-    n: undefined;
+    name: undefined;
 }
 export type NormalExpressionNode = NormalExpressionNodeWithName | NormalExpressionNodeExpression;
+interface CommonBindingTarget {
+    sourceCodeInfo: SourceCodeInfo | undefined;
+    default?: AstNode;
+}
+export type SymbolBindingTarget = CommonBindingTarget & {
+    type: 'symbol';
+    name: string;
+};
+export type RestBindingTarget = CommonBindingTarget & {
+    type: 'rest';
+    name: string;
+};
+export type ObjectBindingTarget = CommonBindingTarget & {
+    type: 'object';
+    elements: Record<string, BindingTarget>;
+};
+export type ArrayBindingTarget = CommonBindingTarget & {
+    type: 'array';
+    elements: (BindingTarget | null)[];
+};
+export type BindingTarget = SymbolBindingTarget | RestBindingTarget | ObjectBindingTarget | ArrayBindingTarget;
 export interface BindingNode extends GenericNode {
-    t: AstNodeType.Binding;
-    n: string;
-    v: AstNode;
+    type: 'Binding';
+    target: BindingTarget;
+    value: AstNode;
 }
 export interface ArgumentNode extends GenericNode {
-    t: AstNodeType.Argument;
-    n: string;
-    d?: AstNode;
+    type: 'Argument';
+    name: string;
+    default?: AstNode;
 }
 export interface CommentNode extends GenericNode {
-    t: AstNodeType.Comment;
-    v: string;
+    type: 'Comment';
+    value: string;
 }
-export type AstNode = NumberNode | StringNode | ReservedSymbolNode | SymbolNode | CommentNode | NormalExpressionNode | ModifierNode | SpecialExpressionNode;
+export type AstNode = NumberNode | StringNode | ReservedSymbolNode | SymbolNode | CommentNode | NormalExpressionNode | ModifierNode | SpecialExpressionNode | SpreadNode;
 type AstBody = AstNode[];
 export interface Ast {
-    b: AstBody;
+    body: AstBody;
     hasDebugData: boolean;
 }
 export {};

package/dist/src/symbolPatterns.d.ts

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

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

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

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

@@ -0,0 +1,12 @@
+declare const binaryOperators: readonly ["**", "*", "/", "%", "+", "-", "<<", ">>", ">>>", "++", "<", "<=", "≤", ">", ">=", "≥", "=", "!=", "≠", "&", "^", "|", "&&", "||", "??"];
+declare const symbolicOperators: readonly ["**", "*", "/", "%", "+", "-", "<<", ">>", ">>>", "++", "<", "<=", "≤", ">", ">=", "≥", "=", "!=", "≠", "&", "^", "|", "&&", "||", "??", "->", "...", ".", ",", ":=", ";"];
+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/src/tokenizer/reservedNames.d.ts

@@ -0,0 +1,115 @@
+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 DELTA: number;
+    readonly '-DELTA': number;
+    readonly δ: number;
+    readonly '-\u03B4': 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 DELTA: number;
+    readonly '-DELTA': number;
+    readonly δ: number;
+    readonly '-\u03B4': number;
+    readonly NaN: number;
+    readonly true: true;
+    readonly false: false;
+    readonly null: null;
+    readonly then: null;
+    readonly else: null;
+    readonly end: 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;
+};
+export declare const validReservedSymbolRecord: {
+    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 DELTA: number;
+    readonly '-DELTA': number;
+    readonly δ: number;
+    readonly '-\u03B4': number;
+    readonly NaN: number;
+    readonly true: true;
+    readonly false: false;
+    readonly null: null;
+    readonly then: null;
+    readonly else: null;
+    readonly end: 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;
+};
+export type ValidReservedSymbol = keyof typeof validReservedSymbolRecord;
+export type ReservedSymbol = keyof typeof reservedSymbolRecord;
+export declare function isReservedSymbol(symbol: string): symbol is keyof typeof validReservedSymbolRecord;
+export declare function isNumberReservedSymbol(symbol: string): symbol is keyof typeof numberReservedSymbolRecord;

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

@@ -0,0 +1,85 @@
+import type { ValidReservedSymbol } from './reservedNames';
+import { type SymbolicBinaryOperator, type SymbolicOperator } from './operators';
+export declare const tokenTypes: readonly ["LBrace", "LBracket", "RBrace", "RBracket", "LParen", "RParen", "BasePrefixedNumber", "MultiLineComment", "Number", "Operator", "RegexpShorthand", "ReservedSymbol", "SingleLineComment", "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 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 ValidReservedSymbol = ValidReservedSymbol> = GenericToken<'ReservedSymbol', T>;
+export type SingleLineCommentToken = GenericToken<'SingleLineComment'>;
+export type StringToken = GenericToken<'String'>;
+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 | MultiLineCommentToken | NumberToken | OperatorToken | RegexpShorthandToken | ReservedSymbolToken | SingleLineCommentToken | 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, symbolName?: T): token is SymbolToken<T>;
+export declare function assertSymbolToken<T extends string>(token: Token, symbolName?: T): asserts token is SymbolToken<T>;
+export declare function asSymbolToken<T extends string>(token: Token, symbolName?: T): SymbolToken<T>;
+export declare function isReservedSymbolToken<T extends ValidReservedSymbol>(token: Token, symbolName?: T): token is ReservedSymbolToken<T>;
+export declare function assertReservedSymbolToken<T extends ValidReservedSymbol>(token: Token, symbolName?: T): asserts token is ReservedSymbolToken<T>;
+export declare function asReservedSymbolToken<T extends ValidReservedSymbol>(token: Token, symbolName?: T): ReservedSymbolToken<T>;
+export declare function isSingleLineCommentToken(token: Token): token is SingleLineCommentToken;
+export declare function assertSingleLineCommentToken(token: Token): asserts token is SingleLineCommentToken;
+export declare function asSingleLineCommentToken(token: Token): SingleLineCommentToken;
+export declare function isMultiLineCommentToken(token: Token): token is MultiLineCommentToken;
+export declare function assertMultiLineCommentToken(token: Token): asserts token is MultiLineCommentToken;
+export declare function asMultiLineCommentToken(token: Token): MultiLineCommentToken;
+export declare function isOperatorToken<T extends SymbolicOperator>(token: Token, operatorName?: T): token is OperatorToken<T>;
+export declare function assertOperatorToken<T extends SymbolicOperator>(token: Token, operatorName?: T): asserts token is OperatorToken<T>;
+export declare function asOperatorToken<T extends SymbolicOperator>(token: Token, operatorName?: T): OperatorToken<T>;
+export declare function isWhitespaceToken(token: Token): token is WhitespaceToken;
+export declare function assertWhitespaceToken(token: Token): asserts token is WhitespaceToken;
+export declare function asWhitespaceToken(token: Token): WhitespaceToken;
+export declare function isNumberToken(token: Token): token is NumberToken;
+export declare function assertNumberToken(token: Token): asserts token is NumberToken;
+export declare function asNumberToken(token: Token): NumberToken;
+export declare function isBasePrefixedNumberToken(token: Token): token is BasePrefixedNumberToken;
+export declare function assertBasePrefixedNumberToken(token: Token): asserts token is BasePrefixedNumberToken;
+export declare function asBasePrefixedNumberToken(token: Token): BasePrefixedNumberToken;
+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 isRegexpShorthandToken(token: Token): token is RegexpShorthandToken;
+export declare function assertRegexpShorthandToken(token: Token): asserts token is RegexpShorthandToken;
+export declare function asRegexpShorthandToken(token: Token): RegexpShorthandToken;
+export declare function isA_BinaryOperatorToken(token: Token): token is OperatorToken<SymbolicBinaryOperator>;
+export declare function assertA_BinaryOperatorToken(token: Token): asserts token is OperatorToken<SymbolicBinaryOperator>;
+export declare function asA_BinaryOperatorToken(token: Token): OperatorToken<SymbolicBinaryOperator>;
+export {};

package/dist/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/src/tokenizer/tokenizers.d.ts

@@ -0,0 +1,12 @@
+import type { BasePrefixedNumberToken, 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>;
+export declare const NO_MATCH: TokenDescriptor<never>;
+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 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<StringToken>, Tokenizer<RegexpShorthandToken>, Tokenizer<BasePrefixedNumberToken>, Tokenizer<NumberToken>, Tokenizer<OperatorToken>, Tokenizer<SymbolToken>];

package/dist/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/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/src/typeGuards/astNode.d.ts

@@ -1,5 +1,5 @@
-import type { AstNode, ExpressionNode, NormalExpressionNode, NormalExpressionNodeWithName, SymbolNode } from '../parser/interface';
-import type { SourceCodeInfo } from '../tokenizer/interface';
+import type { AstNode, ExpressionNode, NormalExpressionNode, NormalExpressionNodeWithName, SymbolNode } from '../parser/types';
+import type { SourceCodeInfo } from '../tokenizer/token';
 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;

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

@@ -1,11 +1,15 @@
 import type { Count } from '../builtin/interface';
 import type { UnknownRecord } from '../interface';
-import type { GenericNode } from '../parser/interface';
-import type { SourceCodeInfo } from '../tokenizer/interface';
-export declare function assertNumberOfParams(count: Count, node: GenericNode): void;
+import type { AstNode, GenericNode } from '../parser/types';
+import type { SourceCodeInfo } from '../tokenizer/token';
+export declare function assertNumberOfParams(count: Count, node: GenericNode & {
+    params: AstNode[];
+    name: string;
+}): 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 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 canBeOperator(count: Count): boolean;

package/dist/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 { 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;

package/dist/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 { BuiltinFunction, LitsFunction, NativeJsFunction, 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;

package/dist/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/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/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/src/utils/debug/getCodeMarker.d.ts

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

package/dist/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/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/src/utils/index.d.ts

@@ -1,11 +1,13 @@
 import type { Any, Coll } from '../interface';
-import type { NativeJsFunction } from '../parser/interface';
-import type { SourceCodeInfo } from '../tokenizer/interface';
+import type { NativeJsFunction } from '../parser/types';
+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 compare<T extends string | number>(a: T, b: T, sourceCodeInfo: SourceCodeInfo | undefined): 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;
 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;