@mojir/lits 2.1.1 → 2.1.3

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

@@ -9,7 +9,6 @@ export declare const api: {
     readonly object: readonly ["dissoc", "keys", "vals", "entries", "find", "merge", "merge-with", "zipmap", "select-keys"];
     readonly predicate: readonly ["boolean?", "null?", "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?"];
     readonly regularExpression: readonly ["regexp", "match", "replace", "replace-all"];
-    readonly specialExpressions: readonly ["&&", "||", "def", "let", "fn", "defn", "function", "try", "throw", "if", "unless", "cond", "switch", "do", "recur", "loop", "doseq", "for", "defined?", "??"];
     readonly string: readonly ["string-repeat", "str", "number", "lower-case", "upper-case", "trim", "trim-left", "trim-right", "pad-left", "pad-right", "split", "split-lines", "template", "to-char-code", "from-char-code", "encode-base64", "decode-base64", "encode-uri-component", "decode-uri-component", "join", "capitalize", "blank?"];
     readonly bitwise: readonly ["<<", ">>", ">>>", "~", "&", "bit-and-not", "|", "^", "bit-flip", "bit-clear", "bit-set", "bit-test"];
     readonly assert: readonly ["assert", "assert=", "assert!=", "assert-gt", "assert-lt", "assert-gte", "assert-lte", "assert-true", "assert-false", "assert-truthy", "assert-falsy", "assert-null", "assert-throws", "assert-throws-error", "assert-not-throws"];

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

@@ -1,4 +1,5 @@
 import type { Any } from '../interface';
 import { type BindingTarget, type Node } from '../parser/types';
+export declare function walkDefaults(bindingTarget: BindingTarget, onDefault: (Node: Node) => void): void;
 export declare function evalueateBindingNodeValues(target: BindingTarget, value: Any, evaluate: (Node: Node) => Any): Record<string, Any>;
 export declare function getAllBindingTargetNames(bindingTarget: BindingTarget): Record<string, true>;

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

@@ -28,6 +28,7 @@ export interface EvaluateHelpers {
 }
 export interface BuiltinSpecialExpression<T, N extends SpecialExpressionNode> {
     evaluate: (node: N, contextStack: ContextStack, helpers: EvaluateHelpers) => T;
+    evaluateAsNormalExpression?: NormalExpressionEvaluator<T>;
     paramCount: Count;
     getUndefinedSymbols: (node: N, contextStack: ContextStack, params: {
         getUndefinedSymbols: GetUndefinedSymbols;

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

@@ -1,16 +1,15 @@
-import type { SpecialExpressionName, SpecialExpressionType } from '.';
 export declare const specialExpressionTypes: {
     readonly '??': 0;
     readonly '&&': 1;
     readonly '||': 2;
     readonly array: 3;
     readonly cond: 4;
-    readonly def: 5;
+    readonly '0_def': 5;
     readonly 'defined?': 6;
-    readonly defn: 7;
+    readonly '0_defn': 7;
     readonly do: 8;
     readonly doseq: 9;
-    readonly fn: 10;
+    readonly '0_fn': 10;
     readonly for: 11;
     readonly function: 12;
     readonly if: 13;
@@ -24,4 +23,3 @@ export declare const specialExpressionTypes: {
     readonly unless: 21;
 };
 export type SpecialExpressionTypes = typeof specialExpressionTypes;
-export declare function getNameFromSpecialExpressionType(type: SpecialExpressionType): SpecialExpressionName;

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

@@ -1,5 +1,5 @@
 import type { BindingNode, SpecialExpressionNode } from '../../parser/types';
 import type { BuiltinSpecialExpression } from '../interface';
 import type { specialExpressionTypes } from '../specialExpressionTypes';
-export type DefNode = SpecialExpressionNode<[typeof specialExpressionTypes['def'], BindingNode]>;
+export type DefNode = SpecialExpressionNode<[typeof specialExpressionTypes['0_def'], BindingNode]>;
 export declare const defSpecialExpression: BuiltinSpecialExpression<null, DefNode>;

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

@@ -2,9 +2,9 @@ import type { LitsFunction, SpecialExpressionNode, SymbolNode } from '../../pars
 import type { BuiltinSpecialExpression } from '../interface';
 import type { Function } from '../utils';
 import type { specialExpressionTypes } from '../specialExpressionTypes';
-export type DefnNode = SpecialExpressionNode<[typeof specialExpressionTypes['defn'], SymbolNode, Function]>;
+export type DefnNode = SpecialExpressionNode<[typeof specialExpressionTypes['0_defn'], SymbolNode, Function]>;
 export type FunctionNode = SpecialExpressionNode<[typeof specialExpressionTypes['function'], SymbolNode, Function]>;
-export type FnNode = SpecialExpressionNode<[typeof specialExpressionTypes['fn'], Function]>;
+export type FnNode = SpecialExpressionNode<[typeof specialExpressionTypes['0_fn'], Function]>;
 export declare const functionSpecialExpression: BuiltinSpecialExpression<null, FunctionNode>;
 export declare const defnSpecialExpression: BuiltinSpecialExpression<null, DefnNode>;
 export declare const fnSpecialExpression: BuiltinSpecialExpression<LitsFunction, FnNode>;

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

@@ -13,7 +13,7 @@ export declare const NodeTypes: {
 export type NodeType = typeof NodeTypes[keyof typeof NodeTypes];
 export declare function getNodeTypeName(type: NodeType): keyof typeof NodeTypes;
 export declare function isNodeType(type: unknown): type is NodeType;
-declare const functionTypes: readonly ["UserDefined", "Partial", "Comp", "Constantly", "Juxt", "Complement", "EveryPred", "SomePred", "Fnull", "Builtin", "NativeJsFunction"];
+declare const functionTypes: readonly ["UserDefined", "Partial", "Comp", "Constantly", "Juxt", "Complement", "EveryPred", "SomePred", "Fnull", "Builtin", "SpecialBuiltin", "NativeJsFunction"];
 export type FunctionType = typeof functionTypes[number];
 export declare function isFunctionType(type: unknown): type is FunctionType;
 export {};

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

@@ -1,6 +1,7 @@
 import type { Any } from '../interface';
 import type { ContextParams, LazyValue } from '../Lits/Lits';
 import type { NativeJsFunction, SymbolNode, UserDefinedSymbolNode } from '../parser/types';
+import type { SourceCodeInfo } from '../tokenizer/token';
 import type { Context, LookUpResult } from './interface';
 export type ContextStack = ContextStackImpl;
 export declare class ContextStackImpl {
@@ -17,8 +18,8 @@ export declare class ContextStackImpl {
     });
     create(context: Context): ContextStack;
     new(context: Context): ContextStack;
-    exportValues(values: Record<string, Any>): void;
-    addValues(values: Record<string, Any>): void;
+    exportValues(values: Record<string, Any>, sourceCodeInfo: SourceCodeInfo | undefined): void;
+    addValues(values: Record<string, Any>, sourceCodeInfo: SourceCodeInfo | undefined): void;
     getValue(name: string): unknown;
     lookUp(node: UserDefinedSymbolNode): LookUpResult;
     evaluateSymbol(node: SymbolNode): Any;

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

@@ -1,5 +1,5 @@
 import type { Any, Arr } from '../interface';
-import { type LitsFunctionType } from '../parser/types';
+import type { LitsFunctionType } from '../parser/types';
 import type { SourceCodeInfo } from '../tokenizer/token';
 import type { ContextStack } from './ContextStack';
 import type { EvaluateNode, ExecuteFunction } from './interface';

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

@@ -1,5 +1,6 @@
 import type { JsFunction } from '../Lits/Lits';
 import type { SpecialExpressionType } from '../builtin';
+import type { specialExpressionTypes } from '../builtin/specialExpressionTypes';
 import type { FunctionType, NodeType, NodeTypes } from '../constants/constants';
 import type { Context } from '../evaluator/interface';
 import type { Any, Arr } from '../interface';
@@ -69,7 +70,11 @@ export interface NormalBuiltinFunction extends GenericLitsFunction {
     functionType: 'Builtin';
     normalBuitinSymbolType: number;
 }
-export type LitsFunction = NativeJsFunction | UserDefinedFunction | NormalBuiltinFunction | PartialFunction | CompFunction | ConstantlyFunction | JuxtFunction | ComplementFunction | EveryPredFunction | SomePredFunction | FNullFunction;
+export interface SpecialBuiltinFunction extends GenericLitsFunction {
+    functionType: 'SpecialBuiltin';
+    specialBuiltinSymbolType: typeof specialExpressionTypes['&&'] | typeof specialExpressionTypes['||'] | typeof specialExpressionTypes['array'] | typeof specialExpressionTypes['object'] | typeof specialExpressionTypes['defined?'] | typeof specialExpressionTypes['recur'] | typeof specialExpressionTypes['throw'] | typeof specialExpressionTypes['??'];
+}
+export type LitsFunction = NativeJsFunction | UserDefinedFunction | NormalBuiltinFunction | SpecialBuiltinFunction | PartialFunction | CompFunction | ConstantlyFunction | JuxtFunction | ComplementFunction | EveryPredFunction | SomePredFunction | FNullFunction;
 export type LitsFunctionType = LitsFunction['functionType'];
 export type DebugData = {
     token: Token;

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

@@ -24,11 +24,11 @@ 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?: {
+    position: {
         line: number;
         column: number;
     };
-    code?: string;
+    code: string;
     filePath?: string;
 }
 export declare function isSymbolToken<T extends string>(token: Token, symbolName?: T): token is SymbolToken<T>;

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

@@ -1,4 +1,3 @@
-import type { SpecialExpressionName } from '../builtin';
 import type { ExpressionNode, Node, NormalBuiltinSymbolNode, NormalExpressionNode, NormalExpressionNodeWithName, SpecialBuiltinSymbolNode, SpreadNode, SymbolNode, UserDefinedSymbolNode } from '../parser/types';
 import type { SourceCodeInfo } from '../tokenizer/token';
 export declare function isSymbolNode(node: Node): node is SymbolNode;
@@ -8,11 +7,7 @@ export declare function isUserDefinedSymbolNode(node: Node): node is UserDefined
 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 asNormalBuiltinSymbolNode(node: Node, sourceCodeInfo?: SourceCodeInfo): NormalBuiltinSymbolNode;
-export declare function assertNormalBuiltinSymbolNode(node: Node, sourceCodeInfo?: SourceCodeInfo): asserts node is NormalBuiltinSymbolNode;
-export declare function isSpecialBuiltinSymbolNode(node: Node, name?: SpecialExpressionName): node is SpecialBuiltinSymbolNode;
-export declare function asSpecialBuiltinSymbolNode(node: Node, sourceCodeInfo?: SourceCodeInfo): SpecialBuiltinSymbolNode;
-export declare function assertSpecialBuiltinSymbolNode(node: Node, sourceCodeInfo?: SourceCodeInfo): asserts node is SpecialBuiltinSymbolNode;
+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;