@cortex-js/compute-engine 0.32.0 → 0.33.0

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

@@ -0,0 +1,48 @@
+/* 0.33.0 */
+ * Fu Algorithm for Trigonometric Simplification
+ *
+ * Implementation of the algorithm by Fu, Zhong, and Zeng:
+ * "Automated and readable simplification of trigonometric expressions."
+ * Mathematical and Computer Modelling 44.11 (2006): 1169-1177.
+ *
+ * The algorithm uses a greedy approach with transformation rules (TR),
+ * combination transforms (CTR), and rule lists (RL) to simplify
+ * trigonometric expressions.
+ */
+import type { BoxedExpression, RuleStep } from '../global-types';
+import { TrigCostFunction } from './fu-cost';
+export interface FuOptions {
+    /**
+     * Cost function to evaluate expression complexity.
+     * Default minimizes trig function count, then leaf count.
+     */
+    measure?: TrigCostFunction;
+    /**
+     * Maximum iterations to prevent infinite loops.
+     * Default: 100
+     */
+    maxIterations?: number;
+}
+/**
+ * Apply the Fu algorithm to simplify a trigonometric expression.
+ *
+ * The algorithm:
+ * 1. Converts sec/csc to reciprocal forms (TR1) if present
+ * 2. For tan/cot expressions, applies RL1
+ * 3. If tan/cot remain, converts to sin/cos ratios (TR2)
+ * 4. For sin/cos expressions, applies RL2
+ * 5. Tries to convert back to tan/cot (TR2i)
+ * 6. Selects the best result based on the cost function
+ *
+ * @param expr The expression to simplify
+ * @param options Configuration options
+ * @returns RuleStep with simplified expression, or undefined if no simplification
+ */
+export declare function fu(expr: BoxedExpression, options?: FuOptions): RuleStep | undefined;
+/**
+ * Simplified entry point that returns the expression directly.
+ */
+export declare function fuSimplify(expr: BoxedExpression, options?: FuOptions): BoxedExpression;
+export { hasTrigFunction, hasOperator } from './fu-transforms';
+export { trigCost, countTrigFunctions, countLeaves } from './fu-cost';
+export type { TrigCostFunction } from './fu-cost';

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

@@ -0,0 +1,12 @@
+/* 0.33.0 */
+export declare function simplifyAbs(x: BoxedExpression): RuleStep | undefined;
+/**
+ * Simplify expressions where Abs appears as the base of a power.
+ * |x|^n -> x^n when n is even
+ */
+export declare function simplifyAbsPower(x: BoxedExpression): RuleStep | undefined;
+/**
+ * Even functions: f(|x|) -> f(x)
+ * This rule handles Cos, Sec, Cosh, Sech with Abs argument
+ */
+export declare function simplifyEvenFunctionAbs(x: BoxedExpression): RuleStep | undefined;

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

@@ -0,0 +1,15 @@
+/* 0.33.0 */
+/**
+ * Division simplification rules consolidated from simplify-rules.ts.
+ * Handles ~5 patterns for simplifying Divide expressions.
+ *
+ * Patterns:
+ * - a/a -> 1 (when a ≠ 0)
+ * - 1/(1/a) -> a (when a ≠ 0)
+ * - a/(1/b) -> a*b (when b ≠ 0)
+ * - a/(b/c) -> a*c/b (when c ≠ 0)
+ * - 0/a -> 0 (when a ≠ 0)
+ *
+ * IMPORTANT: Do not call .simplify() on results to avoid infinite recursion.
+ */
+export declare function simplifyDivide(x: BoxedExpression): RuleStep | undefined;

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

@@ -0,0 +1,2 @@
+/* 0.33.0 */
+export declare function simplifyHyperbolic(x: BoxedExpression): RuleStep | undefined;

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

