@cortex-js/compute-engine 0.35.6 → 0.50.0

package/dist/types/compute-engine/boxed-expression/pattern-utils.d.ts

@@ -0,0 +1,41 @@
+/* 0.50.0 */
+ * Leaf module for wildcard pattern utility functions.
+ *
+ * These are extracted from boxed-patterns.ts to break circular dependencies:
+ * boxed-tensor.ts and match.ts need these functions, but boxed-patterns.ts
+ * has dependencies that create cycles through boxed-symbol.ts.
+ */
+import type { Expression } from '../global-types';
+/**
+ * Check if an expression is a wildcard (universal, sequence, or optional sequence).
+ *
+ * @param expr - The expression to check
+ * @returns `true` if the expression is any type of wildcard
+ */
+export declare function isWildcard(expr: Expression): boolean;
+/**
+ * Get the string representation of a wildcard expression.
+ *
+ * Returns the wildcard symbol including its name (if any):
+ * - `'_'` for anonymous universal wildcard
+ * - `'_a'` for named universal wildcard
+ * - `'__'` for anonymous sequence wildcard
+ * - `'__args'` for named sequence wildcard
+ * - `'___'` for anonymous optional sequence wildcard
+ * - `'___rest'` for named optional sequence wildcard
+ *
+ * @param expr - The expression to get the wildcard name from
+ * @returns The wildcard string, or `null` if not a wildcard
+ */
+export declare function wildcardName(expr: Expression): string | null;
+/**
+ * Determine the type of wildcard.
+ *
+ * @param expr - A Expression or wildcard symbol string
+ * @returns
+ * - `'Wildcard'` - Universal wildcard (`_` or `_name`), matches exactly one element
+ * - `'Sequence'` - Sequence wildcard (`__` or `__name`), matches one or more elements
+ * - `'OptionalSequence'` - Optional sequence (`___` or `___name`), matches zero or more elements
+ * - `null` - Not a wildcard
+ */
+export declare function wildcardType(expr: Expression | string): 'Wildcard' | 'Sequence' | 'OptionalSequence' | null;

package/dist/types/compute-engine/boxed-expression/polynomial-degree.d.ts

@@ -0,0 +1,18 @@
+/* 0.50.0 */
+/**
+ * The total degree of an expression is the sum of the
+ * positive integer degrees of the factors in the expression:
+ *
+ * `3√2x^5y^3` -> 5 + 3 = 8
+ */
+export declare function totalDegree(expr: Expression): number;
+/**
+ * The max degree of a polynomial is the largest positive integer degree
+ * in the factors (monomials) of the expression
+ *
+ * `3√2x^5y^3` -> 5
+ *
+ */
+export declare function maxDegree(expr: Expression): number;
+export declare function lex(expr: Expression): string;
+export declare function revlex(expr: Expression): string;

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

@@ -1,4 +1,5 @@
-/* 0.35.6 */
+/* 0.50.0 */
+export { totalDegree, maxDegree, lex, revlex } from './polynomial-degree';
 /**
  * Coefficient of a univariate (single variable) polynomial.
  *
@@ -12,40 +13,16 @@
  * If a coefficient does not apply (there are no corresponding term), it is `null`.
  *
  */
-export type UnivariateCoefficients = (null | BoxedExpression)[];
-export type MultivariateCoefficients = (null | (null | BoxedExpression)[])[];
+export type UnivariateCoefficients = (null | Expression)[];
+export type MultivariateCoefficients = (null | (null | Expression)[])[];
 /**
  * Return a list of coefficient of powers of `vars` in `poly`,
  * starting with power 0.
  *
  * If `poly`  is not a polynomial, return `null`.
  */
