@cortex-js/compute-engine 0.35.6 → 0.50.0

package/dist/types/compute-engine/index.d.ts

@@ -1,28 +1,34 @@
-/* 0.35.6 */
+/* 0.50.0 */
 import { Decimal } from 'decimal.js';
 import { Type, TypeResolver, TypeString } from '../common/type/types';
 import { BoxedType } from '../common/type/boxed-type';
 import type { OneOf } from '../common/one-of';
-import { ConfigurationChangeListener } from '../common/configuration-change';
-import type { Expression, MathJsonSymbol, MathJsonNumberObject } from '../math-json/types';
-import type { ValueDefinition, OperatorDefinition, AngularUnit, AssignValue, AssumeResult, BoxedExpression, BoxedRule, BoxedRuleSet, BoxedSubstitution, CanonicalOptions, SymbolDefinitions, Metadata, Rule, Scope, EvalContext, SemiBoxedExpression, ComputeEngine as IComputeEngine, BoxedDefinition, SymbolDefinition, SequenceDefinition, SequenceStatus, SequenceInfo, OEISSequenceInfo, OEISOptions } from './global-types';
-import type { LatexDictionaryEntry, LatexString, LibraryCategory, ParseLatexOptions } from './latex-syntax/types';
+import type { ConfigurationChangeListener } from '../common/configuration-change';
+import type { MathJsonExpression, MathJsonSymbol, MathJsonNumberObject } from '../math-json/types';
+import type { ValueDefinition, OperatorDefinition, AngularUnit, AssignValue, AssumeResult, Expression, BoxedRule, BoxedRuleSet, BoxedSubstitution, CanonicalOptions, Metadata, Rule, Scope, EvalContext, ExpressionInput, IComputeEngine, BoxedDefinition, SymbolDefinition, SequenceDefinition, SequenceStatus, SequenceInfo, OEISSequenceInfo, OEISOptions, LibraryDefinition } from './global-types';
+import type { LatexDictionaryEntry, LatexString, LibraryCategory } from './latex-syntax/types';
 import { type IndexedLatexDictionary } from './latex-syntax/dictionary/definitions';
 import type { BigNum, Rational } from './numerics/types';
 import { ExactNumericValueData, NumericValue, NumericValueData } from './numeric-value/types';
+import type { FormOption } from './types-serialization';
 import { validatePattern } from './boxed-expression/boxed-patterns';
-import { factor, factorPerfectSquare, factorDifferenceOfSquares, factorQuadratic, factorPolynomial } from './boxed-expression/factor';
+import { factorPerfectSquare, factorDifferenceOfSquares, factorQuadratic, factorPolynomial } from './boxed-expression/factor';
 import './boxed-expression/serialize';
-export * from './global-types';
+import { type ParseEntrypointOptions } from './engine-parse-entrypoint';
+export type * from './global-types';
+export { parse, simplify, evaluate, N, assign, expand, expandAll, factor, solve, compile, getDefaultEngine, } from './free-functions';
 export { validatePattern };
-export { factor, factorPerfectSquare, factorDifferenceOfSquares, factorQuadratic, factorPolynomial, };
-export type { CompileTarget, CompiledOperators, CompiledFunctions, CompilationOptions, CompiledExecutable, LanguageTarget, TargetSource, CompiledFunction, } from './compilation/types';
+export { factorPerfectSquare, factorDifferenceOfSquares, factorQuadratic, factorPolynomial, };
+export type { CompileTarget, CompiledOperators, CompiledFunctions, CompilationOptions, CompilationResult, LanguageTarget, TargetSource, CompiledFunction, } from './compilation/types';
 export { JavaScriptTarget } from './compilation/javascript-target';
 export { GLSLTarget } from './compilation/glsl-target';
+export { PythonTarget } from './compilation/python-target';
 export { IntervalJavaScriptTarget } from './compilation/interval-javascript-target';
 export { IntervalGLSLTarget } from './compilation/interval-glsl-target';
 export { BaseCompiler } from './compilation/base-compiler';
 import type { LanguageTarget } from './compilation/types';
