@cortex-js/compute-engine 0.50.1 → 0.51.0

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

@@ -0,0 +1,37 @@
+/* 0.51.0 */
+ * Arithmetic helpers for Quantity expressions.
+ *
+ * Extracted from arithmetic.ts to keep that file focused on scalar
+ * arithmetic.  Every function here operates on Quantity expressions
+ * (magnitude + unit pairs) and is called from the evaluate paths of
+ * Add, Multiply, Divide, Power, Negate, Sqrt, and Root.
+ */
+import type { Expression, IComputeEngine as ComputeEngine } from '../global-types';
+/** A Quantity function expression with guaranteed op1 and op2 access. */
+export type QuantityExpr = Expression & {
+    readonly op1: Expression;
+    readonly op2: Expression;
+    readonly ops: ReadonlyArray<Expression>;
+};
+/** Check if an expression is a Quantity and narrow the type. */
+export declare function isQuantity(expr: Expression): expr is QuantityExpr;
+/**
+ * Add Quantity expressions.  All operands must be Quantities with
+ * compatible dimensions.  The result uses the unit with the largest
+ * scale factor (e.g. `m` wins over `cm`, `km` wins over `m`).
+ */
+export declare function quantityAdd(ce: ComputeEngine, ops: ReadonlyArray<Expression>): Expression | undefined;
+/**
+ * Multiply expressions where at least one is a Quantity.
+ * - scalar * Quantity => Quantity with scaled magnitude
+ * - Quantity * Quantity => Quantity with compound unit
+ */
+export declare function quantityMultiply(ce: ComputeEngine, ops: ReadonlyArray<Expression>): Expression | undefined;
+/**
+ * Divide two expressions where at least one is a Quantity.
+ */
+export declare function quantityDivide(ce: ComputeEngine, num: Expression, den: Expression): Expression | undefined;
+/**
+ * Raise a Quantity to a power.
+ */
+export declare function quantityPower(ce: ComputeEngine, base: Expression, exp: Expression): Expression | undefined;

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

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

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

@@ -1,2 +1,2 @@
-/* 0.50.1 */
+/* 0.51.0 */
 export declare const RELOP_LIBRARY: SymbolDefinitions;

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

@@ -1,2 +1,2 @@
-/* 0.50.1 */
+/* 0.51.0 */
 export declare const SETS_LIBRARY: SymbolDefinitions;

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

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

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

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

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

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 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

@@ -0,0 +1,8 @@
+/* 0.51.0 */
+ * Re-export the unit registry from its canonical location in numerics/.
+ *
+ * The unit registry lives in numerics/ so that lower layers (like
+ * latex-syntax/) can access it without violating the layered dependency
+ * rules.
+ */
+export { type DimensionVector, type UnitExpression, dimensionsEqual, isDimensionless, getUnitDimension, getUnitScale, areCompatibleUnits, convertUnit, getExpressionDimension, getExpressionScale, parseUnitDSL, convertCompoundUnit, findNamedUnit, } from '../numerics/unit-data';

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

