@mojir/lits 2.1.37 → 2.1.40

package/dist/src/builtin/modules/numberTheory/sequences/lucky.d.ts

@@ -0,0 +1,2 @@
+import type { SequenceDefinition } from '.';
+export declare const luckySequence: SequenceDefinition<'lucky'>;

package/dist/src/builtin/modules/numberTheory/sequences/mersenne.d.ts

@@ -0,0 +1 @@
+export declare const mersenneNumbers: number[];

package/dist/src/builtin/modules/numberTheory/sequences/padovan.d.ts

@@ -0,0 +1,2 @@
+import type { SequenceDefinition } from '.';
+export declare const padovanSequence: SequenceDefinition<'padovan'>;

package/dist/src/builtin/modules/numberTheory/sequences/partition.d.ts

@@ -0,0 +1 @@
+export declare const partitionNumbers: number[];

package/dist/src/builtin/modules/numberTheory/sequences/pell.d.ts

@@ -0,0 +1 @@
+export declare const pellNumbers: number[];

package/dist/src/builtin/modules/numberTheory/sequences/perfect.d.ts

@@ -0,0 +1 @@
+export declare const perfectNumbers: number[];

package/dist/src/builtin/modules/numberTheory/sequences/perfectCube.d.ts

@@ -0,0 +1,2 @@
+import type { SequenceDefinition } from '.';
+export declare const perfectCubeSequence: SequenceDefinition<'perfect-cube'>;

package/dist/src/builtin/modules/numberTheory/sequences/perfectPower.d.ts

@@ -0,0 +1,10 @@
+import type { SequenceDefinition } from '.';
+/**
+ * Checks if a number is a perfect power and returns the base and exponent if it is.
+ * A perfect power is a number that can be expressed as an integer power of another integer.
+ *
+ * @param n - The number to check
+ * @returns [base, exponent] if n is a perfect power, null otherwise
+ */
+export declare function perfectPower(n: number): [number, number] | null;
+export declare const perfectPowerSequence: SequenceDefinition<'perfect-power'>;

package/dist/src/builtin/modules/numberTheory/sequences/perfectSquare.d.ts

@@ -0,0 +1,2 @@
+import type { SequenceDefinition } from '.';
+export declare const perfectSquareSequence: SequenceDefinition<'perfect-square'>;

package/dist/src/builtin/modules/numberTheory/sequences/poligonal.d.ts

@@ -0,0 +1,2 @@
+import type { SequenceNormalExpressions } from '.';
+export declare const poligonalNormalExpressions: SequenceNormalExpressions<'polygonal'>;

package/dist/src/builtin/modules/numberTheory/sequences/prime.d.ts

@@ -0,0 +1,3 @@
+import type { SequenceDefinition } from '.';
+export declare function isPrime(num: number): boolean;
+export declare const primeSequence: SequenceDefinition<'prime'>;

package/dist/src/builtin/modules/numberTheory/sequences/recaman.d.ts

@@ -0,0 +1,9 @@
+import type { SequenceDefinition } from '.';
+/**
+ * Generates the first 'n' terms of the Recamán sequence.
+ *
+ * @param n - Number of terms to generate
+ * @returns Array containing the first n terms of the Recamán sequence
+ */
+export declare function generateRecamanSequence(n: number): number[];
+export declare const recamanSequence: SequenceDefinition<'recaman'>;

package/dist/src/builtin/modules/numberTheory/sequences/sylvester.d.ts

@@ -0,0 +1 @@
+export declare const sylvesterNumbers: number[];

package/dist/src/builtin/modules/numberTheory/sequences/thueMorse.d.ts

@@ -0,0 +1,2 @@
+import type { SequenceDefinition } from '.';
+export declare const thueMorseSequence: SequenceDefinition<'thue-morse'>;

package/dist/src/builtin/modules/numberTheory/sequences/tribonacci.d.ts

@@ -0,0 +1 @@
+export declare const tribonacciNumbers: number[];

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

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

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

