@the-trybe/formula-engine 1.0.0

package/dist/formula-engine.d.ts

@@ -0,0 +1,79 @@
+import { FormulaEngineConfig, FormulaDefinition, EvaluationContext, EvaluationResult, EvaluationResultSet, ValidationResult, FunctionDefinition, ASTNode, CacheStats, DependencyGraph as IDependencyGraph } from './types';
+import { DecimalUtils, Decimal } from './decimal-utils';
+export declare class FormulaEngine {
+    private config;
+    private parser;
+    private evaluator;
+    private dependencyExtractor;
+    private graphBuilder;
+    private decimalUtils;
+    private functions;
+    private astCache;
+    private dependencyCache;
+    private cacheHits;
+    private cacheMisses;
+    constructor(config?: FormulaEngineConfig);
+    /**
+     * Parse an expression into an AST
+     */
+    parse(expression: string): ASTNode;
+    /**
+     * Extract variable dependencies from an expression
+     */
+    extractDependencies(expression: string): Set<string>;
+    /**
+     * Build a dependency graph from formula definitions
+     */
+    buildDependencyGraph(formulas: FormulaDefinition[]): IDependencyGraph;
+    /**
+     * Get the evaluation order for formulas
+     */
+    getEvaluationOrder(formulas: FormulaDefinition[]): string[];
+    /**
+     * Validate formulas without evaluating
+     */
+    validate(formulas: FormulaDefinition[]): ValidationResult;
+    /**
+     * Evaluate a single expression
+     */
+    evaluate(expression: string, context: EvaluationContext): EvaluationResult;
+    /**
+     * Evaluate all formulas in dependency order
+     */
+    evaluateAll(formulas: FormulaDefinition[], context: EvaluationContext): EvaluationResultSet;
+    /**
+     * Register a custom function
+     */
+    registerFunction(definition: FunctionDefinition): void;
+    /**
+     * Register multiple custom functions
+     */
+    registerFunctions(definitions: FunctionDefinition[]): void;
+    /**
+     * Get registered function names
+     */
+    getRegisteredFunctions(): string[];
+    /**
+     * Clear the AST cache
+     */
+    clearCache(): void;
+    /**
+     * Get cache statistics
+     */
+    getCacheStats(): CacheStats;
+    /**
+     * Get the decimal utilities instance
+     */
+    getDecimalUtils(): DecimalUtils;
+    /**
+     * Create a Decimal from a value
+     */
+    createDecimal(value: string | number): Decimal;
+    private checkExpressionLength;
+    private normalizeContext;
+    private convertValue;
+    private isDecimal;
+    private applyRounding;
+    private handleError;
+    private maybeEvictCache;
+}

package/dist/formula-engine.js