@@ -0,0 +1,14 @@
+/* 0.33.0 */
+/**
+ * Infinity simplification rules consolidated from simplify-rules.ts.
+ * Handles ~20 patterns for simplifying expressions involving infinity.
+ *
+ * Groups rules by operation type:
+ * - Multiply with infinity
+ * - Divide with infinity
+ * - Power with infinity
+ * - Indeterminate forms
+ *
+ * IMPORTANT: Do not call .simplify() on results to avoid infinite recursion.
+ */
+export declare function simplifyInfinity(x: BoxedExpression): RuleStep | undefined;

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

@@ -0,0 +1,15 @@
+/* 0.33.0 */
+/**
+ * Logarithm simplification rules consolidated from simplify-rules.ts.
+ * Handles ~30 patterns for simplifying Ln and Log expressions.
+ *
+ * Categories:
+ * - Ln power rules: ln(x^n) -> n*ln(x)
+ * - Log power rules: log_c(x^n) -> n*log_c(x)
+ * - Logarithm combinations: ln(x) + ln(y) -> ln(xy)
+ * - Change of base rules
+ * - Logarithm with infinity
+ *
+ * IMPORTANT: Do not call .simplify() on results to avoid infinite recursion.
+ */
+export declare function simplifyLog(x: BoxedExpression): RuleStep | undefined;

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

@@ -0,0 +1,15 @@
+/* 0.33.0 */
+/**
+ * Power simplification rules consolidated from simplify-rules.ts.
+ * Handles ~25 patterns for simplifying Power expressions.
+ *
+ * Categories:
+ * - Basic power rules: x^0, x^1, 0^x, 1^x
+ * - Power combination: x^n * x^m -> x^{n+m}
+ * - Nested powers: (x^n)^m -> x^{n*m}
+ * - Root simplifications: sqrt(x^2) -> |x|
+ * - Negative exponent in denominator
+ *
+ * IMPORTANT: Do not call .simplify() on results to avoid infinite recursion.
+ */
+export declare function simplifyPower(x: BoxedExpression): RuleStep | undefined;

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

@@ -0,0 +1,6 @@
+/* 0.33.0 */
+/**
+ * Product simplification rules extracted from simplify-rules.ts.
+ * Handles 13 patterns for simplifying Product expressions.
+ */
+export declare function simplifyProduct(x: BoxedExpression): RuleStep | undefined;

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

@@ -0,0 +1,17 @@
+/* 0.33.0 */
+/**
+ * A set of simplification rules.
+ *
+ * The rules are expressed as
+ *
+ *    `[lhs, rhs, condition]`
+ *
+ * where `lhs` is rewritten as `rhs` if `condition` is true.
+ *
+ * `lhs` and `rhs` can be either an Expression or a LaTeX string.
+ *
+ * If using an Expression, the expression is *not* canonicalized before being
+ * used. Therefore in some cases using Expression, while more verbose,
+ * may be necessary as the expression could be simplified by the canonicalization.
+ */
+export declare const SIMPLIFY_RULES: Rule[];

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

@@ -0,0 +1,6 @@
+/* 0.33.0 */
+/**
+ * Sum simplification rules extracted from simplify-rules.ts.
+ * Handles 16 patterns for simplifying Sum expressions.
+ */
+export declare function simplifySum(x: BoxedExpression): RuleStep | undefined;

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

@@ -0,0 +1,2 @@
+/* 0.33.0 */
+export declare function simplifyTrig(x: BoxedExpression): RuleStep | undefined;

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