@@ -0,0 +1,9 @@
+/* 0.51.0 */
+import { type UnitExpression } from './unit-data';
+/**
+ * Convert a boxed expression representing a unit into a plain
+ * `UnitExpression` (string or JSON array) that `unit-data.ts` functions
+ * can work with.
+ */
+export declare function boxedToUnitExpression(expr: Expression): UnitExpression | null;
+export declare const UNITS_LIBRARY: SymbolDefinitions;

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

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 /**
  * 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,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 import type { BigNumFactory, SmallInteger } from '../numerics/types';
 import { NumericValue, NumericValueData } from './types';
 import { ExactNumericValue } from './exact-numeric-value';

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

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 import { type BigNumFactory, Rational, SmallInteger } from '../numerics/types';
 import { ExactNumericValueData, NumericValue, NumericValueFactory } from './types';
 import { MathJsonExpression } from '../../math-json/types';

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

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 import type { BigNumFactory, SmallInteger } from '../numerics/types';
 import { NumericValue, NumericValueData } from './types';
 import type { MathJsonExpression } from '../../math-json/types';

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

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
  *
  * ## THEORY OF OPERATIONS
  *

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

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

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

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 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;

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

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 /** An interval is a continuous set of real numbers */
 export type Interval = {
     start: number;

package/dist/types/compute-engine/numerics/monte-carlo.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
     estimate: number;
     error: number;
 };

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

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 export declare function lcm(a: bigint, b: bigint): bigint;
 /** Return `[factor, root]` such that
  * pow(n, 1/exponent) = factor * pow(root, 1/exponent)

package/dist/types/compute-engine/numerics/numeric-bignum.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 export declare function gcd(a: BigNum, b: BigNum): BigNum;
 export declare function lcm(a: BigNum, b: BigNum): BigNum;
 export declare function factorial2(ce: IBigNum, n: BigNum): BigNum;

package/dist/types/compute-engine/numerics/numeric-complex.d.ts

@@ -1,3 +1,3 @@
-/* 0.50.1 */
+/* 0.51.0 */
 export declare function gamma(c: Complex): Complex;
 export declare function gammaln(c: Complex): Complex;

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

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 export declare const MACHINE_PRECISION_BITS = 53;
 export declare const MACHINE_PRECISION: number;
 export declare const DEFAULT_TOLERANCE = 1e-10;

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

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 export declare function primeFactors(n: number): {
     [factor: number]: number;
 };

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

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 export declare function isRational(x: unknown | null): x is Rational;
 export declare function isMachineRational(x: unknown | null): x is [SmallInteger, SmallInteger];
 export declare function isBigRational(x: unknown | null): x is [bigint, bigint];

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

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 
     Translated from https://github.com/JuliaMath/Richardson.jl/blob/master/src/Richardson.jl
 

package/dist/types/compute-engine/numerics/special-functions.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 import type { BigNum } from './types';
 export declare function gammaln(z: number): number;
 export declare function gamma(z: number): number;

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

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 export declare function mean(values: Iterable<number>): number;
 export declare function bigMean(bignum: BigNumFactory, values: Iterable<BigNum>): BigNum;
 export declare function median(values: Iterable<number>): number;

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

