@mojir/lits 2.0.19 → 2.0.21

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

@@ -40,7 +40,9 @@ export declare class Lits {
     run(program: string, params?: LitsParams): unknown;
     context(program: string, params?: LitsParams): Context;
     analyze(program: string, params?: LitsParams): Analysis;
-    tokenize(program: string, tokenizeParams?: Pick<TokenizeParams, 'filePath'>): TokenStream;
+    tokenize(program: string, tokenizeParams?: Pick<TokenizeParams, 'filePath'> & {
+        minify?: boolean;
+    }): TokenStream;
     parse(tokenStream: TokenStream): Ast;
     evaluate(ast: Ast, params: LitsParams): Any;
     transform(tokenStream: TokenStream, transformer: (name: string) => string): TokenStream;

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

@@ -2,18 +2,22 @@ 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, ParseState, ParseToken, ParseTokensUntilClosingBracket } from '../parser/interface';
+import type { 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 Count = number | {
+    min?: number;
+    max?: number;
+    even?: boolean;
+    odd?: boolean;
+};
 export type NormalExpressionEvaluator<T> = (params: Arr, sourceCodeInfo: SourceCodeInfo | undefined, contextStack: ContextStack, { executeFunction }: {
     executeFunction: ExecuteFunction;
 }) => T;
-type ValidateNormalExpressionNode = (node: NormalExpressionNode) => void;
-type ValidateSpecialExpressionNode = (node: SpecialExpressionNode) => void;
 interface BuiltinNormalExpression<T> {
     evaluate: NormalExpressionEvaluator<T>;
-    validate?: ValidateNormalExpressionNode;
+    paramCount: Count;
 }
 export interface ParserHelpers {
     parseExpression: ParseExpression;
@@ -31,7 +35,7 @@ interface EvaluateHelpers {
 export interface BuiltinSpecialExpression<T, N extends SpecialExpressionNode> {
     polishParse: (tokenStream: TokenStream, parseState: ParseState, firstToken: Token, parsers: ParserHelpers) => N;
     evaluate: (node: N, contextStack: ContextStack, helpers: EvaluateHelpers) => T;
-    validateParameterCount: ValidateSpecialExpressionNode;
+    paramCount: Count;
     findUnresolvedIdentifiers: (node: N, contextStack: ContextStack, params: {
         findUnresolvedIdentifiers: FindUnresolvedIdentifiers;
         builtin: Builtin;

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

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

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

@@ -11,7 +11,6 @@ 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 {

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

@@ -8,4 +8,4 @@ export declare const tokenizeA_ReservedSymbolToken: Tokenizer<A_ReservedSymbolTo
 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<import("../common/commonTokens").RegexpShorthandToken>, Tokenizer<A_BasePrefixedNumberToken>, Tokenizer<A_NumberToken>, Tokenizer<A_OperatorToken>, Tokenizer<A_ReservedSymbolToken>, Tokenizer<A_SymbolToken>];
+export declare const algebraicTokenizers: [Tokenizer<A_WhitespaceToken>, Tokenizer<A_MultiLineCommentToken>, Tokenizer<A_SingleLineCommentToken>, 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<import("../common/commonTokens").RegexpShorthandToken>, Tokenizer<A_BasePrefixedNumberToken>, Tokenizer<A_NumberToken>, Tokenizer<A_OperatorToken>, Tokenizer<A_ReservedSymbolToken>, Tokenizer<A_SymbolToken>];

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

@@ -2,10 +2,10 @@ import type { CommonSimpleToken, CommonValueToken, CommonValueTokenType } from '
 import type { Token } from '../tokens';
 import { type TokenDebugData } from '../utils';
 import type { ValidAlgebraicReservedName } from './algebraicReservedNames';
-export declare const algebraicSimpleTokenTypes: readonly ["LBrace", "LBracket", "LParen", "RBrace", "RBracket", "RParen", "AlgNotation", "PolNotation", "EndNotation"];
+export declare const algebraicSimpleTokenTypes: readonly ["LBrace", "LBracket", "LParen", "RBrace", "RBracket", "RParen"];
 export declare const algebraicOnlyValueTokenTypes: ["A_Whitespace", "A_Operator", "A_Symbol", "A_ReservedSymbol", "A_SingleLineComment", "A_MultiLineComment", "A_Number", "A_BasePrefixedNumber"];
 export declare const algebraicValueTokenTypes: readonly ["String", "RegexpShorthand", "A_Whitespace", "A_Operator", "A_Symbol", "A_ReservedSymbol", "A_SingleLineComment", "A_MultiLineComment", "A_Number", "A_BasePrefixedNumber"];
-export declare const algebraicTokenTypes: readonly ["LBrace", "LBracket", "LParen", "RBrace", "RBracket", "RParen", "AlgNotation", "PolNotation", "EndNotation", "String", "RegexpShorthand", "A_Whitespace", "A_Operator", "A_Symbol", "A_ReservedSymbol", "A_SingleLineComment", "A_MultiLineComment", "A_Number", "A_BasePrefixedNumber"];
+export declare const algebraicTokenTypes: readonly ["LBrace", "LBracket", "LParen", "RBrace", "RBracket", "RParen", "String", "RegexpShorthand", "A_Whitespace", "A_Operator", "A_Symbol", "A_ReservedSymbol", "A_SingleLineComment", "A_MultiLineComment", "A_Number", "A_BasePrefixedNumber"];
 declare const symbolicUnaryOperators: readonly ["!", "~", "+", "-"];
 declare const symbolicBinaryOperators: readonly ["**", "*", "/", "%", "+", "-", "<<", ">>", ">>>", "++", "<", "<=", ">", ">=", "==", "!=", "&", "^", "|", "&&", "||", "??"];
 declare const symbolicOperators: readonly ["!", "~", "+", "-", "**", "*", "/", "%", "+", "-", "<<", ">>", ">>>", "++", "<", "<=", ">", ">=", "==", "!=", "&", "^", "|", "&&", "||", "??", "=>", "...", ".", ",", "=", ";"];

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

@@ -1,9 +1,9 @@
 import type { TokenDescriptor, Tokenizer } from '../interface';
 import type { SimpleToken } from '../tokens';
-import type { AlgebraicNotationToken, EndNotationToken, LBraceToken, LBracketToken, LParenToken, PolishNotationToken, RBraceToken, RBracketToken, RParenToken, RegexpShorthandToken, StringToken } from './commonTokens';
+import type { LBraceToken, LBracketToken, LParenToken, RBraceToken, RBracketToken, RParenToken, RegexpShorthandToken, 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 const tokenizeRegexpShorthand: Tokenizer<RegexpShorthandToken>;
 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>, Tokenizer<RegexpShorthandToken>];
+export declare const commonTokenizers: readonly [Tokenizer<LParenToken>, Tokenizer<RParenToken>, Tokenizer<LBracketToken>, Tokenizer<RBracketToken>, Tokenizer<LBraceToken>, Tokenizer<RBraceToken>, Tokenizer<StringToken>, Tokenizer<RegexpShorthandToken>];

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

@@ -1,6 +1,6 @@
 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 commonSimpleTokenTypes: readonly ["LBrace", "LBracket", "LParen", "RBrace", "RBracket", "RParen"];
 export declare const commomValueTokenTypes: readonly ["String", "RegexpShorthand"];
 export type CommonSimpleTokenType = typeof commonSimpleTokenTypes[number];
 export type CommonValueTokenType = typeof commomValueTokenTypes[number];
@@ -12,12 +12,9 @@ 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 RegexpShorthandToken = GenericCommonValueToken<'RegexpShorthand'>;
-export type CommonSimpleToken = LParenToken | RParenToken | LBracketToken | RBracketToken | LBraceToken | RBraceToken | AlgebraicNotationToken | PolishNotationToken | EndNotationToken;
+export type CommonSimpleToken = LParenToken | RParenToken | LBracketToken | RBracketToken | LBraceToken | RBraceToken;
 export type CommonValueToken = StringToken | RegexpShorthandToken;
 export declare function isLParenToken(token?: Token): token is LParenToken;
 export declare function assertLParenToken(token?: Token): asserts token is LParenToken;
@@ -43,13 +40,4 @@ 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 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/src/tokenizer/minifyTokenStream.d.ts

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

package/dist/src/tokenizer/polish/polishTokenizers.d.ts

@@ -10,4 +10,4 @@ export declare const tokenizeP_FnShorthand: Tokenizer<P_FnShorthandToken>;
 export declare const tokenizeP_ReservedSymbol: Tokenizer<P_ReservedSymbolToken>;
 export declare const tokenizeP_Modifier: Tokenizer<P_ModifierToken>;
 export declare const tokenizeP_CollectionAccessor: Tokenizer<P_CollectionAccessorToken>;
-export declare const polishTokenizers: [Tokenizer<P_WhitespaceToken>, Tokenizer<P_CommentToken>, 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<import("../common/commonTokens").RegexpShorthandToken>, Tokenizer<P_StringShorthandToken>, Tokenizer<P_NumberToken>, Tokenizer<P_ReservedSymbolToken>, Tokenizer<P_ModifierToken>, Tokenizer<P_SymbolToken>, Tokenizer<P_FnShorthandToken>, Tokenizer<P_CollectionAccessorToken>];
+export declare const polishTokenizers: [Tokenizer<P_WhitespaceToken>, Tokenizer<P_CommentToken>, 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<import("../common/commonTokens").RegexpShorthandToken>, Tokenizer<P_StringShorthandToken>, Tokenizer<P_NumberToken>, Tokenizer<P_ReservedSymbolToken>, Tokenizer<P_ModifierToken>, Tokenizer<P_SymbolToken>, Tokenizer<P_FnShorthandToken>, Tokenizer<P_CollectionAccessorToken>];

package/dist/src/tokenizer/polish/polishTokens.d.ts

@@ -4,10 +4,10 @@ import { type TokenDebugData } from '../utils';
 export declare const modifierNames: readonly ["&rest", "&let", "&when", "&while"];
 export type ModifierName = typeof modifierNames[number];
 export declare const polishOnlySimpleTokenTypes: ["P_FnShorthand"];
-export declare const polishSimpleTokenTypes: readonly ["LBrace", "LBracket", "LParen", "RBrace", "RBracket", "RParen", "AlgNotation", "PolNotation", "EndNotation", "P_FnShorthand"];
+export declare const polishSimpleTokenTypes: readonly ["LBrace", "LBracket", "LParen", "RBrace", "RBracket", "RParen", "P_FnShorthand"];
 export declare const polishOnlyValueTokenTypes: ["P_Modifier", "P_StringShorthand", "P_Symbol", "P_ReservedSymbol", "P_CollectionAccessor", "P_Comment", "P_Whitespace", "P_Number"];
 export declare const polishValueTokenTypes: readonly ["String", "RegexpShorthand", "P_Modifier", "P_StringShorthand", "P_Symbol", "P_ReservedSymbol", "P_CollectionAccessor", "P_Comment", "P_Whitespace", "P_Number"];
-export declare const polishTokenTypes: readonly ["LBrace", "LBracket", "LParen", "RBrace", "RBracket", "RParen", "AlgNotation", "PolNotation", "EndNotation", "P_FnShorthand", "String", "RegexpShorthand", "P_Modifier", "P_StringShorthand", "P_Symbol", "P_ReservedSymbol", "P_CollectionAccessor", "P_Comment", "P_Whitespace", "P_Number"];
+export declare const polishTokenTypes: readonly ["LBrace", "LBracket", "LParen", "RBrace", "RBracket", "RParen", "P_FnShorthand", "String", "RegexpShorthand", "P_Modifier", "P_StringShorthand", "P_Symbol", "P_ReservedSymbol", "P_CollectionAccessor", "P_Comment", "P_Whitespace", "P_Number"];
 export type PolishSimpleTokenType = typeof polishSimpleTokenTypes[number];
 export type PolishValueTokenType = typeof polishValueTokenTypes[number];
 export type PolishTokenType = typeof polishTokenTypes[number];

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

@@ -1,9 +1,9 @@
 import type { CommonSimpleToken, CommonValueToken } from './common/commonTokens';
 import type { AlgebraicOnlyValueToken } from './algebraic/algebraicTokens';
 import type { PolishOnlySimpleToken, PolishOnlyValueToken } from './polish/polishTokens';
-export declare const simpleTokenTypes: readonly ["LBrace", "LBracket", "LParen", "RBrace", "RBracket", "RParen", "AlgNotation", "PolNotation", "EndNotation", "P_FnShorthand"];
+export declare const simpleTokenTypes: readonly ["LBrace", "LBracket", "LParen", "RBrace", "RBracket", "RParen", "P_FnShorthand"];
 export declare const valueTokenTypes: readonly ["String", "RegexpShorthand", "A_Whitespace", "A_Operator", "A_Symbol", "A_ReservedSymbol", "A_SingleLineComment", "A_MultiLineComment", "A_Number", "A_BasePrefixedNumber", "P_Modifier", "P_StringShorthand", "P_Symbol", "P_ReservedSymbol", "P_CollectionAccessor", "P_Comment", "P_Whitespace", "P_Number"];
-export declare const tokenTypes: readonly ["LBrace", "LBracket", "LParen", "RBrace", "RBracket", "RParen", "AlgNotation", "PolNotation", "EndNotation", "P_FnShorthand", "String", "RegexpShorthand", "A_Whitespace", "A_Operator", "A_Symbol", "A_ReservedSymbol", "A_SingleLineComment", "A_MultiLineComment", "A_Number", "A_BasePrefixedNumber", "P_Modifier", "P_StringShorthand", "P_Symbol", "P_ReservedSymbol", "P_CollectionAccessor", "P_Comment", "P_Whitespace", "P_Number"];
+export declare const tokenTypes: readonly ["LBrace", "LBracket", "LParen", "RBrace", "RBracket", "RParen", "P_FnShorthand", "String", "RegexpShorthand", "A_Whitespace", "A_Operator", "A_Symbol", "A_ReservedSymbol", "A_SingleLineComment", "A_MultiLineComment", "A_Number", "A_BasePrefixedNumber", "P_Modifier", "P_StringShorthand", "P_Symbol", "P_ReservedSymbol", "P_CollectionAccessor", "P_Comment", "P_Whitespace", "P_Number"];
 export type TokenType = typeof tokenTypes[number];
 export type SimpleToken = CommonSimpleToken | PolishOnlySimpleToken;
 export type ValueToken = CommonValueToken | AlgebraicOnlyValueToken | PolishOnlyValueToken;

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

@@ -1,12 +1,7 @@
+import type { Count } from '../builtin/interface';
 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 assertOddNumberOfParams(node: GenericNode): void;
 export declare function assertNumberOfParams(count: Count, node: GenericNode): void;
 export declare function isNonUndefined<T>(value: T | undefined): value is T;
 export declare function asNonUndefined<T>(value: T | undefined, sourceCodeInfo?: SourceCodeInfo): T;
@@ -14,4 +9,3 @@ export declare function assertNonUndefined<T>(value: T | undefined, sourceCodeIn
 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 {};