@mojir/lits 2.1.0 → 2.1.2

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

@@ -1,19 +1,15 @@
 import type { JsFunction } from '../Lits/Lits';
-import type { SpecialExpressionName, SpecialExpressionNode } from '../builtin';
-import type { AstNodeType, FunctionType } from '../constants/constants';
+import type { SpecialExpressionType } from '../builtin';
+import type { FunctionType, NodeType, NodeTypes } from '../constants/constants';
 import type { Context } from '../evaluator/interface';
 import type { Any, Arr } from '../interface';
-import type { TokenStream } from '../tokenizer/tokenize';
-import type { ModifierName, SourceCodeInfo, Token } from '../tokenizer/token';
+import type { ReservedSymbol } from '../tokenizer/reservedNames';
+import type { SourceCodeInfo, Token } from '../tokenizer/token';
 import type { FUNCTION_SYMBOL, REGEXP_SYMBOL } from '../utils/symbols';
 export interface ParseState {
     position: number;
 }
-export interface EvaluatedFunction {
-    arguments: BindingTarget[];
-    body: AstNode[];
-    context: Context;
-}
+export type EvaluatedFunction = [BindingTarget[], Node[], Context];
 interface GenericLitsFunction {
     [FUNCTION_SYMBOL]: true;
     sourceCodeInfo?: SourceCodeInfo;
@@ -69,104 +65,45 @@ export interface FNullFunction extends GenericLitsFunction {
     function: Any;
     params: Arr;
 }
-export interface BuiltinFunction extends GenericLitsFunction {
+export interface NormalBuiltinFunction extends GenericLitsFunction {
     functionType: 'Builtin';
-    n: string;
+    normalBuitinSymbolType: number;
 }
-export type LitsFunction = NativeJsFunction | UserDefinedFunction | BuiltinFunction | PartialFunction | CompFunction | ConstantlyFunction | JuxtFunction | ComplementFunction | EveryPredFunction | SomePredFunction | FNullFunction;
+export type LitsFunction = NativeJsFunction | UserDefinedFunction | NormalBuiltinFunction | PartialFunction | CompFunction | ConstantlyFunction | JuxtFunction | ComplementFunction | EveryPredFunction | SomePredFunction | FNullFunction;
 export type LitsFunctionType = LitsFunction['functionType'];
 export type DebugData = {
     token: Token;
     nameToken?: Token;
 };
-export interface GenericNode {
-    type: AstNodeType;
-    sourceCodeInfo?: SourceCodeInfo | undefined;
-}
+export type Node<T extends NodeType = NodeType, Payload = unknown> = [T, Payload] | [T, Payload, SourceCodeInfo];
 export type ExpressionNode = NormalExpressionNode | SpecialExpressionNode | NumberNode | StringNode;
-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 SpreadNode extends GenericNode {
-    type: 'Spread';
-    value: AstNode;
-}
-export interface NumberNode extends GenericNode {
-    type: 'Number';
-    value: number;
-}
-export interface StringNode extends GenericNode {
-    type: 'String';
-    value: string;
-}
-export interface SymbolNode extends GenericNode {
-    type: 'Symbol';
-    value: string;
-}
-export interface ModifierNode extends GenericNode {
-    type: 'Modifier';
-    value: ModifierName;
-}
-export interface ReservedSymbolNode extends GenericNode {
-    type: 'ReservedSymbol';
-    value: string;
-}
-interface CommonNormalExpressionNode extends GenericNode {
-    type: 'NormalExpression';
-    params: AstNode[];
-}
-export interface CommonSpecialExpressionNode<T extends SpecialExpressionName> extends GenericNode {
-    type: 'SpecialExpression';
-    name: T;
-    params: AstNode[];
-}
-export interface NormalExpressionNodeWithName extends CommonNormalExpressionNode {
-    name: string;
-}
-interface NormalExpressionNodeExpression extends CommonNormalExpressionNode {
-    name: undefined;
-}
+export type SpreadNode = Node<typeof NodeTypes.Spread, Node>;
+export type NumberNode = Node<typeof NodeTypes.Number, number>;
+export type StringNode = Node<typeof NodeTypes.String, string>;
+export type UserDefinedSymbolNode = Node<typeof NodeTypes.UserDefinedSymbol, string>;
+export type NormalBuiltinSymbolNode = Node<typeof NodeTypes.NormalBuiltinSymbol, number>;
+export type SpecialBuiltinSymbolNode = Node<typeof NodeTypes.SpecialBuiltinSymbol, SpecialExpressionType>;
+export type SymbolNode = UserDefinedSymbolNode | NormalBuiltinSymbolNode | SpecialBuiltinSymbolNode;
+export type ReservedSymbolNode = Node<typeof NodeTypes.ReservedSymbol, ReservedSymbol>;
+export type SpecialExpressionNode<T extends [SpecialExpressionType, ...unknown[]] = [SpecialExpressionType, ...unknown[]]> = Node<typeof NodeTypes.SpecialExpression, T>;
+export type NormalExpressionNodeWithName = Node<typeof NodeTypes.NormalExpression, [NormalBuiltinSymbolNode | UserDefinedSymbolNode, Node[]]>;
+export type NormalExpressionNodeExpression = Node<typeof NodeTypes.NormalExpression, [Node, Node[]]>;
 export type NormalExpressionNode = NormalExpressionNodeWithName | NormalExpressionNodeExpression;
-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 declare const bindingTargetTypes: {
+    readonly symbol: 11;
+    readonly rest: 12;
+    readonly object: 13;
+    readonly array: 14;
 };
+export type BindingTargetType = typeof bindingTargetTypes[keyof typeof bindingTargetTypes];
+type GenericTarget<T extends BindingTargetType, Payload extends unknown[]> = [T, Payload] | [T, Payload, SourceCodeInfo];
+export type SymbolBindingTarget = GenericTarget<typeof bindingTargetTypes.symbol, [SymbolNode, Node | undefined]>;
+export type RestBindingTarget = GenericTarget<typeof bindingTargetTypes.rest, [string, Node | undefined]>;
+export type ObjectBindingTarget = GenericTarget<typeof bindingTargetTypes.object, [Record<string, BindingTarget>, Node | undefined]>;
+export type ArrayBindingTarget = GenericTarget<typeof bindingTargetTypes.array, [(BindingTarget | null)[], Node | undefined]>;
 export type BindingTarget = SymbolBindingTarget | RestBindingTarget | ObjectBindingTarget | ArrayBindingTarget;
-export interface BindingNode extends GenericNode {
-    type: 'Binding';
-    target: BindingTarget;
-    value: AstNode;
-}
-export interface ArgumentNode extends GenericNode {
-    type: 'Argument';
-    name: string;
-    default?: AstNode;
-}
-export interface CommentNode extends GenericNode {
-    type: 'Comment';
-    value: string;
-}
-export type AstNode = NumberNode | StringNode | ReservedSymbolNode | SymbolNode | CommentNode | NormalExpressionNode | ModifierNode | SpecialExpressionNode | SpreadNode;
-type AstBody = AstNode[];
+export type BindingNode = Node<typeof NodeTypes.Binding, [BindingTarget, Node]>;
+type AstBody = Node[];
 export interface Ast {
     body: AstBody;
     hasDebugData: boolean;

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

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

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

@@ -1,11 +1,8 @@
 import type { Count } from '../builtin/interface';
 import type { UnknownRecord } from '../interface';
-import type { AstNode, GenericNode } from '../parser/types';
+import type { NormalExpressionNodeWithName } 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 assertNumberOfParams(count: Count, node: NormalExpressionNodeWithName): 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;

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

@@ -1,4 +1,4 @@
-import type { BuiltinFunction, LitsFunction, NativeJsFunction, UserDefinedFunction } from '../parser/types';
+import type { LitsFunction, NativeJsFunction, NormalBuiltinFunction, UserDefinedFunction } from '../parser/types';
 import type { SourceCodeInfo } from '../tokenizer/token';
 export declare function isLitsFunction(value: unknown): value is LitsFunction;
 export declare function asLitsFunction(value: unknown, sourceCodeInfo?: SourceCodeInfo): LitsFunction;
@@ -9,4 +9,4 @@ export declare function assertUserDefinedFunction(value: unknown, sourceCodeInfo
 export declare function isNativeJsFunction(value: unknown): value is NativeJsFunction;
 export declare function asNativeJsFunction(value: unknown, sourceCodeInfo?: SourceCodeInfo): NativeJsFunction;
 export declare function assertNativeJsFunction(value: unknown, sourceCodeInfo?: SourceCodeInfo): asserts value is NativeJsFunction;
-export declare function isBuiltinFunction(value: unknown): value is BuiltinFunction;
+export declare function isBuiltinFunction(value: unknown): value is NormalBuiltinFunction;

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

@@ -8,6 +8,5 @@ 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;