@@ -0,0 +1,128 @@
+/* 0.33.0 */
+import { BoxedExpression, ComputeEngine, DataTypeMap, TensorDataType, TensorField } from '../global-types';
+/** @category Tensors */
+export declare function makeTensorField<DT extends keyof DataTypeMap>(ce: ComputeEngine, dtype: DT): TensorField<DataTypeMap[DT]>;
+/** @category Tensors */
+export declare class TensorFieldNumber implements TensorField<number> {
+    private ce;
+    one: number;
+    zero: number;
+    nan: number;
+    constructor(ce: ComputeEngine);
+    cast(x: number, dtype: 'float64'): undefined | number;
+    cast(x: number, dtype: 'float32'): undefined | number;
+    cast(x: number, dtype: 'int32'): undefined | number;
+    cast(x: number, dtype: 'uint8'): undefined | number;
+    cast(x: number, dtype: 'complex128'): undefined | Complex;
+    cast(x: number, dtype: 'complex64'): undefined | Complex;
+    cast(x: number, dtype: 'bool'): undefined | boolean;
+    cast(x: number, dtype: 'expression'): undefined | BoxedExpression;
+    cast(x: number[], dtype: 'float64'): undefined | number[];
+    cast(x: number[], dtype: 'float32'): undefined | number[];
+    cast(x: number[], dtype: 'int32'): undefined | number[];
+    cast(x: number[], dtype: 'uint8'): undefined | number[];
+    cast(x: number[], dtype: 'complex128'): undefined | Complex[];
+    cast(x: number[], dtype: 'complex64'): undefined | Complex[];
+    cast(x: number[], dtype: 'bool'): undefined | boolean[];
+    cast(x: number[], dtype: 'expression'): undefined | BoxedExpression[];
+    expression(x: number): BoxedExpression;
+    isZero(x: number): boolean;
+    isOne(x: number): boolean;
+    equals(lhs: number, rhs: number): boolean;
+    add(lhs: number, rhs: number): number;
+    addn(...xs: number[]): number;
+    neg(x: number): number;
+    sub(lhs: number, rhs: number): number;
+    mul(lhs: number, rhs: number): number;
+    muln(...xs: number[]): number;
+    div(lhs: number, rhs: number): number;
+    pow(lhs: number, rhs: number): number;
+    conjugate(x: number): number;
+}
+/** @category Tensors */
+export declare class TensorFieldExpression implements TensorField<BoxedExpression> {
+    one: BoxedExpression;
+    zero: BoxedExpression;
+    nan: BoxedExpression;
+    private ce;
+    constructor(ce: ComputeEngine);
+    cast(x: BoxedExpression, dtype: 'float64'): undefined | number;
+    cast(x: BoxedExpression, dtype: 'float32'): undefined | number;
+    cast(x: BoxedExpression, dtype: 'int32'): undefined | number;
+    cast(x: BoxedExpression, dtype: 'uint8'): undefined | number;
+    cast(x: BoxedExpression, dtype: 'complex128'): undefined | Complex;
+    cast(x: BoxedExpression, dtype: 'complex64'): undefined | Complex;
+    cast(x: BoxedExpression, dtype: 'bool'): undefined | boolean;
+    cast(x: BoxedExpression, dtype: 'expression'): undefined | BoxedExpression;
+    cast(x: BoxedExpression[], dtype: 'float64'): undefined | number[];
+    cast(x: BoxedExpression[], dtype: 'float32'): undefined | number[];
+    cast(x: BoxedExpression[], dtype: 'int32'): undefined | number[];
+    cast(x: BoxedExpression[], dtype: 'uint8'): undefined | number[];
+    cast(x: BoxedExpression[], dtype: 'complex128'): undefined | Complex[];
+    cast(x: BoxedExpression[], dtype: 'complex64'): undefined | Complex[];
+    cast(x: BoxedExpression[], dtype: 'bool'): undefined | boolean[];
+    cast(x: BoxedExpression[], dtype: 'expression'): undefined | BoxedExpression[];
+    expression(x: BoxedExpression): BoxedExpression;
+    isZero(x: BoxedExpression): boolean;
+    isOne(x: BoxedExpression): boolean;
+    equals(lhs: BoxedExpression, rhs: BoxedExpression): boolean;
+    add(lhs: BoxedExpression, rhs: BoxedExpression): BoxedExpression;
+    addn(...xs: BoxedExpression[]): BoxedExpression;
+    neg(x: BoxedExpression): BoxedExpression;
+    sub(lhs: BoxedExpression, rhs: BoxedExpression): BoxedExpression;
+    mul(lhs: BoxedExpression, rhs: BoxedExpression): BoxedExpression;
+    muln(...xs: BoxedExpression[]): BoxedExpression;
+    div(lhs: BoxedExpression, rhs: BoxedExpression): BoxedExpression;
+    pow(lhs: BoxedExpression, rhs: number): BoxedExpression;
+    conjugate(x: BoxedExpression): BoxedExpression;
+}
+/** @category Tensors */
+export declare class TensorFieldComplex implements TensorField<Complex> {
+    one: Complex;
+    zero: Complex;
+    nan: Complex;
+    private ce;
+    constructor(ce: ComputeEngine);
+    cast(x: Complex, dtype: 'float64'): undefined | number;
+    cast(x: Complex, dtype: 'float32'): undefined | number;
+    cast(x: Complex, dtype: 'int32'): undefined | number;
+    cast(x: Complex, dtype: 'uint8'): undefined | number;
+    cast(x: Complex, dtype: 'complex128'): undefined | Complex;
+    cast(x: Complex, dtype: 'complex64'): undefined | Complex;
+    cast(x: Complex, dtype: 'bool'): undefined | boolean;
+    cast(x: Complex, dtype: 'expression'): undefined | BoxedExpression;
+    cast(x: Complex[], dtype: 'float64'): undefined | number[];
+    cast(x: Complex[], dtype: 'float32'): undefined | number[];
+    cast(x: Complex[], dtype: 'int32'): undefined | number[];
+    cast(x: Complex[], dtype: 'uint8'): undefined | number[];
+    cast(x: Complex[], dtype: 'complex128'): undefined | Complex[];
+    cast(x: Complex[], dtype: 'complex64'): undefined | Complex[];
+    cast(x: Complex[], dtype: 'bool'): undefined | boolean[];
+    cast(x: Complex[], dtype: 'expression'): undefined | BoxedExpression[];
+    expression(z: Complex): BoxedExpression;
+    isZero(z: Complex): boolean;
+    isOne(z: Complex): boolean;
+    equals(lhs: Complex, rhs: Complex): boolean;
+    add(lhs: Complex, rhs: Complex): Complex;
+    addn(...xs: Complex[]): Complex;
+    neg(z: Complex): Complex;
+    sub(lhs: Complex, rhs: Complex): Complex;
+    mul(lhs: Complex, rhs: Complex): Complex;
+    muln(...xs: Complex[]): Complex;
+    div(lhs: Complex, rhs: Complex): Complex;
+    pow(lhs: Complex, rhs: number): Complex;
+    conjugate(z: Complex): Complex;
+}
+/**
+ * @category Tensors
+ * @internal
+ */
+export declare function getSupertype(t1: TensorDataType | undefined, t2: TensorDataType): TensorDataType;
+/**
+ * If the expression is a literal number, return the datatype of the
+ * number (or boolean). Otherwise, return the `expression`.
+ *
+ * @category Tensors
+ * @internal
+ */
+export declare function getExpressionDatatype(expr: BoxedExpression): TensorDataType;

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