@@ -0,0 +1,9 @@
+/**
+ * Counts occurrences of each integer value in an array of non-negative integers.
+ *
+ * @param array - Array of non-negative integers to count
+ * @param minLength - Minimum length of the output array (default: 0)
+ * @param weights - Optional array of weights (same length as input array)
+ * @returns An array where index i contains the count of occurrences of i in the input array
+ */
+export declare function bincount(array: number[], minLength?: number, weights?: number[]): number[];

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,2 @@
+export declare function calcStdDev(vector: number[], optionalMean?: number): number;
+export declare function calcSampleStdDev(vector: number[], optionalMean?: number): number;

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

@@ -0,0 +1,2 @@
+export declare function calcVariance(vector: number[], optionalMean?: number): number;
+export declare function calcSampleVariance(vector: number[], optionalMean?: number): number;

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

@@ -0,0 +1,8 @@
+/**
+ * Calculates the Shannon entropy of a vector.
+ * Entropy measures the amount of uncertainty or randomness in the data.
+ *
+ * @param vector - An array of values to calculate entropy for
+ * @returns The entropy value (in bits) or 0 for empty arrays
+ */
+export declare function calculateEntropy<T>(vector: T[]): number;

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

@@ -0,0 +1,9 @@
+/**
+ * Creates a histogram from an array of numbers, returning bin ranges and counts.
+ * Each bin is represented as a tuple of [minValue, maxValue, count].
+ *
+ * @param vector - Array of numeric values
+ * @param bins - Number of bins to divide the data into
+ * @returns Array of tuples, each containing [binStart, binEnd, count]
+ */
+export declare function calcHistogram(vector: number[], bins: number): [number, number, number][];

package/dist/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/modules/vector/mode.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Calculates the mode (most frequent value(s)) of a dataset
+ * @param values An array of values of any type
+ * @returns An array containing the mode(s) of the dataset
+ */
+export declare function mode(values: number[]): number[];

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

@@ -0,0 +1,7 @@
+/**
+ * Checks if a vector has no extreme outliers using the IQR method
+ * @param vector An array of numbers to check for extreme outliers
+ * @returns true if there are no extreme outliers, false otherwise
+ */
+export declare function hasOutliers(vector: number[]): boolean;
+export declare function outliers(vector: number[]): number[];

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

@@ -0,0 +1,7 @@
+/**
+ * Calculate the percentile value from an array of numbers
+ * @param data Array of numbers to calculate percentile from
+ * @param percentile The percentile to calculate (0-100)
+ * @returns The value at the specified percentile
+ */
+export declare function calcPercentile(data: number[], percentile: number): number;

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

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

package/dist/src/builtin/modules/vector/reductionFunctions/entropy.d.ts

@@ -0,0 +1,2 @@
+import type { ReductionFunctionDefinition } from '.';
+export declare const entropyReductionFunction: ReductionFunctionDefinition<'entropy'>;

package/dist/src/builtin/modules/vector/reductionFunctions/giniCoefficient.d.ts

@@ -0,0 +1,2 @@
+import type { ReductionFunctionDefinition } from '.';
+export declare const giniCoefficientReductionFunction: ReductionFunctionDefinition<'gini-coefficient'>;

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

@@ -0,0 +1,13 @@
+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> & {
+    minLength?: number;
+    padding?: number;
+};
+export declare const reductionFunctionNormalExpressions: BuiltinNormalExpressions;
+export {};

package/dist/src/builtin/modules/vector/reductionFunctions/iqr.d.ts

@@ -0,0 +1,2 @@
+import type { ReductionFunctionDefinition } from '.';
+export declare const iqrReductionFunction: ReductionFunctionDefinition<'iqr'>;

package/dist/src/builtin/modules/vector/reductionFunctions/kurtosis.d.ts

@@ -0,0 +1,5 @@
+import type { ReductionFunctionDefinition } from '.';
+export declare const kurtosisReductionFunction: ReductionFunctionDefinition<'kurtosis'>;
+export declare const eccessKurtosisReductionFunction: ReductionFunctionDefinition<'excess-kurtosis'>;
+export declare const sampleKurtosisReductionFunction: ReductionFunctionDefinition<'sample-kurtosis'>;
+export declare const sampleExcessKurtosisReductionFunction: ReductionFunctionDefinition<'sample-excess-kurtosis'>;

package/dist/src/builtin/modules/vector/reductionFunctions/mad.d.ts