@@ -1,2 +1,2 @@
-/* 0.50.1 */
+/* 0.51.0 */
 export declare function numberToString(num: number | bigint, fractionalDigits?: number | string): string;

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

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 /** @internal */
 type IsInteger<N extends number> = `${N}` extends `${string}.${string}` ? never : `${N}` extends `-${string}.${string}` ? never : number;
 /** A `SmallInteger` is an integer < 1e6

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

@@ -0,0 +1,128 @@
+/* 0.51.0 */
+ * Unit registry: dimension vectors, SI base units, prefixes, and conversion.
+ *
+ * A DimensionVector encodes the exponents for each of the 7 SI base
+ * dimensions: [length, mass, time, current, temperature, amount, luminosity].
+ *
+ * Every unit in the registry stores its dimension vector and a scale factor
+ * relative to the coherent SI unit for that dimension.  For example the meter
+ * has scale 1, the kilometer has scale 1000, and the inch has scale 0.0254
+ * (all measuring length).
+ *
+ * Prefixed units (km, mg, GHz, ...) are resolved on the fly by
+ * `parsePrefixedUnit` rather than stored explicitly.
+ */
+/**
+ * 7-tuple of exponents over the SI base dimensions:
+ * [length, mass, time, current, temperature, amount, luminosity]
+ */
+export type DimensionVector = [
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number
+];
+export declare function dimensionsEqual(a: DimensionVector, b: DimensionVector): boolean;
+export declare function isDimensionless(dim: DimensionVector): boolean;
+/**
+ * Return the dimension vector for `symbol`, or `null` if unknown.
+ *
+ * Handles direct units (m, kg, N, ...) and prefixed units (km, MHz, ...).
+ */
+export declare function getUnitDimension(symbol: string): DimensionVector | null;
+/**
+ * Return the scale factor of `symbol` relative to the coherent SI unit
+ * for the same dimension, or `null` if unknown.
+ *
+ * Examples:
+ * - getUnitScale('m')  → 1
+ * - getUnitScale('km') → 1000
+ * - getUnitScale('mg') → 1e-6   (milli × gram: 1e-3 × 1e-3)
+ */
+export declare function getUnitScale(symbol: string): number | null;
+/**
+ * Return `true` when `a` and `b` share the same dimension vector
+ * (i.e. they measure the same physical quantity and can be inter-converted).
+ */
+export declare function areCompatibleUnits(a: string, b: string): boolean;
+/**
+ * Search for a named derived SI unit that matches the given dimension vector
+ * and has scale=1.
+ *
+ * Returns the unit symbol (e.g., 'N', 'J', 'W') or `null` if no match.
+ */
+export declare function findNamedUnit(dim: DimensionVector): string | null;
+/**
+ * Convert a numeric `value` from `fromUnit` to `toUnit`.
+ *
+ * Returns the converted value, or `null` when the units are unknown or
+ * dimensionally incompatible.
+ *
+ * Handles both linear conversions (most units) and affine conversions
+ * (degC, degF) via the optional `offset` field.
+ */
+export declare function convertUnit(value: number, fromUnit: string, toUnit: string): number | null;
+/**
+ * A MathJSON-like unit expression: either a string (simple unit symbol) or
+ * an array like `["Divide", "m", "s"]`.
+ */
+export type UnitExpression = string | [string, ...any[]];
+/**
+ * Compute the dimension vector for a MathJSON unit expression.
+ *
+ * - If `expr` is a string, delegates to `getUnitDimension`.
+ * - `["Multiply", a, b, ...]` — adds dimension vectors component-wise.
+ * - `["Divide", a, b]` — subtracts b's dimension from a's.
+ * - `["Power", base, exp]` — multiplies base dimension by exp.
+ *
+ * Returns `null` if any component is unrecognised.
+ */
+export declare function getExpressionDimension(expr: UnitExpression): DimensionVector | null;
+/**
+ * Compute the scale factor for a MathJSON unit expression relative to
+ * coherent SI.
+ *
+ * - If `expr` is a string, delegates to `getUnitScale`.
+ * - `["Multiply", a, b, ...]` — multiplies scales.
+ * - `["Divide", a, b]` — a.scale / b.scale.
+ * - `["Power", base, exp]` — base.scale ^ exp.
+ *
+ * Returns `null` if any component is unrecognised.
+ */
+export declare function getExpressionScale(expr: UnitExpression): number | null;
+/**
+ * Parse a unit DSL string like `"m/s^2"` or `"kg*m/s^2"` into a
+ * MathJSON unit expression.
+ *
+ * Grammar:
+ * - `*` = multiplication
+ * - `/` = division (everything after `/` is in denominator)
+ * - `^N` = power (integer exponent)
+ * - `(...)` = grouping
+ * - Simple units (no operators) stay as strings.
+ *
+ * Examples:
+ * ```
+ * parseUnitDSL("m")          // "m"
+ * parseUnitDSL("km")         // "km"
+ * parseUnitDSL("m/s")        // ["Divide", "m", "s"]
+ * parseUnitDSL("m/s^2")      // ["Divide", "m", ["Power", "s", 2]]
+ * parseUnitDSL("kg*m/s^2")   // ["Divide", ["Multiply", "kg", "m"], ["Power", "s", 2]]
+ * parseUnitDSL("kg/(m*s^2)") // ["Divide", "kg", ["Multiply", "m", ["Power", "s", 2]]]
+ * ```
+ */
+export declare function parseUnitDSL(s: string): UnitExpression | null;
+/**
+ * Convert a numeric `value` between two compound unit expressions.
+ *
+ * Both `fromUnit` and `toUnit` may be simple strings or MathJSON arrays.
+ * Returns the converted value, or `null` on dimensional mismatch or
+ * unknown units.
+ *
+ * For simple string units, delegates to `convertUnit` so that affine
+ * offsets (degC, degF) are handled correctly.
+ */
+export declare function convertCompoundUnit(value: number, fromUnit: UnitExpression, toUnit: UnitExpression): number | null;

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

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
  * OEIS (Online Encyclopedia of Integer Sequences) Integration
  *
  * This module provides functions to look up sequences in the OEIS database

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

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
  * Utilities for declarative sequence definitions.
  *
  * This module provides functions to create subscriptEvaluate handlers

package/dist/types/compute-engine/symbolic/antiderivative.d.ts

@@ -1,3 +1,3 @@
-/* 0.50.1 */
+/* 0.51.0 */
 /** Calculate the antiderivative of fn, as an expression (not a function) */
 export declare function antiderivative(fn: Expression, index: string): Expression;

package/dist/types/compute-engine/symbolic/derivative.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 /**
  *
  * @param fn The function to differentiate, a function literal.

package/dist/types/compute-engine/symbolic/distribute.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 /**
  *
  */