@@ -0,0 +1,93 @@
+/* 0.33.0 */
+/** @category Tensors */
+export declare abstract class AbstractTensor<DT extends keyof DataTypeMap> implements Tensor<DT> {
+    private ce;
+    /**
+     * Return a tuple of tensors that have the same dtype.
+     * If necessary, one of the two input tensors is upcast.
+     *
+     * The shape of the tensors is reshaped to a compatible
+     * shape. If the shape is not compatible, `undefined` is returned.
+     *
+     * @param lhs
+     * @param rhs
+     */
+    static align<T1 extends TensorDataType, T2 extends TensorDataType>(lhs: AbstractTensor<T1>, rhs: AbstractTensor<T2>): [AbstractTensor<T1>, AbstractTensor<T1>];
+    static align<T1 extends TensorDataType, T2 extends TensorDataType>(lhs: AbstractTensor<T1>, rhs: AbstractTensor<T2>): [AbstractTensor<T2>, AbstractTensor<T2>];
+    /**
+     * Apply a function to the elements of two tensors, or to a tensor
+     * and a scalar.
+     *
+     * The tensors are aligned and broadcasted if necessary.
+     *
+     * @param fn
+     * @param lhs
+     * @param rhs
+     * @returns
+     */
+    static broadcast<T extends TensorDataType>(fn: (lhs: DataTypeMap[T], rhs: DataTypeMap[T]) => DataTypeMap[T], lhs: AbstractTensor<T>, rhs: AbstractTensor<T> | DataTypeMap[T]): AbstractTensor<T>;
+    readonly field: TensorField<DataTypeMap[DT]>;
+    readonly shape: number[];
+    readonly rank: number;
+    private readonly _strides;
+    constructor(ce: ComputeEngine, tensorData: TensorData<DT>);
+    abstract get dtype(): DT;
+    abstract get data(): DataTypeMap[DT][];
+    get expression(): BoxedExpression;
+    /**
+     * Like expression(), but return a nested JS array instead
+     * of a BoxedExpression
+     */
+    get array(): NestedArray<DataTypeMap[DT]>;
+    /** Indices are 1-based, return a 0-based index in the data */
+    private _index;
+    get isSquare(): boolean;
+    get isSymmetric(): boolean;
+    get isSkewSymmetric(): boolean;
+    get isUpperTriangular(): boolean;
+    get isLowerTriangular(): boolean;
+    get isTriangular(): boolean;
+    get isDiagonal(): boolean;
+    get isIdentity(): boolean;
+    get isZero(): boolean;
+    /**
+     *  The number of indices should match the rank of the tensor.
+     *
+     * Note: the indices are 1-based
+     * Note: the data is broadcast (wraps around) if the indices are out of bounds
+     *
+     * LaTeX notation `A\lbracki, j\rbrack` or `A_{i, j}`
+     */
+    at(...indices: number[]): DataTypeMap[DT];
+    diagonal(axis1?: number, axis2?: number): undefined | DataTypeMap[DT][];
+    trace(axis1?: number, axis2?: number): undefined | DataTypeMap[DT] | AbstractTensor<DT>;
+    /**
+     * Change the shape of the tensor
+     *
+     * The data is reused (and shared) between the two tensors.
+     */
+    reshape(...shape: number[]): AbstractTensor<DT>;
+    slice(index: number): AbstractTensor<DT>;
+    flatten(): DataTypeMap[DT][];
+    upcast<DT extends keyof DataTypeMap>(dtype: DT): AbstractTensor<DT>;
+    /** Transpose the last two axes (default) */
+    transpose(): undefined | AbstractTensor<DT>;
+    /** Transpose two axes. */
+    transpose(axis1: number, axis2: number, fn?: (v: DataTypeMap[DT]) => DataTypeMap[DT]): undefined | AbstractTensor<DT>;
+    conjugateTranspose(axis1: number, axis2: number): undefined | AbstractTensor<DT>;
+    determinant(): undefined | DataTypeMap[DT];
+    inverse(): undefined | AbstractTensor<DT>;
+    pseudoInverse(): undefined | AbstractTensor<DT>;
+    adjugateMatrix(): undefined | AbstractTensor<DT>;
+    minor(i: number, j: number): undefined | DataTypeMap[DT];
+    map1(fn: (lhs: DataTypeMap[DT], rhs: DataTypeMap[DT]) => DataTypeMap[DT], scalar: DataTypeMap[DT]): AbstractTensor<DT>;
+    map2(fn: (lhs: DataTypeMap[DT], rhs: DataTypeMap[DT]) => DataTypeMap[DT], rhs: AbstractTensor<DT>): AbstractTensor<DT>;
+    add(rhs: AbstractTensor<DT> | DataTypeMap[DT]): AbstractTensor<DT>;
+    subtract(rhs: AbstractTensor<DT> | DataTypeMap[DT]): AbstractTensor<DT>;
+    multiply(rhs: AbstractTensor<DT> | DataTypeMap[DT]): AbstractTensor<DT>;
+    divide(rhs: AbstractTensor<DT> | DataTypeMap[DT]): AbstractTensor<DT>;
+    power(rhs: AbstractTensor<DT> | DataTypeMap[DT]): AbstractTensor<DT>;
+    equals(rhs: AbstractTensor<DT>): boolean;
+}
+/** @category Tensors */
+export declare function makeTensor<T extends TensorDataType>(ce: ComputeEngine, data: TensorData<T>): AbstractTensor<T>;

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

