@mojir/lits 2.1.38 → 2.1.40

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

@@ -4,6 +4,7 @@ import type { Ast, LitsFunction } from '../parser/types';
 import type { TokenStream } from '../tokenizer/tokenize';
 import { AutoCompleter } from '../AutoCompleter/AutoCompleter';
 import type { Arity } from '../builtin/interface';
+import type { LitsModule } from '../builtin/modules/interface';
 import { Cache } from './Cache';
 export interface LitsRuntimeInfo {
     astCache: Cache | null;
@@ -19,7 +20,7 @@ export interface ContextParams {
     globalContext?: Context;
     contexts?: Context[];
     values?: Record<string, unknown>;
-    jsFunctions?: Record<string, JsFunction>;
+    jsFunctions?: Record<string, unknown>;
     globalModuleScope?: boolean;
 }
 export interface MinifyParams {
@@ -32,11 +33,13 @@ interface LitsConfig {
     initialCache?: Record<string, Ast>;
     astCacheSize?: number | null;
     debug?: boolean;
+    modules?: LitsModule[];
 }
 export declare class Lits {
     private astCache;
     private astCacheSize;
     private debug;
+    private modules;
     constructor(config?: LitsConfig);
     getRuntimeInfo(): LitsRuntimeInfo;
     run(program: string, params?: ContextParams & FilePathParams): unknown;

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

@@ -0,0 +1,2 @@
+import type { LitsModule } from './builtin/modules/interface';
+export declare const allBuiltinModules: LitsModule[];

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

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

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

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

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

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

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

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

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

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

package/dist/{src/builtin/normalExpressions/categories → cli/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/cli/src/builtin/{normalExpressions/categories → 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/cli/src/builtin/{normalExpressions/categories → 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/{src/builtin/normalExpressions/categories → cli/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/{src/builtin/normalExpressions/categories → cli/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/cli/src/builtin/{normalExpressions/categories → 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/{src/builtin/normalExpressions/categories → cli/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/cli/src/builtin/index.d.ts

@@ -1,6 +1,6 @@
 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("../parser/types").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 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;

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

@@ -9,6 +9,72 @@ 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;
@@ -16,10 +82,10 @@ export interface BuiltinNormalExpression<T> {
     evaluate: NormalExpressionEvaluator<T>;
     name?: string;
     arity: Arity;
-    aliases?: string[];
+    docs?: FunctionDocs;
 }
 export type BuiltinNormalExpressions = Record<string, BuiltinNormalExpression<Any>>;
-export type BuiltingAllNormalExpressions = BuiltinNormalExpression<Any>[];
+export type BuiltinAllNormalExpressions = BuiltinNormalExpression<Any>[];
 export interface EvaluateHelpers {
     evaluateNode: EvaluateNode;
     builtin: Builtin;
@@ -29,6 +95,7 @@ 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;
@@ -37,6 +104,7 @@ export interface BuiltinSpecialExpression<T, N extends SpecialExpressionNode> {
 }
 export interface Builtin {
     normalExpressions: BuiltinNormalExpressions;
-    allNormalExpressions: BuiltingAllNormalExpressions;
+    allNormalExpressions: BuiltinAllNormalExpressions;
     specialExpressions: SpecialExpressions;
 }
+export {};

package/dist/cli/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/cli/src/builtin/modules/assert/index.d.ts

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

package/dist/cli/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/cli/src/builtin/modules/grid/index.d.ts

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

package/dist/cli/src/builtin/{normalExpressions/categories/namespaces → 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/cli/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/cli/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/cli/src/builtin/{normalExpressions/categories/namespaces → 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/cli/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/cli/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/cli/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/{src/builtin/normalExpressions/categories/namespaces → cli/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/{src/builtin/normalExpressions/categories/namespaces → cli/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/cli/src/builtin/{normalExpressions/categories/namespaces → 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/cli/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/{src/builtin/normalExpressions/categories/namespaces → cli/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/cli/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/cli/src/builtin/{normalExpressions/categories/namespaces → 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/{src/builtin/normalExpressions/categories/namespaces → cli/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/cli/src/builtin/modules/numberTheory/powerSet.d.ts

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

package/dist/cli/src/builtin/{normalExpressions/categories/namespaces → 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/{src/builtin/normalExpressions/categories/namespaces → cli/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/{src/builtin/normalExpressions/categories/namespaces → cli/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/cli/src/builtin/{normalExpressions/categories/namespaces → 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/cli/src/builtin/{normalExpressions/categories/namespaces → 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/cli/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/cli/src/builtin/modules/random/index.d.ts

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

package/dist/cli/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/cli/src/builtin/modules/vector/index.d.ts

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

package/dist/{src/builtin/normalExpressions/categories/namespaces → cli/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/cli/src/builtin/normalExpressions/index.d.ts

@@ -1,8 +1,8 @@
 import type { BuiltinNormalExpression, BuiltinNormalExpressions } from '../interface';
 import type { Any } from '../../interface';
 import type { FunctionReference } from '../../../reference';
-import type { NormalExpressionName } from '../../../reference/api';
-export declare function setNormalExpressionReference(reference: Record<NormalExpressionName, FunctionReference>): void;
+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/cli/src/builtin/specialExpressions/qq.d.ts

@@ -2,5 +2,5 @@ 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, Node | undefined]]>;
+export type QqNode = SpecialExpressionNode<[typeof specialExpressionTypes['??'], Node[]]>;
 export declare const qqSpecialExpression: BuiltinSpecialExpression<Any, QqNode>;

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

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-export {};
+import '../../src/initReferenceData';

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

@@ -13,7 +13,7 @@ export declare const NodeTypes: {
 export type NodeType = typeof NodeTypes[keyof typeof NodeTypes];
 export declare function getNodeTypeName(type: NodeType): keyof typeof NodeTypes;
 export declare function isNodeType(type: unknown): type is NodeType;
-declare const functionTypes: readonly ["UserDefined", "Partial", "Comp", "Constantly", "Juxt", "Complement", "EveryPred", "SomePred", "Fnull", "Builtin", "SpecialBuiltin", "NativeJsFunction"];
+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/cli/src/evaluator/ContextStack.d.ts

@@ -1,6 +1,7 @@
 import type { Any } from '../interface';
 import type { ContextParams } from '../Lits/Lits';
-import type { NativeJsNamespace, SymbolNode, UserDefinedSymbolNode } from '../parser/types';
+import type { LitsModule } from '../builtin/modules/interface';
+import { type NativeJsModule, type SymbolNode, type UserDefinedSymbolNode } from '../parser/types';
 import type { SourceCodeInfo } from '../tokenizer/token';
 import type { Context, LookUpResult } from './interface';
 export type ContextStack = ContextStackImpl;
@@ -9,11 +10,14 @@ export declare class ContextStackImpl {
     globalContext: Context;
     private values?;
     private nativeJsFunctions?;
-    constructor({ contexts, values: hostValues, nativeJsFunctions, }: {
+    private modules;
+    constructor({ contexts, values: hostValues, nativeJsFunctions, modules, }: {
         contexts: Context[];
         values?: Record<string, unknown>;
-        nativeJsFunctions?: NativeJsNamespace;
+        nativeJsFunctions?: NativeJsModule;
+        modules?: Map<string, LitsModule>;
     });
+    getModule(name: string): LitsModule | undefined;
     create(context: Context): ContextStack;
     new(context: Context): ContextStack;
     exportValues(values: Record<string, Any>, sourceCodeInfo: SourceCodeInfo | undefined): void;
@@ -22,4 +26,4 @@ export declare class ContextStackImpl {
     lookUp(node: UserDefinedSymbolNode): LookUpResult;
     evaluateSymbol(node: SymbolNode): Any;
 }
-export declare function createContextStack(params?: ContextParams): ContextStack;
+export declare function createContextStack(params?: ContextParams, modules?: Map<string, LitsModule>): ContextStack;

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

@@ -0,0 +1,14 @@
+export { isBuiltinFunction, isLitsFunction, asLitsFunction, assertLitsFunction, isUserDefinedFunction, asUserDefinedFunction, assertUserDefinedFunction, isNativeJsFunction, asNativeJsFunction, assertNativeJsFunction, } from './typeGuards/litsFunction';
+export { type Arity } from './builtin/interface';
+export { type LitsFunction, type NativeJsFunction } from './parser/types';
+export type { Context } from './evaluator/interface';
+export type { Ast } from './parser/types';
+export type { SourceCodeInfo } from './tokenizer/token';
+export type { Token, TokenType } from './tokenizer/token';
+export { normalExpressionKeys, specialExpressionKeys } from './builtin';
+export { Lits } from './Lits/Lits';
+export type { LitsModule } from './builtin/modules/interface';
+export { type LitsError, isLitsError } from './errors';
+export type { ContextParams, FilePathParams, MinifyParams, LitsRuntimeInfo, JsFunction } from './Lits/Lits';
+export { isGrid, isMatrix, isVector } from './typeGuards/annotatedArrays';
+export type { AutoCompleter } from './AutoCompleter/AutoCompleter';

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

@@ -0,0 +1 @@
+export {};

package/dist/cli/src/js-interop/Cli/Fs/index.d.ts

@@ -0,0 +1,2 @@
+import type { GetFsModule } from '../../utils';
+export declare const getFsModule: GetFsModule;

package/dist/cli/src/js-interop/Cli/Proc/index.d.ts

@@ -0,0 +1,3 @@
+import type { GetFsModule } from '../../utils';
+export declare function sys_cwd(): string;
+export declare const getProcModule: GetFsModule;

package/dist/cli/src/js-interop/Cli/index.d.ts

@@ -0,0 +1,3 @@
+export declare function getCliModule(): {
+    [x: string]: unknown;
+};

package/dist/cli/src/js-interop/utils.d.ts

@@ -0,0 +1,2 @@
+export type Module = Record<string, unknown>;
+export type GetFsModule = (modulePath: string[]) => Module;

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

@@ -30,8 +30,10 @@ export interface NativeJsFunction extends GenericLitsFunction {
     nativeFn: JsFunction;
     docString: string;
 }
-export interface NativeJsNamespace {
-    [key: string]: NativeJsFunction | NativeJsNamespace;
+export declare function isJsFunction(fn: unknown): fn is JsFunction;
+export declare function assertJsFunction(fn: unknown): asserts fn is JsFunction;
+export interface NativeJsModule {
+    [key: string]: NativeJsFunction | NativeJsModule;
 }
 export interface UserDefinedFunction extends GenericLitsFunction {
     functionType: 'UserDefined';
@@ -83,7 +85,12 @@ export interface SpecialBuiltinFunction extends GenericLitsFunction {
     functionType: 'SpecialBuiltin';
     specialBuiltinSymbolType: typeof specialExpressionTypes['&&'] | typeof specialExpressionTypes['||'] | typeof specialExpressionTypes['array'] | typeof specialExpressionTypes['object'] | typeof specialExpressionTypes['defined?'] | typeof specialExpressionTypes['recur'] | typeof specialExpressionTypes['throw'] | typeof specialExpressionTypes['??'];
 }
-export type LitsFunction = NativeJsFunction | UserDefinedFunction | NormalBuiltinFunction | SpecialBuiltinFunction | PartialFunction | CompFunction | ConstantlyFunction | JuxtFunction | ComplementFunction | EveryPredFunction | SomePredFunction | FNullFunction;
+export interface ModuleFunction extends GenericLitsFunction {
+    functionType: 'Module';
+    moduleName: string;
+    functionName: string;
+}
+export type LitsFunction = NativeJsFunction | UserDefinedFunction | NormalBuiltinFunction | SpecialBuiltinFunction | ModuleFunction | PartialFunction | CompFunction | ConstantlyFunction | JuxtFunction | ComplementFunction | EveryPredFunction | SomePredFunction | FNullFunction;
 export type LitsFunctionType = LitsFunction['functionType'];
 export type FunctionLike = LitsFunction | Coll | number;
 export type DebugData = {

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

@@ -46,6 +46,7 @@ export declare const reservedSymbolRecord: {
     readonly true: true;
     readonly false: false;
     readonly null: null;
+    readonly do: null;
     readonly else: null;
     readonly case: null;
     readonly each: null;