@mojir/lits 2.2.2-alpha.6 → 2.2.2

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

@@ -0,0 +1,8 @@
+/**
+ * Calculates the trace of a square matrix.
+ * The trace is defined as the sum of the elements on the main diagonal.
+ *
+ * @param matrix - A 2D array representing a square matrix.
+ * @returns The trace of the matrix.
+ */
+export declare function trace(matrix: number[][]): number;

package/dist/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/modules/number-theory/binomialCefficient.d.ts

@@ -0,0 +1 @@
+export declare function binomialCoefficient(n: number, k: number): number;

package/dist/src/builtin/modules/number-theory/combinations.d.ts

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

package/dist/src/builtin/modules/number-theory/derangements.d.ts

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

package/dist/src/builtin/modules/number-theory/divisors.d.ts

@@ -0,0 +1,4 @@
+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/src/builtin/modules/number-theory/docs.d.ts

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

package/dist/src/builtin/modules/number-theory/factorial.d.ts

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

package/dist/src/builtin/modules/number-theory/index.d.ts

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

package/dist/src/builtin/modules/number-theory/partitions.d.ts

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

package/dist/src/builtin/modules/number-theory/permutations.d.ts

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

package/dist/src/builtin/modules/number-theory/powerSet.d.ts

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

package/dist/src/builtin/modules/number-theory/primeFactors.d.ts

@@ -0,0 +1,11 @@
+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].
+ * Special case: factors(1) returns an empty array [].
+ *
+ * @param n - A positive integer to factorize
+ * @returns An array of prime factors in ascending order
+ */
+export declare function primeFactors(n: number): number[];
+export declare const primeFactorsNormalExpressions: BuiltinNormalExpressions;

package/dist/src/builtin/modules/number-theory/sequences/abundant.d.ts

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

package/dist/src/builtin/modules/number-theory/sequences/arithmetic.d.ts

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

package/dist/src/builtin/modules/number-theory/sequences/bell.d.ts

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

package/dist/src/builtin/modules/number-theory/sequences/bernoulli.d.ts

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

package/dist/src/builtin/modules/number-theory/sequences/catalan.d.ts

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

package/dist/src/builtin/modules/number-theory/sequences/collatz.d.ts

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

package/dist/src/builtin/modules/number-theory/sequences/composite.d.ts

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

package/dist/src/builtin/modules/number-theory/sequences/deficient.d.ts

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

package/dist/src/builtin/modules/number-theory/sequences/factorial.d.ts

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

package/dist/src/builtin/modules/number-theory/sequences/fibonacci.d.ts

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

package/dist/src/builtin/modules/number-theory/sequences/geometric.d.ts

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

package/dist/src/builtin/modules/number-theory/sequences/golomb.d.ts

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

package/dist/src/builtin/modules/number-theory/sequences/happy.d.ts

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

package/dist/src/builtin/modules/number-theory/sequences/index.d.ts

@@ -0,0 +1,26 @@
+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;
+export type SequenceKeys<T extends string> = SeqKey<T> | TakeWhileKey<T> | NthKey<T> | PredKey<T>;
+export type SequenceDefinition<T extends string, Type extends number | string = number> = {
+    [key in Exclude<SequenceKeys<T>, NthKey<T>>]: key extends SeqKey<T> ? SeqFunction<Type> : key extends TakeWhileKey<T> ? TakeWhileFunction<Type> : PredFunction<Type>;
+} & {
+    maxLength?: number;
+} & (Type extends string ? {
+    string: true;
+} : {
+    string?: never;
+}) & {
+    noNth?: true;
+};
+export type SequenceNormalExpressions<T extends string, Type extends string | number = number> = {
+    [key in SequenceKeys<T>]: key extends SeqKey<T> ? BuiltinNormalExpression<Type[]> : key extends TakeWhileKey<T> ? BuiltinNormalExpression<Type[]> : key extends NthKey<T> ? BuiltinNormalExpression<Type> : BuiltinNormalExpression<boolean>;
+};
+export declare const sequenceNormalExpressions: BuiltinNormalExpressions;
+export {};