-export declare function coefficients(poly: BoxedExpression, vars: string): UnivariateCoefficients | null;
-export declare function coefficients(poly: BoxedExpression, vars: string[]): MultivariateCoefficients | null;
-/**
- * The total degree of an expression is the sum of the
- * positive integer degrees of the factors in the expression:
- *
- * `3√2x^5y^3` -> 5 + 3 = 8
- */
-export declare function totalDegree(expr: BoxedExpression): number;
-/**
- * The max degree of a polynomial is the largest positive integer degree
- * in the factors (monomials) of the expression
- *
- * `3√2x^5y^3` -> 5
- *
- */
-export declare function maxDegree(expr: BoxedExpression): number;
-/**
- * Return a lexicographic key of the expression, for example
- * `xy^2` -> `x y`
- * `x\frac{1}{y}` -> `x y`
- * `2xy + y^2` -> `x y y`
- *
- */
-export declare function lex(expr: BoxedExpression): string;
-export declare function revlex(expr: BoxedExpression): string;
+export declare function coefficients(poly: Expression, vars: string): UnivariateCoefficients | null;
+export declare function coefficients(poly: Expression, vars: string[]): MultivariateCoefficients | null;
 /**
  * Get the degree of a polynomial in a specific variable.
  * Returns -1 if the expression is not a polynomial in the variable.
@@ -55,7 +32,7 @@ export declare function revlex(expr: BoxedExpression): string;
  * - `polynomialDegree(x*y + y^2, 'x')` → 1
  * - `polynomialDegree(sin(x), 'x')` → -1 (not a polynomial)
  */
-export declare function polynomialDegree(expr: BoxedExpression, variable: string): number;
+export declare function polynomialDegree(expr: Expression, variable: string): number;
 /**
  * Extract coefficients of a univariate polynomial.
  * Returns an array where index i contains the coefficient of x^i.
@@ -65,7 +42,7 @@ export declare function polynomialDegree(expr: BoxedExpression, variable: string
  * - `getPolynomialCoefficients(x^3 + 2x + 1, 'x')` → [1, 2, 0, 1]
  * - `getPolynomialCoefficients(3x^2 - x + 5, 'x')` → [5, -1, 3]
  */
-export declare function getPolynomialCoefficients(expr: BoxedExpression, variable: string): BoxedExpression[] | null;
+export declare function getPolynomialCoefficients(expr: Expression, variable: string): Expression[] | null;
 /**
  * Construct a polynomial expression from its coefficients.
  * coeffs[i] is the coefficient of x^i.
@@ -74,7 +51,7 @@ export declare function getPolynomialCoefficients(expr: BoxedExpression, variabl
  * - `fromCoefficients([1, 2, 0, 1], 'x')` → x^3 + 2x + 1
  * - `fromCoefficients([5, -1, 3], 'x')` → 3x^2 - x + 5
  */
-export declare function fromCoefficients(coeffs: BoxedExpression[], variable: string): BoxedExpression;
+export declare function fromCoefficients(coeffs: Expression[], variable: string): Expression;
 /**
  * Polynomial long division.
  * Returns [quotient, remainder] such that dividend = divisor * quotient + remainder.
@@ -84,7 +61,7 @@ export declare function fromCoefficients(coeffs: BoxedExpression[], variable: st
  * - `polynomialDivide(x^3-1, x-1, 'x')` → [x^2+x+1, 0]
  * - `polynomialDivide(x^3+2x+1, x+1, 'x')` → [x^2-x+3, -2]
  */
-export declare function polynomialDivide(dividend: BoxedExpression, divisor: BoxedExpression, variable: string): [BoxedExpression, BoxedExpression] | null;
+export declare function polynomialDivide(dividend: Expression, divisor: Expression, variable: string): [Expression, Expression] | null;
 /**
  * Compute the GCD of two polynomials using the Euclidean algorithm.
  * Returns a monic polynomial (leading coefficient = 1).
@@ -93,7 +70,7 @@ export declare function polynomialDivide(dividend: BoxedExpression, divisor: Box
  * - `polynomialGCD(x^2-1, x-1, 'x')` → x-1
  * - `polynomialGCD(x^3-1, x^2-1, 'x')` → x-1
  */
-export declare function polynomialGCD(a: BoxedExpression, b: BoxedExpression, variable: string): BoxedExpression;
+export declare function polynomialGCD(a: Expression, b: Expression, variable: string): Expression;
 /**
  * Cancel common polynomial factors in a rational expression (Divide).
  * Returns the simplified expression.
@@ -102,4 +79,4 @@ export declare function polynomialGCD(a: BoxedExpression, b: BoxedExpression, va
  * - `cancelCommonFactors((x^2-1)/(x-1), 'x')` → x+1
  * - `cancelCommonFactors((x+1)/(x^2+3x+2), 'x')` → 1/(x+2)
  */
-export declare function cancelCommonFactors(expr: BoxedExpression, variable: string): BoxedExpression;
+export declare function cancelCommonFactors(expr: Expression, variable: string): Expression;

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

