@mojir/lits 2.1.38 → 2.1.41

package/dist/{cli/src/builtin/normalExpressions/categories → modules/src/builtin/core}/meta.d.ts

@@ -1,3 +1,3 @@
-import type { FunctionReference } from '../../../../reference';
-import type { BuiltinNormalExpressions } from '../../interface';
+import type { FunctionReference } from '../../../reference';
+import type { BuiltinNormalExpressions } from '../interface';
 export declare function getMetaNormalExpression(normalExpressionReference: Record<string, FunctionReference>): BuiltinNormalExpressions;

package/dist/{src/builtin/normalExpressions/categories → modules/src/builtin/core}/misc.d.ts

@@ -1,2 +1,2 @@
-import type { BuiltinNormalExpressions } from '../../interface';
+import type { BuiltinNormalExpressions } from '../interface';
 export declare const miscNormalExpression: BuiltinNormalExpressions;

package/dist/{src/builtin/normalExpressions/categories → modules/src/builtin/core}/object.d.ts

@@ -1,2 +1,2 @@
-import type { BuiltinNormalExpressions } from '../../interface';
+import type { BuiltinNormalExpressions } from '../interface';
 export declare const objectNormalExpression: BuiltinNormalExpressions;

package/dist/{cli/src/builtin/normalExpressions/categories → modules/src/builtin/core}/predicates.d.ts

@@ -1,2 +1,2 @@
-import type { BuiltinNormalExpressions } from '../../interface';
+import type { BuiltinNormalExpressions } from '../interface';
 export declare const predicatesNormalExpression: BuiltinNormalExpressions;

package/dist/{cli/src/builtin/normalExpressions/categories → modules/src/builtin/core}/regexp.d.ts

@@ -1,2 +1,2 @@
-import type { BuiltinNormalExpressions } from '../../interface';
+import type { BuiltinNormalExpressions } from '../interface';
 export declare const regexpNormalExpression: BuiltinNormalExpressions;

package/dist/{src/builtin/normalExpressions/categories → modules/src/builtin/core}/sequence.d.ts

@@ -1,2 +1,2 @@
-import type { BuiltinNormalExpressions } from '../../interface';
+import type { BuiltinNormalExpressions } from '../interface';
 export declare const sequenceNormalExpression: BuiltinNormalExpressions;

package/dist/{cli/src/builtin/normalExpressions/categories → modules/src/builtin/core}/string.d.ts

@@ -1,2 +1,2 @@
-import type { BuiltinNormalExpressions } from '../../interface';
+import type { BuiltinNormalExpressions } from '../interface';
 export declare const stringNormalExpression: BuiltinNormalExpressions;

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

@@ -0,0 +1,14 @@
+import type { Builtin } from './interface';
+import { specialExpressionTypes } from './specialExpressionTypes';
+export declare const specialExpressions: readonly [import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/qq").QqNode>, import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/and").AndNode>, import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/or").OrNode>, import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/array").ArrayNode>, import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/cond").CondNode>, import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/def").DefNode>, import("./interface").BuiltinSpecialExpression<boolean, import("./specialExpressions/defined").DefinedNode>, import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/block").DoNode>, import("./interface").BuiltinSpecialExpression<null, import("./specialExpressions/loops").DoSeqNode>, import("./interface").BuiltinSpecialExpression<import("..").LitsFunction, import("./specialExpressions/functions").LambdaNode>, import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/loops").ForNode>, import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/if").IfNode>, import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/let").LetNode>, import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/loop").LoopNode>, import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/object").ObjectNode>, import("./interface").BuiltinSpecialExpression<null, import("./specialExpressions/recur").RecurNode>, import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/switch").SwitchNode>, import("./interface").BuiltinSpecialExpression<null, import("./specialExpressions/throw").ThrowNode>, import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/try").TryNode>, import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/unless").UnlessNode>];
+export type SpecialExpressions = typeof specialExpressions;
+export type SpecialExpression = SpecialExpressions[number];
+export type SpecialExpressionName = keyof typeof specialExpressionTypes;
+export type CommonSpecialExpressionType = [
+    typeof specialExpressionTypes['??'] | typeof specialExpressionTypes['&&'] | typeof specialExpressionTypes['cond'] | typeof specialExpressionTypes['switch'] | typeof specialExpressionTypes['defined?'] | typeof specialExpressionTypes['block'] | typeof specialExpressionTypes['if'] | typeof specialExpressionTypes['unless'] | typeof specialExpressionTypes['||'] | typeof specialExpressionTypes['throw'] | typeof specialExpressionTypes['array'] | typeof specialExpressionTypes['object']
+];
+export type SpecialExpressionType = typeof specialExpressionTypes[SpecialExpressionName];
+export declare const builtin: Builtin;
+export declare const normalExpressionKeys: string[];
+export declare const specialExpressionKeys: string[];
+export declare const specialExpressionNameSet: Set<string>;

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