package/dist/types/compute-engine/symbolic/fu-cost.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
  * Cost functions for the Fu trigonometric simplification algorithm.
  *
  * The primary objective is to minimize the number of trigonometric functions,

package/dist/types/compute-engine/symbolic/fu-transforms.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
  * Fu Algorithm Transformation Rules
  *
  * Programmatic implementations of TR1-TR22 from the Fu trigonometric

package/dist/types/compute-engine/symbolic/fu.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
  * Fu Algorithm for Trigonometric Simplification
  *
  * Implementation of the algorithm by Fu, Zhong, and Zeng:

package/dist/types/compute-engine/symbolic/logic-utils.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 export declare function evaluateAnd(args: ReadonlyArray<Expression>, { engine: ce }: {
     engine: ComputeEngine;
 }): Expression | undefined;

package/dist/types/compute-engine/symbolic/simplify-abs.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 export declare function simplifyAbs(x: Expression): RuleStep | undefined;
 /**
  * Simplify expressions where Abs appears as the base of a power.

package/dist/types/compute-engine/symbolic/simplify-divide.d.ts

@@ -1,7 +1,6 @@
-/* 0.50.1 */
+/* 0.51.0 */
 /**
  * Division simplification rules consolidated from simplify-rules.ts.
- * Handles ~5 patterns for simplifying Divide expressions.
  *
  * Patterns:
  * - a/a -> 1 (when a ≠ 0)
@@ -9,6 +8,9 @@
  * - a/(1/b) -> a*b (when b ≠ 0)
  * - a/(b/c) -> a*c/b (when c ≠ 0)
  * - 0/a -> 0 (when a ≠ 0)
+ * - n!/k! -> partial product (concrete integers)
+ * - n!/k! -> (k+1)(k+2)...n (symbolic, small constant diff)
+ * - n!/(k!(n-k)!) -> Binomial(n, k)
  *
  * IMPORTANT: Do not call .simplify() on results to avoid infinite recursion.
  */

package/dist/types/compute-engine/symbolic/simplify-factorial.d.ts

@@ -0,0 +1,33 @@
+/* 0.51.0 */
+/**
+ * Extracts base + integer offset from an expression.
+ * - Symbol `n` → { base: n, offset: 0 }
+ * - Add(n, 3) → { base: n, offset: 3 }
+ * - Add(n, -2) → { base: n, offset: -2 }
+ * - Multiply(2, x) → { base: Multiply(2, x), offset: 0 }
+ * - Number → null (pure numeric, no symbolic base)
+ */
+export declare function baseOffset(expr: Expression): {
+    base: Expression;
+    offset: number;
+} | null;
+/**
+ * Simplification rules for Binomial and Choose expressions.
+ *
+ * Patterns:
+ * - C(n, 0) → 1
+ * - C(n, 1) → n
+ * - C(n, n) → 1
+ * - C(n, n-1) → n
+ */
+export declare function simplifyBinomial(x: Expression): RuleStep | undefined;
+/**
+ * Simplification for Add expressions containing factorial terms.
+ * Factors out the common (smallest) factorial for symbolic expressions.
+ *
+ * Examples:
+ * - n! - (n-1)! → (n-1)! * (n - 1)
+ * - (n+1)! - n! → n! * n
+ * - (n+1)! + n! → n! * (n + 2)
+ */
+export declare function simplifyFactorialAdd(x: Expression): RuleStep | undefined;

package/dist/types/compute-engine/symbolic/simplify-hyperbolic.d.ts

@@ -1,2 +1,2 @@
-/* 0.50.1 */
+/* 0.51.0 */
 export declare function simplifyHyperbolic(x: Expression): RuleStep | undefined;