@@ -0,0 +1,355 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormulaEngine = void 0;
+const parser_1 = require("./parser");
+const evaluator_1 = require("./evaluator");
+const dependency_extractor_1 = require("./dependency-extractor");
+const dependency_graph_1 = require("./dependency-graph");
+const decimal_utils_1 = require("./decimal-utils");
+const functions_1 = require("./functions");
+const errors_1 = require("./errors");
+class FormulaEngine {
+    constructor(config) {
+        // Caches
+        this.astCache = new Map();
+        this.dependencyCache = new Map();
+        this.cacheHits = 0;
+        this.cacheMisses = 0;
+        this.config = {
+            enableCache: true,
+            maxCacheSize: 1000,
+            strictMode: true,
+            ...config,
+        };
+        this.decimalUtils = new decimal_utils_1.DecimalUtils(this.config.decimal);
+        this.functions = (0, functions_1.createBuiltInFunctions)(this.decimalUtils);
+        this.parser = new parser_1.Parser();
+        this.dependencyExtractor = new dependency_extractor_1.DependencyExtractor();
+        this.graphBuilder = new dependency_graph_1.DependencyGraphBuilder();
+        this.evaluator = new evaluator_1.Evaluator(this.decimalUtils, this.functions, this.config);
+        // Register any custom functions from config
+        if (this.config.functions) {
+            for (const fn of this.config.functions) {
+                this.registerFunction(fn);
+            }
+        }
+    }
+    /**
+     * Parse an expression into an AST
+     */
+    parse(expression) {
+        this.checkExpressionLength(expression);
+        if (this.config.enableCache) {
+            const cached = this.astCache.get(expression);
+            if (cached) {
+                this.cacheHits++;
+                return cached;
+            }
+            this.cacheMisses++;
+        }
+        const ast = this.parser.parse(expression);
+        if (this.config.enableCache) {
+            this.maybeEvictCache();
+            this.astCache.set(expression, ast);
+        }
+        return ast;
+    }
+    /**
+     * Extract variable dependencies from an expression
+     */
+    extractDependencies(expression) {
+        if (this.config.enableCache) {
+            const cached = this.dependencyCache.get(expression);
+            if (cached) {
+                return new Set(cached);
+            }
+        }
+        const deps = this.dependencyExtractor.extract(expression);
+        if (this.config.enableCache) {
+            this.dependencyCache.set(expression, new Set(deps));
+        }
+        return deps;
+    }
+    /**
+     * Build a dependency graph from formula definitions
+     */
+    buildDependencyGraph(formulas) {
+        return this.graphBuilder.build(formulas);
+    }
+    /**
+     * Get the evaluation order for formulas
+     */
+    getEvaluationOrder(formulas) {
+        return this.graphBuilder.getEvaluationOrder(formulas);
+    }
+    /**
+     * Validate formulas without evaluating
+     */
+    validate(formulas) {
+        const errors = [];
+        const warnings = [];
+        // Check for duplicate IDs
+        const ids = new Set();
+        for (const formula of formulas) {
+            if (ids.has(formula.id)) {
+                errors.push(new errors_1.DuplicateFormulaError(formula.id));
+            }
+            ids.add(formula.id);
+        }
+        // Try to parse all expressions
+        for (const formula of formulas) {
+            try {
+                this.parse(formula.expression);
+            }
+            catch (error) {
+                if (error instanceof errors_1.FormulaEngineError) {
+                    errors.push(error);
+                }
+                else {
+                    errors.push(new errors_1.GeneralFormulaError(String(error)));
+                }
+            }
+        }
+        // Build dependency graph and check for cycles
+        let dependencyGraph = new dependency_graph_1.DependencyGraph();
+        let evaluationOrder = [];
+        try {
+            dependencyGraph = this.buildDependencyGraph(formulas);
+            evaluationOrder = dependencyGraph.topologicalSort();
+        }
+        catch (error) {
+            if (error instanceof errors_1.FormulaEngineError) {
+                errors.push(error);
+            }
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+            warnings,
+            dependencyGraph,
+            evaluationOrder,
+        };
+    }
+    /**
+     * Evaluate a single expression
+     */
+    evaluate(expression, context) {
+        this.checkExpressionLength(expression);
+        const normalizedContext = this.normalizeContext(context);
+        return this.evaluator.evaluate(expression, normalizedContext);
+    }
+    /**
+     * Evaluate all formulas in dependency order
+     */
+    evaluateAll(formulas, context) {
+        const startTime = Date.now();
+        const results = new Map();
+        const errors = [];
+        // Get evaluation order
+        let evaluationOrder;
+        try {
+            evaluationOrder = this.getEvaluationOrder(formulas);
+        }
+        catch (error) {
+            return {
+                results,
+                success: false,
+                errors: [error],
+                totalExecutionTimeMs: Date.now() - startTime,
+                evaluationOrder: [],
+            };
+        }
+        // Create a map of formulas by ID
+        const formulaMap = new Map();
+        for (const formula of formulas) {
+            formulaMap.set(formula.id, formula);
+        }
+        // Evaluate in order, merging results into context
+        const workingContext = this.normalizeContext(context);
+        for (const formulaId of evaluationOrder) {
+            const formula = formulaMap.get(formulaId);
+            if (!formula)
+                continue;
+            try {
+                const result = this.evaluator.evaluate(formula.expression, workingContext);
+                // Apply rounding if configured
+                let value = result.value;
+                if (formula.rounding && this.isDecimal(value)) {
+                    value = this.applyRounding(value, formula.rounding);
+                }
+                // Handle errors based on formula config
+                if (!result.success && formula.onError) {
+                    value = this.handleError(formula, result.error);
+                }
+                results.set(formulaId, {
+                    ...result,
+                    value,
+                });
+                // Merge result into context for subsequent formulas
+                workingContext.variables[formulaId] = value;
+                if (!result.success) {
+                    errors.push(result.error);
+                }
+            }
+            catch (error) {
+                const evalResult = {
+                    value: null,
+                    success: false,
+                    error: error,
+                    executionTimeMs: 0,
+                    accessedVariables: new Set(),
+                };
+                // Handle error based on formula config
+                if (formula.onError) {
+                    evalResult.value = this.handleError(formula, error);
+                }
+                results.set(formulaId, evalResult);
+                errors.push(error);
+                // Still add to context (as null or default value) so dependent formulas can proceed
+                workingContext.variables[formulaId] = evalResult.value;
+            }
+        }
+        return {
+            results,
+            success: errors.length === 0,
+            errors,
+            totalExecutionTimeMs: Date.now() - startTime,
+            evaluationOrder,
+        };
+    }
+    /**
+     * Register a custom function
+     */
+    registerFunction(definition) {
+        const name = definition.name.toUpperCase();
+        this.functions.set(name, definition);
+    }
+    /**
+     * Register multiple custom functions
+     */
+    registerFunctions(definitions) {
+        for (const definition of definitions) {
+            this.registerFunction(definition);
+        }
+    }
+    /**
+     * Get registered function names
+     */
+    getRegisteredFunctions() {
+        return Array.from(this.functions.keys());
+    }
+    /**
+     * Clear the AST cache
+     */
+    clearCache() {
+        this.astCache.clear();
+        this.dependencyCache.clear();
+        this.cacheHits = 0;
+        this.cacheMisses = 0;
+    }
+    /**
+     * Get cache statistics
+     */
+    getCacheStats() {
+        const total = this.cacheHits + this.cacheMisses;
+        return {
+            size: this.astCache.size,
+            hits: this.cacheHits,
+            misses: this.cacheMisses,
+            hitRate: total > 0 ? this.cacheHits / total : 0,
+        };
+    }
+    /**
+     * Get the decimal utilities instance
+     */
+    getDecimalUtils() {
+        return this.decimalUtils;
+    }
+    /**
+     * Create a Decimal from a value
+     */
+    createDecimal(value) {
+        return this.decimalUtils.from(value);
+    }
+    // ============================================================================
+    // Private methods
+    // ============================================================================
+    checkExpressionLength(expression) {
+        const maxLength = this.config.security?.maxExpressionLength ?? 10000;
+        if (expression.length > maxLength) {
+            throw new errors_1.MaxExpressionLengthError(expression.length, maxLength);
+        }
+    }
+    normalizeContext(context) {
+        // Deep copy and convert numeric values to Decimal if autoConvertFloats is enabled
+        const autoConvert = this.config.decimal?.autoConvertFloats ?? true;
+        if (!autoConvert) {
+            return { ...context };
+        }
+        const normalizedVariables = {};
+        for (const [key, value] of Object.entries(context.variables)) {
+            normalizedVariables[key] = this.convertValue(value);
+        }
+        return {
+            ...context,
+            variables: normalizedVariables,
+        };
+    }
+    convertValue(value) {
+        if (typeof value === 'number' && !isNaN(value) && isFinite(value)) {
+            return this.decimalUtils.from(value);
+        }
+        if (Array.isArray(value)) {
+            return value.map(v => this.convertValue(v));
+        }
+        if (value !== null && typeof value === 'object') {
+            const converted = {};
+            for (const [k, v] of Object.entries(value)) {
+                converted[k] = this.convertValue(v);
+            }
+            return converted;
+        }
+        return value;
+    }
+    isDecimal(value) {
+        return value instanceof decimal_utils_1.Decimal;
+    }
+    applyRounding(value, config) {
+        if (config.mode === 'NONE') {
+            return value;
+        }
+        return this.decimalUtils.round(value, config.precision, config.mode);
+    }
+    handleError(formula, _error) {
+        const behavior = formula.onError;
+        if (!behavior)
+            return null;
+        switch (behavior.type) {
+            case 'NULL':
+                return null;
+            case 'ZERO':
+                return this.decimalUtils.zero();
+            case 'DEFAULT':
+                return behavior.defaultValue ?? formula.defaultValue ?? null;
+            case 'SKIP':
+                return undefined;
+            case 'THROW':
+            default:
+                throw _error;
+        }
+    }
+    maybeEvictCache() {
+        const maxSize = this.config.maxCacheSize ?? 1000;
+        if (this.astCache.size >= maxSize) {
+            // Simple FIFO eviction - remove first 10% of entries
+            const toRemove = Math.ceil(maxSize * 0.1);
+            const keys = Array.from(this.astCache.keys()).slice(0, toRemove);
+            for (const key of keys) {
+                this.astCache.delete(key);
+                this.dependencyCache.delete(key);
+            }
+        }
+    }
+}
+exports.FormulaEngine = FormulaEngine;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"formula-engine.js","sourceRoot":"","sources":["../src/formula-engine.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  FormulaEngineConfig,\n  FormulaDefinition,\n  EvaluationContext,\n  EvaluationResult,\n  EvaluationResultSet,\n  ValidationResult,\n  FunctionDefinition,\n  ASTNode,\n  CacheStats,\n  DependencyGraph as IDependencyGraph,\n} from './types';\nimport { Parser } from './parser';\nimport { Evaluator } from './evaluator';\nimport { DependencyExtractor } from './dependency-extractor';\nimport { DependencyGraph, DependencyGraphBuilder } from './dependency-graph';\nimport { DecimalUtils, Decimal } from './decimal-utils';\nimport { createBuiltInFunctions } from './functions';\nimport {\n  FormulaEngineError,\n  GeneralFormulaError,\n  DuplicateFormulaError,\n  MaxExpressionLengthError,\n} from './errors';\n\nexport class FormulaEngine {\n  private config: FormulaEngineConfig;\n  private parser: Parser;\n  private evaluator: Evaluator;\n  private dependencyExtractor: DependencyExtractor;\n  private graphBuilder: DependencyGraphBuilder;\n  private decimalUtils: DecimalUtils;\n  private functions: Map<string, FunctionDefinition>;\n\n  // Caches\n  private astCache: Map<string, ASTNode> = new Map();\n  private dependencyCache: Map<string, Set<string>> = new Map();\n  private cacheHits: number = 0;\n  private cacheMisses: number = 0;\n\n  constructor(config?: FormulaEngineConfig) {\n    this.config = {\n      enableCache: true,\n      maxCacheSize: 1000,\n      strictMode: true,\n      ...config,\n    };\n\n    this.decimalUtils = new DecimalUtils(this.config.decimal);\n    this.functions = createBuiltInFunctions(this.decimalUtils);\n    this.parser = new Parser();\n    this.dependencyExtractor = new DependencyExtractor();\n    this.graphBuilder = new DependencyGraphBuilder();\n    this.evaluator = new Evaluator(this.decimalUtils, this.functions, this.config);\n\n    // Register any custom functions from config\n    if (this.config.functions) {\n      for (const fn of this.config.functions) {\n        this.registerFunction(fn);\n      }\n    }\n  }\n\n  /**\n   * Parse an expression into an AST\n   */\n  parse(expression: string): ASTNode {\n    this.checkExpressionLength(expression);\n\n    if (this.config.enableCache) {\n      const cached = this.astCache.get(expression);\n      if (cached) {\n        this.cacheHits++;\n        return cached;\n      }\n      this.cacheMisses++;\n    }\n\n    const ast = this.parser.parse(expression);\n\n    if (this.config.enableCache) {\n      this.maybeEvictCache();\n      this.astCache.set(expression, ast);\n    }\n\n    return ast;\n  }\n\n  /**\n   * Extract variable dependencies from an expression\n   */\n  extractDependencies(expression: string): Set<string> {\n    if (this.config.enableCache) {\n      const cached = this.dependencyCache.get(expression);\n      if (cached) {\n        return new Set(cached);\n      }\n    }\n\n    const deps = this.dependencyExtractor.extract(expression);\n\n    if (this.config.enableCache) {\n      this.dependencyCache.set(expression, new Set(deps));\n    }\n\n    return deps;\n  }\n\n  /**\n   * Build a dependency graph from formula definitions\n   */\n  buildDependencyGraph(formulas: FormulaDefinition[]): IDependencyGraph {\n    return this.graphBuilder.build(formulas);\n  }\n\n  /**\n   * Get the evaluation order for formulas\n   */\n  getEvaluationOrder(formulas: FormulaDefinition[]): string[] {\n    return this.graphBuilder.getEvaluationOrder(formulas);\n  }\n\n  /**\n   * Validate formulas without evaluating\n   */\n  validate(formulas: FormulaDefinition[]): ValidationResult {\n    const errors: FormulaEngineError[] = [];\n    const warnings: string[] = [];\n\n    // Check for duplicate IDs\n    const ids = new Set<string>();\n    for (const formula of formulas) {\n      if (ids.has(formula.id)) {\n        errors.push(new DuplicateFormulaError(formula.id));\n      }\n      ids.add(formula.id);\n    }\n\n    // Try to parse all expressions\n    for (const formula of formulas) {\n      try {\n        this.parse(formula.expression);\n      } catch (error) {\n        if (error instanceof FormulaEngineError) {\n          errors.push(error);\n        } else {\n          errors.push(new GeneralFormulaError(String(error)));\n        }\n      }\n    }\n\n    // Build dependency graph and check for cycles\n    let dependencyGraph: IDependencyGraph = new DependencyGraph();\n    let evaluationOrder: string[] = [];\n\n    try {\n      dependencyGraph = this.buildDependencyGraph(formulas);\n      evaluationOrder = dependencyGraph.topologicalSort();\n    } catch (error) {\n      if (error instanceof FormulaEngineError) {\n        errors.push(error);\n      }\n    }\n\n    return {\n      valid: errors.length === 0,\n      errors,\n      warnings,\n      dependencyGraph,\n      evaluationOrder,\n    };\n  }\n\n  /**\n   * Evaluate a single expression\n   */\n  evaluate(expression: string, context: EvaluationContext): EvaluationResult {\n    this.checkExpressionLength(expression);\n    const normalizedContext = this.normalizeContext(context);\n    return this.evaluator.evaluate(expression, normalizedContext);\n  }\n\n  /**\n   * Evaluate all formulas in dependency order\n   */\n  evaluateAll(\n    formulas: FormulaDefinition[],\n    context: EvaluationContext\n  ): EvaluationResultSet {\n    const startTime = Date.now();\n    const results = new Map<string, EvaluationResult>();\n    const errors: Error[] = [];\n\n    // Get evaluation order\n    let evaluationOrder: string[];\n    try {\n      evaluationOrder = this.getEvaluationOrder(formulas);\n    } catch (error) {\n      return {\n        results,\n        success: false,\n        errors: [error as Error],\n        totalExecutionTimeMs: Date.now() - startTime,\n        evaluationOrder: [],\n      };\n    }\n\n    // Create a map of formulas by ID\n    const formulaMap = new Map<string, FormulaDefinition>();\n    for (const formula of formulas) {\n      formulaMap.set(formula.id, formula);\n    }\n\n    // Evaluate in order, merging results into context\n    const workingContext: EvaluationContext = this.normalizeContext(context);\n\n    for (const formulaId of evaluationOrder) {\n      const formula = formulaMap.get(formulaId);\n      if (!formula) continue;\n\n      try {\n        const result = this.evaluator.evaluate(formula.expression, workingContext);\n\n        // Apply rounding if configured\n        let value = result.value;\n        if (formula.rounding && this.isDecimal(value)) {\n          value = this.applyRounding(value as Decimal, formula.rounding);\n        }\n\n        // Handle errors based on formula config\n        if (!result.success && formula.onError) {\n          value = this.handleError(formula, result.error);\n        }\n\n        results.set(formulaId, {\n          ...result,\n          value,\n        });\n\n        // Merge result into context for subsequent formulas\n        workingContext.variables[formulaId] = value;\n\n        if (!result.success) {\n          errors.push(result.error!);\n        }\n      } catch (error) {\n        const evalResult: EvaluationResult = {\n          value: null,\n          success: false,\n          error: error as Error,\n          executionTimeMs: 0,\n          accessedVariables: new Set(),\n        };\n\n        // Handle error based on formula config\n        if (formula.onError) {\n          evalResult.value = this.handleError(formula, error as Error);\n        }\n\n        results.set(formulaId, evalResult);\n        errors.push(error as Error);\n\n        // Still add to context (as null or default value) so dependent formulas can proceed\n        workingContext.variables[formulaId] = evalResult.value;\n      }\n    }\n\n    return {\n      results,\n      success: errors.length === 0,\n      errors,\n      totalExecutionTimeMs: Date.now() - startTime,\n      evaluationOrder,\n    };\n  }\n\n  /**\n   * Register a custom function\n   */\n  registerFunction(definition: FunctionDefinition): void {\n    const name = definition.name.toUpperCase();\n    this.functions.set(name, definition);\n  }\n\n  /**\n   * Register multiple custom functions\n   */\n  registerFunctions(definitions: FunctionDefinition[]): void {\n    for (const definition of definitions) {\n      this.registerFunction(definition);\n    }\n  }\n\n  /**\n   * Get registered function names\n   */\n  getRegisteredFunctions(): string[] {\n    return Array.from(this.functions.keys());\n  }\n\n  /**\n   * Clear the AST cache\n   */\n  clearCache(): void {\n    this.astCache.clear();\n    this.dependencyCache.clear();\n    this.cacheHits = 0;\n    this.cacheMisses = 0;\n  }\n\n  /**\n   * Get cache statistics\n   */\n  getCacheStats(): CacheStats {\n    const total = this.cacheHits + this.cacheMisses;\n    return {\n      size: this.astCache.size,\n      hits: this.cacheHits,\n      misses: this.cacheMisses,\n      hitRate: total > 0 ? this.cacheHits / total : 0,\n    };\n  }\n\n  /**\n   * Get the decimal utilities instance\n   */\n  getDecimalUtils(): DecimalUtils {\n    return this.decimalUtils;\n  }\n\n  /**\n   * Create a Decimal from a value\n   */\n  createDecimal(value: string | number): Decimal {\n    return this.decimalUtils.from(value);\n  }\n\n  // ============================================================================\n  // Private methods\n  // ============================================================================\n\n  private checkExpressionLength(expression: string): void {\n    const maxLength = this.config.security?.maxExpressionLength ?? 10000;\n    if (expression.length > maxLength) {\n      throw new MaxExpressionLengthError(expression.length, maxLength);\n    }\n  }\n\n  private normalizeContext(context: EvaluationContext): EvaluationContext {\n    // Deep copy and convert numeric values to Decimal if autoConvertFloats is enabled\n    const autoConvert = this.config.decimal?.autoConvertFloats ?? true;\n\n    if (!autoConvert) {\n      return { ...context };\n    }\n\n    const normalizedVariables: Record<string, unknown> = {};\n    for (const [key, value] of Object.entries(context.variables)) {\n      normalizedVariables[key] = this.convertValue(value);\n    }\n\n    return {\n      ...context,\n      variables: normalizedVariables,\n    };\n  }\n\n  private convertValue(value: unknown): unknown {\n    if (typeof value === 'number' && !isNaN(value) && isFinite(value)) {\n      return this.decimalUtils.from(value);\n    }\n    if (Array.isArray(value)) {\n      return value.map(v => this.convertValue(v));\n    }\n    if (value !== null && typeof value === 'object') {\n      const converted: Record<string, unknown> = {};\n      for (const [k, v] of Object.entries(value)) {\n        converted[k] = this.convertValue(v);\n      }\n      return converted;\n    }\n    return value;\n  }\n\n  private isDecimal(value: unknown): boolean {\n    return value instanceof Decimal;\n  }\n\n  private applyRounding(\n    value: Decimal,\n    config: { mode: string; precision: number }\n  ): Decimal {\n    if (config.mode === 'NONE') {\n      return value;\n    }\n    return this.decimalUtils.round(value, config.precision, config.mode as any);\n  }\n\n  private handleError(formula: FormulaDefinition, _error?: Error): unknown {\n    const behavior = formula.onError;\n    if (!behavior) return null;\n\n    switch (behavior.type) {\n      case 'NULL':\n        return null;\n      case 'ZERO':\n        return this.decimalUtils.zero();\n      case 'DEFAULT':\n        return behavior.defaultValue ?? formula.defaultValue ?? null;\n      case 'SKIP':\n        return undefined;\n      case 'THROW':\n      default:\n        throw _error;\n    }\n  }\n\n  private maybeEvictCache(): void {\n    const maxSize = this.config.maxCacheSize ?? 1000;\n    if (this.astCache.size >= maxSize) {\n      // Simple FIFO eviction - remove first 10% of entries\n      const toRemove = Math.ceil(maxSize * 0.1);\n      const keys = Array.from(this.astCache.keys()).slice(0, toRemove);\n      for (const key of keys) {\n        this.astCache.delete(key);\n        this.dependencyCache.delete(key);\n      }\n    }\n  }\n}\n"]}

package/dist/functions.d.ts

@@ -0,0 +1,3 @@
+import { FunctionDefinition } from './types';
+import { DecimalUtils } from './decimal-utils';
+export declare function createBuiltInFunctions(decimalUtils: DecimalUtils): Map<string, FunctionDefinition>;