@@ -0,0 +1,110 @@
+import type { ContextStack } from '../evaluator/ContextStack';
+import type { EvaluateNode, ExecuteFunction } from '../evaluator/interface';
+import type { GetUndefinedSymbols, UndefinedSymbols } from '../getUndefinedSymbols';
+import type { Any, Arr } from '../interface';
+import type { SpecialExpressionNode } from '../parser/types';
+import type { SourceCodeInfo } from '../tokenizer/token';
+import type { SpecialExpressions } from '.';
+export type Arity = {
+    min?: number;
+    max?: number;
+};
+declare const dataTypes: readonly ["number", "string", "object", "array", "vector", "matrix", "grid", "boolean", "function", "integer", "any", "null", "collection", "sequence", "regexp", "never"];
+export type DataType = typeof dataTypes[number];
+export declare function isDataType(arg: string): arg is DataType;
+export declare const categoryRecord: {
+    readonly 'Special expression': true;
+    readonly Predicate: true;
+    readonly Sequence: true;
+    readonly Collection: true;
+    readonly Array: true;
+    readonly Object: true;
+    readonly String: true;
+    readonly Math: true;
+    readonly Functional: true;
+    readonly 'Regular expression': true;
+    readonly Bitwise: true;
+    readonly Misc: true;
+    readonly Meta: true;
+    readonly Assert: true;
+    readonly Vector: true;
+    readonly 'Linear Algebra': true;
+    readonly Matrix: true;
+    readonly Grid: true;
+    readonly 'Number-Theory': true;
+    readonly Random: true;
+    readonly Shorthand: true;
+    readonly Datatype: true;
+};
+export type Category = keyof typeof categoryRecord;
+export declare const categories: Category[];
+export declare const moduleCategories: Category[];
+export declare const coreCategories: ("String" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Array" | "Object" | "Math" | "Functional" | "Regular expression" | "Bitwise" | "Misc" | "Meta" | "Assert" | "Vector" | "Linear Algebra" | "Matrix" | "Grid" | "Number-Theory" | "Random" | "Shorthand" | "Datatype")[];
+export interface TypedValue {
+    type: DataType[] | DataType;
+    rest?: true;
+    array?: true;
+}
+export type Argument = TypedValue & {
+    description?: string;
+};
+export interface Variant {
+    argumentNames: string[];
+}
+export interface FunctionDocs {
+    category: Category;
+    description: string;
+    returns: TypedValue;
+    args: Record<string, Argument>;
+    variants: Variant[];
+    examples: string[];
+    seeAlso?: string[];
+    hideOperatorForm?: true;
+    tags?: string[];
+}
+export interface CustomDocs {
+    category: Category;
+    description: string;
+    customVariants: string[];
+    details?: [string, string, string | undefined][];
+    returns?: TypedValue;
+    examples: string[];
+    seeAlso?: string[];
+    tags?: string[];
+}
+export type SpecialExpressionDocs = FunctionDocs | CustomDocs;
+export declare function isFunctionDocs(docs: SpecialExpressionDocs): docs is FunctionDocs;
+export declare function isCustomDocs(docs: SpecialExpressionDocs): docs is CustomDocs;
+export type NormalExpressionEvaluator<T> = (params: Arr, sourceCodeInfo: SourceCodeInfo | undefined, contextStack: ContextStack, { executeFunction }: {
+    executeFunction: ExecuteFunction;
+}) => T;
+export interface BuiltinNormalExpression<T> {
+    evaluate: NormalExpressionEvaluator<T>;
+    name?: string;
+    arity: Arity;
+    docs?: FunctionDocs;
+}
+export type BuiltinNormalExpressions = Record<string, BuiltinNormalExpression<Any>>;
+export type BuiltinAllNormalExpressions = BuiltinNormalExpression<Any>[];
+export interface EvaluateHelpers {
+    evaluateNode: EvaluateNode;
+    builtin: Builtin;
+    getUndefinedSymbols: GetUndefinedSymbols;
+}
+export interface BuiltinSpecialExpression<T, N extends SpecialExpressionNode> {
+    evaluate: (node: N, contextStack: ContextStack, helpers: EvaluateHelpers) => T;
+    evaluateAsNormalExpression?: NormalExpressionEvaluator<T>;
+    arity: Arity;
+    docs?: SpecialExpressionDocs;
+    getUndefinedSymbols: (node: N, contextStack: ContextStack, params: {
+        getUndefinedSymbols: GetUndefinedSymbols;
+        builtin: Builtin;
+        evaluateNode: EvaluateNode;
+    }) => UndefinedSymbols;
+}
+export interface Builtin {
+    normalExpressions: BuiltinNormalExpressions;
+    allNormalExpressions: BuiltinAllNormalExpressions;
+    specialExpressions: SpecialExpressions;
+}
+export {};

package/dist/modules/src/builtin/modules/assert/docs.d.ts

@@ -0,0 +1,2 @@
+import type { FunctionDocs } from '../../interface';
+export declare const moduleDocs: Record<string, FunctionDocs>;

package/dist/modules/src/builtin/modules/assert/index.d.ts

@@ -0,0 +1,2 @@
+import type { LitsModule } from '../interface';
+export declare const assertModule: LitsModule;

package/dist/modules/src/builtin/modules/grid/docs.d.ts

@@ -0,0 +1,2 @@
+import type { FunctionDocs } from '../../interface';
+export declare const moduleDocs: Record<string, FunctionDocs>;

package/dist/modules/src/builtin/modules/grid/index.d.ts

@@ -0,0 +1,2 @@
+import type { LitsModule } from '../interface';
+export declare const gridModule: LitsModule;

package/dist/{src/builtin/normalExpressions/categories/namespaces → modules/src/builtin/modules}/grid/transpose.d.ts

@@ -1,2 +1,2 @@
-import type { Any } from '../../../../../interface';
+import type { Any } from '../../../interface';
 export declare function transpose<T extends Any>(grid: T[][]): T[][];

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

@@ -0,0 +1,11 @@
+import type { BuiltinNormalExpressions } from '../../builtin/interface';
+/**
+ * Represents a Lits module that can be imported dynamically.
+ * Modules contain a collection of functions that are not part of the core bundle.
+ */
+export interface LitsModule {
+    /** The name of the module (e.g., 'grid', 'vec', 'mat') */
+    name: string;
+    /** The functions provided by this module, keyed by their short name (e.g., 'transpose') */
+    functions: BuiltinNormalExpressions;
+}

package/dist/modules/src/builtin/modules/linearAlgebra/docs.d.ts

@@ -0,0 +1,2 @@
+import type { FunctionDocs } from '../../interface';
+export declare const moduleDocs: Record<string, FunctionDocs>;

package/dist/{src/builtin/normalExpressions/categories/namespaces → modules/src/builtin/modules}/linearAlgebra/helpers/getUnit.d.ts

@@ -1,2 +1,2 @@
-import type { SourceCodeInfo } from '../../../../../../tokenizer/token';
+import type { SourceCodeInfo } from '../../../../tokenizer/token';
 export declare function getUnit<T extends number[]>(value: T, sourceCodeInfo: SourceCodeInfo | undefined): T;

package/dist/modules/src/builtin/modules/linearAlgebra/index.d.ts

@@ -0,0 +1,4 @@
+import type { BuiltinNormalExpressions } from '../../../builtin/interface';
+import type { LitsModule } from '../interface';
+export declare const linearAlgebraNormalExpression: BuiltinNormalExpressions;
+export declare const linearAlgebraModule: LitsModule;

package/dist/modules/src/builtin/modules/matrix/docs.d.ts

@@ -0,0 +1,2 @@
+import type { FunctionDocs } from '../../interface';
+export declare const moduleDocs: Record<string, FunctionDocs>;

package/dist/modules/src/builtin/modules/matrix/index.d.ts

@@ -0,0 +1,4 @@
+import type { BuiltinNormalExpressions } from '../../../builtin/interface';
+import type { LitsModule } from '../interface';
+export declare const matrixNormalExpression: BuiltinNormalExpressions;
+export declare const matrixModule: LitsModule;

package/dist/{cli/src/builtin/normalExpressions/categories/namespaces → modules/src/builtin/modules}/numberTheory/combinations.d.ts

@@ -1,2 +1,2 @@
-import type { BuiltinNormalExpressions } from '../../../../interface';
+import type { BuiltinNormalExpressions } from '../../../builtin/interface';
 export declare const combinationsNormalExpressions: BuiltinNormalExpressions;

package/dist/{cli/src/builtin/normalExpressions/categories/namespaces → modules/src/builtin/modules}/numberTheory/derangements.d.ts

@@ -1,2 +1,2 @@
-import type { BuiltinNormalExpressions } from '../../../../interface';
+import type { BuiltinNormalExpressions } from '../../../builtin/interface';
 export declare const derangementsNormalExpressions: BuiltinNormalExpressions;

package/dist/{src/builtin/normalExpressions/categories/namespaces → modules/src/builtin/modules}/numberTheory/divisors.d.ts

@@ -1,4 +1,4 @@
-import type { BuiltinNormalExpressions } from '../../../../interface';
+import type { BuiltinNormalExpressions } from '../../../builtin/interface';
 export declare function getDivisors(n: number): number[];
 export declare function getProperDivisors(n: number): number[];
 export declare const divisorsNormalExpressions: BuiltinNormalExpressions;

package/dist/modules/src/builtin/modules/numberTheory/docs.d.ts

@@ -0,0 +1,2 @@
+import type { FunctionDocs } from '../../interface';
+export declare const moduleDocs: Record<string, FunctionDocs>;

package/dist/{cli/src/builtin/normalExpressions/categories/namespaces → modules/src/builtin/modules}/numberTheory/factorial.d.ts

@@ -1,3 +1,3 @@
-import type { BuiltinNormalExpressions } from '../../../../interface';
+import type { BuiltinNormalExpressions } from '../../../builtin/interface';
 export declare function factorialOf(n: number): number;
 export declare const factorialNormalExpressions: BuiltinNormalExpressions;

package/dist/modules/src/builtin/modules/numberTheory/index.d.ts

@@ -0,0 +1,4 @@
+import type { BuiltinNormalExpressions } from '../../../builtin/interface';
+import type { LitsModule } from '../interface';
+export declare const combinatoricalNormalExpression: BuiltinNormalExpressions;
+export declare const numberTheoryModule: LitsModule;

package/dist/{src/builtin/normalExpressions/categories/namespaces → modules/src/builtin/modules}/numberTheory/partitions.d.ts

@@ -1,2 +1,2 @@
-import type { BuiltinNormalExpressions } from '../../../../interface';
+import type { BuiltinNormalExpressions } from '../../../builtin/interface';
 export declare const partitionsNormalExpressions: BuiltinNormalExpressions;

package/dist/{cli/src/builtin/normalExpressions/categories/namespaces → modules/src/builtin/modules}/numberTheory/permutations.d.ts

@@ -1,2 +1,2 @@
-import type { BuiltinNormalExpressions } from '../../../../interface';
+import type { BuiltinNormalExpressions } from '../../../builtin/interface';
 export declare const permutationsNormalExpressions: BuiltinNormalExpressions;

package/dist/modules/src/builtin/modules/numberTheory/powerSet.d.ts

@@ -0,0 +1,2 @@
+import type { BuiltinNormalExpressions } from '../../../builtin/interface';
+export declare const powerSetNormalExpressions: BuiltinNormalExpressions;

package/dist/{src/builtin/normalExpressions/categories/namespaces → modules/src/builtin/modules}/numberTheory/primeFactors.d.ts

@@ -1,4 +1,4 @@
-import type { BuiltinNormalExpressions } from '../../../../interface';
+import type { BuiltinNormalExpressions } from '../../../builtin/interface';
 /**
  * Returns the prime factorization of a number as an array of its prime factors.
  * For example, factors(12) returns [2, 2, 3].

package/dist/{cli/src/builtin/normalExpressions/categories/namespaces → modules/src/builtin/modules}/numberTheory/sequences/bernoulli.d.ts

@@ -1,2 +1,2 @@
 import type { SequenceNormalExpressions } from '.';
-export declare const bernoulliNormalExpressions: Omit<SequenceNormalExpressions<'bernoulli'>, 'nth:bernoulli?'>;
+export declare const bernoulliNormalExpressions: Omit<SequenceNormalExpressions<'bernoulli'>, 'bernoulli?'>;

package/dist/{cli/src/builtin/normalExpressions/categories/namespaces → modules/src/builtin/modules}/numberTheory/sequences/collatz.d.ts

@@ -1,2 +1,2 @@
 import type { SequenceDefinition } from '.';
-export declare const collatzSequence: Omit<SequenceDefinition<'collatz'>, 'nth:collatz-nth' | 'nth:collatz-take-while' | 'nth:collatz?'>;
+export declare const collatzSequence: Omit<SequenceDefinition<'collatz'>, 'collatz-nth' | 'collatz-take-while' | 'collatz?'>;

package/dist/{src/builtin/normalExpressions/categories/namespaces → modules/src/builtin/modules}/numberTheory/sequences/index.d.ts

@@ -1,9 +1,9 @@
-import type { SourceCodeInfo } from '../../../../../../tokenizer/token';
-import type { BuiltinNormalExpression, BuiltinNormalExpressions } from '../../../../../interface';
-type SeqKey<T extends string> = `nth:${T}-seq`;
-type TakeWhileKey<T extends string> = `nth:${T}-take-while`;
-type NthKey<T extends string> = `nth:${T}-nth`;
-type PredKey<T extends string> = `nth:${T}?`;
+import type { SourceCodeInfo } from '../../../../tokenizer/token';
+import type { BuiltinNormalExpression, BuiltinNormalExpressions } from '../../../../builtin/interface';
+type SeqKey<T extends string> = `${T}-seq`;
+type TakeWhileKey<T extends string> = `${T}-take-while`;
+type NthKey<T extends string> = `${T}-nth`;
+type PredKey<T extends string> = `${T}?`;
 type SeqFunction<Type extends number | string> = (length: number, sourceCodeInfo: SourceCodeInfo | undefined) => Type[];
 type TakeWhileFunction<Type extends number | string> = (pred: (value: Type, index: number) => boolean, sourceCodeInfo: SourceCodeInfo | undefined) => Type[];
 type PredFunction<Type extends number | string> = (n: Type, sourceCodeInfo: SourceCodeInfo | undefined) => boolean;

package/dist/{src/builtin/normalExpressions/categories/namespaces → modules/src/builtin/modules}/numberTheory/sequences/juggler.d.ts

@@ -1,2 +1,2 @@
 import type { SequenceDefinition } from '.';
-export declare const jugglerSequence: Omit<SequenceDefinition<'juggler'>, 'nth:juggler-nth' | 'nth:juggler-take-while' | 'nth:juggler?'>;
+export declare const jugglerSequence: Omit<SequenceDefinition<'juggler'>, 'juggler-nth' | 'juggler-take-while' | 'juggler?'>;

package/dist/modules/src/builtin/modules/random/docs.d.ts

@@ -0,0 +1,2 @@
+import type { FunctionDocs } from '../../interface';
+export declare const moduleDocs: Record<string, FunctionDocs>;

package/dist/modules/src/builtin/modules/random/index.d.ts

@@ -0,0 +1,2 @@
+import type { LitsModule } from '../interface';
+export declare const randomModule: LitsModule;

package/dist/modules/src/builtin/modules/vector/docs.d.ts

@@ -0,0 +1,2 @@
+import type { FunctionDocs } from '../../interface';
+export declare const moduleDocs: Record<string, FunctionDocs>;

package/dist/modules/src/builtin/modules/vector/index.d.ts

@@ -0,0 +1,2 @@
+import type { LitsModule } from '../interface';
+export declare const vectorModule: LitsModule;

package/dist/{cli/src/builtin/normalExpressions/categories/namespaces → modules/src/builtin/modules}/vector/reductionFunctions/index.d.ts

@@ -1,8 +1,8 @@
-import type { BuiltinNormalExpressions } from '../../../../../interface';
-type VectorReductionKey<T extends string> = `vec:${T}`;
-type VectorMovingWindowKey<T extends string> = `vec:moving-${T}`;
-type VectorCenteredMovingWindowKey<T extends string> = `vec:centered-moving-${T}`;
-type VectorRunningKey<T extends string> = `vec:running-${T}`;
+import type { BuiltinNormalExpressions } from '../../../../builtin/interface';
+type VectorReductionKey<T extends string> = `${T}`;
+type VectorMovingWindowKey<T extends string> = `moving-${T}`;
+type VectorCenteredMovingWindowKey<T extends string> = `centered-moving-${T}`;
+type VectorRunningKey<T extends string> = `running-${T}`;
 export type VectorReductionKeys<T extends string> = VectorReductionKey<T> | VectorMovingWindowKey<T> | VectorCenteredMovingWindowKey<T> | VectorRunningKey<T>;
 type ReductionFunction = (vector: number[]) => number;
 export type ReductionFunctionDefinition<T extends string> = Record<VectorReductionKey<T>, ReductionFunction> & {

package/dist/modules/src/builtin/normalExpressions/index.d.ts

@@ -0,0 +1,8 @@
+import type { BuiltinNormalExpression, BuiltinNormalExpressions } from '../interface';
+import type { Any } from '../../interface';
+import type { FunctionReference } from '../../../reference';
+import type { CoreNormalExpressionName } from '../../../reference/api';
+export declare function setNormalExpressionReference(reference: Record<CoreNormalExpressionName, FunctionReference>): void;
+export declare const normalExpressions: BuiltinNormalExpressions;
+export declare const normalExpressionTypes: Record<string, number>;
+export declare const allNormalExpressions: BuiltinNormalExpression<Any>[];

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

@@ -0,0 +1,23 @@
+export declare const specialExpressionTypes: {
+    readonly '??': 0;
+    readonly '&&': 1;
+    readonly '||': 2;
+    readonly array: 3;
+    readonly cond: 4;
+    readonly '0_def': 5;
+    readonly 'defined?': 6;
+    readonly block: 7;
+    readonly doseq: 8;
+    readonly '0_lambda': 9;
+    readonly for: 10;
+    readonly if: 11;
+    readonly let: 12;
+    readonly loop: 13;
+    readonly object: 14;
+    readonly recur: 15;
+    readonly switch: 16;
+    readonly throw: 17;
+    readonly try: 18;
+    readonly unless: 19;
+};
+export type SpecialExpressionTypes = typeof specialExpressionTypes;

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

@@ -0,0 +1,6 @@
+import type { Any } from '../../interface';
+import type { Node, SpecialExpressionNode } from '../../parser/types';
+import type { BuiltinSpecialExpression } from '../interface';
+import type { specialExpressionTypes } from '../specialExpressionTypes';
+export type AndNode = SpecialExpressionNode<[typeof specialExpressionTypes['&&'], Node[]]>;
+export declare const andSpecialExpression: BuiltinSpecialExpression<Any, AndNode>;

package/dist/modules/src/builtin/specialExpressions/array.d.ts

@@ -0,0 +1,6 @@
+import type { Any } from '../../interface';
+import type { Node, SpecialExpressionNode } from '../../parser/types';
+import type { BuiltinSpecialExpression } from '../interface';
+import type { specialExpressionTypes } from '../specialExpressionTypes';
+export type ArrayNode = SpecialExpressionNode<[typeof specialExpressionTypes['array'], Node[]]>;
+export declare const arraySpecialExpression: BuiltinSpecialExpression<Any, ArrayNode>;

package/dist/modules/src/builtin/specialExpressions/block.d.ts

@@ -0,0 +1,6 @@
+import type { Any } from '../../interface';
+import type { Node, SpecialExpressionNode } from '../../parser/types';
+import type { BuiltinSpecialExpression } from '../interface';
+import type { specialExpressionTypes } from '../specialExpressionTypes';
+export type DoNode = SpecialExpressionNode<[typeof specialExpressionTypes['block'], Node[]]>;
+export declare const doSpecialExpression: BuiltinSpecialExpression<Any, DoNode>;

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

@@ -0,0 +1,6 @@
+import type { Any } from '../../interface';
+import type { Node, SpecialExpressionNode } from '../../parser/types';
+import type { BuiltinSpecialExpression } from '../interface';
+import type { specialExpressionTypes } from '../specialExpressionTypes';
+export type CondNode = SpecialExpressionNode<[typeof specialExpressionTypes['cond'], [Node, Node][]]>;
+export declare const condSpecialExpression: BuiltinSpecialExpression<Any, CondNode>;

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

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

package/dist/modules/src/builtin/specialExpressions/defined.d.ts

@@ -0,0 +1,5 @@
+import type { SpecialExpressionNode, SymbolNode } from '../../parser/types';
+import type { BuiltinSpecialExpression } from '../interface';
+import type { specialExpressionTypes } from '../specialExpressionTypes';
+export type DefinedNode = SpecialExpressionNode<[typeof specialExpressionTypes['defined?'], SymbolNode]>;
+export declare const definedSpecialExpression: BuiltinSpecialExpression<boolean, DefinedNode>;

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

@@ -0,0 +1,6 @@
+import { type LitsFunction, type SpecialExpressionNode } from '../../parser/types';
+import type { BuiltinSpecialExpression } from '../interface';
+import type { Function } from '../utils';
+import type { specialExpressionTypes } from '../specialExpressionTypes';
+export type LambdaNode = SpecialExpressionNode<[typeof specialExpressionTypes['0_lambda'], Function, string]>;
+export declare const lambdaSpecialExpression: BuiltinSpecialExpression<LitsFunction, LambdaNode>;

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

@@ -0,0 +1,6 @@
+import type { Any } from '../../interface';
+import type { Node, SpecialExpressionNode } from '../../parser/types';
+import type { BuiltinSpecialExpression } from '../interface';
+import type { specialExpressionTypes } from '../specialExpressionTypes';
+export type IfNode = SpecialExpressionNode<[typeof specialExpressionTypes['if'], [Node, Node, Node?]]>;
+export declare const ifSpecialExpression: BuiltinSpecialExpression<Any, IfNode>;

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

@@ -0,0 +1,6 @@
+import type { Any } from '../../interface';
+import type { BindingNode, SpecialExpressionNode } from '../../parser/types';
+import type { BuiltinSpecialExpression } from '../interface';
+import type { specialExpressionTypes } from '../specialExpressionTypes';
+export type LetNode = SpecialExpressionNode<[typeof specialExpressionTypes['let'], BindingNode]>;
+export declare const letSpecialExpression: BuiltinSpecialExpression<Any, LetNode>;

package/dist/modules/src/builtin/specialExpressions/loop.d.ts

@@ -0,0 +1,6 @@
+import type { Any } from '../../interface';
+import type { BindingNode, Node, SpecialExpressionNode } from '../../parser/types';
+import type { BuiltinSpecialExpression } from '../interface';
+import type { specialExpressionTypes } from '../specialExpressionTypes';
+export type LoopNode = SpecialExpressionNode<[typeof specialExpressionTypes['loop'], BindingNode[], Node]>;
+export declare const loopSpecialExpression: BuiltinSpecialExpression<Any, LoopNode>;

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

@@ -0,0 +1,9 @@
+import type { Any } from '../../interface';
+import type { BindingNode, Node, SpecialExpressionNode } from '../../parser/types';
+import type { BuiltinSpecialExpression } from '../interface';
+import type { specialExpressionTypes } from '../specialExpressionTypes';
+export type LoopBindingNode = [BindingNode, BindingNode[], Node?, Node?];
+export type ForNode = SpecialExpressionNode<[typeof specialExpressionTypes['for'], LoopBindingNode[], Node]>;
+export type DoSeqNode = SpecialExpressionNode<[typeof specialExpressionTypes['doseq'], LoopBindingNode[], Node]>;
+export declare const forSpecialExpression: BuiltinSpecialExpression<Any, ForNode>;
+export declare const doseqSpecialExpression: BuiltinSpecialExpression<null, DoSeqNode>;

package/dist/modules/src/builtin/specialExpressions/object.d.ts

@@ -0,0 +1,6 @@
+import type { Any } from '../../interface';
+import type { Node, SpecialExpressionNode } from '../../parser/types';
+import type { BuiltinSpecialExpression } from '../interface';
+import type { specialExpressionTypes } from '../specialExpressionTypes';
+export type ObjectNode = SpecialExpressionNode<[typeof specialExpressionTypes['object'], Node[]]>;
+export declare const objectSpecialExpression: BuiltinSpecialExpression<Any, ObjectNode>;

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

@@ -0,0 +1,6 @@
+import type { Any } from '../../interface';
+import type { Node, SpecialExpressionNode } from '../../parser/types';
+import type { BuiltinSpecialExpression } from '../interface';
+import type { specialExpressionTypes } from '../specialExpressionTypes';
+export type OrNode = SpecialExpressionNode<[typeof specialExpressionTypes['||'], Node[]]>;
+export declare const orSpecialExpression: BuiltinSpecialExpression<Any, OrNode>;

package/dist/modules/src/builtin/specialExpressions/qq.d.ts

@@ -0,0 +1,6 @@
+import type { Any } from '../../interface';
+import type { Node, SpecialExpressionNode } from '../../parser/types';
+import type { BuiltinSpecialExpression } from '../interface';
+import type { specialExpressionTypes } from '../specialExpressionTypes';
+export type QqNode = SpecialExpressionNode<[typeof specialExpressionTypes['??'], Node[]]>;
+export declare const qqSpecialExpression: BuiltinSpecialExpression<Any, QqNode>;

package/dist/modules/src/builtin/specialExpressions/recur.d.ts

@@ -0,0 +1,5 @@
+import type { Node, SpecialExpressionNode } from '../../parser/types';
+import type { BuiltinSpecialExpression } from '../interface';
+import type { specialExpressionTypes } from '../specialExpressionTypes';
+export type RecurNode = SpecialExpressionNode<[typeof specialExpressionTypes['recur'], Node[]]>;
+export declare const recurSpecialExpression: BuiltinSpecialExpression<null, RecurNode>;

package/dist/modules/src/builtin/specialExpressions/switch.d.ts

@@ -0,0 +1,6 @@
+import type { Any } from '../../interface';
+import type { Node, SpecialExpressionNode } from '../../parser/types';
+import type { BuiltinSpecialExpression } from '../interface';
+import type { specialExpressionTypes } from '../specialExpressionTypes';
+export type SwitchNode = SpecialExpressionNode<[typeof specialExpressionTypes['switch'], Node, [Node, Node][]]>;
+export declare const switchSpecialExpression: BuiltinSpecialExpression<Any, SwitchNode>;

package/dist/modules/src/builtin/specialExpressions/throw.d.ts

@@ -0,0 +1,5 @@
+import type { Node, SpecialExpressionNode } from '../../parser/types';
+import type { BuiltinSpecialExpression } from '../interface';
+import type { specialExpressionTypes } from '../specialExpressionTypes';
+export type ThrowNode = SpecialExpressionNode<[typeof specialExpressionTypes['throw'], Node]>;
+export declare const throwSpecialExpression: BuiltinSpecialExpression<null, ThrowNode>;

package/dist/modules/src/builtin/specialExpressions/try.d.ts

@@ -0,0 +1,6 @@
+import type { Any } from '../../interface';
+import type { Node, SpecialExpressionNode, SymbolNode } from '../../parser/types';
+import type { BuiltinSpecialExpression } from '../interface';
+import type { specialExpressionTypes } from '../specialExpressionTypes';
+export type TryNode = SpecialExpressionNode<[typeof specialExpressionTypes['try'], Node, SymbolNode | undefined, Node]>;
+export declare const trySpecialExpression: BuiltinSpecialExpression<Any, TryNode>;

package/dist/modules/src/builtin/specialExpressions/unless.d.ts

@@ -0,0 +1,6 @@
+import type { Any } from '../../interface';
+import type { Node, SpecialExpressionNode } from '../../parser/types';
+import type { BuiltinSpecialExpression } from '../interface';
+import type { specialExpressionTypes } from '../specialExpressionTypes';
+export type UnlessNode = SpecialExpressionNode<[typeof specialExpressionTypes['unless'], [Node, Node, Node?]]>;
+export declare const unlessSpecialExpression: BuiltinSpecialExpression<Any, UnlessNode>;

package/dist/modules/src/builtin/utils.d.ts

@@ -0,0 +1,6 @@
+import type { ContextStack } from '../evaluator/ContextStack';
+import type { BindingTarget, Node } from '../parser/types';
+import type { SourceCodeInfo } from '../tokenizer/token';
+import type { Builtin } from './interface';
+export type Function = [BindingTarget[], Node[]];
+export declare function assertNameNotDefined<T>(name: T, contextStack: ContextStack, builtin: Builtin, sourceCodeInfo?: SourceCodeInfo): asserts name is T;

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

@@ -0,0 +1,19 @@
+export declare const NodeTypes: {
+    readonly Number: 1;
+    readonly String: 2;
+    readonly NormalExpression: 3;
+    readonly SpecialExpression: 4;
+    readonly UserDefinedSymbol: 5;
+    readonly NormalBuiltinSymbol: 6;
+    readonly SpecialBuiltinSymbol: 7;
+    readonly ReservedSymbol: 8;
+    readonly Binding: 9;
+    readonly Spread: 10;
+};
+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", "SpecialBuiltin", "NativeJsFunction", "Module"];
+export type FunctionType = typeof functionTypes[number];
+export declare function isFunctionType(type: unknown): type is FunctionType;
+export {};

package/dist/modules/src/errors.d.ts

@@ -0,0 +1,24 @@
+import type { Arr } from './interface';
+import type { SourceCodeInfo } from './tokenizer/token';
+export declare class RecurSignal extends Error {
+    params: Arr;
+    constructor(params: Arr);
+}
+export declare class LitsError extends Error {
+    readonly sourceCodeInfo?: SourceCodeInfo;
+    readonly shortMessage: string;
+    constructor(err: unknown, sourceCodeInfo: SourceCodeInfo | undefined);
+    getCodeMarker(): string | undefined;
+}
+export declare class UserDefinedError extends LitsError {
+    userMessage: string;
+    constructor(message: string, sourceCodeInfo?: SourceCodeInfo);
+}
+export declare class AssertionError extends LitsError {
+    constructor(message: string | Error, sourceCodeInfo?: SourceCodeInfo);
+}
+export declare class UndefinedSymbolError extends LitsError {
+    symbol: string;
+    constructor(symbolName: string, sourceCodeInfo?: SourceCodeInfo);
+}
+export declare function isLitsError(error: unknown): error is LitsError;