@mojir/lits 1.1.0 → 1.2.1-alpha.0

package/dist/cli/common/utils.d.ts

@@ -1,3 +1,2 @@
-export declare function throttle<T extends (...args: any[]) => void>(func: T): (this: any, ...args: Parameters<T>) => void;
 export declare function stringifyValue(value: unknown, html: boolean): string;
 export declare function findAllOccurrences(input: string, pattern: RegExp): Set<string>;

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

@@ -52,7 +52,7 @@ export declare const categoryRecord: {
     readonly Datatype: true;
 };
 export type Category = keyof typeof categoryRecord;
-export declare const categories: ("String" | "Functional" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Array" | "Object" | "Math" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Shorthand" | "Datatype")[];
+export declare const categories: Category[];
 declare const dataTypes: readonly ["number", "string", "object", "array", "boolean", "function", "integer", "any", "nil", "collection", "sequence", "regexp", "never"];
 export type DataType = typeof dataTypes[number];
 export declare function isDataType(arg: string): arg is DataType;

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

@@ -5,12 +5,7 @@ export interface Example {
     code: string;
     context?: {
         values?: Record<string, unknown>;
-        lazyValues?: Record<string, {
-            read: string;
-        }>;
-        jsFunctions?: Record<string, {
-            fn: string;
-        }>;
+        jsFunctions?: Record<string, string>;
     };
 }
 export declare const examples: Example[];

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

@@ -1,9 +1,8 @@
-import type { AnalyzeResult } from '../analyze/interface';
-import { ContextStack } from '../evaluator/ContextStack';
+import type { Analysis } from '../analyze';
 import type { Context } from '../evaluator/interface';
 import type { Any } from '../interface';
 import type { Ast, LitsFunction } from '../parser/interface';