@@ -0,0 +1,2 @@
+import type { ReductionFunctionDefinition } from '.';
+export declare const madReductionFunction: ReductionFunctionDefinition<'mad'>;

package/dist/src/builtin/modules/vector/reductionFunctions/max.d.ts

@@ -0,0 +1,2 @@
+import type { ReductionFunctionDefinition } from '.';
+export declare const maxReductionFunction: ReductionFunctionDefinition<'max'>;

package/dist/src/builtin/modules/vector/reductionFunctions/mean.d.ts

@@ -0,0 +1,4 @@
+import type { ReductionFunctionDefinition } from '.';
+export declare const meanReductionFunction: ReductionFunctionDefinition<'mean'>;
+export declare const geometricMeanReductionFunction: ReductionFunctionDefinition<'geometric-mean'>;
+export declare const harmonicMeanReductionFunction: ReductionFunctionDefinition<'harmonic-mean'>;

package/dist/src/builtin/modules/vector/reductionFunctions/medad.d.ts

@@ -0,0 +1,2 @@
+import type { ReductionFunctionDefinition } from '.';
+export declare const medadReductionFunction: ReductionFunctionDefinition<'medad'>;

package/dist/src/builtin/modules/vector/reductionFunctions/median.d.ts

@@ -0,0 +1,2 @@
+import type { ReductionFunctionDefinition } from '.';
+export declare const medianReductionFunction: ReductionFunctionDefinition<'median'>;

package/dist/src/builtin/modules/vector/reductionFunctions/min.d.ts

@@ -0,0 +1,2 @@
+import type { ReductionFunctionDefinition } from '.';
+export declare const minReductionFunction: ReductionFunctionDefinition<'min'>;

package/dist/src/builtin/modules/vector/reductionFunctions/prod.d.ts

@@ -0,0 +1,2 @@
+import type { ReductionFunctionDefinition } from '.';
+export declare const prodReductionFunction: ReductionFunctionDefinition<'prod'>;

package/dist/src/builtin/modules/vector/reductionFunctions/rms.d.ts

@@ -0,0 +1,2 @@
+import type { ReductionFunctionDefinition } from '.';
+export declare const rmsReductionFunction: ReductionFunctionDefinition<'rms'>;

package/dist/src/builtin/modules/vector/reductionFunctions/skewness.d.ts

@@ -0,0 +1,3 @@
+import type { ReductionFunctionDefinition } from '.';
+export declare const skewnessReductionFunction: ReductionFunctionDefinition<'skewness'>;
+export declare const sampleSkewnessReductionFunction: ReductionFunctionDefinition<'sample-skewness'>;

package/dist/src/builtin/modules/vector/reductionFunctions/span.d.ts

@@ -0,0 +1,2 @@
+import type { ReductionFunctionDefinition } from '.';
+export declare const spanReductionFunction: ReductionFunctionDefinition<'span'>;

package/dist/src/builtin/modules/vector/reductionFunctions/standardDeviation.d.ts

@@ -0,0 +1,3 @@
+import type { ReductionFunctionDefinition } from '.';
+export declare const stdevReductionFunction: ReductionFunctionDefinition<'stdev'>;
+export declare const sampleStdevReductionFunction: ReductionFunctionDefinition<'sample-stdev'>;

package/dist/src/builtin/modules/vector/reductionFunctions/sum.d.ts

@@ -0,0 +1,2 @@
+import type { ReductionFunctionDefinition } from '.';
+export declare const sumReductionFunction: ReductionFunctionDefinition<'sum'>;

package/dist/src/builtin/modules/vector/reductionFunctions/variance.d.ts

@@ -0,0 +1,3 @@
+import type { ReductionFunctionDefinition } from '.';
+export declare const varianceReductionFunction: ReductionFunctionDefinition<'variance'>;
+export declare const sampleVarianceReductionFunction: ReductionFunctionDefinition<'sample-variance'>;

package/dist/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/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/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/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/src/full.d.ts