@@ -0,0 +1,8 @@
+/* 0.33.0 */
+export * from '../math-json/types';
+export * from '../common/type/boxed-type';
+export * from '../common/type/types';
+export type * from './latex-syntax/types';
+export * from './numerics/types';
+export * from './numeric-value/types';
+export * from './global-types';

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

@@ -0,0 +1,3 @@
+/* 0.33.0 */
+export { ComputeEngine } from './compute-engine/index';
+export * from './compute-engine/types';

package/dist/types/math-json/symbols.d.ts

@@ -0,0 +1,11 @@
+/* 0.33.0 */
+ * Return true if the string is a valid symbol.
+ *
+ * Check for symbols matching a profile of [Unicode UAX31](https://unicode.org/reports/tr31/)
+ *
+ * See https://cortexjs.io/math-json/#symbols for a full definition of the
+ * profile.
+ */
+export declare function isValidSymbol(s: string): boolean;
+export declare const EMOJIS: RegExp;
+export declare function validateSymbol(s: unknown): 'valid' | 'not-a-string' | 'empty-string' | 'expected-nfc' | 'unexpected-mixed-emoji' | 'unexpected-bidi-marker' | 'unexpected-script' | 'invalid-first-char' | 'invalid-char';

package/dist/types/math-json/types.d.ts

@@ -0,0 +1,122 @@
+/* 0.33.0 */
+ * The following properties can be added to any MathJSON expression
+ * to provide additional information about the expression.
+ *
+ * @category MathJSON */
+export type MathJsonAttributes = {
+    /** A human readable string to annotate this expression, since JSON does not
+     * allow comments in its encoding */
+    comment?: string;
+    /** A Markdown-encoded string providing documentation about this expression.
+     */
+    documentation?: string;
+    /** A visual representation of this expression as a LaTeX string.
+     *
+     * This can be useful to preserve non-semantic details, for example
+     * parentheses in an expression or styling attributes.
+     */
+    latex?: string;
+    /**
+     * A short string referencing an entry in a wikibase.
+     *
+     * For example:
+     *
+     * `"Q167"` is the [wikidata entry](https://www.wikidata.org/wiki/Q167)
+     *  for the `Pi` constant.
+     */
+    wikidata?: string;
+    /** A base URL for the `wikidata` key.
+     *
+     * A full URL can be produced by concatenating this key with the `wikidata`
+     * key. This key applies to this node and all its children.
+     *
+     * The default value is "https://www.wikidata.org/wiki/"
+     */
+    wikibase?: string;
+    /** A short string indicating an entry in an OpenMath Content Dictionary.
+     *
+     * For example: `arith1/#abs`.
+     *
+     */
+    openmathSymbol?: string;
+    /** A base URL for an OpenMath content dictionary. This key applies to this
+     * node and all its children.
+     *
+     * The default value is "http://www.openmath.org/cd".
+     */
+    openmathCd?: string;
+    /**  A URL to the source code from which this expression was generated.
+     */
+    sourceUrl?: string;
+    /** The source code from which this expression was generated.
+     *
+     * It could be a LaTeX expression, or some other source language.
+     */
+    sourceContent?: string;
+    /**
+     * A character offset in `sourceContent` or `sourceUrl` from which this
+     * expression was generated.
+     */
+    sourceOffsets?: [start: number, end: number];
+};
+/** @category MathJSON */
+export type MathJsonSymbol = string;
+/**
+ * A MathJSON numeric quantity.
+ *
+ * The `num` string is made of:
+ * - an optional `-` minus sign
+ * - a string of decimal digits
+ * - an optional fraction part (a `.` decimal marker followed by decimal digits)
+ * - an optional repeating decimal pattern: a string of digits enclosed in
+ *    parentheses
+ * - an optional exponent part (a `e` or `E` exponent marker followed by an
+ *   optional `-` minus sign, followed by a string of digits)
+ *
+ * It can also consist of the string `NaN`, `-Infinity` or `+Infinity` to
+ * represent these respective values.
+ *
+ * A MathJSON number may contain more digits or an exponent with a greater
+ * range than can be represented in an IEEE 64-bit floating-point.
+ *
+ * For example:
+ * - `-12.34`
+ * - `0.234e-56`
+ * - `1.(3)`
+ * - `123456789123456789.123(4567)e999`
+ * @category MathJSON
+ */
+export type MathJsonNumberObject = {
+    num: 'NaN' | '-Infinity' | '+Infinity' | string;
+} & MathJsonAttributes;
+/** @category MathJSON */
+export type MathJsonSymbolObject = {
+    sym: MathJsonSymbol;
+} & MathJsonAttributes;
+/** @category MathJSON */
+export type MathJsonStringObject = {
+    str: string;
+} & MathJsonAttributes;
+/** @category MathJSON */
+export type MathJsonFunctionObject = {
+    fn: [MathJsonSymbol, ...Expression[]];
+} & MathJsonAttributes;
+/** @category MathJSON */
+export type DictionaryValue = boolean | number | string | ExpressionObject | ReadonlyArray<DictionaryValue>;
+/** @category MathJSON */
+export type MathJsonDictionaryObject = {
+    dict: Record<string, DictionaryValue>;
+} & MathJsonAttributes;
+/**
+ * @category MathJSON
+ */
+export type ExpressionObject = MathJsonNumberObject | MathJsonStringObject | MathJsonSymbolObject | MathJsonFunctionObject | MathJsonDictionaryObject;
+/**
+ * A MathJSON expression is a recursive data structure.
+ *
+ * The leaf nodes of an expression are numbers, strings and symbols.
+ * The dictionary and function nodes can contain expressions themselves.
+ *
+ * @category MathJSON
+ */
+export type Expression = ExpressionObject | number | MathJsonSymbol | string | readonly [MathJsonSymbol, ...Expression[]];

package/dist/types/math-json/utils.d.ts

@@ -0,0 +1,87 @@
+/* 0.33.0 */
+export declare const MISSING: Expression;
+export declare function isNumberExpression(expr: Expression | null): expr is number | string | MathJsonNumberObject;
+export declare function isNumberObject(expr: Expression | null): expr is MathJsonNumberObject;
+export declare function isSymbolObject(expr: Expression | null): expr is MathJsonSymbolObject;
+export declare function isStringObject(expr: Expression | null): expr is MathJsonStringObject;
+export declare function isDictionaryObject(expr: Expression | null): expr is MathJsonDictionaryObject;
+export declare function isFunctionObject(expr: Expression | null): expr is MathJsonFunctionObject;
+export declare function isExpressionObject(expr: Expression | null): expr is ExpressionObject;
+/**
+ * Returns true if `expr` has at least one recognized metadata property
+ * (`latex` or `wikidata`) with a non-undefined value.
+ */
+export declare function hasMetaData(expr: Expression | null): expr is ExpressionObject & Partial<MathJsonAttributes>;
+/**  If expr is a string literal, return it.
+ *
+ * A string literal is a JSON string that begins and ends with
+ * **U+0027 APOSTROPHE** : **`'`** or an object literal with a `str` key.
+ */
+export declare function stringValue(expr: Expression | null | undefined): string | null;
+export declare function stripText(expr: Expression | null | undefined): Expression | null;
+/**
+ * The operator of a function is symbol.
+ *
+ * Return an empty string if the expression is not a function.
+ *
+ * Examples:
+ * * `["Negate", 5]`  -> `"Negate"`
+ */
+export declare function operator(expr: Expression | null | undefined): MathJsonSymbol;
+/**
+ * Return the arguments of a function, or an empty array if not a function
+ * or no arguments.
+ */
+export declare function operands(expr: Expression | null | undefined): ReadonlyArray<Expression>;
+/** Return the nth operand of a function expression */
+export declare function operand(expr: Expression | null, n: 1 | 2 | 3): Expression | null;
+export declare function nops(expr: Expression | null | undefined): number;
+export declare function unhold(expr: Expression | null): Expression | null;
+export declare function symbol(expr: Expression | null | undefined): string | null;
+export declare function dictionaryFromExpression(expr: Expression | null): null | MathJsonDictionaryObject;
+export declare function dictionaryFromEntries(dict: Record<string, Expression>): Expression;
+/**
+ *  CAUTION: `machineValue()` will return a truncated value if the number
+ *  has a precision outside of the machine range.
+ */
+export declare function machineValue(expr: Expression | null | undefined): number | null;
+/**
+ * Return a rational (numer over denom) representation of the expression,
+ * if possible, `null` otherwise.
+ *
+ * The expression can be:
+ * - Some symbols: "Infinity", "Half"...
+ * - ["Power", d, -1]
+ * - ["Power", n, 1]
+ * - ["Divide", n, d]
+ *
+ * The denominator is always > 0.
+ */
+export declare function rationalValue(expr: Expression | undefined | null): [number, number] | null;
+/**
+ * Apply a substitution to an expression.
+ */
+export declare function subs(expr: Expression, s: {
+    [symbol: string]: Expression;
+}): Expression;
+/**
+ * Apply a function to the arguments of a function and return an array of T
+ */
+export declare function mapArgs<T>(expr: Expression, fn: (x: Expression) => T): T[];
+/**
+ * Assuming that op is an associative operator, fold lhs or rhs
+ * if either are the same operator.
+ */
+export declare function foldAssociativeOperator(op: string, lhs: Expression, rhs: Expression): Expression;
+/** Return the elements of a sequence, or null if the expression is not a sequence. The sequence can be optionally enclosed by a`["Delimiter"]` expression  */
+export declare function getSequence(expr: Expression | null | undefined): ReadonlyArray<Expression> | null;
+/** `Nothing` or the empty sequence (`["Sequence"]`) */
+export declare function isEmptySequence(expr: Expression | null | undefined): expr is null | undefined;
+export declare function missingIfEmpty(expr: Expression | null | undefined): Expression;
+/** The number of leaves (atomic expressions) in the expression */
+export declare function countLeaves(expr: Expression | null): number;
+/** True if the string matches the expected pattern for a number */
+export declare function matchesNumber(s: string): boolean;
+/** True if the string matches the expected pattern for a symbol */
+export declare function matchesSymbol(s: string): boolean;
+export declare function matchesString(s: string): boolean;

package/dist/types/math-json.d.ts

@@ -0,0 +1,3 @@
+/* 0.33.0 */
+export { isSymbolObject, isStringObject, isFunctionObject, stringValue, operator, operand, symbol, mapArgs, dictionaryFromExpression, } from './math-json/utils';
+export declare const version = "0.33.0";

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.32.0",
+  "version": "0.33.0",
   "scripts": {
     "doc": "bash ./scripts/doc.sh",
     "build": "bash ./scripts/build.sh",