+import { compile as _compile } from './compilation/compile-expression';
+import { fu as _fu } from './symbolic/fu';
 /**
  *
  * To use the Compute Engine, create a `ComputeEngine` instance:
@@ -56,21 +62,21 @@ import type { LanguageTarget } from './compilation/types';
  *
  */
 export declare class ComputeEngine implements IComputeEngine {
-    readonly True: BoxedExpression;
-    readonly False: BoxedExpression;
-    readonly Pi: BoxedExpression;
-    readonly E: BoxedExpression;
-    readonly Nothing: BoxedExpression;
-    readonly Zero: BoxedExpression;
-    readonly One: BoxedExpression;
-    readonly Half: BoxedExpression;
-    readonly NegativeOne: BoxedExpression;
-    readonly Two: BoxedExpression;
-    readonly I: BoxedExpression;
-    readonly NaN: BoxedExpression;
-    readonly PositiveInfinity: BoxedExpression;
-    readonly NegativeInfinity: BoxedExpression;
-    readonly ComplexInfinity: BoxedExpression;
+    readonly True: Expression;
+    readonly False: Expression;
+    readonly Pi: Expression;
+    readonly E: Expression;
+    readonly Nothing: Expression;
+    readonly Zero: Expression;
+    readonly One: Expression;
+    readonly Half: Expression;
+    readonly NegativeOne: Expression;
+    readonly Two: Expression;
+    readonly I: Expression;
+    readonly NaN: Expression;
+    readonly PositiveInfinity: Expression;
+    readonly NegativeInfinity: Expression;
+    readonly ComplexInfinity: Expression;
     /** The symbol separating the whole part of a number from its fractional
      *  part in a LaTeX string.
      *
@@ -83,35 +89,21 @@ export declare class ComputeEngine implements IComputeEngine {
      * */
     decimalSeparator: LatexString;
     /** @internal */
-    _BIGNUM_NAN: Decimal;
+    private _numericConfiguration;
     /** @internal */
-    _BIGNUM_ZERO: Decimal;
-    /** @internal */
-    _BIGNUM_ONE: Decimal;
-    /** @internal */
-    _BIGNUM_TWO: Decimal;
-    /** @internal */
-    _BIGNUM_HALF: Decimal;
-    /** @internal */
-    _BIGNUM_PI: Decimal;
-    /** @internal */
-    _BIGNUM_NEGATIVE_ONE: Decimal;
-    /** @internal */
-    private _precision;
-    /** @ internal */
-    private _angularUnit;
-    /** @internal */
-    private _tolerance;
-    /** @internal */
-    private _bignumTolerance;
-    private _negBignumTolerance;
-    /** @internal */
-    private __cache;
-    private _configurationChangeTracker;
+    private _cacheStore;
+    /** @internal Runtime execution limits and verification mode state */
+    private _runtimeState;
+    /** @internal Configuration change generation/tracking lifecycle */
+    private _configurationLifecycle;
     /** @internal */
     private _cost?;
+    /** @internal Backing state for simplificationRules */
+    private _simplificationRules;
     /** @internal Registry of compilation targets */
     private _compilationTargets;
+    /** @internal Fu trigonometric simplification algorithm */
+    _fuAlgorithm: typeof _fu;
     /** @internal */
     private _commonSymbols;
     /** @internal */
@@ -129,6 +121,20 @@ export declare class ComputeEngine implements IComputeEngine {
     get contextStack(): ReadonlyArray<EvalContext>;
     set contextStack(stack: ReadonlyArray<EvalContext>);
     /** @internal */
+    get _BIGNUM_NAN(): Decimal;
+    /** @internal */
+    get _BIGNUM_ZERO(): Decimal;
+    /** @internal */
+    get _BIGNUM_ONE(): Decimal;
+    /** @internal */
+    get _BIGNUM_TWO(): Decimal;
+    /** @internal */
+    get _BIGNUM_HALF(): Decimal;
+    /** @internal */
+    get _BIGNUM_PI(): Decimal;
+    /** @internal */
+    get _BIGNUM_NEGATIVE_ONE(): Decimal;
+    /** @internal */
     get _typeResolver(): TypeResolver;
     /**
      * Declare a new type in the current scope.
@@ -136,7 +142,7 @@ export declare class ComputeEngine implements IComputeEngine {
      * By default, types are nominal. To declare a structural type, set
      * `alias` to `true`.
      */
-    declareType(name: string, type: BoxedType | Type | TypeString, { alias }?: {
+    declareType(name: string, type: BoxedType | Type | TypeString, options?: {
         alias?: boolean;
     }): void;
     /**
@@ -149,7 +155,8 @@ export declare class ComputeEngine implements IComputeEngine {
      * It is used to invalidate caches.
      * @internal
      */
-    _generation: number;
+    get _generation(): number;
+    set _generation(value: number);
     /** In strict mode (the default) the Compute Engine performs
      * validation of domains and signature and may report errors.
      *
@@ -160,10 +167,6 @@ export declare class ComputeEngine implements IComputeEngine {
      *
      */
     strict: boolean;
-    /** Absolute time beyond which evaluation should not proceed.
-     * @internal
-     */
-    deadline?: number;
     /**
      * Return symbol tables suitable for the specified categories, or `"all"`
      * for all categories (`"arithmetic"`, `"algebra"`, etc...).
@@ -172,12 +175,8 @@ export declare class ComputeEngine implements IComputeEngine {
      *
      */
     /** @internal */
-    private _latexDictionaryInput;
-    /** @internal */
-    __indexedLatexDictionary: IndexedLatexDictionary;
-    /** @internal */
-    _bignum: Decimal.Constructor;
-    static getStandardLibrary(categories?: LibraryCategory[] | LibraryCategory | 'all'): readonly SymbolDefinitions[];
+    private _latexDictionaryState;
+    static getStandardLibrary(categories?: LibraryCategory[] | LibraryCategory | 'all'): readonly LibraryDefinition[];
     /**
      * Return a LaTeX dictionary suitable for the specified category, or `"all"`
      * for all categories (`"arithmetic"`, `"algebra"`, etc...).
@@ -230,9 +229,13 @@ export declare class ComputeEngine implements IComputeEngine {
      * @param options.tolerance If the absolute value of the difference of two
      * numbers is less than `tolerance`, they are considered equal. Used by
      * `chop()` as well.
+     *
+     * @param options.libraries Optional standard/custom library list.
+     * Custom library entries are validated during startup (name, dependencies,
+     * definitions, and LaTeX dictionary shape).
      */
     constructor(options?: {
-        ids?: readonly SymbolDefinitions[];
+        libraries?: readonly (string | LibraryDefinition)[];
         precision?: number | 'machine';
         tolerance?: number | 'auto';
     });
@@ -275,19 +278,40 @@ export declare class ComputeEngine implements IComputeEngine {
      *
      * // Use the custom target
      * const expr = ce.parse('x^2 + y^2');
-     * const code = expr.compile({ to: 'python' });
+     * const code = compile(expr, { to: 'python' });
      * ```
+     *
+     * Throws if:
+     * - `name` is empty or contains whitespace
+     * - `target` does not implement the required `LanguageTarget` methods
      */
-    registerCompilationTarget(name: string, target: LanguageTarget): void;
+    registerCompilationTarget(name: string, target: LanguageTarget<Expression>): void;
     /**
      * Get a registered compilation target by name.
      *
-     * @param name - The name of the target (e.g., 'javascript', 'glsl')
+     * @param name - The name of the target (e.g., 'javascript', 'glsl', 'python')
      * @returns The LanguageTarget implementation, or undefined if not found
+     */
+    getCompilationTarget(name: string): LanguageTarget<Expression> | undefined;
+    /**
+     * Return the names of all registered compilation targets.
      *
-     * @internal
+     * @example
+     * ```typescript
+     * const ce = new ComputeEngine();
+     * console.log(ce.listCompilationTargets());
+     * // → ['javascript', 'glsl', 'interval-js', 'interval-glsl']
+     * ```
      */
-    _getCompilationTarget(name: string): LanguageTarget | undefined;
+    listCompilationTargets(): string[];
+    /**
+     * Remove a registered compilation target.
+     *
+     * @param name - The name of the target to remove
+     */
+    unregisterCompilationTarget(name: string): void;
+    /** @internal Compile a boxed expression. */
+    _compile(expr: Expression, options?: Parameters<typeof _compile>[1]): ReturnType<typeof _compile>;
     get precision(): number;
     /** The precision, or number of significant digits, of numeric
      * calculations.
@@ -326,9 +350,14 @@ export declare class ComputeEngine implements IComputeEngine {
      */
     get timeLimit(): number;
     set timeLimit(t: number);
-    private _timeLimit;
+    /** Absolute time beyond which evaluation should not proceed.
+     * @internal
+     */
+    get deadline(): number | undefined;
+    set deadline(value: number | undefined);
     /** The time after which the time limit has been exceeded */
-    _deadline: number | undefined;
+    get _deadline(): number | undefined;
+    set _deadline(value: number | undefined);
     get _timeRemaining(): number;
     /** Throw `CancellationError` `iteration-limit-exceeded` when the iteration limit
      * in a loop is exceeded. Default: no limits.
@@ -337,7 +366,6 @@ export declare class ComputeEngine implements IComputeEngine {
      */
     get iterationLimit(): number;
     set iterationLimit(t: number);
-    private _iterationLimit;
     /** Signal `recursion-depth-exceeded` when the recursion depth for this
      * scope is exceeded.
      *
@@ -345,7 +373,6 @@ export declare class ComputeEngine implements IComputeEngine {
      */
     get recursionLimit(): number;
     set recursionLimit(t: number);
-    private _recursionLimit;
     /**
      * Flag to prevent infinite recursion in the verify/ask/equality checking cycle.
      *
@@ -368,7 +395,9 @@ export declare class ComputeEngine implements IComputeEngine {
      * @see eq() in compare.ts
      * @see Equal/NotEqual operators in relational-operator.ts
      */
-    private _isVerifying;
+    /** @internal */
+    get _isVerifying(): boolean;
+    set _isVerifying(value: boolean);
     /**
      * @internal
      * Indicates whether we're currently inside a verify() call.
@@ -436,9 +465,9 @@ export declare class ComputeEngine implements IComputeEngine {
      * - `isNegative()`
      * - `isPositive()`
      * - `isZero()`
-     * - `sign()` (1, 0 or -1)
-     *
-     */
+    * - `sign()` (1, 0 or -1)
+    *
+    */
     bignum(a: Decimal.Value | bigint): Decimal;
     /** Create a complex number.
      * The return value is an object with methods to perform arithmetic
@@ -496,8 +525,27 @@ export declare class ComputeEngine implements IComputeEngine {
     /**
      * The cost function is used to determine the "cost" of an expression. For example, when simplifying an expression, the simplification that results in the lowest cost is chosen.
      */
-    get costFunction(): (expr: BoxedExpression) => number;
-    set costFunction(fn: ((expr: BoxedExpression) => number) | undefined);
+    get costFunction(): (expr: Expression) => number;
+    set costFunction(fn: ((expr: Expression) => number) | undefined);
+    /**
+     * The rules used by `.simplify()` when no explicit `rules` option is passed.
+     * Initialized to a copy of the built-in simplification rules.
+     *
+     * Add custom rules with `push()`:
+     * ```ts
+     * ce.simplificationRules.push({
+     *   match: ['Power', ['Sin', '_x'], 2],
+     *   replace: ['Subtract', 1, ['Power', ['Cos', '_x'], 2]],
+     * });
+     * ```
+     *
+     * Or replace entirely:
+     * ```ts
+     * ce.simplificationRules = myCustomRules;
+     * ```
+     */
+    get simplificationRules(): Rule[];
+    set simplificationRules(rules: Rule[]);
     /**
      * Return definition matching the symbol, starting with the current
      * lexical scope and going up the scope chain.
@@ -544,19 +592,19 @@ export declare class ComputeEngine implements IComputeEngine {
     /**
      * Use `ce.box(name)` instead
      * @internal */
-    _getSymbolValue(id: MathJsonSymbol): BoxedExpression | undefined;
+    _getSymbolValue(id: MathJsonSymbol): Expression | undefined;
     /**
      * For internal use. Use `ce.assign(name, value)` instead.
      * @internal
      */
-    _setSymbolValue(id: MathJsonSymbol, value: BoxedExpression | boolean | number | undefined): void;
+    _setSymbolValue(id: MathJsonSymbol, value: Expression | boolean | number | undefined): void;
     /**
      * Set a value directly in the current context's values map.
      * This is used for assumptions so that the value is scoped to the current
      * evaluation context and is automatically removed when the scope is popped.
      * @internal
      */
-    _setCurrentContextValue(id: MathJsonSymbol, value: BoxedExpression | boolean | number | undefined): void;
+    _setCurrentContextValue(id: MathJsonSymbol, value: Expression | boolean | number | undefined): void;
     /**
      * Declare a symbol in the current lexical scope: specify their type and
      * other attributes, including optionally a value.
@@ -625,7 +673,7 @@ export declare class ComputeEngine implements IComputeEngine {
      * For single-index sequences, keys are numbers.
      * For multi-index sequences, keys are comma-separated strings (e.g., '5,2').
      */
-    getSequenceCache(name: string): Map<number | string, BoxedExpression> | undefined;
+    getSequenceCache(name: string): Map<number | string, Expression> | undefined;
     /**
      * Generate a list of sequence terms from start to end (inclusive).
      *
@@ -642,7 +690,7 @@ export declare class ComputeEngine implements IComputeEngine {
      * // → [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
      * ```
      */
-    getSequenceTerms(name: string, start: number, end: number, step?: number): BoxedExpression[] | undefined;
+    getSequenceTerms(name: string, start: number, end: number, step?: number): Expression[] | undefined;
     /**
      * Look up sequences in OEIS by their terms.
      *
@@ -656,7 +704,7 @@ export declare class ComputeEngine implements IComputeEngine {
      * // → [{ id: 'A000045', name: 'Fibonacci numbers', ... }]
      * ```
      */
-    lookupOEIS(terms: (number | BoxedExpression)[], options?: OEISOptions): Promise<OEISSequenceInfo[]>;
+    lookupOEIS(terms: (number | Expression)[], options?: OEISOptions): Promise<OEISSequenceInfo[]>;
     /**
      * Check if a defined sequence matches an OEIS sequence.
      *
@@ -716,45 +764,43 @@ export declare class ComputeEngine implements IComputeEngine {
     _checkContinueExecution(): void;
     /** @internal */
     _cache<T>(cacheName: string, build: () => T, purge?: (t: T) => T | undefined): T;
-    /** Return a boxed expression from a number, string or semiboxed expression.
+    /** Return a boxed expression from a number, string or expression input.
      * Calls `ce.function()`, `ce.number()` or `ce.symbol()` as appropriate.
      */
-    box(expr: NumericValue | SemiBoxedExpression, options?: {
-        canonical?: CanonicalOptions;
-        structural?: boolean;
+    box(expr: NumericValue | ExpressionInput, options?: {
+        form?: FormOption;
         scope?: Scope | undefined;
-    }): BoxedExpression;
-    function(name: string, ops: ReadonlyArray<BoxedExpression> | ReadonlyArray<Expression>, options?: {
+    }): Expression;
+    function(name: string, ops: ReadonlyArray<Expression> | ReadonlyArray<MathJsonExpression>, options?: {
         metadata?: Metadata;
-        canonical?: CanonicalOptions;
-        structural?: boolean;
+        form?: FormOption;
         scope?: Scope | undefined;
-    }): BoxedExpression;
+    }): Expression;
     /**
      *
      * Shortcut for `this.box(["Error",...])`.
      *
      * The result is canonical.
      */
-    error(message: string | string[], where?: string): BoxedExpression;
-    typeError(expected: Type, actual: undefined | Type | BoxedType, where?: string): BoxedExpression;
+    error(message: string | string[], where?: string): Expression;
+    typeError(expected: Type, actual: undefined | Type | BoxedType, where?: string): Expression;
     /**
      * Add a `["Hold"]` wrapper to `expr`.
      */
-    hold(expr: SemiBoxedExpression): BoxedExpression;
+    hold(expr: ExpressionInput): Expression;
     /** Shortcut for `this.box(["Tuple", ...])`
      *
      * The result is canonical.
      */
-    tuple(...elements: ReadonlyArray<number>): BoxedExpression;
-    tuple(...elements: ReadonlyArray<BoxedExpression>): BoxedExpression;
+    tuple(...elements: ReadonlyArray<number>): Expression;
+    tuple(...elements: ReadonlyArray<Expression>): Expression;
     type(type: Type | TypeString | BoxedType): BoxedType;
-    string(s: string, metadata?: Metadata): BoxedExpression;
+    string(s: string, metadata?: Metadata): Expression;
     /** Create a boxed symbol */
     symbol(name: string, options?: {
         canonical?: CanonicalOptions;
         metadata?: Metadata;
-    }): BoxedExpression;
+    }): Expression;
     /**
      * This function tries to avoid creating a boxed number if `num` corresponds
      * to a common value for which we have a shared instance (-1, 0, NaN, etc...)
@@ -762,7 +808,7 @@ export declare class ComputeEngine implements IComputeEngine {
     number(value: number | bigint | string | NumericValue | MathJsonNumberObject | Decimal | Complex | Rational, options?: {
         metadata: Metadata;
         canonical: CanonicalOptions;
-    }): BoxedExpression;
+    }): Expression;
     rules(rules: Rule | ReadonlyArray<Rule | BoxedRule> | BoxedRuleSet | undefined | null, options?: {
         canonical?: boolean;
     }): BoxedRuleSet;
@@ -786,23 +832,20 @@ export declare class ComputeEngine implements IComputeEngine {
      *    canonical form
      *
      * @internal */
-    _fn(name: MathJsonSymbol, ops: ReadonlyArray<BoxedExpression>, options?: {
+    _fn(name: MathJsonSymbol, ops: ReadonlyArray<Expression>, options?: {
         metadata?: Metadata;
         canonical?: boolean;
         scope?: Scope;
-    }): BoxedExpression;
+    }): Expression;
     /**
-     * Parse a string of LaTeX and return a corresponding `BoxedExpression`.
+     * Parse a string of LaTeX and return a corresponding `Expression`.
      *
-     * If the `canonical` option is set to `true`, the result will be canonical
+     * If the `form` option is set to `'canonical'` (the default), the result
+     * will be canonical.
      *
      */
-    parse(latex: null, options?: Partial<ParseLatexOptions> & {
-        canonical?: CanonicalOptions;
-    }): null;
-    parse(latex: LatexString, options?: Partial<ParseLatexOptions> & {
-        canonical?: CanonicalOptions;
-    }): BoxedExpression;
+    parse(latex: null, options?: ParseEntrypointOptions): null;
+    parse(latex: LatexString, options?: ParseEntrypointOptions): Expression;
     /**
      * Return a list of all the assumptions that match a pattern.
      *
@@ -812,12 +855,12 @@ export declare class ComputeEngine implements IComputeEngine {
      *  //  -> [{'val': 0}]
      * ```
      */
-    ask(pattern: BoxedExpression): BoxedSubstitution[];
+    ask(pattern: Expression): BoxedSubstitution[];
     /**
      * Answer a query based on the current assumptions.
      *
      */
-    verify(query: BoxedExpression): boolean | undefined;
+    verify(query: Expression): boolean | undefined;
     /**
      * Add an assumption.
      *
@@ -831,7 +874,7 @@ export declare class ComputeEngine implements IComputeEngine {
      *
      *
      */
-    assume(predicate: BoxedExpression): AssumeResult;
+    assume(predicate: Expression): AssumeResult;
     /**
      * Remove all assumptions about one or more symbols.
      *

package/dist/types/compute-engine/interval/arithmetic.d.ts

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.0 */
  * Basic interval arithmetic operations
  *
  * @module interval/arithmetic

package/dist/types/compute-engine/interval/comparison.d.ts

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.0 */
  * Comparison and conditional interval operations
  *
  * @module interval/comparison

package/dist/types/compute-engine/interval/elementary.d.ts

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.0 */
  * Elementary interval functions (sqrt, pow, exp, ln, abs, floor, ceil, min, max, mod)
  *
  * @module interval/elementary

package/dist/types/compute-engine/interval/index.d.ts

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.0 */
  * Interval arithmetic library for reliable function evaluation
  *
  * This module provides interval versions of mathematical operations

package/dist/types/compute-engine/interval/trigonometric.d.ts

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.0 */
  * Trigonometric interval functions
  *
  * @module interval/trigonometric

package/dist/types/compute-engine/interval/types.d.ts

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.0 */
  * Interval arithmetic types for reliable function evaluation
  *
  * @module interval/types

package/dist/types/compute-engine/interval/util.d.ts

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.0 */
  * Utility functions for interval arithmetic
  *
  * @module interval/util

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-algebra.d.ts

@@ -1,2 +1,2 @@
-/* 0.35.6 */
+/* 0.50.0 */
 export declare const DEFINITIONS_ALGEBRA: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-arithmetic.d.ts

@@ -1,2 +1,2 @@
-/* 0.35.6 */
+/* 0.50.0 */
 export declare const DEFINITIONS_ARITHMETIC: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-calculus.d.ts

@@ -1,2 +1,2 @@
-/* 0.35.6 */
+/* 0.50.0 */
 export declare const DEFINITIONS_CALCULUS: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-complex.d.ts

@@ -1,2 +1,2 @@
-/* 0.35.6 */
+/* 0.50.0 */
 export declare const DEFINITIONS_COMPLEX: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-core.d.ts

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.0 */
 export declare const DEFINITIONS_CORE: LatexDictionary;
 export declare const DELIMITERS_SHORTHAND: {
     '(': string;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-linear-algebra.d.ts

@@ -1,2 +1,2 @@
-/* 0.35.6 */
+/* 0.50.0 */
 export declare const DEFINITIONS_LINEAR_ALGEBRA: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-logic.d.ts

@@ -1,2 +1,2 @@
-/* 0.35.6 */
+/* 0.50.0 */
 export declare const DEFINITIONS_LOGIC: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-other.d.ts

@@ -1,2 +1,2 @@
-/* 0.35.6 */
+/* 0.50.0 */
 export declare const DEFINITIONS_OTHERS: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-relational-operators.d.ts

@@ -1,2 +1,2 @@
-/* 0.35.6 */
+/* 0.50.0 */
 export declare const DEFINITIONS_INEQUALITIES: LatexDictionaryEntry[];

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-sets.d.ts

@@ -1,2 +1,2 @@
-/* 0.35.6 */
+/* 0.50.0 */
 export declare const DEFINITIONS_SETS: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-statistics.d.ts

@@ -1,2 +1,2 @@
-/* 0.35.6 */
+/* 0.50.0 */
 export declare const DEFINITIONS_STATISTICS: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-symbols.d.ts

@@ -1,3 +1,3 @@
-/* 0.35.6 */
+/* 0.50.0 */
 export declare const SYMBOLS: [string, string, number][];
 export declare const DEFINITIONS_SYMBOLS: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-trigonometry.d.ts

@@ -1,2 +1,2 @@
-/* 0.35.6 */
+/* 0.50.0 */
 export declare const DEFINITIONS_TRIGONOMETRY: LatexDictionary;