package/dist/types/compute-engine/symbolic/simplify-infinity.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 /**
  * Infinity simplification rules consolidated from simplify-rules.ts.
  * Handles ~20 patterns for simplifying expressions involving infinity.

package/dist/types/compute-engine/symbolic/simplify-log.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 /**
  * Logarithm simplification rules consolidated from simplify-rules.ts.
  * Handles ~30 patterns for simplifying Ln and Log expressions.

package/dist/types/compute-engine/symbolic/simplify-logic.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 export declare function simplifyLogicFunction(x: Expression): {
     value: Expression;
     because: string;

package/dist/types/compute-engine/symbolic/simplify-power.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 /**
  * Power simplification rules consolidated from simplify-rules.ts.
  * Handles ~25 patterns for simplifying Power expressions.

package/dist/types/compute-engine/symbolic/simplify-product.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 /**
  * Product simplification rules extracted from simplify-rules.ts.
  * Handles 13 patterns for simplifying Product expressions.

package/dist/types/compute-engine/symbolic/simplify-rules.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 /**
  * # Performance Optimization Notes for Simplification Rules
  *

package/dist/types/compute-engine/symbolic/simplify-sum.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 /**
  * Sum simplification rules extracted from simplify-rules.ts.
  * Handles 16 patterns for simplifying Sum expressions.

package/dist/types/compute-engine/symbolic/simplify-trig.d.ts

@@ -1,2 +1,2 @@
-/* 0.50.1 */
+/* 0.51.0 */
 export declare function simplifyTrig(x: Expression): RuleStep | undefined;

package/dist/types/compute-engine/tensor/tensor-fields.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 import { Expression, IComputeEngine as ComputeEngine, DataTypeMap, TensorDataType, TensorField } from '../global-types';
 /** @category Tensors */
 export declare function makeTensorField<DT extends keyof DataTypeMap>(ce: ComputeEngine, dtype: DT): TensorField<DataTypeMap[DT]>;

package/dist/types/compute-engine/tensor/tensors.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 /** @category Tensors */
 export declare abstract class AbstractTensor<DT extends keyof DataTypeMap> implements Tensor<DT> {
     private ce;

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

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 import type { Type, TypeString } from '../common/type/types';
 import type { BoxedType } from '../common/type/boxed-type';
 import type { LatexString, LatexDictionaryEntry } from './latex-syntax/types';

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

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 import type { OneOf } from '../common/one-of';
 import type { MathJsonSymbol, MathJsonNumberObject } from '../math-json';
 import type { Type, TypeString, TypeResolver } from '../common/type/types';

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

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 import type { IComputeEngine as ComputeEngine } from './types-engine';
 import type { Expression, ExpressionInput } from './types-expression';
 import type { Assumption as KernelAssumption, AssumeResult, AssignValue as KernelAssignValue, BoxedRule as KernelBoxedRule, BoxedRuleSet as KernelBoxedRuleSet, EvaluateOptions as KernelEvaluateOptions, EvalContext as KernelEvalContext, ExpressionMapInterface as KernelExpressionMapInterface, Rule as KernelRule, RuleConditionFunction as KernelRuleConditionFunction, RuleFunction as KernelRuleFunction, RuleReplaceFunction as KernelRuleReplaceFunction, RuleStep as KernelRuleStep, RuleSteps as KernelRuleSteps, Scope as KernelScope } from './types-kernel-evaluation';

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

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 import type { OneOf } from '../common/one-of';
 import type { MathJsonExpression, MathJsonNumberObject, MathJsonStringObject, MathJsonSymbolObject, MathJsonFunctionObject, MathJsonSymbol, MathJsonDictionaryObject } from '../math-json';
 import type { Type, TypeString } from '../common/type/types';

package/dist/types/compute-engine/types-kernel-evaluation.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 import type { TypeReference } from '../common/type/types';
 import type { BoxedType } from '../common/type/boxed-type';
 import type { LatexString } from './latex-syntax/types';

package/dist/types/compute-engine/types-kernel-serialization.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 export type Hold = 'none' | 'all' | 'first' | 'rest' | 'last' | 'most';
 /**
  * Options to control serialization to MathJSON when using

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

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 import type { BoxedSubstitution as KernelBoxedSubstitution, CanonicalForm, CanonicalOptions, FormOption, Hold, JsonSerializationOptions, Metadata, PatternMatchOptions as KernelPatternMatchOptions, ReplaceOptions, Substitution as KernelSubstitution } from './types-kernel-serialization';
 export type { Hold, JsonSerializationOptions, ReplaceOptions, CanonicalForm, CanonicalOptions, FormOption, Metadata, };
 /**

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

@@ -1,4 +1,4 @@
-/* 0.50.1 */
+/* 0.51.0 */
 export type { MathJsonExpression, MathJsonAttributes, MathJsonNumberObject, MathJsonSymbolObject, MathJsonStringObject, MathJsonFunctionObject, DictionaryValue, MathJsonDictionaryObject, ExpressionObject, MathJsonSymbol, } from '../math-json/types';
 export * from '../common/type/boxed-type';
 export * from '../common/type/types';