@mojir/lits 2.2.2-alpha.6 → 2.2.2

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

@@ -1,155 +0,0 @@
-import type { JsFunction, LazyValue } 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 { ReservedName } from '../reservedNames';
-import type { SourceCodeInfo, Token, TokenStream } from '../tokenizer/interface';
-import type { FUNCTION_SYMBOL, REGEXP_SYMBOL } from '../utils/symbols';
-export interface EvaluatedFunctionArguments {
-    mandatoryArguments: string[];
-    restArgument?: string;
-}
-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;
-}
-export interface RegularExpression {
-    [REGEXP_SYMBOL]: true;
-    sourceCodeInfo?: SourceCodeInfo;
-    s: string;
-    f: string;
-}
-export interface NativeJsFunction extends GenericLitsFunction {
-    t: FunctionType.NativeJsFunction;
-    n: string | undefined;
-    f: JsFunction;
-}
-export interface UserDefinedFunction extends GenericLitsFunction {
-    t: FunctionType.UserDefined;
-    n: string | undefined;
-    o: EvaluatedFunctionOverload[];
-    x?: ExtraData;
-}
-export interface PartialFunction extends GenericLitsFunction {
-    t: FunctionType.Partial;
-    f: Any;
-    p: Arr;
-}
-export interface CompFunction extends GenericLitsFunction {
-    t: FunctionType.Comp;
-    f: Arr;
-}
-export interface ConstantlyFunction extends GenericLitsFunction {
-    t: FunctionType.Constantly;
-    v: Any;
-}
-export interface JuxtFunction extends GenericLitsFunction {
-    t: FunctionType.Juxt;
-    f: Arr;
-}
-export interface ComplementFunction extends GenericLitsFunction {
-    t: FunctionType.Complement;
-    f: Any;
-}
-export interface EveryPredFunction extends GenericLitsFunction {
-    t: FunctionType.EveryPred;
-    f: Arr;
-}
-export interface SomePredFunction extends GenericLitsFunction {
-    t: FunctionType.SomePred;
-    f: Arr;
-}
-export interface FNilFunction extends GenericLitsFunction {
-    t: FunctionType.Fnil;
-    f: Any;
-    p: Arr;
-}
-export interface BuiltinFunction extends GenericLitsFunction {
-    t: 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 ModifierName = '&' | '&let' | '&when' | '&while';
-export interface GenericNode {
-    t: AstNodeType;
-    p: AstNode[];
-    n: string | undefined;
-    debugData: {
-        token: Token;
-        lastToken: Token;
-        nameToken?: Token;
-    } | undefined;
-}
-export type ExpressionNode = NormalExpressionNode | SpecialExpressionNode | NumberNode | StringNode;
-export type ParseBinding = (tokens: TokenStream, position: number) => [number, BindingNode];
-export type ParseBindings = (tokens: TokenStream, position: number) => [number, BindingNode[]];
-export type ParseArgument = (tokens: TokenStream, position: number) => [number, ArgumentNode | ModifierNode];
-export type ParseExpression = (tokens: TokenStream, position: number) => [number, ExpressionNode];
-export type ParseTokensUntilClosingBracket = (tokens: TokenStream, position: number) => [number, AstNode[]];
-export type ParseToken = (tokens: TokenStream, position: number) => [number, AstNode];
-export interface NumberNode extends GenericNode {
-    t: AstNodeType.Number;
-    v: number;
-}
-export interface StringNode extends GenericNode {
-    t: AstNodeType.String;
-    v: string;
-}
-export interface NameNode extends GenericNode {
-    t: AstNodeType.Name;
-    v: string;
-}
-export interface ModifierNode extends GenericNode {
-    t: AstNodeType.Modifier;
-    v: ModifierName;
-}
-export interface ReservedNameNode extends GenericNode {
-    t: AstNodeType.ReservedName;
-    v: ReservedName;
-}
-interface CommonNormalExpressionNode extends GenericNode {
-    t: AstNodeType.NormalExpression;
-}
-export interface CommonSpecialExpressionNode<T extends SpecialExpressionName> extends GenericNode {
-    t: AstNodeType.SpecialExpression;
-    n: T;
-}
-export interface NormalExpressionNodeWithName extends CommonNormalExpressionNode {
-    n: string;
-}
-interface NormalExpressionNodeExpression extends CommonNormalExpressionNode {
-    n: undefined;
-}
-export type NormalExpressionNode = NormalExpressionNodeWithName | NormalExpressionNodeExpression;
-export interface BindingNode extends GenericNode {
-    t: AstNodeType.Binding;
-    n: string;
-    v: AstNode;
-}
-export interface ArgumentNode extends GenericNode {
-    t: AstNodeType.Argument;
-    n: string;
-    d?: AstNode;
-}
-export interface CommentNode extends GenericNode {
-    t: AstNodeType.Comment;
-    v: string;
-}
-export type AstNode = NumberNode | StringNode | ReservedNameNode | NameNode | CommentNode | NormalExpressionNode | ModifierNode | SpecialExpressionNode;
-type AstBody = AstNode[];
-export interface Ast {
-    b: AstBody;
-    hasDebugData: boolean;
-}
-export {};

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

@@ -1,4 +0,0 @@
-import type { TokenStream } from '../tokenizer/interface';
-import type { AstNode, NumberNode } from './interface';
-export declare function parseNumber(tokenStream: TokenStream, position: number): [number, NumberNode];
-export declare function parseToken(tokenStream: TokenStream, position: number): [number, AstNode];

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

@@ -1,11 +0,0 @@
-import type { Ast, AstNode } from '../parser/interface';
-declare const removeOptions: {
-    readonly recursivelyRemoveCommentNodes: typeof recursivelyRemoveCommentNodes;
-    readonly removeCommenNodesFromArray: typeof removeCommenNodesFromArray;
-};
-export type RemoveOptions = typeof removeOptions;
-export declare function removeCommenNodes(ast: Ast): void;
-declare function recursivelyRemoveCommentNodes(astNode: AstNode): void;
-declare function removeCommenNodesFromArray(astNodes: AstNode[]): void;
-export declare function withoutCommentNodes(astNodes: AstNode[]): (import("../parser/interface").NumberNode | import("../parser/interface").StringNode | import("../parser/interface").ReservedNameNode | import("../parser/interface").NameNode | import("../parser/interface").NormalExpressionNode | import("../parser/interface").ModifierNode | import("../builtin/specialExpressions/and").AndNode | import("../builtin/specialExpressions/comment").CommentExpressionNode | import("../builtin/specialExpressions/cond").CondNode | import("../builtin/specialExpressions/def").DefNode | import("../builtin/specialExpressions/functions").DefnNode | import("../builtin/specialExpressions/functions").DefnsNode | import("../builtin/specialExpressions/defs").DefsNode | import("../builtin/specialExpressions/do").DoNode | import("../builtin/specialExpressions/loops").DoSeqNode | import("../builtin/specialExpressions/loops").ForNode | import("../builtin/specialExpressions/functions").FnNode | import("../builtin/specialExpressions/if").IfNode | import("../builtin/specialExpressions/if-let").IfLetNode | import("../builtin/specialExpressions/if-not").IfNotNode | import("../builtin/specialExpressions/let").LetNode | import("../builtin/specialExpressions/loop").LoopNode | import("../builtin/specialExpressions/or").OrNode | import("../builtin/specialExpressions/recur").RecurNode | import("../builtin/specialExpressions/throw").ThrowNode | import("../builtin/specialExpressions/time").TimeNode | import("../builtin/specialExpressions/try").TryNode | import("../builtin/specialExpressions/when").WhenNode | import("../builtin/specialExpressions/when-first").WhenFirstNode | import("../builtin/specialExpressions/when-let").WhenLetNode | import("../builtin/specialExpressions/when-not").WhenNotNode | import("../builtin/specialExpressions/declared").DeclaredNode | import("../builtin/specialExpressions/qq").QqNode)[];
-export {};

package/dist/cli/src/removeCommentNodes/removeCommentNodesFromSpecialExpression.d.ts

@@ -1,3 +0,0 @@
-import type { SpecialExpressionNode } from '../builtin';
-import type { RemoveOptions } from '.';
-export declare function removeCommentNodesFromSpecialExpression(node: SpecialExpressionNode, removeOptions: RemoveOptions): void;

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

@@ -1,7 +0,0 @@
-import type { Any } from './interface';
-export type ReservedName = 'true' | 'false' | 'nil' | 'null' | 'undefined' | '===' | '!==' | '&&' | '||';
-export declare const reservedNamesRecord: Record<ReservedName, {
-    value: Any;
-    forbidden?: true;
-}>;
-export declare const reservedNames: ReservedName[];

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

@@ -1,9 +0,0 @@
-import { TokenType } from '../constants/constants';
-import type { MetaToken, Token, TokenStream, TokenizeParams } from './interface';
-export declare function tokenize(input: string, params: TokenizeParams): TokenStream;
-export declare function isMetaToken(token?: Token): token is MetaToken;
-export declare function assertMetaToken(token?: Token): asserts token is MetaToken;
-export declare function isCommentToken(token?: Token): token is Token<TokenType.Comment>;
-export declare function assertCommentToken(token?: Token): asserts token is Token<TokenType.Comment>;
-export declare function isNewLineToken(token?: Token): token is Token<TokenType.NewLine>;
-export declare function assertNewLineToken(token?: Token): asserts token is Token<TokenType.NewLine>;

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

@@ -1,35 +0,0 @@
-import type { TokenType } from '../constants/constants';
-export interface SourceCodeInfo {
-    position?: {
-        line: number;
-        column: number;
-    };
-    code?: string;
-    filePath?: string;
-}
-export type MetaToken = Token<TokenType.NewLine> | Token<TokenType.Comment>;
-export interface MetaTokens {
-    leadingMetaTokens: MetaToken[];
-    inlineCommentToken: Token<TokenType.Comment> | null;
-}
-export interface TokenDebugData {
-    sourceCodeInfo: SourceCodeInfo;
-    metaTokens: MetaTokens;
-}
-export interface Token<T extends TokenType = TokenType> {
-    t: T;
-    v: string;
-    o?: Record<string, boolean>;
-    debugData: TokenDebugData | undefined;
-}
-export type TokenDescriptor = [length: number, token: Token | undefined];
-export type Tokenizer = (input: string, position: number, debugData?: TokenDebugData) => TokenDescriptor;
-export interface TokenStream {
-    tokens: Token[];
-    hasDebugData: boolean;
-    filePath?: string;
-}
-export interface TokenizeParams {
-    debug?: boolean;
-    filePath?: string;
-}

package/dist/cli/src/tokenizer/sugar/applyCollectionAccessor.d.ts

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

package/dist/cli/src/tokenizer/sugar/index.d.ts

@@ -1,3 +0,0 @@
-import type { TokenStream } from '../interface';
-export type SugarFunction = (tokenStream: TokenStream) => TokenStream;
-export declare function getSugar(): SugarFunction[];

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

@@ -1,13 +0,0 @@
-import { TokenType } from '../constants/constants';
-import type { Token } from '../tokenizer/interface';
-type TokenAssertionOptions = {
-    type: TokenType;
-    value?: string;
-} | {
-    type?: never;
-    value?: never;
-};
-export declare function isToken(value: unknown, options?: TokenAssertionOptions): value is Token;
-export declare function assertToken(value: unknown, filePath: string | undefined, options?: TokenAssertionOptions): asserts value is Token;
-export declare function asToken(value: unknown, filePath: string | undefined, options?: TokenAssertionOptions): Token;
-export {};

package/dist/cli/src/unparser/UnparseOptions.d.ts

@@ -1,15 +0,0 @@
-import type { Unparse } from './unparse';
-export declare class UnparseOptions {
-    readonly unparse: Unparse;
-    readonly lineLength: number;
-    readonly col: number;
-    readonly inlined: boolean;
-    readonly locked: boolean;
-    readonly indent: string;
-    constructor(unparse: Unparse, lineLength: number, col?: number, inlined?: boolean, locked?: boolean);
-    inc(count?: number): UnparseOptions;
-    inline(): UnparseOptions;
-    noInline(): UnparseOptions;
-    lock(): UnparseOptions;
-    assertNotOverflown(value: string): string;
-}

package/dist/cli/src/unparser/unparse.d.ts

@@ -1,5 +0,0 @@
-import type { Ast, AstNode, NormalExpressionNode } from '../parser/interface';
-import { UnparseOptions } from './UnparseOptions';
-export type ExpressionWithParamsNode = Pick<NormalExpressionNode, 'debugData' | 'n' | 'p'>;
-export type Unparse = (node: AstNode, options: UnparseOptions) => string;
-export declare function unparseAst(ast: Ast, lineLength: number): string;

package/dist/cli/src/unparser/unparseArrayLiteral.d.ts

@@ -1,3 +0,0 @@
-import type { NormalExpressionNode } from '../parser/interface';
-import type { UnparseOptions } from './UnparseOptions';
-export declare function unparseArrayLiteral(node: NormalExpressionNode, options: UnparseOptions): string;

package/dist/cli/src/unparser/unparseBindings.d.ts

@@ -1,3 +0,0 @@
-import type { NormalExpressionNode } from '../parser/interface';
-import type { UnparseOptions } from './UnparseOptions';
-export declare function unparseBindings(node: NormalExpressionNode, options: UnparseOptions): string;

package/dist/cli/src/unparser/unparseNormalExpression.d.ts

@@ -1,3 +0,0 @@
-import type { UnparseOptions } from './UnparseOptions';
-import type { ExpressionWithParamsNode } from './unparse';
-export declare function unparseNormalExpression(node: ExpressionWithParamsNode, options: UnparseOptions): string;

package/dist/cli/src/unparser/unparseObjectLiteral.d.ts

@@ -1,3 +0,0 @@
-import type { NormalExpressionNode } from '../parser/interface';
-import type { UnparseOptions } from './UnparseOptions';
-export declare function unparseObjectLiteral(node: NormalExpressionNode, options: UnparseOptions): string;

package/dist/cli/src/unparser/unparseParams.d.ts

@@ -1,17 +0,0 @@
-import type { AstNode } from '../parser/interface';
-import type { UnparseOptions } from './UnparseOptions';
-export declare function unparseParams({ params, options, prefix, inline, endBracket, body, name, noMultilineInline, pairs, }: {
-    params: AstNode[];
-    prefix: string;
-    inline: boolean;
-    endBracket: string;
-    options: UnparseOptions;
-    body?: boolean;
-    name?: string;
-    noMultilineInline?: boolean;
-    pairs?: boolean;
-}): string;
-export declare function unparseSingleLineParams(params: AstNode[], options: UnparseOptions): string;
-export declare function unparseSingleLinePairs(params: AstNode[], options: UnparseOptions): string;
-export declare function unparseMultilineParams(params: AstNode[], options: UnparseOptions): string;
-export declare function unparseMultilinePairwise(params: AstNode[], options: UnparseOptions): string;

package/dist/cli/src/unparser/unparseSpecialExpression/index.d.ts

@@ -1,3 +0,0 @@
-import type { SpecialExpressionNode } from '../../builtin';
-import type { UnparseOptions } from '../UnparseOptions';
-export declare function unparseSpecialExpression(node: SpecialExpressionNode, options: UnparseOptions): string;

package/dist/cli/src/unparser/unparseSpecialExpression/unparseCond.d.ts

@@ -1,3 +0,0 @@
-import type { CondNode } from '../../builtin/specialExpressions/cond';
-import type { UnparseOptions } from '../UnparseOptions';
-export declare function unparseCond(node: CondNode, options: UnparseOptions): string;

package/dist/cli/src/unparser/unparseSpecialExpression/unparseDo.d.ts

@@ -1,3 +0,0 @@
-import type { DoNode } from '../../builtin/specialExpressions/do';
-import type { UnparseOptions } from '../UnparseOptions';
-export declare function unparseDo(node: DoNode, options: UnparseOptions): string;

package/dist/cli/src/unparser/unparseSpecialExpression/unparseIfLet.d.ts

@@ -1,3 +0,0 @@
-import type { IfLetNode } from '../../builtin/specialExpressions/if-let';
-import type { UnparseOptions } from '../UnparseOptions';
-export declare function unparseIfLet(node: IfLetNode, options: UnparseOptions): string;

package/dist/cli/src/unparser/unparseSpecialExpression/unparseIfOrWhenLike.d.ts

@@ -1,6 +0,0 @@
-import type { IfNode } from '../../builtin/specialExpressions/if';
-import type { IfNotNode } from '../../builtin/specialExpressions/if-not';
-import type { WhenNode } from '../../builtin/specialExpressions/when';
-import type { WhenNotNode } from '../../builtin/specialExpressions/when-not';
-import type { UnparseOptions } from '../UnparseOptions';
-export declare function unparseIfOrWhenLike(node: WhenNode | WhenNotNode | IfNode | IfNotNode, options: UnparseOptions): string;

package/dist/cli/src/unparser/unparseSpecialExpression/unparseLet.d.ts

@@ -1,3 +0,0 @@
-import type { LetNode } from '../../builtin/specialExpressions/let';
-import type { UnparseOptions } from '../UnparseOptions';
-export declare function unparseLet(node: LetNode, options: UnparseOptions): string;

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

@@ -1,5 +0,0 @@
-import type { MetaTokens } from '../tokenizer/interface';
-import type { UnparseOptions } from './UnparseOptions';
-export declare function ensureNewlineSeparator(a: string, b: string): string;
-export declare function ensureSpaceSeparator(a: string, b: string): string;
-export declare function applyMetaTokens(value: string | number, metaTokens: MetaTokens | undefined, options: UnparseOptions): string;

package/dist/common/clojureDocs.d.ts

@@ -1 +0,0 @@
-export declare function getClojureDocsLink(functionName: string, clojureDocs?: string | null): string | null;

package/dist/reference/categories/array.d.ts

@@ -1,3 +0,0 @@
-import type { ArrayApiName } from '../api.ts';
-import type { FunctionReference } from '../index.ts';
-export declare const arrayReference: Record<ArrayApiName, FunctionReference<'Array'>>;

package/dist/reference/categories/assert.d.ts

@@ -1,3 +0,0 @@
-import type { AssertApiName } from '../api.ts';
-import type { FunctionReference } from '../index.ts';
-export declare const assertReference: Record<AssertApiName, FunctionReference<'Assert'>>;

package/dist/reference/categories/bitwise.d.ts

@@ -1,3 +0,0 @@
-import type { BitwiseApiName } from '../api.ts';
-import type { FunctionReference } from '../index.ts';
-export declare const bitwiseReference: Record<BitwiseApiName, FunctionReference<'Bitwise'>>;

package/dist/reference/categories/collection.d.ts

@@ -1,3 +0,0 @@
-import type { CollectionApiName } from '../api.ts';
-import type { FunctionReference } from '../index.ts';
-export declare const collectionReference: Record<CollectionApiName, FunctionReference<'Collection'>>;

package/dist/reference/categories/functional.d.ts

@@ -1,3 +0,0 @@
-import type { FunctionalApiName } from '../api.ts';
-import type { FunctionReference } from '../index.ts';
-export declare const functionalReference: Record<FunctionalApiName, FunctionReference<'Functional'>>;

package/dist/reference/categories/math.d.ts

@@ -1,3 +0,0 @@
-import type { FunctionReference } from '..';
-import type { MathApiName } from '../api';
-export declare const mathReference: Record<MathApiName, FunctionReference<'Math'>>;

package/dist/reference/categories/misc.d.ts

@@ -1,3 +0,0 @@
-import type { FunctionReference } from '..';
-import type { MiscApiName } from '../api';
-export declare const miscReference: Record<MiscApiName, FunctionReference<'Misc'>>;

package/dist/reference/categories/object.d.ts

@@ -1,3 +0,0 @@
-import type { FunctionReference } from '..';
-import type { ObjectApiName } from '../api';
-export declare const objectReference: Record<ObjectApiName, FunctionReference<'Object'>>;

package/dist/reference/categories/predicate.d.ts

@@ -1,3 +0,0 @@
-import type { FunctionReference } from '..';
-import type { PredicateApiName } from '../api';
-export declare const predicateReference: Record<PredicateApiName, FunctionReference<'Predicate'>>;

package/dist/reference/categories/regularExpression.d.ts

@@ -1,3 +0,0 @@
-import type { FunctionReference } from '..';
-import type { RegularExpressionApiName } from '../api';
-export declare const regularExpressionReference: Record<RegularExpressionApiName, FunctionReference<'Regular expression'>>;

package/dist/reference/categories/sequence.d.ts

@@ -1,3 +0,0 @@
-import type { FunctionReference } from '..';
-import type { SequenceApiName } from '../api';
-export declare const sequenceReference: Record<SequenceApiName, FunctionReference<'Sequence'>>;

package/dist/reference/categories/specialExpressions.d.ts

@@ -1,3 +0,0 @@
-import type { SpecialExpressionsApiName } from '../api.ts';
-import type { FunctionReference } from '../index.ts';
-export declare const specialExpressionsReference: Record<SpecialExpressionsApiName, FunctionReference<'Special expression'>>;

package/dist/reference/categories/string.d.ts

@@ -1,3 +0,0 @@
-import type { FunctionReference } from '..';
-import type { StringApiName } from '../api';
-export declare const stringReference: Record<StringApiName, FunctionReference<'String'>>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,5 +0,0 @@
-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/src/analyze/calculateOutcomes/calculateIfLetOutcomes.d.ts

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

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

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

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

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

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

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

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

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

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

@@ -1,4 +0,0 @@
-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/src/analyze/calculateOutcomes/calculateOrOutcomes.d.ts

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,18 +0,0 @@
-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;