@cortex-js/compute-engine 0.54.1 → 0.55.2

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

@@ -0,0 +1,113 @@
+/* 0.55.2 */
+ * Standalone LaTeX <-> MathJSON parsing and serialization.
+ *
+ * This module provides a `LatexSyntax` class and free-standing `parse()` /
+ * `serialize()` functions that operate purely on MathJSON expressions --
+ * no `ComputeEngine` instance is required.
+ *
+ * @module latex-syntax
+ */
+import type { MathJsonExpression } from '../../math-json/types';
+import type { LatexDictionaryEntry, LatexString, ParseLatexOptions, SerializeLatexOptions } from './types';
+/**
+ * Options accepted by the {@link LatexSyntax} constructor.
+ *
+ * Every field is optional; sensible defaults (matching the ComputeEngine
+ * defaults) are used for any field that is not provided.
+ */
+export interface LatexSyntaxOptions {
+    /**
+     * Custom LaTeX dictionary entries.  When provided, replaces the default
+     * dictionary entirely.  Use {@link LATEX_DICTIONARY} as a starting point
+     * if you want to extend rather than replace.
+     */
+    dictionary?: ReadonlyArray<Partial<LatexDictionaryEntry>>;
+    /** @default `"."` */
+    decimalSeparator?: '.' | '{,}';
+    /** @default `"\\,"` */
+    digitGroupSeparator?: LatexString | [LatexString, LatexString];
+    /** @default `3` */
+    digitGroup?: 'lakh' | number | [number | 'lakh', number];
+    /** @default `true` */
+    parseStrict?: boolean;
+    /** @default `true` */
+    skipSpace?: boolean;
+    /** @default `"auto"` */
+    parseNumbers?: 'auto' | 'rational' | 'decimal' | 'never';
+    /** @default `false` */
+    preserveLatex?: boolean;
+    /** @default `"tight"` */
+    quantifierScope?: 'tight' | 'loose';
+    /** @default `"t"` */
+    timeDerivativeVariable?: string;
+    /** @default `"max"` */
+    fractionalDigits?: 'auto' | 'max' | number;
+    /** @default `"auto"` */
+    notation?: 'auto' | 'engineering' | 'scientific' | 'adaptiveScientific';
+    /** @default `[-7, 20]` */
+    avoidExponentsInRange?: undefined | null | [negativeExponent: number, positiveExponent: number];
+    /** @default `true` */
+    prettify?: boolean;
+}
+/**
+ * A lightweight LaTeX parser/serializer that operates on raw MathJSON
+ * expressions without requiring a `ComputeEngine` instance.
+ *
+ * ```ts
+ * import { LatexSyntax } from '@cortex-js/compute-engine/latex-syntax';
+ *
+ * const syntax = new LatexSyntax();
+ * const expr = syntax.parse('x^2 + 1');
+ * const latex = syntax.serialize(['Add', ['Power', 'x', 2], 1]);
+ * ```
+ */
+export declare class LatexSyntax {
+    private _options;
+    private _indexed;
+    constructor(options?: LatexSyntaxOptions);
+    /** Lazily built indexed dictionary. */
+    private get indexed();
+    /**
+     * Parse a LaTeX string into a MathJSON expression.
+     *
+     * @param latex  The LaTeX source string
+     * @param options  Per-call overrides for parse options
+     * @returns The resulting MathJSON expression, or `null` if the input is
+     *   empty / invalid.
+     */
+    parse(latex: string, options?: Partial<ParseLatexOptions>): MathJsonExpression | null;
+    /**
+     * Serialize a MathJSON expression into a LaTeX string.
+     *
+     * @param expr  The MathJSON expression to serialize
+     * @param options  Per-call overrides for serialize options
+     * @returns The resulting LaTeX string
+     */
+    serialize(expr: MathJsonExpression, options?: Partial<SerializeLatexOptions>): string;
+}
+/**
+ * Parse a LaTeX string into a MathJSON expression using the default
+ * dictionary and options.
+ *
+ * This is a convenience wrapper around `new LatexSyntax().parse()`.
+ *
+ * ```ts
+ * import { parse } from '@cortex-js/compute-engine/latex-syntax';
+ * const expr = parse('\\frac{x}{2}');
+ * // => ['Divide', 'x', 2]
+ * ```
+ */
+export declare function parse(latex: string): MathJsonExpression | null;
+/**
+ * Serialize a MathJSON expression to LaTeX using the default dictionary
+ * and options.
+ *
+ * This is a convenience wrapper around `new LatexSyntax().serialize()`.
+ *
+ * ```ts
+ * import { serialize } from '@cortex-js/compute-engine/latex-syntax';
+ * const latex = serialize(['Add', 'x', 1]);
+ * // => 'x + 1'
+ * ```
+ */
+export declare function serialize(expr: MathJsonExpression): string;