@@ -0,0 +1,27 @@
+import './initReferenceData';
+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';
+export { allBuiltinModules } from './allModules';
+export { assertModule } from './builtin/modules/assert';
+export { gridModule } from './builtin/modules/grid';
+export { randomModule } from './builtin/modules/random';
+export { vectorModule } from './builtin/modules/vector';
+export { linearAlgebraModule } from './builtin/modules/linearAlgebra';
+export { matrixModule } from './builtin/modules/matrix';
+export { numberTheoryModule } from './builtin/modules/numberTheory';
+export { apiReference, isCustomReference, isDatatypeReference, isFunctionReference, isShorthandReference } from '../reference';
+export type { Argument, CommonReference, CustomReference, DatatypeReference, FunctionReference, Reference, ShorthandReference } from '../reference';
+export type { ApiName, FunctionName, ShorthandName, DatatypeName } from '../reference/api';
+export { isApiName, isDataType } from '../reference/api';

package/dist/src/index.d.ts

@@ -7,11 +7,8 @@ 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 { apiReference, isDatatypeReference, isFunctionReference, isShorthandReference } from '../reference';
-export type { Argument, CommonReference, DatatypeReference, FunctionReference, Reference, ShorthandReference } from '../reference';
-export type { ApiName, FunctionName, ShorthandName, DatatypeName } from '../reference/api';
-export { isApiName, isDataType } from '../reference/api';
 export { isGrid, isMatrix, isVector } from './typeGuards/annotatedArrays';
 export type { AutoCompleter } from './AutoCompleter/AutoCompleter';

package/dist/src/initReferenceData.d.ts

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

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

@@ -0,0 +1,2 @@
+export { assertModule } from '../builtin/modules/assert';
+export type { LitsModule } from '../builtin/modules/interface';

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

@@ -0,0 +1,2 @@
+export { gridModule } from '../builtin/modules/grid';
+export type { LitsModule } from '../builtin/modules/interface';

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

@@ -0,0 +1,2 @@
+export { linearAlgebraModule } from '../builtin/modules/linearAlgebra';
+export type { LitsModule } from '../builtin/modules/interface';

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

@@ -0,0 +1,2 @@
+export { matrixModule } from '../builtin/modules/matrix';
+export type { LitsModule } from '../builtin/modules/interface';

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

@@ -0,0 +1,2 @@
+export { numberTheoryModule } from '../builtin/modules/numberTheory';
+export type { LitsModule } from '../builtin/modules/interface';

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

@@ -0,0 +1,2 @@
+export { randomModule } from '../builtin/modules/random';
+export type { LitsModule } from '../builtin/modules/interface';

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

@@ -0,0 +1,2 @@
+export { vectorModule } from '../builtin/modules/vector';
+export type { LitsModule } from '../builtin/modules/interface';

package/dist/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/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;

package/dist/src/tokenizer/token.d.ts

@@ -1,6 +1,6 @@
 import type { ReservedSymbol } from './reservedNames';
 import { type SymbolicBinaryOperator, type SymbolicOperator } from './operators';
-export declare const tokenTypes: readonly ["LBrace", "LBracket", "RBrace", "RBracket", "LParen", "RParen", "BasePrefixedNumber", "DocString", "Error", "MultiLineComment", "Number", "Operator", "RegexpShorthand", "ReservedSymbol", "SingleLineComment", "String", "Symbol", "Whitespace"];
+export declare const tokenTypes: readonly ["LBrace", "LBracket", "RBrace", "RBracket", "LParen", "RParen", "BasePrefixedNumber", "DocString", "Error", "MultiLineComment", "Number", "Operator", "RegexpShorthand", "ReservedSymbol", "SingleLineComment", "Shebang", "String", "Symbol", "Whitespace"];
 export type TokenType = typeof tokenTypes[number];
 declare const modifierNames: readonly ["&rest", "&let", "&when", "&while"];
 export type ModifierName = typeof modifierNames[number];
@@ -19,11 +19,12 @@ export type OperatorToken<T extends SymbolicOperator = SymbolicOperator> = Gener
 export type RegexpShorthandToken = GenericToken<'RegexpShorthand'>;
 export type ReservedSymbolToken<T extends ReservedSymbol = ReservedSymbol> = GenericToken<'ReservedSymbol', T>;
 export type SingleLineCommentToken = GenericToken<'SingleLineComment'>;