@@ -0,0 +1,2 @@
+/* 0.50.0 */
+export declare function isPrime(expr: Expression): boolean | undefined;

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

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.0 */
 export declare const ConditionParent: {
     boolean: string;
     string: string;
@@ -49,54 +49,54 @@ export declare const ConditionParent: {
     polynomial: string;
 };
 export declare const CONDITIONS: {
-    boolean: (x: BoxedExpression) => boolean;
-    string: (x: BoxedExpression) => boolean;
-    number: (x: BoxedExpression) => boolean;
-    symbol: (x: BoxedExpression) => boolean;
-    expression: (x: BoxedExpression) => boolean;
-    numeric: (x: BoxedExpression) => boolean;
-    integer: (x: BoxedExpression) => boolean;
-    rational: (x: BoxedExpression) => boolean;
-    irrational: (x: BoxedExpression) => boolean;
-    real: (x: BoxedExpression) => boolean;
-    notreal: (x: BoxedExpression) => boolean;
-    complex: (x: BoxedExpression) => boolean;
-    imaginary: (x: BoxedExpression) => boolean;
-    positive: (x: BoxedExpression) => boolean;
-    negative: (x: BoxedExpression) => boolean;
-    nonnegative: (x: BoxedExpression) => boolean;
-    nonpositive: (x: BoxedExpression) => boolean;
-    even: (x: BoxedExpression) => boolean;
-    odd: (x: BoxedExpression) => boolean;
-    prime: (x: BoxedExpression) => boolean;
-    composite: (x: BoxedExpression) => boolean;
-    notzero: (x: BoxedExpression) => boolean;
-    notone: (x: BoxedExpression) => boolean;
-    finite: (x: BoxedExpression) => boolean;
-    infinite: (x: BoxedExpression) => boolean;
-    constant: (x: BoxedExpression) => boolean;
-    variable: (x: BoxedExpression) => boolean;
-    function: (x: BoxedExpression) => boolean;
-    relation: (x: BoxedExpression) => boolean;
-    equation: (x: BoxedExpression) => boolean;
-    inequality: (x: BoxedExpression) => boolean;
-    collection: (x: BoxedExpression) => boolean;
-    list: (x: BoxedExpression) => boolean;
-    set: (x: BoxedExpression) => boolean;
-    tuple: (x: BoxedExpression) => boolean;
-    single: (x: BoxedExpression) => boolean;
-    pair: (x: BoxedExpression) => boolean;
-    triple: (x: BoxedExpression) => boolean;
-    scalar: (x: BoxedExpression) => boolean;
-    tensor: (x: BoxedExpression) => boolean;
-    vector: (x: BoxedExpression) => boolean;
-    matrix: (x: BoxedExpression) => boolean;
-    unit: (x: BoxedExpression) => boolean;
-    dimension: (x: BoxedExpression) => boolean;
-    angle: (x: BoxedExpression) => boolean;
-    polynomial: (x: BoxedExpression) => boolean;
+    boolean: (x: Expression) => boolean;
+    string: (x: Expression) => x is Expression & import("../types-expression").StringInterface;
+    number: (x: Expression) => x is Expression & import("../types-expression").NumberLiteralInterface;
+    symbol: (x: Expression) => x is Expression & import("../types-expression").SymbolInterface;
+    expression: (_x: Expression) => boolean;
+    numeric: (x: Expression) => boolean;
+    integer: (x: Expression) => boolean;
+    rational: (x: Expression) => boolean;
+    irrational: (x: Expression) => boolean;
+    real: (x: Expression) => boolean;
+    notreal: (x: Expression) => boolean;
+    complex: (x: Expression) => boolean;
+    imaginary: (x: Expression) => boolean;
+    positive: (x: Expression) => boolean;
+    negative: (x: Expression) => boolean;
+    nonnegative: (x: Expression) => boolean;
+    nonpositive: (x: Expression) => boolean;
+    even: (x: Expression) => boolean;
+    odd: (x: Expression) => boolean;
+    prime: (x: Expression) => boolean;
+    composite: (x: Expression) => boolean;
+    notzero: (x: Expression) => boolean;
+    notone: (x: Expression) => boolean;
+    finite: (x: Expression) => boolean;
+    infinite: (x: Expression) => boolean;
+    constant: (x: Expression) => boolean;
+    variable: (x: Expression) => boolean;
+    function: (x: Expression) => boolean;
+    relation: (x: Expression) => boolean;
+    equation: (x: Expression) => boolean;
+    inequality: (x: Expression) => boolean;
+    collection: (x: Expression) => boolean;
+    list: (x: Expression) => boolean;
+    set: (x: Expression) => boolean;
+    tuple: (x: Expression) => boolean;
+    single: (x: Expression) => boolean;
+    pair: (x: Expression) => boolean;
+    triple: (x: Expression) => boolean;
+    scalar: (x: Expression) => boolean;
+    tensor: (x: Expression) => boolean;
+    vector: (x: Expression) => boolean;
+    matrix: (x: Expression) => boolean;
+    unit: (x: Expression) => boolean;
+    dimension: (x: Expression) => boolean;
+    angle: (x: Expression) => boolean;
+    polynomial: (x: Expression) => boolean;
 };
-export declare function checkConditions(x: BoxedExpression, conditions: string[]): boolean;
+export declare function checkConditions(x: Expression, conditions: string[]): boolean;
 /**
  * Create a boxed rule set from a collection of non-boxed rules
  */
@@ -111,7 +111,7 @@ export declare function boxRules(ce: ComputeEngine, rs: Rule | ReadonlyArray<Rul
  * @param options
  * @returns A transformed expression, if the rule matched. `null` otherwise.
  */
-export declare function applyRule(rule: Readonly<BoxedRule>, expr: BoxedExpression, substitution: BoxedSubstitution, options?: Readonly<Partial<ReplaceOptions>>): RuleStep | null;
+export declare function applyRule(rule: Readonly<BoxedRule>, expr: Expression, substitution: BoxedSubstitution, options?: Readonly<Partial<ReplaceOptions>>): RuleStep | null;
 /**
  * Apply the rules in the ruleset and return a modified expression
  * and the set of rules that were applied.
@@ -120,10 +120,10 @@ export declare function applyRule(rule: Readonly<BoxedRule>, expr: BoxedExpressi
  * expression.
  *
  */
-export declare function replace(expr: BoxedExpression, rules: Rule | (Rule | BoxedRule)[] | BoxedRuleSet, options?: Partial<ReplaceOptions>): RuleSteps;
+export declare function replace(expr: Expression, rules: Rule | (Rule | BoxedRule)[] | BoxedRuleSet, options?: Partial<ReplaceOptions>): RuleSteps;
 /**
  * For each rules in the rule set that match, return the `replace` of the rule
  *
  * @param rules
  */
-export declare function matchAnyRules(expr: BoxedExpression, rules: BoxedRuleSet, sub: BoxedSubstitution, options?: Partial<ReplaceOptions>): BoxedExpression[];
+export declare function matchAnyRules(expr: Expression, rules: BoxedRuleSet, sub: BoxedSubstitution, options?: Partial<ReplaceOptions>): Expression[];

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

@@ -1,3 +1,3 @@
-/* 0.35.6 */
-import type { ComputeEngine, BoxedExpression, JsonSerializationOptions } from '../global-types';
-export declare function serializeJson(ce: ComputeEngine, expr: BoxedExpression, options: Readonly<JsonSerializationOptions>): Expression;
+/* 0.50.0 */
+import type { IComputeEngine as ComputeEngine, Expression, JsonSerializationOptions } from '../global-types';
+export declare function serializeJson(ce: ComputeEngine, expr: Expression, options: Readonly<JsonSerializationOptions>): MathJsonExpression;

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

@@ -1,5 +1,5 @@
-/* 0.35.6 */
-export declare function sgn(expr: BoxedExpression): Sign | undefined;
+/* 0.50.0 */
+export declare function sgn(expr: Expression): Sign | undefined;
 /**
  * Sign `s` is > 0.
  *

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

@@ -1,6 +1,6 @@
-/* 0.35.6 */
+/* 0.50.0 */
 type InternalSimplifyOptions = SimplifyOptions & {
     useVariations: boolean;
 };
-export declare function simplify(expr: BoxedExpression, options?: Partial<InternalSimplifyOptions>, steps?: RuleSteps): RuleSteps;
+export declare function simplify(expr: Expression, options?: Partial<InternalSimplifyOptions>, steps?: RuleSteps): RuleSteps;
 export {};

package/dist/types/compute-engine/boxed-expression/solve-linear-system.d.ts

@@ -1,8 +1,8 @@
-/* 0.35.6 */
+/* 0.50.0 */
 /**
  * Solve a system of linear equations.
  *
- * @param equations - Array of BoxedExpression representing equations (Equal expressions)
+ * @param equations - Array of Expression representing equations (Equal expressions)
  * @param variables - Array of variable names to solve for
  * @returns Object mapping variable names to their solutions, or null if unsolvable
  *
@@ -14,7 +14,7 @@
  * // Unique solution
  * const e = ce.parse('\\begin{cases}x+y=70\\\\2x-4y=80\\end{cases}');
  * const result = e.solve(['x', 'y']);
- * // result = { x: BoxedExpression(60), y: BoxedExpression(10) }
+ * // result = { x: Expression(60), y: Expression(10) }
  *
  * // Parametric solution (under-determined)
  * const e2 = ce.parse('\\begin{cases}x+y=5\\end{cases}');
@@ -22,14 +22,14 @@
  * // result2 = { x: 5 - y, y: y }
  * ```
  */
-export declare function solveLinearSystem(equations: BoxedExpression[], variables: string[]): Record<string, BoxedExpression> | null;
+export declare function solveLinearSystem(equations: Expression[], variables: string[]): Record<string, Expression> | null;
 /**
  * Solve a system of polynomial equations that may be non-linear.
  * Currently supports:
  * 1. Product + sum pattern: xy = p, x + y = s (2 equations, 2 variables)
  * 2. Substitution-reducible: one equation is linear in one variable
  *
- * @param equations - Array of BoxedExpression representing equations (Equal expressions)
+ * @param equations - Array of Expression representing equations (Equal expressions)
  * @param variables - Array of variable names to solve for
  * @returns Array of solution objects, or null if unsolvable
  *
@@ -41,12 +41,12 @@ export declare function solveLinearSystem(equations: BoxedExpression[], variable
  * // result = [{ x: 2, y: 3 }, { x: 3, y: 2 }]
  * ```
  */
-export declare function solvePolynomialSystem(equations: BoxedExpression[], variables: string[]): Array<Record<string, BoxedExpression>> | null;
+export declare function solvePolynomialSystem(equations: Expression[], variables: string[]): Array<Record<string, Expression>> | null;
 /**
  * Solve a system of linear inequalities in 2 variables.
  * Returns the vertices of the feasible region (convex polygon).
  *
- * @param inequalities - Array of BoxedExpression representing inequalities
+ * @param inequalities - Array of Expression representing inequalities
  * @param variables - Array of exactly 2 variable names
  * @returns Array of vertex coordinate objects, or null if unsolvable/unbounded
  *
@@ -57,4 +57,4 @@ export declare function solvePolynomialSystem(equations: BoxedExpression[], vari
  * // result = [{ x: 0, y: 0 }, { x: 10, y: 0 }, { x: 0, y: 10 }]
  * ```
  */
-export declare function solveLinearInequalitySystem(inequalities: BoxedExpression[], variables: string[]): Array<Record<string, BoxedExpression>> | null;
+export declare function solveLinearInequalitySystem(inequalities: Expression[], variables: string[]): Array<Record<string, Expression>> | null;

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

@@ -1,20 +1,12 @@
-/* 0.35.6 */
+/* 0.50.0 */
 export declare const UNIVARIATE_ROOTS: Rule[];
 /**
- * Expression is a function of a single variable (`x`) or an Equality
+ * MathJsonExpression is a function of a single variable (`x`) or an Equality
  *
  * Return the roots of that variable
  *
  */
-export declare function findUnivariateRoots(expr: BoxedExpression, x: string): ReadonlyArray<BoxedExpression>;
-/** Expr is an equation with an operator of
- * - `Equal`, `Less`, `Greater`, `LessEqual`, `GreaterEqual`
- *
- * Return an expression with the same operator, but with the first argument
- * a variable, if possible:
- * `2x < 4` => `x < 2`
- */
-export declare function univariateSolve(expr: BoxedExpression, x: string): ReadonlyArray<BoxedExpression> | null;
+export declare function findUnivariateRoots(expr: Expression, x: string): ReadonlyArray<Expression>;
 /** Harmonization rules transform an expr into one or more equivalent
  * expressions that are easier to solve */
 export declare const HARMONIZATION_RULES: Rule[];

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

@@ -1,8 +1,8 @@
-/* 0.35.6 */
+/* 0.50.0 */
 /** Assuming x in an expression in radians, convert to current angular unit. */
-export declare function radiansToAngle(x: BoxedExpression | undefined): BoxedExpression | undefined;
-export declare function evalTrig(name: string, op: BoxedExpression | undefined): BoxedExpression | undefined;
-export declare function processInverseFunction(ce: ComputeEngine, xs: ReadonlyArray<BoxedExpression>): BoxedExpression | undefined;
-export declare function trigSign(operator: string, x: BoxedExpression): Sign | undefined;
-export declare function isConstructible(x: string | BoxedExpression): boolean;
-export declare function constructibleValues(operator: string, x: BoxedExpression | undefined): undefined | BoxedExpression;
+export declare function radiansToAngle(x: Expression | undefined): Expression | undefined;
+export declare function evalTrig(name: string, op: Expression | undefined): Expression | undefined;
+export declare function processInverseFunction(ce: ComputeEngine, xs: ReadonlyArray<Expression>): Expression | undefined;
+export declare function trigSign(operator: string, x: Expression): Sign | undefined;
+export declare function isConstructible(x: string | Expression): boolean;
+export declare function constructibleValues(operator: string, x: Expression | undefined): undefined | Expression;

package/dist/types/compute-engine/boxed-expression/type-guards.d.ts

@@ -0,0 +1,31 @@
+/* 0.50.0 */
+/** Preferred guard for runtime expressions. */
+export declare function isExpression(x: unknown): x is Expression;
+export declare function isNumber(expr: Expression | null | undefined): expr is Expression & NumberLiteralInterface;
+export declare function isSymbol(expr: Expression | null | undefined): expr is Expression & SymbolInterface;
+export declare function isFunction(expr: Expression | null | undefined): expr is Expression & FunctionInterface;
+export declare function isString(expr: Expression | null | undefined): expr is Expression & StringInterface;
+export declare function isTensor(expr: Expression | null | undefined): expr is Expression & TensorInterface;
+/** @deprecated Use `isExpression()` instead. */
+export declare function isBoxedExpression(x: unknown): x is Expression;
+/** @deprecated Use `isNumber()` instead. */
+export declare function isBoxedNumber(expr: Expression | null | undefined): expr is Expression & NumberLiteralInterface;
+/** @deprecated Use `isSymbol()` instead. */
+export declare function isBoxedSymbol(expr: Expression | null | undefined): expr is Expression & SymbolInterface;
+/** @deprecated Use `isFunction()` instead. */
+export declare function isBoxedFunction(expr: Expression | null | undefined): expr is Expression & FunctionInterface;
+/** @deprecated Use `isString()` instead. */
+export declare function isBoxedString(expr: Expression | null | undefined): expr is Expression & StringInterface;
+/** @deprecated Use `isTensor()` instead. */
+export declare function isBoxedTensor(expr: Expression | null | undefined): expr is Expression & TensorInterface;
+export declare function isDictionary(expr: Expression | null | undefined): expr is Expression & DictionaryInterface;
+export declare function isCollection(expr: Expression | null | undefined): expr is Expression & CollectionInterface;
+export declare function isIndexedCollection(expr: Expression | null | undefined): expr is Expression & IndexedCollectionInterface;
+/**
+ * Get the symbol name if `expr` is a symbol expression, otherwise `undefined`.
+ *
+ * Convenience helper that combines `isSymbol()` with `.symbol` access
+ * so callers can write `sym(expr) === 'Pi'` instead of the more verbose
+ * `isSymbol(expr) && expr.symbol === 'Pi'`.
+ */
+export declare function sym(expr: Expression | null | undefined): string | undefined;

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

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.0 */
 import { Type } from '../../common/type/types';
 import { NumericValue } from '../numeric-value/types';
 /**
@@ -10,31 +10,31 @@ import { NumericValue } from '../numeric-value/types';
  * - sin(0) -> 0
  * - cos(0) -> 1
  */
-export declare function hasSymbolicTranscendental(expr: BoxedExpression): boolean;
-export declare function isDictionary(expr: any | null | undefined): expr is DictionaryInterface;
-export declare function isBoxedExpression(x: unknown): x is BoxedExpression;
+export declare function hasSymbolicTranscendental(expr: Expression): boolean;
+export declare function isDictionary(expr: unknown): expr is DictionaryInterface;
+export declare function isExpression(x: unknown): x is Expression;
 /**
  * For any numeric result, if `bignumPreferred()` is true, calculate using
  * bignums. If `bignumPreferred()` is false, calculate using machine numbers
  */
 export declare function bignumPreferred(ce: ComputeEngine): boolean;
 export declare function hashCode(s: string): number;
-export declare function normalizedUnknownsForSolve(syms: string | Iterable<string> | BoxedExpression | Iterable<BoxedExpression> | null | undefined): string[];
+export declare function normalizedUnknownsForSolve(syms: string | Iterable<string> | Expression | Iterable<Expression> | null | undefined): string[];
 /** Return the local variables in the expression.
  *
  * A local variable is a symbol that is declared with a `Declare`
  * expression in a `Block` expression.
  *
  */
-export declare function getLocalVariables(expr: BoxedExpression): string[];
-export declare function domainToType(expr: BoxedExpression): Type;
+export declare function getLocalVariables(expr: Expression): string[];
+export declare function domainToType(expr: Expression): Type;
 /**
  * Return the angle in the range [0, 2π) that is equivalent to the given angle.
  *
  * @param x
  * @returns
  */
-export declare function canonicalAngle(x: BoxedExpression | undefined): BoxedExpression | undefined;
+export declare function canonicalAngle(x: Expression | undefined): Expression | undefined;
 /**
  * Return a multiple of the imaginary unit, e.g.
  * - 'ImaginaryUnit'  -> 1
@@ -45,7 +45,7 @@ export declare function canonicalAngle(x: BoxedExpression | undefined): BoxedExp
  * - ['Divide', 'ImaginaryUnit', 2] -> 0.5
  *
  */
-export declare function getImaginaryFactor(expr: number | BoxedExpression): BoxedExpression | undefined;
+export declare function getImaginaryFactor(expr: number | Expression): Expression | undefined;
 /**
  * `true` if expr is a number with imaginary part 1 and real part 0, or a symbol with a definition
  * matching this. Does not bind expr if a symbol.
@@ -54,10 +54,10 @@ export declare function getImaginaryFactor(expr: number | BoxedExpression): Boxe
  * @param expr
  * @returns
  */
-export declare function isImaginaryUnit(expr: BoxedExpression): boolean;
-export declare function getPiTerm(expr: BoxedExpression): [k: NumericValue, t: NumericValue];
-export declare function isValidOperatorDef(def: any): def is Partial<OperatorDefinition>;
-export declare function isValidValueDef(def: any): def is Partial<ValueDefinition>;
+export declare function isImaginaryUnit(expr: Expression): boolean;
+export declare function getPiTerm(expr: Expression): [k: NumericValue, t: NumericValue];
+export declare function isValidOperatorDef(def: unknown): def is Partial<OperatorDefinition>;
+export declare function isValidValueDef(def: unknown): def is Partial<ValueDefinition>;
 export declare function isValueDef(def: BoxedDefinition | undefined): def is TaggedValueDefinition;
 export declare function isOperatorDef(def: BoxedDefinition | undefined): def is TaggedOperatorDefinition;
 export declare function updateDef(ce: ComputeEngine, name: string, def: BoxedDefinition, newDef: Partial<OperatorDefinition> | BoxedOperatorDefinition | Partial<ValueDefinition> | BoxedValueDefinition): void;

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

@@ -1,11 +1,11 @@
-/* 0.35.6 */
-import type { BoxedExpression, ComputeEngine } from '../global-types';
+/* 0.50.0 */
+import type { Expression, IComputeEngine as ComputeEngine } from '../global-types';
 /**
  * Check that the number of arguments is as expected.
  *
  * Converts the arguments to canonical, and flattens the sequence.
  */
-export declare function checkArity(ce: ComputeEngine, ops: ReadonlyArray<BoxedExpression>, count: number): ReadonlyArray<BoxedExpression>;
+export declare function checkArity(ce: ComputeEngine, ops: ReadonlyArray<Expression>, count: number): ReadonlyArray<Expression>;
 /**
  * Validation of arguments is normally done by checking the signature of the
  * function vs the arguments of the expression. However, we have a fastpath
@@ -22,21 +22,21 @@ export declare function checkArity(ce: ComputeEngine, ops: ReadonlyArray<BoxedEx
  *
  * Flattens sequence expressions.
  */
-export declare function checkNumericArgs(ce: ComputeEngine, ops: ReadonlyArray<BoxedExpression>, options?: number | {
+export declare function checkNumericArgs(ce: ComputeEngine, ops: ReadonlyArray<Expression>, options?: number | {
     count?: number;
     flatten?: string;
-}): ReadonlyArray<BoxedExpression>;
+}): ReadonlyArray<Expression>;
 /**
  * Check that an argument is of the expected type.
  *
  * Converts the arguments to canonical
  */
-export declare function checkType(ce: ComputeEngine, arg: BoxedExpression | undefined | null, type: Type | undefined): BoxedExpression;
-export declare function checkTypes(ce: ComputeEngine, args: ReadonlyArray<BoxedExpression>, types: Type[]): ReadonlyArray<BoxedExpression>;
+export declare function checkType(ce: ComputeEngine, arg: Expression | undefined | null, type: Type | undefined): Expression;
+export declare function checkTypes(ce: ComputeEngine, args: ReadonlyArray<Expression>, types: Type[]): ReadonlyArray<Expression>;
 /**
  * Check that the argument is pure.
  */
-export declare function checkPure(ce: ComputeEngine, arg: BoxedExpression | BoxedExpression | undefined | null): BoxedExpression;
+export declare function checkPure(ce: ComputeEngine, arg: Expression | Expression | undefined | null): Expression;
 /**
  *
  * If the arguments match the parameters, return null.
@@ -54,5 +54,5 @@ export declare function checkPure(ce: ComputeEngine, arg: BoxedExpression | Boxe
  * -->
  *
  */
-export declare function validateArguments(ce: ComputeEngine, ops: ReadonlyArray<BoxedExpression>, signature: Type, lazy?: boolean, threadable?: boolean): ReadonlyArray<BoxedExpression> | null;
-export declare function spellCheckMessage(expr: BoxedExpression): string;
+export declare function validateArguments(ce: ComputeEngine, ops: ReadonlyArray<Expression>, signature: Type, lazy?: boolean, threadable?: boolean): ReadonlyArray<Expression> | null;
+export declare function spellCheckMessage(expr: Expression): string;

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

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.0 */
 /** If a collection has fewer than this many elements, eagerly evaluate it.
  *
  * For example, evaluate the Union of two sets with 10 elements each will
@@ -9,8 +9,8 @@
  *
  */
 export declare const MAX_SIZE_EAGER_COLLECTION = 100;
-export declare function isFiniteIndexedCollection(col: BoxedExpression): boolean;
-export declare function repeat(value: BoxedExpression, count?: number): Iterator<BoxedExpression>;
+export declare function isFiniteIndexedCollection(col: Expression): boolean;
+export declare function repeat(value: Expression, count?: number): Iterator<Expression>;
 /**
  * Zips together multiple collections into a single iterator.
  *
@@ -24,7 +24,7 @@ export declare function repeat(value: BoxedExpression, count?: number): Iterator
  * }
  * ```
  */
-export declare function zip(items: ReadonlyArray<BoxedExpression>): Iterator<BoxedExpression[]>;
+export declare function zip(items: ReadonlyArray<Expression>): Iterator<Expression[]>;
 /**
  * Default collection handlers suitable for collections that store their
  * elements as operands.

package/dist/types/compute-engine/compilation/base-compiler.d.ts

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.0 */
 import type { CompileTarget, TargetSource } from './types';
 /**
  * Base compiler class containing language-agnostic compilation logic
@@ -7,11 +7,11 @@ export declare class BaseCompiler {
     /**
      * Compile an expression to target language source code
      */
-    static compile(expr: BoxedExpression | undefined, target: CompileTarget, prec?: number): TargetSource;
+    static compile(expr: Expression | undefined, target: CompileTarget<Expression>, prec?: number): TargetSource;
     /**
      * Compile a function expression
      */
-    static compileExpr(engine: ComputeEngine, h: string, args: ReadonlyArray<BoxedExpression>, prec: number, target: CompileTarget): TargetSource;
+    static compileExpr(engine: ComputeEngine, h: string, args: ReadonlyArray<Expression>, prec: number, target: CompileTarget<Expression>): TargetSource;
     /**
      * Compile a block expression
      */