package/dist/types/compute-engine/latex-syntax/parse-number.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.2 */
  * Number parsing extracted from the _Parser class for modularity.
  *
  * All functions take a `Parser` interface and a `NumberFormatTokens` config

package/dist/types/compute-engine/latex-syntax/parse-symbol.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.2 */
 import { Parser } from './types';
 /** For error handling, if we have a symbol prefix, assume
  * the symbol is invalid (it would have been captured by

package/dist/types/compute-engine/latex-syntax/parse.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.2 */
 import { ParseLatexOptions, LatexToken, Terminator, Parser, SymbolTable } from './types';
 import type { IndexedLatexDictionary, IndexedLatexDictionaryEntry, IndexedInfixEntry, IndexedPostfixEntry, IndexedPrefixEntry, IndexedSymbolEntry, IndexedExpressionEntry, IndexedFunctionEntry } from './dictionary/definitions';
 import { BoxedType } from '../../common/type/boxed-type';
@@ -202,6 +202,16 @@ export declare class _Parser implements Parser {
     parseNumber(): MathJsonExpression | null;
     private parsePrefixOperator;
     private parseInfixOperator;
+    /**
+     * Speculatively check if any \text infix entry (e.g. "and", "or", "where")
+     * would match the upcoming tokens. This is used to prevent InvisibleOperator
+     * from consuming \text{keyword} as a text run when the keyword is actually
+     * an infix operator that was skipped due to precedence constraints.
+     *
+     * Returns true if any entry's parse function would succeed (non-null result).
+     * The parser index is always restored to its original position.
+     */
+    private wouldMatchTextInfix;
     /**
      * This returns an array of arguments (as in a function application),
      * or null if there is no match.

package/dist/types/compute-engine/latex-syntax/serialize-dms.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.2 */
  * DMS (Degrees-Minutes-Seconds) serialization utilities.
  */
 export interface DMSComponents {

package/dist/types/compute-engine/latex-syntax/serialize-number.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.2 */
 import { NumberSerializationFormat } from './types';
 /**
  * @param expr - A number, can be represented as a string

package/dist/types/compute-engine/latex-syntax/serializer-style.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.2 */
 import { DelimiterScale } from './types';
 export declare function getApplyFunctionStyle(_expr: MathJsonExpression, _level: number): DelimiterScale;
 export declare function getGroupStyle(_expr: MathJsonExpression, _level: number): DelimiterScale;

package/dist/types/compute-engine/latex-syntax/serializer.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.2 */
 import { LatexString, SerializeLatexOptions, DelimiterScale } from './types';
 import type { IndexedLatexDictionary, IndexedLatexDictionaryEntry } from './dictionary/definitions';
 export declare class Serializer {

package/dist/types/compute-engine/latex-syntax/tokenizer.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.2 */
  * ## Reference
  * TeX source code:
  * {@link  http://tug.org/texlive/devsrc/Build/source/texk/web2c/tex.web | Tex.web}

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

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.2 */
 import type { MathJsonExpression, MathJsonSymbol } from '../../math-json/types';
 import type { TypeString } from '../../common/type/types';
 import { BoxedType } from '../../common/type/boxed-type';
@@ -881,7 +881,7 @@ export type SerializeLatexOptions = NumberSerializationFormat & {
      * @example
      * ```typescript
      * const ce = new ComputeEngine();
-     * const angle = ce.box(['Quantity', 9.5, 'deg']);
+     * const angle = ce.expr(['Quantity', 9.5, 'deg']);
      *
      * // DMS format
      * angle.latex({ dmsFormat: true });  // "9°30'"
@@ -890,7 +890,7 @@ export type SerializeLatexOptions = NumberSerializationFormat & {
      * angle.latex({ dmsFormat: false }); // "9.5°"
      *
      * // Full DMS notation
-     * ce.box(['Quantity', 9.504166, 'deg'])
+     * ce.expr(['Quantity', 9.504166, 'deg'])
      *   .latex({ dmsFormat: true });     // "9°30'15\""
      * ```
      */
@@ -906,22 +906,22 @@ export type SerializeLatexOptions = NumberSerializationFormat & {
      * const ce = new ComputeEngine();
      *
      * // No normalization (show exact value)
-     * ce.box(['Degrees', 370])
+     * ce.expr(['Degrees', 370])
      *   .latex({ angleNormalization: 'none' });  // "370°"
      *
      * // Normalize to [0, 360) - useful for bearings
-     * ce.box(['Degrees', 370])
+     * ce.expr(['Degrees', 370])
      *   .latex({ angleNormalization: '0...360' }); // "10°"
      *
-     * ce.box(['Degrees', -45])
+     * ce.expr(['Degrees', -45])
      *   .latex({ angleNormalization: '0...360' }); // "315°"
      *
      * // Normalize to [-180, 180] - useful for longitude
-     * ce.box(['Degrees', 190])
+     * ce.expr(['Degrees', 190])
      *   .latex({ angleNormalization: '-180...180' }); // "-170°"
      *
      * // Combine with DMS format
-     * ce.box(['Degrees', 370])
+     * ce.expr(['Degrees', 370])
      *   .latex({
      *     dmsFormat: true,
      *     angleNormalization: '0...360'

package/dist/types/compute-engine/latex-syntax/utils.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.2 */
 export declare function asLatexString(s: unknown): string | null;
 export declare function isRelationalOperator(name: string | undefined): boolean;
 export declare function isInequalityOperator(operator: string | undefined): boolean;

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

@@ -1,3 +1,3 @@
-/* 0.54.1 */
+/* 0.55.2 */
 export type CanonicalArithmeticOperators = 'Add' | 'Negate' | 'Multiply' | 'Divide' | 'Power' | 'Sqrt' | 'Root' | 'Ln';
 export declare const ARITHMETIC_LIBRARY: SymbolDefinitions[];

package/dist/types/compute-engine/library/calculus.d.ts

@@ -1,2 +1,2 @@
-/* 0.54.1 */
+/* 0.55.2 */
 export declare const CALCULUS_LIBRARY: SymbolDefinitions[];

package/dist/types/compute-engine/library/collections.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.2 */
 export declare const DEFAULT_LINSPACE_COUNT = 50;
 export declare const COLLECTIONS_LIBRARY: SymbolDefinitions;
 /**

package/dist/types/compute-engine/library/colors.d.ts

@@ -1,2 +1,2 @@
-/* 0.54.1 */
+/* 0.55.2 */
 export declare const COLORS_LIBRARY: SymbolDefinitions;

package/dist/types/compute-engine/library/combinatorics.d.ts

@@ -1,2 +1,2 @@
-/* 0.54.1 */
+/* 0.55.2 */
 export declare const COMBINATORICS_LIBRARY: SymbolDefinitions[];

package/dist/types/compute-engine/library/complex.d.ts

@@ -1,2 +1,2 @@
-/* 0.54.1 */
+/* 0.55.2 */
 export declare const COMPLEX_LIBRARY: SymbolDefinitions[];

package/dist/types/compute-engine/library/control-structures.d.ts

@@ -1,2 +1,2 @@
-/* 0.54.1 */
+/* 0.55.2 */
 export declare const CONTROL_STRUCTURES_LIBRARY: SymbolDefinitions[];

package/dist/types/compute-engine/library/core.d.ts

@@ -1,2 +1,2 @@
-/* 0.54.1 */
+/* 0.55.2 */
 export declare const CORE_LIBRARY: SymbolDefinitions[];

package/dist/types/compute-engine/library/fractals.d.ts

@@ -1,2 +1,2 @@
-/* 0.54.1 */
+/* 0.55.2 */
 export declare const FRACTALS_LIBRARY: SymbolDefinitions[];

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

@@ -1,10 +1,10 @@
-/* 0.54.1 */
+/* 0.55.2 */
 import type { SymbolDefinitions, IComputeEngine as ComputeEngine, LibraryDefinition } from '../global-types';
 /**
  * The standard libraries bundled with the Compute Engine.
  *
- * Each entry bundles symbol/operator definitions with their LaTeX dictionary
- * entries and declares dependencies on other libraries.
+ * Each entry bundles symbol/operator definitions and declares dependencies
+ * on other libraries.
  */
 export declare const STANDARD_LIBRARIES: LibraryDefinition[];
 /**

package/dist/types/compute-engine/library/linear-algebra.d.ts

@@ -1,2 +1,2 @@
-/* 0.54.1 */
+/* 0.55.2 */
 export declare const LINEAR_ALGEBRA_LIBRARY: SymbolDefinitions[];

package/dist/types/compute-engine/library/logic-analysis.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.2 */
 /**
  * Quantifier domain helpers and boolean analysis functions.
  * Extracted from logic.ts for better code organization.

package/dist/types/compute-engine/library/logic.d.ts

@@ -1,3 +1,3 @@
-/* 0.54.1 */
+/* 0.55.2 */
 export declare const LOGIC_LIBRARY: SymbolDefinitions;
 export declare const LOGIC_FUNCTION_LIBRARY: SymbolDefinitions;

package/dist/types/compute-engine/library/number-theory.d.ts

@@ -1,2 +1,2 @@
-/* 0.54.1 */
+/* 0.55.2 */
 export declare const NUMBER_THEORY_LIBRARY: SymbolDefinitions[];

package/dist/types/compute-engine/library/polynomials.d.ts

@@ -1,2 +1,2 @@
-/* 0.54.1 */
+/* 0.55.2 */
 export declare const POLYNOMIALS_LIBRARY: SymbolDefinitions[];

package/dist/types/compute-engine/library/quantity-arithmetic.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.2 */
  * Arithmetic helpers for Quantity expressions.
  *
  * Extracted from arithmetic.ts to keep that file focused on scalar

package/dist/types/compute-engine/library/random-expression.d.ts

@@ -1,2 +1,2 @@
-/* 0.54.1 */
+/* 0.55.2 */
 export declare function randomExpression(level?: number): MathJsonExpression;

package/dist/types/compute-engine/library/relational-operator.d.ts

@@ -1,2 +1,2 @@
-/* 0.54.1 */
+/* 0.55.2 */
 export declare const RELOP_LIBRARY: SymbolDefinitions;

package/dist/types/compute-engine/library/sets.d.ts

@@ -1,2 +1,2 @@
-/* 0.54.1 */
+/* 0.55.2 */
 export declare const SETS_LIBRARY: SymbolDefinitions;

package/dist/types/compute-engine/library/statistics.d.ts

@@ -1,2 +1,2 @@
-/* 0.54.1 */
+/* 0.55.2 */
 export declare const STATISTICS_LIBRARY: SymbolDefinitions[];

package/dist/types/compute-engine/library/trigonometry.d.ts

@@ -1,2 +1,2 @@
-/* 0.54.1 */
+/* 0.55.2 */
 export declare const TRIGONOMETRY_LIBRARY: SymbolDefinitions[];

package/dist/types/compute-engine/library/type-handlers.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.2 */
 import type { Type } from '../../common/type/types';
 /** Real inputs → finite_real, otherwise → finite_number. */
 export declare function numericTypeHandler(ops: ReadonlyArray<Expression>): Type;

package/dist/types/compute-engine/library/unit-data.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.2 */
  * Re-export the unit registry from its canonical location in numerics/.
  *
  * The unit registry lives in numerics/ so that lower layers (like

package/dist/types/compute-engine/library/units.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.2 */
 import { type UnitExpression } from './unit-data';
 /**
  * Convert a boxed expression representing a unit into a plain

package/dist/types/compute-engine/library/utils.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.2 */
 /**
  * EL-4: Convert known infinite integer sets to their equivalent Limits bounds.
  * Returns undefined if the set cannot be converted to a Limits form.

package/dist/types/compute-engine/numeric-value/big-numeric-value.d.ts

@@ -1,23 +1,38 @@
-/* 0.54.1 */
-import type { BigNumFactory, SmallInteger } from '../numerics/types';
+/* 0.55.2 */
+import type { SmallInteger } from '../numerics/types';
 import { NumericValue, NumericValueData } from './types';
 import { ExactNumericValue } from './exact-numeric-value';
 import { MathJsonExpression } from '../../math-json/types';
 import { NumericPrimitiveType } from '../../common/type/types';
 export declare class BigNumericValue extends NumericValue {
     __brand: 'BigNumericValue';
-    decimal: Decimal;
-    bignum: BigNumFactory;
-    constructor(value: number | Decimal | NumericValueData, bignum: BigNumFactory);
+    decimal: BigDecimal;
+    constructor(value: number | BigDecimal | NumericValueData);
     get type(): NumericPrimitiveType;
     get isExact(): boolean;
     get asExact(): ExactNumericValue | undefined;
+    /**
+     * Serialize to MathJSON. Preserves the full raw `BigDecimal` value
+     * with no rounding, ensuring lossless round-tripping. Digits beyond
+     * `BigDecimal.precision` may be present (from exact arithmetic) but
+     * are not guaranteed to be accurate after precision-bounded operations.
+     */
     toJSON(): MathJsonExpression;
+    /**
+     * Return a human-readable string representation.
+     *
+     * The real part is rounded to `BigDecimal.precision` significant digits
+     * so that noise digits from precision-bounded operations (division,
+     * transcendentals) are not displayed. The imaginary part uses native
+     * `Number.toString()` (always machine precision).
+     *
+     * For the full unrounded value, use `toJSON()`.
+     */
     toString(): string;
-    clone(value: number | Decimal | NumericValueData): BigNumericValue;
+    clone(value: number | BigDecimal | NumericValueData): BigNumericValue;
     private _makeExact;
     get re(): number;
-    get bignumRe(): Decimal;
+    get bignumRe(): BigDecimal;
     get numerator(): BigNumericValue;
     get denominator(): ExactNumericValue;
     get isNaN(): boolean;
@@ -25,7 +40,7 @@ export declare class BigNumericValue extends NumericValue {
     get isNegativeInfinity(): boolean;
     get isComplexInfinity(): boolean;
     get isZero(): boolean;
-    isZeroWithTolerance(tolerance: number | Decimal): boolean;
+    isZeroWithTolerance(tolerance: number | BigDecimal): boolean;
     get isOne(): boolean;
     get isNegativeOne(): boolean;
     sgn(): -1 | 0 | 1 | undefined;
@@ -34,7 +49,7 @@ export declare class BigNumericValue extends NumericValue {
     inv(): BigNumericValue;
     add(other: number | NumericValue): NumericValue;
     sub(other: NumericValue): NumericValue;
-    mul(other: number | Decimal | NumericValue): NumericValue;
+    mul(other: number | BigDecimal | NumericValue): NumericValue;
     div(other: SmallInteger | NumericValue): NumericValue;
     pow(exponent: number | NumericValue | {
         re: number;

package/dist/types/compute-engine/numeric-value/exact-numeric-value.d.ts

@@ -1,5 +1,5 @@
-/* 0.54.1 */
-import { type BigNumFactory, Rational, SmallInteger } from '../numerics/types';
+/* 0.55.2 */
+import { Rational, SmallInteger } from '../numerics/types';
 import { ExactNumericValueData, NumericValue, NumericValueFactory } from './types';
 import { MathJsonExpression } from '../../math-json/types';
 import { NumericPrimitiveType } from '../../common/type/types';
@@ -19,12 +19,11 @@ export declare class ExactNumericValue extends NumericValue {
     radical: number;
     im: number;
     factory: NumericValueFactory;
-    bignum: BigNumFactory;
     /** The caller is responsible to make sure the input is valid, i.e.
      * - rational is a fraction of integers (but it may not be reduced)
      * - radical is an integer
      */
-    constructor(value: number | bigint | ExactNumericValueData, factory: NumericValueFactory, bignum: BigNumFactory);
+    constructor(value: number | bigint | ExactNumericValueData, factory: NumericValueFactory);
     get type(): NumericPrimitiveType;
     get isExact(): boolean;
     get asExact(): NumericValue | undefined;
@@ -34,7 +33,7 @@ export declare class ExactNumericValue extends NumericValue {
     toString(): string;
     get sign(): -1 | 0 | 1;
     get re(): number;
-    get bignumRe(): Decimal;
+    get bignumRe(): BigDecimal;
     get numerator(): ExactNumericValue;
     get denominator(): ExactNumericValue;
     normalize(): void;
@@ -51,7 +50,7 @@ export declare class ExactNumericValue extends NumericValue {
     inv(): NumericValue;
     add(other: number | NumericValue): NumericValue;
     sub(other: NumericValue): NumericValue;
-    mul(other: number | Decimal | NumericValue): NumericValue;
+    mul(other: number | BigDecimal | NumericValue): NumericValue;
     div(other: SmallInteger | NumericValue): NumericValue;
     pow(exponent: number | NumericValue | {
         re: number;
@@ -71,5 +70,5 @@ export declare class ExactNumericValue extends NumericValue {
     lte(other: number | NumericValue): boolean | undefined;
     gt(other: number | NumericValue): boolean | undefined;
     gte(other: number | NumericValue): boolean | undefined;
-    static sum(values: NumericValue[], factory: NumericValueFactory, bignumFactory: BigNumFactory): NumericValue[];
+    static sum(values: NumericValue[], factory: NumericValueFactory): NumericValue[];
 }

package/dist/types/compute-engine/numeric-value/machine-numeric-value.d.ts

@@ -1,22 +1,21 @@
-/* 0.54.1 */
-import type { BigNumFactory, SmallInteger } from '../numerics/types';
+/* 0.55.2 */
+import type { SmallInteger } from '../numerics/types';
 import { NumericValue, NumericValueData } from './types';
 import type { MathJsonExpression } from '../../math-json/types';
 import { NumericPrimitiveType } from '../../common/type/types';
 export declare class MachineNumericValue extends NumericValue {
     __brand: 'MachineNumericValue';
     decimal: number;
-    bignum: BigNumFactory;
-    constructor(value: number | Decimal | NumericValueData, bignum: BigNumFactory);
+    constructor(value: number | BigDecimal | NumericValueData);
     private _makeExact;
     get type(): NumericPrimitiveType;
     get isExact(): boolean;
     get asExact(): NumericValue | undefined;
     toJSON(): MathJsonExpression;
     toString(): string;
-    clone(value: number | Decimal | NumericValueData): MachineNumericValue;
+    clone(value: number | BigDecimal | NumericValueData): MachineNumericValue;
     get re(): number;
-    get bignumRe(): Decimal | undefined;
+    get bignumRe(): BigDecimal | undefined;
     get numerator(): MachineNumericValue;
     get denominator(): NumericValue;
     get isNaN(): boolean;
@@ -24,7 +23,7 @@ export declare class MachineNumericValue extends NumericValue {
     get isNegativeInfinity(): boolean;
     get isComplexInfinity(): boolean;
     get isZero(): boolean;
-    isZeroWithTolerance(tolerance: number | Decimal): boolean;
+    isZeroWithTolerance(tolerance: number | BigDecimal): boolean;
     get isOne(): boolean;
     get isNegativeOne(): boolean;
     sgn(): -1 | 0 | 1 | undefined;
@@ -33,7 +32,7 @@ export declare class MachineNumericValue extends NumericValue {
     inv(): NumericValue;
     add(other: number | NumericValue): NumericValue;
     sub(other: NumericValue): NumericValue;
-    mul(other: number | Decimal | NumericValue): NumericValue;
+    mul(other: number | BigDecimal | NumericValue): NumericValue;
     div(other: SmallInteger | NumericValue): NumericValue;
     pow(exponent: number | {
         re: number;

package/dist/types/compute-engine/numeric-value/types.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.2 */
  *
  * ## THEORY OF OPERATIONS
  *
@@ -23,7 +23,7 @@
  * A float numeric value is never converted to an exact one.
  *
  */
-import { Decimal } from 'decimal.js';
+import { BigDecimal } from '../../big-decimal';
 import type { Rational, SmallInteger } from '../numerics/types';
 import { NumericPrimitiveType } from '../../common/type/types';
 /** The value is equal to `(decimal * rational * sqrt(radical)) + im * i`
@@ -34,11 +34,11 @@ export type ExactNumericValueData = {
 };
 /** @category Numerics */
 export type NumericValueData = {
-    re?: Decimal | number;
+    re?: BigDecimal | number;
     im?: number;
 };
 /** @category Numerics */
-export type NumericValueFactory = (data: number | Decimal | NumericValueData) => NumericValue;
+export type NumericValueFactory = (data: number | BigDecimal | NumericValueData) => NumericValue;
 /** @category Numerics */
 export declare abstract class NumericValue {
     abstract get type(): NumericPrimitiveType;
@@ -59,13 +59,13 @@ export declare abstract class NumericValue {
      */
     abstract get re(): number;
     /**  bignum version of .re, if available */
-    get bignumRe(): Decimal | undefined;
+    get bignumRe(): BigDecimal | undefined;
     /** The imaginary part of this numeric value.
      *
      * Can be negative, zero or positive.
      */
     im: number;
-    get bignumIm(): Decimal | undefined;
+    get bignumIm(): BigDecimal | undefined;
     abstract get numerator(): NumericValue;
     abstract get denominator(): NumericValue;
     abstract get isNaN(): boolean;
@@ -73,7 +73,7 @@ export declare abstract class NumericValue {
     abstract get isNegativeInfinity(): boolean;
     abstract get isComplexInfinity(): boolean;
     abstract get isZero(): boolean;
-    isZeroWithTolerance(_tolerance: number | Decimal): boolean;
+    isZeroWithTolerance(_tolerance: number | BigDecimal): boolean;
     abstract get isOne(): boolean;
     abstract get isNegativeOne(): boolean;
     /** The sign of complex numbers is undefined */
@@ -84,7 +84,7 @@ export declare abstract class NumericValue {
     abstract inv(): NumericValue;
     abstract add(other: number | NumericValue): NumericValue;
     abstract sub(other: NumericValue): NumericValue;
-    abstract mul(other: number | Decimal | NumericValue): NumericValue;
+    abstract mul(other: number | BigDecimal | NumericValue): NumericValue;
     abstract div(other: SmallInteger | NumericValue): NumericValue;
     abstract pow(n: number | NumericValue | {
         re: number;

package/dist/types/compute-engine/numerics/bigint.d.ts

@@ -1,2 +1,2 @@
-/* 0.54.1 */
-export declare function bigint(a: Decimal | number | bigint | string): bigint | null;
+/* 0.55.2 */
+export declare function bigint(a: BigDecimal | number | bigint | string): bigint | null;

package/dist/types/compute-engine/numerics/expression.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.2 */
 export declare function bigintValue(expr: MathJsonExpression | null | undefined): bigint | null;
 /** Output a shorthand if possible */
 export declare function numberToExpression(num: number | bigint, fractionalDigits?: string | number): MathJsonExpression;