+export type ShebangToken = GenericToken<'Shebang'>;
 export type StringToken = GenericToken<'String'>;
 export type DocStringToken = GenericToken<'DocString'>;
 export type SymbolToken<T extends string = string> = GenericToken<'Symbol', T>;
 export type WhitespaceToken = GenericToken<'Whitespace'>;
-export type Token = LBraceToken | LBracketToken | LParenToken | RBraceToken | RBracketToken | RParenToken | BasePrefixedNumberToken | DocStringToken | ErrorToken | MultiLineCommentToken | NumberToken | OperatorToken | RegexpShorthandToken | ReservedSymbolToken | SingleLineCommentToken | StringToken | SymbolToken | WhitespaceToken;
+export type Token = LBraceToken | LBracketToken | LParenToken | RBraceToken | RBracketToken | RParenToken | BasePrefixedNumberToken | DocStringToken | ErrorToken | MultiLineCommentToken | NumberToken | OperatorToken | RegexpShorthandToken | ReservedSymbolToken | SingleLineCommentToken | ShebangToken | StringToken | SymbolToken | WhitespaceToken;
 export type TokenDescriptor<T extends Token> = [length: number, token?: T];
 export interface SourceCodeInfo {
     position: {
@@ -39,12 +40,9 @@ export declare function asSymbolToken<T extends string>(token: Token | undefined
 export declare function isReservedSymbolToken<T extends ReservedSymbol>(token: Token | undefined | undefined, symbolName?: T): token is ReservedSymbolToken<T>;
 export declare function assertReservedSymbolToken<T extends ReservedSymbol>(token: Token | undefined | undefined, symbolName?: T): asserts token is ReservedSymbolToken<T>;
 export declare function asReservedSymbolToken<T extends ReservedSymbol>(token: Token | undefined | undefined, symbolName?: T): ReservedSymbolToken<T>;
+export declare function isShebangToken(token: Token | undefined): token is SingleLineCommentToken;
 export declare function isSingleLineCommentToken(token: Token | undefined): token is SingleLineCommentToken;
-export declare function assertSingleLineCommentToken(token: Token | undefined): asserts token is SingleLineCommentToken;
-export declare function asSingleLineCommentToken(token: Token | undefined): SingleLineCommentToken;
 export declare function isMultiLineCommentToken(token: Token | undefined): token is MultiLineCommentToken;
-export declare function assertMultiLineCommentToken(token: Token | undefined): asserts token is MultiLineCommentToken;
-export declare function asMultiLineCommentToken(token: Token | undefined): MultiLineCommentToken;
 export declare function isOperatorToken<T extends SymbolicOperator>(token: Token | undefined | undefined, operatorName?: T): token is OperatorToken<T>;
 export declare function assertOperatorToken<T extends SymbolicOperator>(token: Token | undefined | undefined, operatorName?: T): asserts token is OperatorToken<T>;
 export declare function asOperatorToken<T extends SymbolicOperator>(token: Token | undefined | undefined, operatorName?: T): OperatorToken<T>;

package/dist/src/tokenizer/tokenizers.d.ts

@@ -9,5 +9,6 @@ export declare const tokenizeSymbol: Tokenizer<SymbolToken>;
 export declare const tokenizeReservedSymbolToken: Tokenizer<ReservedSymbolToken>;
 export declare const tokenizeOperator: Tokenizer<OperatorToken>;
 export declare const tokenizeMultiLineComment: Tokenizer<MultiLineCommentToken>;
+export declare const tokenizeShebang: Tokenizer<SingleLineCommentToken>;
 export declare const tokenizeSingleLineComment: Tokenizer<SingleLineCommentToken>;
 export declare const tokenizers: [Tokenizer<WhitespaceToken>, Tokenizer<MultiLineCommentToken>, Tokenizer<SingleLineCommentToken>, Tokenizer<ReservedSymbolToken>, Tokenizer<LParenToken>, Tokenizer<RParenToken>, Tokenizer<LBracketToken>, Tokenizer<RBracketToken>, Tokenizer<LBraceToken>, Tokenizer<RBraceToken>, Tokenizer<DocStringToken>, Tokenizer<StringToken>, Tokenizer<RegexpShorthandToken>, Tokenizer<BasePrefixedNumberToken>, Tokenizer<NumberToken>, Tokenizer<OperatorToken>, Tokenizer<SymbolToken>];