-import type { TokenStream } from '../tokenizer/interface';
+import type { TokenStream, TokenizeParams } from '../tokenizer/interface';
 import { Cache } from './Cache';
 export interface LitsRuntimeInfo {
     astCache: Cache | null;
@@ -25,12 +24,16 @@ export interface LitsParams {
     lazyValues?: Record<string, LazyValue>;
     jsFunctions?: Record<string, JsFunction>;
     filePath?: string;
+    debug?: boolean;
 }
 interface LitsConfig {
     initialCache?: Record<string, Ast>;
     astCacheSize?: number | null;
     debug?: boolean;
 }
+type FormatParams = LitsParams & {
+    lineLength?: number;
+};
 export declare class Lits {
     private astCache;
     private astCacheSize;
@@ -38,13 +41,13 @@ export declare class Lits {
     constructor(config?: LitsConfig);
     getRuntimeInfo(): LitsRuntimeInfo;
     run(program: string, params?: LitsParams): unknown;
+    format(program: string, params?: FormatParams): string;
     context(program: string, params?: LitsParams): Context;
-    analyze(program: string): AnalyzeResult;
-    tokenize(program: string, filePath?: string): TokenStream;
+    analyze(program: string, params?: LitsParams): Analysis;
+    tokenize(program: string, tokenizeParams?: TokenizeParams): TokenStream;
     parse(tokenStream: TokenStream): Ast;
-    private evaluate;
+    evaluate(ast: Ast, params: LitsParams): Any;
     apply(fn: LitsFunction, fnParams: unknown[], params?: LitsParams): Any;
     private generateAst;
 }
-export declare function createContextStack(params?: LitsParams): ContextStack;
 export {};

package/dist/cli/src/analyze/calculateOutcomes/calculateAndOutcomes.d.ts

@@ -0,0 +1,3 @@
+import type { AndNode } from '../../builtin/specialExpressions/and';
+import type { CalculatePossibleAstNodesHelper } from '.';
+export declare const calculateAndOutcomes: CalculatePossibleAstNodesHelper<AndNode>;

package/dist/cli/src/analyze/calculateOutcomes/calculateCommentOutcomes.d.ts

@@ -0,0 +1,3 @@
+import type { CommentExpressionNode } from '../../builtin/specialExpressions/comment';
+import type { CalculatePossibleAstNodesHelper } from '.';
+export declare const calculateCommentOutcomes: CalculatePossibleAstNodesHelper<CommentExpressionNode>;

package/dist/cli/src/analyze/calculateOutcomes/calculateCondOutcomes.d.ts

@@ -0,0 +1,3 @@
+import type { CondNode } from '../../builtin/specialExpressions/cond';
+import type { CalculatePossibleAstNodesHelper } from '.';
+export declare const calculateCondOutcomes: CalculatePossibleAstNodesHelper<CondNode>;

package/dist/cli/src/analyze/calculateOutcomes/calculateDeclaredOutcomes.d.ts

@@ -0,0 +1,3 @@
+import type { DeclaredNode } from '../../builtin/specialExpressions/declared';
+import type { CalculatePossibleAstNodesHelper } from '.';
+export declare const calculateDeclaredOutcomes: CalculatePossibleAstNodesHelper<DeclaredNode>;

package/dist/cli/src/analyze/calculateOutcomes/calculateDefOutcomes.d.ts

@@ -0,0 +1,3 @@
+import type { DefNode } from '../../builtin/specialExpressions/def';
+import type { CalculatePossibleAstNodesHelper } from '.';
+export declare const calculateDefOutcomes: CalculatePossibleAstNodesHelper<DefNode>;

package/dist/cli/src/analyze/calculateOutcomes/calculateDefsOutcomes.d.ts

@@ -0,0 +1,3 @@
+import type { DefsNode } from '../../builtin/specialExpressions/defs';
+import type { CalculatePossibleAstNodesHelper } from '.';
+export declare const calculateDefsOutcomes: CalculatePossibleAstNodesHelper<DefsNode>;

package/dist/cli/src/analyze/calculateOutcomes/calculateDoOutcomes.d.ts

@@ -0,0 +1,3 @@
+import type { DoNode } from '../../builtin/specialExpressions/do';
+import type { CalculatePossibleAstNodesHelper } from '.';
+export declare const calculateDoOutcomes: CalculatePossibleAstNodesHelper<DoNode>;

package/dist/cli/src/analyze/calculateOutcomes/calculateFunctionOutcomes.d.ts

@@ -0,0 +1,5 @@
+import type { DefnNode, DefnsNode, FnNode } from '../../builtin/specialExpressions/functions';
+import type { CalculatePossibleAstNodesHelper } from '.';
+export declare const calculateDefnOutcomes: CalculatePossibleAstNodesHelper<DefnNode>;
+export declare const calculateDefnsOutcomes: CalculatePossibleAstNodesHelper<DefnsNode>;
+export declare const calculateFnOutcomes: CalculatePossibleAstNodesHelper<FnNode>;

package/dist/cli/src/analyze/calculateOutcomes/calculateIfLetOutcomes.d.ts

@@ -0,0 +1,3 @@
+import type { IfLetNode } from '../../builtin/specialExpressions/if-let';
+import type { CalculatePossibleAstNodesHelper } from '.';
+export declare const calculateIfLetOutcomes: CalculatePossibleAstNodesHelper<IfLetNode>;

package/dist/cli/src/analyze/calculateOutcomes/calculateIfNotOutcomes.d.ts

@@ -0,0 +1,3 @@
+import type { IfNotNode } from '../../builtin/specialExpressions/if-not';
+import type { CalculatePossibleAstNodesHelper } from '.';
+export declare const calculateIfNotOutcomes: CalculatePossibleAstNodesHelper<IfNotNode>;

package/dist/cli/src/analyze/calculateOutcomes/calculateIfOutcomes.d.ts

@@ -0,0 +1,3 @@
+import type { IfNode } from '../../builtin/specialExpressions/if';
+import type { CalculatePossibleAstNodesHelper } from '.';
+export declare const calculateIfOutcomes: CalculatePossibleAstNodesHelper<IfNode>;

package/dist/cli/src/analyze/calculateOutcomes/calculateLetOutcomes.d.ts

@@ -0,0 +1,3 @@
+import type { LetNode } from '../../builtin/specialExpressions/let';
+import type { CalculatePossibleAstNodesHelper } from '.';
+export declare const calculateLetOutcomes: CalculatePossibleAstNodesHelper<LetNode>;

package/dist/cli/src/analyze/calculateOutcomes/calculateLoopOutcomes.d.ts

@@ -0,0 +1,3 @@
+import type { LoopNode } from '../../builtin/specialExpressions/loop';
+import type { CalculatePossibleAstNodesHelper } from '.';
+export declare const calculateLoopOutcomes: CalculatePossibleAstNodesHelper<LoopNode>;

package/dist/cli/src/analyze/calculateOutcomes/calculateLoopsOutcomes.d.ts

@@ -0,0 +1,4 @@
+import type { DoSeqNode, ForNode } from '../../builtin/specialExpressions/loops';
+import type { CalculatePossibleAstNodesHelper } from '.';
+export declare const calculateForOutcomes: CalculatePossibleAstNodesHelper<ForNode>;
+export declare const calculateDoSeqOutcomes: CalculatePossibleAstNodesHelper<DoSeqNode>;

package/dist/cli/src/analyze/calculateOutcomes/calculateOrOutcomes.d.ts

@@ -0,0 +1,3 @@
+import type { OrNode } from '../../builtin/specialExpressions/or';
+import type { CalculatePossibleAstNodesHelper } from '.';
+export declare const calculateOrOutcomes: CalculatePossibleAstNodesHelper<OrNode>;

package/dist/cli/src/analyze/calculateOutcomes/calculateQqOutcomes.d.ts

@@ -0,0 +1,3 @@
+import type { QqNode } from '../../builtin/specialExpressions/qq';
+import type { CalculatePossibleAstNodesHelper } from '.';
+export declare const calculateQqOutcomes: CalculatePossibleAstNodesHelper<QqNode>;

package/dist/cli/src/analyze/calculateOutcomes/calculateRecurOutcomes.d.ts

@@ -0,0 +1,3 @@
+import type { RecurNode } from '../../builtin/specialExpressions/recur';
+import type { CalculatePossibleAstNodesHelper } from '.';
+export declare const calculateRecurOutcomes: CalculatePossibleAstNodesHelper<RecurNode>;

package/dist/cli/src/analyze/calculateOutcomes/calculateThrowOutcomes.d.ts

@@ -0,0 +1,3 @@
+import type { ThrowNode } from '../../builtin/specialExpressions/throw';
+import type { CalculatePossibleAstNodesHelper } from '.';
+export declare const calculateThrowOutcomes: CalculatePossibleAstNodesHelper<ThrowNode>;

package/dist/cli/src/analyze/calculateOutcomes/calculateTimeOutcomes.d.ts

@@ -0,0 +1,3 @@
+import type { TimeNode } from '../../builtin/specialExpressions/time';
+import type { CalculatePossibleAstNodesHelper } from '.';
+export declare const calculateTimeOutcomes: CalculatePossibleAstNodesHelper<TimeNode>;

package/dist/cli/src/analyze/calculateOutcomes/calculateTryOutcomes.d.ts

@@ -0,0 +1,3 @@
+import type { TryNode } from '../../builtin/specialExpressions/try';
+import type { CalculatePossibleAstNodesHelper } from '.';
+export declare const calculateTryOutcomes: CalculatePossibleAstNodesHelper<TryNode>;

package/dist/cli/src/analyze/calculateOutcomes/calculateWhenFirstOutcomes.d.ts

@@ -0,0 +1,3 @@
+import type { WhenFirstNode } from '../../builtin/specialExpressions/when-first';
+import type { CalculatePossibleAstNodesHelper } from '.';
+export declare const calculateWhenFirstOutcomes: CalculatePossibleAstNodesHelper<WhenFirstNode>;

package/dist/cli/src/analyze/calculateOutcomes/calculateWhenLetOutcomes.d.ts

@@ -0,0 +1,3 @@
+import type { WhenLetNode } from '../../builtin/specialExpressions/when-let';
+import type { CalculatePossibleAstNodesHelper } from '.';
+export declare const calculateWhenLetOutcomes: CalculatePossibleAstNodesHelper<WhenLetNode>;

package/dist/cli/src/analyze/calculateOutcomes/calculateWhenNotOutcomes.d.ts

@@ -0,0 +1,3 @@
+import type { WhenNotNode } from '../../builtin/specialExpressions/when-not';
+import type { CalculatePossibleAstNodesHelper } from '.';
+export declare const calculateWhenNotOutcomes: CalculatePossibleAstNodesHelper<WhenNotNode>;

package/dist/cli/src/analyze/calculateOutcomes/calculateWhenOutcomes.d.ts

@@ -0,0 +1,3 @@
+import type { WhenNode } from '../../builtin/specialExpressions/when';
+import type { CalculatePossibleAstNodesHelper } from '.';
+export declare const calculateWhenOutcomes: CalculatePossibleAstNodesHelper<WhenNode>;

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

@@ -0,0 +1,18 @@
+import type { Outcomes } from '..';
+import type { ContextStack } from '../../evaluator/ContextStack';
+import type { AstNode } from '../../parser/interface';
+export type CalculatePossibleAstNodes = (astNode: AstNode, indentifiers?: string[]) => AstNode[];
+export type CombinateAstNodes = (astNodes: AstNode[], indentifiers?: string[]) => AstNode[][];
+export type IsAstComputable = (node: AstNode | AstNode[] | AstNode[][]) => boolean;
+export type AddGlobaleIdentifier = (name: string) => void;
+export interface CalculatePossibleAstNodesHelperOptions<T extends AstNode> {
+    astNode: T;
+    nilNode: AstNode;
+    calculatePossibleAstNodes: CalculatePossibleAstNodes;
+    combinateAstNodes: CombinateAstNodes;
+    isAstComputable: IsAstComputable;
+    addGlobalIdentifier: AddGlobaleIdentifier;
+}
+export type CalculatePossibleAstNodesHelper<T extends AstNode> = (options: CalculatePossibleAstNodesHelperOptions<T>) => AstNode[];
+export declare function calculateOutcomes(contextStack: ContextStack, astNodes: AstNode[]): Outcomes | null;
+export declare function calculateOutcomesInner(contextStack: ContextStack, astNodes: AstNode[]): Outcomes | null;

package/dist/cli/src/analyze/calculateOutcomes/specialExpressionCalculators.d.ts

@@ -0,0 +1,55 @@
+import type { AndNode } from '../../builtin/specialExpressions/and';
+import type { CommentExpressionNode } from '../../builtin/specialExpressions/comment';
+import type { CondNode } from '../../builtin/specialExpressions/cond';
+import type { DeclaredNode } from '../../builtin/specialExpressions/declared';
+import type { DefNode } from '../../builtin/specialExpressions/def';
+import type { DefsNode } from '../../builtin/specialExpressions/defs';
+import type { DoNode } from '../../builtin/specialExpressions/do';
+import type { DefnNode, DefnsNode, FnNode } from '../../builtin/specialExpressions/functions';
+import type { IfNode } from '../../builtin/specialExpressions/if';
+import type { IfLetNode } from '../../builtin/specialExpressions/if-let';
+import type { IfNotNode } from '../../builtin/specialExpressions/if-not';
+import type { LetNode } from '../../builtin/specialExpressions/let';
+import type { LoopNode } from '../../builtin/specialExpressions/loop';
+import type { DoSeqNode, ForNode } from '../../builtin/specialExpressions/loops';
+import type { OrNode } from '../../builtin/specialExpressions/or';
+import type { QqNode } from '../../builtin/specialExpressions/qq';
+import type { RecurNode } from '../../builtin/specialExpressions/recur';
+import type { ThrowNode } from '../../builtin/specialExpressions/throw';
+import type { TimeNode } from '../../builtin/specialExpressions/time';
+import type { TryNode } from '../../builtin/specialExpressions/try';
+import type { WhenNode } from '../../builtin/specialExpressions/when';
+import type { WhenFirstNode } from '../../builtin/specialExpressions/when-first';
+import type { WhenLetNode } from '../../builtin/specialExpressions/when-let';
+import type { WhenNotNode } from '../../builtin/specialExpressions/when-not';
+import type { AstNode } from '../../parser/interface';
+import type { CalculatePossibleAstNodesHelperOptions } from '.';
+export declare const specialExpressionCalculator: {
+    and: (astNode: AndNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
+    comment: (astNode: CommentExpressionNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
+    cond: (astNode: CondNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
+    'declared?': (astNode: DeclaredNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
+    defn: (astNode: DefnNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
+    def: (astNode: DefNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
+    defns: (astNode: DefnsNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
+    defs: (astNode: DefsNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
+    do: (astNode: DoNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
+    doseq: (astNode: DoSeqNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
+    fn: (astNode: FnNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
+    for: (astNode: ForNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
+    'if-let': (astNode: IfLetNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
+    if: (astNode: IfNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
+    'if-not': (astNode: IfNotNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
+    let: (astNode: LetNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
+    loop: (astNode: LoopNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
+    or: (astNode: OrNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
+    '??': (astNode: QqNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
+    recur: (astNode: RecurNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
+    'time!': (astNode: TimeNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
+    throw: (astNode: ThrowNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
+    try: (astNode: TryNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
+    'when-first': (astNode: WhenFirstNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
+    'when-let': (astNode: WhenLetNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
+    when: (astNode: WhenNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
+    'when-not': (astNode: WhenNotNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
+};

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

@@ -0,0 +1,2 @@
+import type { FindUnresolvedIdentifiers } from '.';
+export declare const findUnresolvedIdentifiers: FindUnresolvedIdentifiers;

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

@@ -1,2 +1,17 @@
-import type { AnalyzeAst } from './interface';
-export declare const analyzeAst: AnalyzeAst;
+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';
+export interface UnresolvedIdentifier {
+    symbol: string;
+    token: Token | undefined;
+}
+export type UnresolvedIdentifiers = Set<UnresolvedIdentifier>;
+export type Outcomes = unknown[];
+export interface Analysis {
+    unresolvedIdentifiers: UnresolvedIdentifiers;
+    outcomes: Outcomes | null;
+}
+export type FindUnresolvedIdentifiers = (ast: Ast | AstNode[], contextStack: ContextStack, builtin: Builtin) => UnresolvedIdentifiers;
+export declare function analyze(ast: Ast, params: LitsParams): Analysis;

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

@@ -1,3 +1,4 @@
-import type { AnalyzeResult } from './interface';
-export declare function joinAnalyzeResults(...results: AnalyzeResult[]): AnalyzeResult;
-export declare function addAnalyzeResults(target: AnalyzeResult, source: AnalyzeResult): void;
+import type { UnresolvedIdentifiers } from '.';
+export declare function joinAnalyzeResults(...results: UnresolvedIdentifiers[]): UnresolvedIdentifiers;
+export declare function addAnalyzeResults(target: UnresolvedIdentifiers, source: UnresolvedIdentifiers): void;
+export declare function combinate<T>(arrays: T[][]): T[][];

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

@@ -1,5 +1,38 @@
-import type { Builtin, BuiltinSpecialExpressions } from './interface';
-export declare const specialExpressions: BuiltinSpecialExpressions;
+import type { Builtin } from './interface';
+declare const specialExpressions: {
+    readonly and: import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/and").AndNode>;
+    readonly comment: import("./interface").BuiltinSpecialExpression<null, import("./specialExpressions/comment").CommentExpressionNode>;
+    readonly cond: import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/cond").CondNode>;
+    readonly def: import("./interface").BuiltinSpecialExpression<null, import("./specialExpressions/def").DefNode>;
+    readonly defn: import("./interface").BuiltinSpecialExpression<null, import("./specialExpressions/functions").DefnNode>;
+    readonly defns: import("./interface").BuiltinSpecialExpression<null, import("./specialExpressions/functions").DefnsNode>;
+    readonly defs: import("./interface").BuiltinSpecialExpression<null, import("./specialExpressions/defs").DefsNode>;
+    readonly do: import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/do").DoNode>;
+    readonly doseq: import("./interface").BuiltinSpecialExpression<null, import("./specialExpressions/loops").DoSeqNode>;
+    readonly for: import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/loops").ForNode>;
+    readonly fn: import("./interface").BuiltinSpecialExpression<import("..").LitsFunction, import("./specialExpressions/functions").FnNode>;
+    readonly if: import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/if").IfNode>;
+    readonly 'if-let': import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/if-let").IfLetNode>;
+    readonly 'if-not': import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/if-not").IfNotNode>;
+    readonly let: import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/let").LetNode>;
+    readonly loop: import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/loop").LoopNode>;
+    readonly or: import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/or").OrNode>;
+    readonly recur: import("./interface").BuiltinSpecialExpression<null, import("./specialExpressions/recur").RecurNode>;
+    readonly throw: import("./interface").BuiltinSpecialExpression<null, import("./specialExpressions/throw").ThrowNode>;
+    readonly 'time!': import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/time").TimeNode>;
+    readonly try: import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/try").TryNode>;
+    readonly when: import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/when").WhenNode>;
+    readonly 'when-first': import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/when-first").WhenFirstNode>;
+    readonly 'when-let': import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/when-let").WhenLetNode>;
+    readonly 'when-not': import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/when-not").WhenNotNode>;
+    readonly 'declared?': import("./interface").BuiltinSpecialExpression<boolean, import("./specialExpressions/declared").DeclaredNode>;
+    readonly '??': import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/qq").QqNode>;
+};
+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 declare const builtin: Builtin;
 export declare const normalExpressionKeys: string[];
 export declare const specialExpressionKeys: string[];
+export {};

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

@@ -1,9 +1,10 @@
+import type { FindUnresolvedIdentifiers, UnresolvedIdentifiers } from '../analyze';
+import type { ContextStack } from '../evaluator/ContextStack';
 import type { EvaluateAstNode, ExecuteFunction } from '../evaluator/interface';
-import type { NormalExpressionNode, ParseArgument, ParseBinding, ParseBindings, ParseExpression, ParseToken, ParseTokens, SpecialExpressionNode } from '../parser/interface';
-import type { SourceCodeInfo, TokenStream } from '../tokenizer/interface';
 import type { Any, Arr } from '../interface';
-import type { AnalyzeAst, AnalyzeResult } from '../analyze/interface';
-import type { ContextStack } from '../evaluator/ContextStack';
+import type { NormalExpressionNode, ParseArgument, ParseBinding, ParseBindings, ParseExpression, ParseToken, ParseTokensUntilClosingBracket } from '../parser/interface';
+import type { SourceCodeInfo, Token, TokenStream } from '../tokenizer/interface';
+import type { BuiltinSpecialExpressions, SpecialExpressionNode } from '.';
 export type NormalExpressionEvaluator<T> = (params: Arr, sourceCodeInfo: SourceCodeInfo | undefined, contextStack: ContextStack, { executeFunction }: {
     executeFunction: ExecuteFunction;
 }) => T;
@@ -14,28 +15,26 @@ interface BuiltinNormalExpression<T> {
 }
 export interface ParserHelpers {
     parseExpression: ParseExpression;
-    parseTokens: ParseTokens;
+    parseTokensUntilClosingBracket: ParseTokensUntilClosingBracket;
     parseToken: ParseToken;
     parseBinding: ParseBinding;
     parseBindings: ParseBindings;
     parseArgument: ParseArgument;
 }
 export type BuiltinNormalExpressions = Record<string, BuiltinNormalExpression<Any>>;
-export type BuiltinSpecialExpressions = Record<string, BuiltinSpecialExpression<Any>>;
 interface EvaluateHelpers {
     evaluateAstNode: EvaluateAstNode;
     builtin: Builtin;
 }
-export interface BuiltinSpecialExpression<T> {
-    parse: (tokenStream: TokenStream, position: number, parsers: ParserHelpers) => [number, SpecialExpressionNode];
-    evaluate: (node: SpecialExpressionNode, contextStack: ContextStack, helpers: EvaluateHelpers) => T;
-    validate?: (node: SpecialExpressionNode) => void;
-    analyze: (node: SpecialExpressionNode, contextStack: ContextStack, params: {
-        analyzeAst: AnalyzeAst;
+export interface BuiltinSpecialExpression<T, N extends SpecialExpressionNode> {
+    parse: (tokenStream: TokenStream, position: number, firstToken: Token, parsers: ParserHelpers) => [number, N];
+    evaluate: (node: N, contextStack: ContextStack, helpers: EvaluateHelpers) => T;
+    findUnresolvedIdentifiers: (node: N, contextStack: ContextStack, params: {
+        findUnresolvedIdentifiers: FindUnresolvedIdentifiers;
         builtin: Builtin;
-    }) => AnalyzeResult;
+        evaluateAstNode: EvaluateAstNode;
+    }) => UnresolvedIdentifiers;
 }
-export type SpecialExpressionName = 'and' | 'block' | 'comment' | 'cond' | 'def' | 'defn' | 'defns' | 'defs' | 'do' | 'doseq' | 'fn' | 'for' | 'function' | 'if-let' | 'if-not' | 'if' | 'let' | 'loop' | 'or' | 'partial' | 'recur' | 'return-from' | 'return' | 'throw' | 'time!' | 'try' | 'when-first' | 'when-let' | 'when-not' | 'when' | 'declared?' | '??';
 export interface Builtin {
     normalExpressions: BuiltinNormalExpressions;
     specialExpressions: BuiltinSpecialExpressions;

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

@@ -1,3 +1,6 @@
 import type { Any } from '../../interface';
+import type { CommonSpecialExpressionNode } from '../../parser/interface';
 import type { BuiltinSpecialExpression } from '../interface';
-export declare const andSpecialExpression: BuiltinSpecialExpression<Any>;
+export interface AndNode extends CommonSpecialExpressionNode<'and'> {
+}
+export declare const andSpecialExpression: BuiltinSpecialExpression<Any, AndNode>;

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

@@ -1,2 +1,5 @@
+import type { CommonSpecialExpressionNode } from '../../parser/interface';
 import type { BuiltinSpecialExpression } from '../interface';
-export declare const commentSpecialExpression: BuiltinSpecialExpression<null>;
+export interface CommentExpressionNode extends CommonSpecialExpressionNode<'comment'> {
+}
+export declare const commentSpecialExpression: BuiltinSpecialExpression<null, CommentExpressionNode>;

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

@@ -1,8 +1,6 @@
 import type { Any } from '../../interface';
-import type { AstNode } from '../../parser/interface';
+import type { CommonSpecialExpressionNode } from '../../parser/interface';
 import type { BuiltinSpecialExpression } from '../interface';
-export interface Condition {
-    t: AstNode;
-    f: AstNode;
+export interface CondNode extends CommonSpecialExpressionNode<'cond'> {
 }
-export declare const condSpecialExpression: BuiltinSpecialExpression<Any>;
+export declare const condSpecialExpression: BuiltinSpecialExpression<Any, CondNode>;

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

@@ -1,2 +1,5 @@
+import type { CommonSpecialExpressionNode } from '../../parser/interface';
 import type { BuiltinSpecialExpression } from '../interface';
-export declare const declaredSpecialExpression: BuiltinSpecialExpression<boolean>;
+export interface DeclaredNode extends CommonSpecialExpressionNode<'declared?'> {
+}
+export declare const declaredSpecialExpression: BuiltinSpecialExpression<boolean, DeclaredNode>;

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

@@ -1,3 +1,5 @@
-import type { Any } from '../../interface';
+import type { CommonSpecialExpressionNode } from '../../parser/interface';
 import type { BuiltinSpecialExpression } from '../interface';
-export declare const defSpecialExpression: BuiltinSpecialExpression<Any>;
+export interface DefNode extends CommonSpecialExpressionNode<'def'> {
+}
+export declare const defSpecialExpression: BuiltinSpecialExpression<null, DefNode>;

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

@@ -1,3 +1,5 @@
-import type { Any } from '../../interface';
+import type { CommonSpecialExpressionNode } from '../../parser/interface';
 import type { BuiltinSpecialExpression } from '../interface';
-export declare const defsSpecialExpression: BuiltinSpecialExpression<Any>;
+export interface DefsNode extends CommonSpecialExpressionNode<'defs'> {
+}
+export declare const defsSpecialExpression: BuiltinSpecialExpression<null, DefsNode>;

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

@@ -1,3 +1,6 @@
 import type { Any } from '../../interface';
+import type { CommonSpecialExpressionNode } from '../../parser/interface';
 import type { BuiltinSpecialExpression } from '../interface';
-export declare const doSpecialExpression: BuiltinSpecialExpression<Any>;
+export interface DoNode extends CommonSpecialExpressionNode<'do'> {
+}
+export declare const doSpecialExpression: BuiltinSpecialExpression<Any, DoNode>;

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

@@ -1,9 +1,18 @@
-import type { LitsFunction, SpecialExpressionNode } from '../../parser/interface';
+import type { AstNode, CommonSpecialExpressionNode, LitsFunction, NameNode } from '../../parser/interface';
 import type { BuiltinSpecialExpression } from '../interface';
 import type { FunctionOverload } from '../utils';
-export type FnNode = SpecialExpressionNode & {
+export interface DefnNode extends CommonSpecialExpressionNode<'defn'> {
+    f: NameNode;
     o: FunctionOverload[];
-};
-export declare const defnSpecialExpression: BuiltinSpecialExpression<null>;
-export declare const defnsSpecialExpression: BuiltinSpecialExpression<null>;
-export declare const fnSpecialExpression: BuiltinSpecialExpression<LitsFunction>;
+}
+export interface DefnsNode extends CommonSpecialExpressionNode<'defns'> {
+    f: AstNode;
+    o: FunctionOverload[];
+}
+export interface FnNode extends CommonSpecialExpressionNode<'fn'> {
+    p: AstNode[];
+    o: FunctionOverload[];
+}
+export declare const defnSpecialExpression: BuiltinSpecialExpression<null, DefnNode>;
+export declare const defnsSpecialExpression: BuiltinSpecialExpression<null, DefnsNode>;
+export declare const fnSpecialExpression: BuiltinSpecialExpression<LitsFunction, FnNode>;

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

@@ -1,3 +1,10 @@
 import type { Any } from '../../interface';
+import type { BindingNode, CommonSpecialExpressionNode, NormalExpressionNode } from '../../parser/interface';
 import type { BuiltinSpecialExpression } from '../interface';
-export declare const ifLetSpecialExpression: BuiltinSpecialExpression<Any>;
+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/if-not.d.ts

@@ -1,3 +1,6 @@
 import type { Any } from '../../interface';
+import type { CommonSpecialExpressionNode } from '../../parser/interface';
 import type { BuiltinSpecialExpression } from '../interface';
-export declare const ifNotSpecialExpression: BuiltinSpecialExpression<Any>;
+export interface IfNotNode extends CommonSpecialExpressionNode<'if-not'> {
+}
+export declare const ifNotSpecialExpression: BuiltinSpecialExpression<Any, IfNotNode>;

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

@@ -1,3 +1,6 @@
 import type { Any } from '../../interface';
+import type { CommonSpecialExpressionNode } from '../../parser/interface';
 import type { BuiltinSpecialExpression } from '../interface';
-export declare const ifSpecialExpression: BuiltinSpecialExpression<Any>;
+export interface IfNode extends CommonSpecialExpressionNode<'if'> {
+}
+export declare const ifSpecialExpression: BuiltinSpecialExpression<Any, IfNode>;

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

@@ -1,3 +1,10 @@
 import type { Any } from '../../interface';
+import type { BindingNode, CommonSpecialExpressionNode, NormalExpressionNode } from '../../parser/interface';
 import type { BuiltinSpecialExpression } from '../interface';
-export declare const letSpecialExpression: BuiltinSpecialExpression<Any>;
+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/loop.d.ts

@@ -1,3 +1,7 @@
 import type { Any } from '../../interface';
+import type { BindingNode, CommonSpecialExpressionNode } from '../../parser/interface';
 import type { BuiltinSpecialExpression } from '../interface';
-export declare const loopSpecialExpression: BuiltinSpecialExpression<Any>;
+export interface LoopNode extends CommonSpecialExpressionNode<'loop'> {
+    bs: BindingNode[];
+}
+export declare const loopSpecialExpression: BuiltinSpecialExpression<Any, LoopNode>;

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

@@ -1,6 +1,12 @@
 import type { Any } from '../../interface';
-import type { AstNode, BindingNode } from '../../parser/interface';
+import type { AstNode, BindingNode, CommonSpecialExpressionNode } from '../../parser/interface';
 import type { BuiltinSpecialExpression } from '../interface';
+export interface ForNode extends CommonSpecialExpressionNode<'for'> {
+    l: LoopBindingNode[];
+}
+export interface DoSeqNode extends CommonSpecialExpressionNode<'doseq'> {
+    l: LoopBindingNode[];
+}
 export interface LoopBindingNode {
     b: BindingNode;
     m: Array<'&let' | '&when' | '&while'>;
@@ -8,5 +14,5 @@ export interface LoopBindingNode {
     wn?: AstNode;
     we?: AstNode;
 }
-export declare const forSpecialExpression: BuiltinSpecialExpression<Any>;
-export declare const doseqSpecialExpression: BuiltinSpecialExpression<null>;
+export declare const forSpecialExpression: BuiltinSpecialExpression<Any, ForNode>;
+export declare const doseqSpecialExpression: BuiltinSpecialExpression<null, DoSeqNode>;

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

@@ -1,3 +1,6 @@
 import type { Any } from '../../interface';
+import type { CommonSpecialExpressionNode } from '../../parser/interface';
 import type { BuiltinSpecialExpression } from '../interface';
-export declare const orSpecialExpression: BuiltinSpecialExpression<Any>;
+export interface OrNode extends CommonSpecialExpressionNode<'or'> {
+}
+export declare const orSpecialExpression: BuiltinSpecialExpression<Any, OrNode>;