@mojir/lits 2.2.2-alpha.6 → 2.2.3

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

@@ -1,4 +1,4 @@
-import type { Ast } from '../parser/interface';
+import type { Ast } from '../parser/types';
 export declare class Cache {
     private cache;
     private firstEntry;

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

@@ -1,54 +1,58 @@
-import type { Analysis } from '../analyze';
 import type { Context } from '../evaluator/interface';
 import type { Any } from '../interface';
-import type { Ast, LitsFunction } from '../parser/interface';
-import type { TokenStream, TokenizeParams } from '../tokenizer/interface';
+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;
     astCacheSize: number | null;
     debug: boolean;
 }
-export interface LazyValue {
-    read: () => unknown;
-    [key: string]: unknown;
-}
 export interface JsFunction {
     fn: (...args: any[]) => unknown;
+    arity?: Arity;
+    docString?: string;
 }
-export interface LitsParams {
+export interface ContextParams {
     globalContext?: Context;
     contexts?: Context[];
     values?: Record<string, unknown>;
-    lazyValues?: Record<string, LazyValue>;
-    jsFunctions?: Record<string, JsFunction>;
+    jsFunctions?: Record<string, unknown>;
+    globalModuleScope?: boolean;
+}
+export interface MinifyParams {
+    minify?: boolean;
+}
+export interface FilePathParams {
     filePath?: string;
-    debug?: boolean;
 }
 interface LitsConfig {
     initialCache?: Record<string, Ast>;
     astCacheSize?: number | null;
     debug?: boolean;
+    modules?: LitsModule[];
 }
-type FormatParams = LitsParams & {
-    lineLength?: number;
-};
 export declare class Lits {
     private astCache;
     private astCacheSize;
     private debug;
+    private modules;
     constructor(config?: LitsConfig);
     getRuntimeInfo(): LitsRuntimeInfo;
-    run(program: string, params?: LitsParams): unknown;
-    format(program: string, params?: FormatParams): string;
-    context(program: string, params?: LitsParams): Context;
-    analyze(program: string, params?: LitsParams): Analysis;
-    tokenize(program: string, tokenizeParams?: TokenizeParams): TokenStream;
+    run(program: string, params?: ContextParams & FilePathParams): unknown;
+    context(programOrAst: string | Ast, params?: ContextParams & FilePathParams): Context;
+    getUndefinedSymbols(programOrAst: string | Ast, params?: ContextParams): Set<string>;
+    tokenize(program: string, tokenizeParams?: FilePathParams & MinifyParams): TokenStream;
     parse(tokenStream: TokenStream): Ast;
-    evaluate(ast: Ast, params: LitsParams): Any;
-    transform(tokenStream: TokenStream, transformer: (name: string) => string): TokenStream;
+    evaluate(ast: Ast, params: ContextParams): Any;
+    transformSymbols(tokenStream: TokenStream, transformer: (symbol: string) => string): TokenStream;
     untokenize(tokenStream: TokenStream): string;
-    apply(fn: LitsFunction, fnParams: unknown[], params?: LitsParams): Any;
+    apply(fn: LitsFunction, fnParams: unknown[], params?: ContextParams): Any;
+    private generateApplyFunctionCall;
     private generateAst;
+    getAutoCompleter(program: string, position: number, params?: ContextParams): AutoCompleter;
 }
 export {};

package/dist/src/allModules.d.ts

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

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

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

package/dist/src/builtin/core/array.d.ts

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

package/dist/src/builtin/core/bitwise.d.ts

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

package/dist/src/builtin/core/collection.d.ts

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

package/dist/src/builtin/core/functional.d.ts

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

package/dist/src/builtin/core/math.d.ts

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

package/dist/src/builtin/core/meta.d.ts

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

package/dist/src/builtin/core/misc.d.ts

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

package/dist/src/builtin/core/object.d.ts

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

package/dist/src/builtin/core/predicates.d.ts

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

package/dist/src/builtin/core/regexp.d.ts

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

package/dist/src/builtin/core/sequence.d.ts

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

package/dist/src/builtin/core/string.d.ts

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

package/dist/src/builtin/core/vector.d.ts

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

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

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

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

@@ -1,42 +1,109 @@
-import type { FindUnresolvedIdentifiers, UnresolvedIdentifiers } from '../analyze';
 import type { ContextStack } from '../evaluator/ContextStack';
-import type { EvaluateAstNode, ExecuteFunction } from '../evaluator/interface';
+import type { EvaluateNode, ExecuteFunction } from '../evaluator/interface';
+import type { GetUndefinedSymbols, UndefinedSymbols } from '../getUndefinedSymbols';
 import type { Any, Arr } from '../interface';
-import type { NormalExpressionNode, ParseArgument, ParseBinding, ParseBindings, ParseExpression, ParseToken, ParseTokensUntilClosingBracket } from '../parser/interface';
-import type { SourceCodeInfo, Token, TokenStream } from '../tokenizer/interface';
-import type { BuiltinSpecialExpressions, SpecialExpressionNode } from '.';
-export type NormalExpressionEvaluator<T> = (params: Arr, sourceCodeInfo: SourceCodeInfo | undefined, contextStack: ContextStack, { executeFunction }: {
+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: Category[];
+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;
+type NormalExpressionEvaluator<T> = (params: Arr, sourceCodeInfo: SourceCodeInfo | undefined, contextStack: ContextStack, { executeFunction }: {
     executeFunction: ExecuteFunction;
 }) => T;
-type ValidateNode = (node: NormalExpressionNode) => void;
-interface BuiltinNormalExpression<T> {
+export interface BuiltinNormalExpression<T> {
     evaluate: NormalExpressionEvaluator<T>;
-    validate?: ValidateNode;
-}
-export interface ParserHelpers {
-    parseExpression: ParseExpression;
-    parseTokensUntilClosingBracket: ParseTokensUntilClosingBracket;
-    parseToken: ParseToken;
-    parseBinding: ParseBinding;
-    parseBindings: ParseBindings;
-    parseArgument: ParseArgument;
+    name?: string;
+    arity: Arity;
+    docs?: FunctionDocs;
 }
 export type BuiltinNormalExpressions = Record<string, BuiltinNormalExpression<Any>>;
+type BuiltinAllNormalExpressions = BuiltinNormalExpression<Any>[];
 interface EvaluateHelpers {
-    evaluateAstNode: EvaluateAstNode;
+    evaluateNode: EvaluateNode;
     builtin: Builtin;
+    getUndefinedSymbols: GetUndefinedSymbols;
 }
 export interface BuiltinSpecialExpression<T, N extends SpecialExpressionNode> {
-    parse: (tokenStream: TokenStream, position: number, firstToken: Token, parsers: ParserHelpers) => [number, N];
     evaluate: (node: N, contextStack: ContextStack, helpers: EvaluateHelpers) => T;
-    findUnresolvedIdentifiers: (node: N, contextStack: ContextStack, params: {
-        findUnresolvedIdentifiers: FindUnresolvedIdentifiers;
+    evaluateAsNormalExpression?: NormalExpressionEvaluator<T>;
+    arity: Arity;
+    docs?: SpecialExpressionDocs;
+    getUndefinedSymbols: (node: N, contextStack: ContextStack, params: {
+        getUndefinedSymbols: GetUndefinedSymbols;
         builtin: Builtin;
-        evaluateAstNode: EvaluateAstNode;
-    }) => UnresolvedIdentifiers;
+        evaluateNode: EvaluateNode;
+    }) => UndefinedSymbols;
 }
 export interface Builtin {
     normalExpressions: BuiltinNormalExpressions;
-    specialExpressions: BuiltinSpecialExpressions;
+    allNormalExpressions: BuiltinAllNormalExpressions;
+    specialExpressions: SpecialExpressions;
 }
 export {};

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,8 @@
+/**
+ * Creates a grid from a flat array with specified dimensions
+ *
+ * @param flatArray The flat array of values
+ * @param rows Number of rows in the resulting grid
+ * @returns A 2D array representing the grid
+ */
+export declare function fromArray(flatArray: unknown[], rows: number): unknown[][];

package/dist/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/modules/grid/transpose.d.ts

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

package/dist/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/src/builtin/modules/linear-algebra/docs.d.ts

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

package/dist/src/builtin/modules/linear-algebra/helpers/calcFractionalRanks.d.ts

@@ -0,0 +1 @@
+export declare function calcFractionalRanks(vector: number[]): number[];

package/dist/src/builtin/modules/linear-algebra/helpers/collinear.d.ts

@@ -0,0 +1,2 @@
+export declare function areVectorsCollinear(vectorA: number[], vectorB: number[]): boolean;
+export declare function areVectorsParallel(vectorA: number[], vectorB: number[]): boolean;

package/dist/src/builtin/modules/linear-algebra/helpers/corrleation.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Calculate Pearson correlation between two segments
+ */
+export declare function calcCorrelation(segmentA: number[], segmentB: number[]): number;
+/**
+ * Extract overlapping segments from two vectors based on lag
+ */
+export declare function extractOverlappingSegments(vectorA: number[], vectorB: number[], lag: number): [number[], number[]];

package/dist/src/builtin/modules/linear-algebra/helpers/covariance.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Calculate covariance between two segments
+ */
+export declare function calcCovariance(segmentA: number[], segmentB: number[]): number;

package/dist/src/builtin/modules/linear-algebra/helpers/dot.d.ts

@@ -0,0 +1 @@
+export declare function dot(vector1: number[], vector2: number[]): number;

package/dist/src/builtin/modules/linear-algebra/helpers/gaussJordanElimination.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Performs Gauss-Jordan elimination on a matrix, transforming it to reduced row echelon form
+ *
+ * @param matrix - The input matrix
+ * @returns A tuple containing the reduced row echelon form matrix and the rank
+ */
+export declare function gaussJordanElimination(matrix: number[][]): [number[][], number];

package/dist/src/builtin/modules/linear-algebra/helpers/getUnit.d.ts

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

package/dist/src/builtin/modules/linear-algebra/helpers/isZeroVector.d.ts

@@ -0,0 +1 @@
+export declare function isZeroVector(vector: number[]): boolean;

package/dist/src/builtin/modules/linear-algebra/helpers/kendallTau.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Calculates Kendall's Tau-b rank correlation coefficient between two vectors
+ * This implementation handles ties and uses an epsilon value for floating-point comparisons
+ *
+ * @param vectorA - First vector of numbers
+ * @param vectorB - Second vector of numbers
+ * @param epsilon - Threshold for considering two values as equal (default: 1e-10)
+ * @returns The Kendall's Tau-b correlation coefficient
+ */
+export declare function kendallTau(vectorA: number[], vectorB: number[], epsilon?: number): number;

package/dist/src/builtin/modules/linear-algebra/helpers/length.d.ts

@@ -0,0 +1 @@
+export declare function length(vector: number[]): number;

package/dist/src/builtin/modules/linear-algebra/helpers/pearsonCorr.d.ts

@@ -0,0 +1 @@
+export declare function pearsonCorr(vectorA: number[], vectorB: number[]): number;

package/dist/src/builtin/modules/linear-algebra/helpers/scale.d.ts

@@ -0,0 +1 @@
+export declare function scale<T extends number[]>(vector: T, scalar: number): T;

package/dist/src/builtin/modules/linear-algebra/helpers/solve.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Solves a system of linear equations Ax = b
+ *
+ * @param A - The coefficient matrix
+ * @param b - The constant vector
+ * @returns The solution vector x, or null if no unique solution exists
+ */
+export declare function solve(A: number[][], b: number[]): number[] | null;

package/dist/src/builtin/modules/linear-algebra/helpers/subtract.d.ts

@@ -0,0 +1 @@
+export declare function subtract<T extends number[]>(vector1: T, vector2: T): T;

package/dist/src/builtin/modules/linear-algebra/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/src/builtin/modules/math/index.d.ts

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

package/dist/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/src/builtin/modules/matrix/helpers/adjugate.d.ts

@@ -0,0 +1 @@
+export declare function adjugate(matrix: number[][]): number[][];

package/dist/src/builtin/modules/matrix/helpers/band.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Creates a band matrix with specified lower and upper bandwidths
+ *
+ * @param n Size of the square matrix
+ * @param lband Lower bandwidth (number of non-zero diagonals below main diagonal)
+ * @param uband Upper bandwidth (number of non-zero diagonals above main diagonal)
+ * @returns A 2D array representing the band matrix with 1s in the band and 0s elsewhere
+ */
+export declare function band(n: number, lband: number, uband: number): number[][];

package/dist/src/builtin/modules/matrix/helpers/cofactor.d.ts

@@ -0,0 +1 @@
+export declare function cofactor(matrix: number[][]): number[][];

package/dist/src/builtin/modules/matrix/helpers/determinant.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Calculates the determinant of a matrix using Gaussian Elimination
+ * @param matrix A square matrix represented as a 2D array
+ * @returns The determinant of the matrix
+ */
+export declare function determinant(matrix: number[][]): number;

package/dist/src/builtin/modules/matrix/helpers/diagonal.d.ts

@@ -0,0 +1 @@
+export declare function diagonal(matrix: number[][]): number[];

package/dist/src/builtin/modules/matrix/helpers/inverse.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Calculate the inverse of a matrix using the adjugate method
+ * @param matrix The input matrix
+ * @returns The inverse matrix or null if the matrix is not invertible
+ */
+export declare function inverse(matrix: number[][]): number[][] | null;

package/dist/src/builtin/modules/matrix/helpers/isBanded.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Checks if a matrix is banded with the given lower and upper bandwidth.
+ * A matrix is banded if all non-zero elements are within 'lower' diagonals
+ * below the main diagonal and 'upper' diagonals above the main diagonal.
+ *
+ * @param matrix - The matrix to check, represented as a 2D array of numbers
+ * @param lower - Number of non-zero diagonals below the main diagonal
+ * @param upper - Number of non-zero diagonals above the main diagonal
+ * @returns true if the matrix is banded with the given parameters, false otherwise
+ */
+export declare function isBanded(matrix: number[][], lower: number, upper: number): boolean;

package/dist/src/builtin/modules/matrix/helpers/isDiagonal.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Checks if a given matrix is diagonal.
+ *
+ * A matrix is considered diagonal if it is square (i.e., the number of rows equals the number of columns)
+ * and all elements outside the main diagonal are zero.
+ *
+ * @param matrix - A two-dimensional array of numbers representing the matrix to check.
+ * @returns `true` if the matrix is diagonal, otherwise `false`.
+ */
+export declare function isDiagonal(matrix: number[][]): boolean;

package/dist/src/builtin/modules/matrix/helpers/isIdentity.d.ts

@@ -0,0 +1 @@
+export declare function isIdentity(matrix: number[][]): boolean;

package/dist/src/builtin/modules/matrix/helpers/isOrthogonal.d.ts

@@ -0,0 +1 @@
+export declare function isOrthogonal(matrix: number[][]): boolean;

package/dist/src/builtin/modules/matrix/helpers/isSquare.d.ts

@@ -0,0 +1 @@
+export declare function isSquare(matrix: number[][]): boolean;

package/dist/src/builtin/modules/matrix/helpers/isSymetric.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Checks if a given matrix is symmetric.
+ * A matrix is symmetric if it is square and its transpose is equal to itself.
+ *
+ * @param matrix - A 2D array representing the matrix.
+ * @returns `true` if the matrix is symmetric, otherwise `false`.
+ */
+export declare function isSymetric(matrix: number[][]): boolean;

package/dist/src/builtin/modules/matrix/helpers/isTriangular.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Determines whether a given matrix is triangular.
+ *
+ * A triangular matrix is a square matrix where all elements
+ * below or above the main diagonal are zero. This function
+ * checks if the matrix is square and symmetric.
+ *
+ * @param matrix - A two-dimensional array of numbers representing the matrix.
+ * @returns `true` if the matrix is triangular, otherwise `false`.
+ */
+export declare function isTriangular(matrix: number[][]): boolean;
+export declare function isTriangularUpper(matrix: number[][]): boolean;
+export declare function isTriangularLower(matrix: number[][]): boolean;

package/dist/src/builtin/modules/matrix/helpers/matrixMultiply.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Performs cache-optimized matrix multiplication.
+ * @param A The first input matrix (m x n)
+ * @param B The second input matrix (n x p)
+ * @returns The result matrix C (m x p) where C = A × B
+ */
+export declare function matrixMultiply(A: number[][], B: number[][]): number[][];

package/dist/src/builtin/modules/matrix/helpers/minor.d.ts

@@ -0,0 +1 @@
+export declare function minor(matrix: number[][], row: number, col: number): number[][];