@mojir/dvala 0.0.1 → 0.0.2

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

@@ -0,0 +1,113 @@
+import type { ContextStack } from '../evaluator/ContextStack';
+import type { EvaluateNode, ExecuteFunction } from '../evaluator/interface';
+import type { GetUndefinedSymbols, UndefinedSymbols } from '../getUndefinedSymbols';
+import type { Any, Arr } from '../interface';
+import type { SpecialExpressionNode } from '../parser/types';
+import type { SourceCodeInfo } from '../tokenizer/token';
+import type { MaybePromise } from '../utils/maybePromise';
+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 assertion: true;
+    readonly vector: true;
+    readonly 'linear-algebra': true;
+    readonly matrix: true;
+    readonly grid: true;
+    readonly 'number-theory': true;
+    readonly random: true;
+    readonly convert: true;
+    readonly shorthand: true;
+    readonly datatype: true;
+    readonly effect: 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;
+}) => MaybePromise<T>;
+export interface BuiltinNormalExpression<T> {
+    evaluate: NormalExpressionEvaluator<T>;
+    pure?: boolean;
+    name?: string;
+    arity: Arity;
+    docs?: FunctionDocs;
+}
+export type BuiltinNormalExpressions = Record<string, BuiltinNormalExpression<Any>>;
+type BuiltinAllNormalExpressions = BuiltinNormalExpression<Any>[];
+interface EvaluateHelpers {
+    evaluateNode: EvaluateNode;
+    builtin: Builtin;
+    getUndefinedSymbols: GetUndefinedSymbols;
+}
+export interface BuiltinSpecialExpression<T, N extends SpecialExpressionNode> {
+    evaluate?: (node: N, contextStack: ContextStack, helpers: EvaluateHelpers) => MaybePromise<T>;
+    evaluateAsNormalExpression?: NormalExpressionEvaluator<T>;
+    arity: Arity;
+    docs?: SpecialExpressionDocs;
+    getUndefinedSymbols: (node: N, contextStack: ContextStack, params: {
+        getUndefinedSymbols: GetUndefinedSymbols;
+        builtin: Builtin;
+        evaluateNode: EvaluateNode;
+    }) => UndefinedSymbols;
+}
+export interface Builtin {
+    normalExpressions: BuiltinNormalExpressions;
+    allNormalExpressions: BuiltinAllNormalExpressions;
+    specialExpressions: SpecialExpressions;
+}
+export {};

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,11 @@
+import type { BuiltinNormalExpressions } from '../../builtin/interface';
+/**
+ * Represents a Dvala module that can be imported dynamically.
+ * Modules contain a collection of functions that are not part of the core bundle.
+ */
+export interface DvalaModule {
+    /** 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/linear-algebra/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/linear-algebra/helpers/calcFractionalRanks.d.ts

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

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

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

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

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

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

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

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

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

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

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

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

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

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/helpers/adjugate.d.ts

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

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

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

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

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

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

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

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

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

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

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

package/dist/cli/src/builtin/modules/matrix/helpers/norm1.d.ts

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,27 @@
+import type { SourceCodeInfo } from '../../../../tokenizer/token';
+import type { MaybePromise } from '../../../../utils/maybePromise';
+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) => MaybePromise<boolean>, sourceCodeInfo: SourceCodeInfo | undefined) => MaybePromise<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/cli/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/cli/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/cli/src/builtin/modules/number-theory/sequences/lucas.d.ts

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

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

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

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

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

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

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

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

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

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