package/dist/src/builtin/modules/number-theory/sequences/juggler.d.ts

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

package/dist/src/builtin/modules/number-theory/sequences/lookAndSay.d.ts

@@ -0,0 +1,2 @@
+import type { SequenceDefinition } from '.';
+export declare const lookAndSaySequence: SequenceDefinition<'look-and-say', string>;

package/dist/src/builtin/modules/number-theory/sequences/lucas.d.ts

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

package/dist/src/builtin/modules/number-theory/sequences/lucky.d.ts

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

package/dist/src/builtin/modules/number-theory/sequences/mersenne.d.ts

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

package/dist/src/builtin/modules/number-theory/sequences/padovan.d.ts

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

package/dist/src/builtin/modules/number-theory/sequences/partition.d.ts

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

package/dist/src/builtin/modules/number-theory/sequences/pell.d.ts

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

package/dist/src/builtin/modules/number-theory/sequences/perfect.d.ts

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

package/dist/src/builtin/modules/number-theory/sequences/perfectCube.d.ts

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

package/dist/src/builtin/modules/number-theory/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/number-theory/sequences/perfectSquare.d.ts

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

package/dist/src/builtin/modules/number-theory/sequences/poligonal.d.ts

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

package/dist/src/builtin/modules/number-theory/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/number-theory/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/number-theory/sequences/sylvester.d.ts

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

package/dist/src/builtin/modules/number-theory/sequences/thueMorse.d.ts

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,18 +1,6 @@
-import type { AstNode, CommonSpecialExpressionNode, LitsFunction, NameNode } from '../../parser/interface';
+import { type LitsFunction, type SpecialExpressionNode } from '../../parser/types';
 import type { BuiltinSpecialExpression } from '../interface';
-import type { FunctionOverload } from '../utils';
-export interface DefnNode extends CommonSpecialExpressionNode<'defn'> {
-    f: NameNode;
-    o: FunctionOverload[];
-}
-export interface DefnsNode extends CommonSpecialExpressionNode<'defns'> {
-    f: AstNode;
-    o: FunctionOverload[];
-}
-export interface FnNode extends CommonSpecialExpressionNode<'fn'> {
-    p: AstNode[];
-    o: FunctionOverload[];
-}
-export declare const defnSpecialExpression: BuiltinSpecialExpression<null, DefnNode>;
-export declare const defnsSpecialExpression: BuiltinSpecialExpression<null, DefnsNode>;
-export declare const fnSpecialExpression: BuiltinSpecialExpression<LitsFunction, FnNode>;
+import type { Function } from '../utils';
+import type { specialExpressionTypes } from '../specialExpressionTypes';
+export type LambdaNode = SpecialExpressionNode<[typeof specialExpressionTypes['0_lambda'], Function, string]>;
+export declare const lambdaSpecialExpression: BuiltinSpecialExpression<LitsFunction, LambdaNode>;

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

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

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

@@ -1,10 +1,6 @@
 import type { Any } from '../../interface';
-import type { BindingNode, CommonSpecialExpressionNode, NormalExpressionNode } from '../../parser/interface';
+import type { BindingNode, SpecialExpressionNode } from '../../parser/types';
 import type { BuiltinSpecialExpression } from '../interface';
-export interface LetNode extends CommonSpecialExpressionNode<'let'> {
-    bs: BindingNode[];
-    debugData: CommonSpecialExpressionNode<'let'>['debugData'] & ({
-        bindingArray: NormalExpressionNode;
-    } | undefined);
-}
+import type { specialExpressionTypes } from '../specialExpressionTypes';
+export type LetNode = SpecialExpressionNode<[typeof specialExpressionTypes['let'], BindingNode]>;
 export declare const letSpecialExpression: BuiltinSpecialExpression<Any, LetNode>;