@cortex-js/compute-engine 0.32.1 → 0.34.0

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

@@ -0,0 +1,120 @@
+/* 0.34.0 */
+ * Utilities for declarative sequence definitions.
+ *
+ * This module provides functions to create subscriptEvaluate handlers
+ * from sequence definitions (base cases + recurrence relation).
+ */
+import type { BoxedExpression, ComputeEngine, SequenceDefinition, SequenceStatus, SequenceInfo } from './global-types';
+/**
+ * Create a subscriptEvaluate handler from a sequence definition.
+ *
+ * The handler evaluates expressions like `F_{10}` or `P_{5,2}` by:
+ * 1. Checking base cases first (with pattern matching for multi-index)
+ * 2. Looking up memoized values
+ * 3. Recursively evaluating the recurrence relation
+ *
+ * Supports both single-index and multi-index sequences:
+ * - Single-index: `F_{10}` with subscript as a number
+ * - Multi-index: `P_{5,2}` with subscript as `Sequence(5, 2)`
+ */
+export declare function createSequenceHandler(ce: ComputeEngine, name: string, def: SequenceDefinition): (subscript: BoxedExpression, options: {
+    engine: ComputeEngine;
+    numericApproximation?: boolean;
+}) => BoxedExpression | undefined;
+/**
+ * Validate a sequence definition.
+ */
+export declare function validateSequenceDefinition(ce: ComputeEngine, name: string, def: SequenceDefinition): {
+    valid: boolean;
+    error?: string;
+};
+/**
+ * Add a base case for a single-index sequence definition.
+ * e.g., from `L_0 := 1`
+ */
+export declare function addSequenceBaseCase(ce: ComputeEngine, name: string, index: number, value: BoxedExpression): void;
+/**
+ * Add a base case for a multi-index sequence definition.
+ * e.g., from `P_{0,0} := 1` or `P_{n,0} := 1`
+ *
+ * @param key - The base case key, e.g., '0,0' for exact or 'n,0' for pattern
+ */
+export declare function addMultiIndexBaseCase(ce: ComputeEngine, name: string, key: string, value: BoxedExpression): void;
+/**
+ * Add a recurrence relation for a single-index sequence definition.
+ * e.g., from `L_n := L_{n-1} + 1`
+ *
+ * We store the recurrence as a LaTeX string rather than a BoxedExpression
+ * because the expression may have been parsed before the symbol was declared
+ * with subscriptEvaluate. Storing as LaTeX allows us to re-parse fresh when
+ * creating the handler, ensuring proper binding.
+ */
+export declare function addSequenceRecurrence(ce: ComputeEngine, name: string, variable: string, expr: BoxedExpression): void;
+/**
+ * Add a recurrence relation for a multi-index sequence definition.
+ * e.g., from `P_{n,k} := P_{n-1,k-1} + P_{n-1,k}`
+ *
+ * @param variables - The index variable names, e.g., ['n', 'k']
+ */
+export declare function addMultiIndexRecurrence(ce: ComputeEngine, name: string, variables: string[], expr: BoxedExpression): void;
+/**
+ * Check if expression contains self-reference to sequence name.
+ * e.g., `a_{n-1}` when defining sequence 'a'
+ */
+export declare function containsSelfReference(expr: BoxedExpression, seqName: string): boolean;
+/**
+ * Extract the index variable from a subscript expression.
+ * e.g., from `n-1` extract 'n', from `2*k` extract 'k'
+ */
+export declare function extractIndexVariable(subscript: BoxedExpression): string | undefined;
+/**
+ * Get the status of a sequence definition.
+ *
+ * Returns information about whether a sequence is complete, pending, or not defined.
+ * Supports both single-index and multi-index sequences.
+ */
+export declare function getSequenceStatus(ce: ComputeEngine, name: string): SequenceStatus;
+/**
+ * Get information about a defined sequence.
+ * Returns `undefined` if the symbol is not a complete sequence.
+ * Supports both single-index and multi-index sequences.
+ */
+export declare function getSequenceInfo(ce: ComputeEngine, name: string): SequenceInfo | undefined;
+/**
+ * List all defined sequences.
+ */
+export declare function listSequences(ce: ComputeEngine): string[];
+/**
+ * Check if a symbol is a defined sequence.
+ */
+export declare function isSequence(ce: ComputeEngine, name: string): boolean;
+/**
+ * Clear the memoization cache for a sequence or all sequences.
+ */
+export declare function clearSequenceCache(ce: ComputeEngine, name?: string): void;
+/**
+ * Get the memoization cache for a sequence.
+ * Returns a copy of the cache Map, or `undefined` if not a sequence or memoization is disabled.
+ *
+ * For single-index sequences, keys are numbers.
+ * For multi-index sequences, keys are comma-separated strings (e.g., '5,2').
+ */
+export declare function getSequenceCache(ce: ComputeEngine, name: string): Map<number | string, BoxedExpression> | undefined;
+/**
+ * Generate a list of sequence terms from start to end (inclusive).
+ *
+ * @param ce - The compute engine
+ * @param name - The sequence name
+ * @param start - Starting index (inclusive)
+ * @param end - Ending index (inclusive)
+ * @param step - Step size (default: 1)
+ * @returns Array of BoxedExpressions for each term, or undefined if not a sequence
+ *
+ * @example
+ * ```typescript
+ * // For Fibonacci sequence F
+ * generateSequenceTerms(ce, 'F', 0, 10);
+ * // → [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
+ * ```
+ */
+export declare function generateSequenceTerms(ce: ComputeEngine, name: string, start: number, end: number, step?: number): BoxedExpression[] | undefined;

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

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

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.34.0 */
 /**
  *
  * @param fn The function to differentiate, a function literal.
@@ -14,5 +14,20 @@ export declare function derivative(fn: BoxedExpression, order: number): BoxedExp
  * All expressions that do not explicitly depend on `v` are taken to have zero
  * partial derivative.
  *
+ * ## Recursion Safety
+ *
+ * This function includes a depth limit (`MAX_DIFFERENTIATION_DEPTH`) to prevent
+ * stack overflow from pathological expressions. The depth is tracked internally
+ * and incremented on each recursive call. If the limit is reached, the function
+ * returns `undefined` rather than continuing to recurse.
+ *
+ * Normal differentiation (including higher-order derivatives of complex
+ * expressions) should never approach this limit. Hitting the limit indicates
+ * either a bug in the differentiation rules or a maliciously constructed input.
+ *
+ * @param expr - The expression to differentiate
+ * @param v - The variable to differentiate with respect to
+ * @param depth - Internal recursion depth counter (do not pass manually)
+ * @returns The derivative expression, or `undefined` if unable to differentiate
  */
-export declare function differentiate(expr: BoxedExpression, v: string): BoxedExpression | undefined;
+export declare function differentiate(expr: BoxedExpression, v: string, depth?: number): BoxedExpression | undefined;

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.34.0 */
 /**
  *
  */

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

@@ -0,0 +1,33 @@
+/* 0.34.0 */
+ * Cost functions for the Fu trigonometric simplification algorithm.
+ *
+ * The primary objective is to minimize the number of trigonometric functions,
+ * with secondary consideration for overall expression complexity.
+ */
+import type { BoxedExpression } from '../global-types';
+/**
+ * Count the number of trigonometric function occurrences in an expression.
+ * This is the primary metric for the Fu algorithm.
+ */
+export declare function countTrigFunctions(expr: BoxedExpression): number;
+/**
+ * Count the number of leaves (atoms) in an expression.
+ * Includes symbols, numbers, and function names.
+ */
+export declare function countLeaves(expr: BoxedExpression): number;
+/**
+ * The default trig cost function for the Fu algorithm.
+ *
+ * Priority:
+ * 1. Minimize number of trig functions (weighted heavily)
+ * 2. Minimize leaf count (secondary)
+ *
+ * This ensures that expressions with fewer trig functions are always
+ * preferred, even if they have slightly more total operations.
+ */
+export declare function trigCost(expr: BoxedExpression): number;
+export type TrigCostFunction = (expr: BoxedExpression) => number;
+/**
+ * Default cost function for the Fu algorithm
+ */
+export declare const DEFAULT_TRIG_COST: TrigCostFunction;

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

@@ -0,0 +1,130 @@
+/* 0.34.0 */
+ * Fu Algorithm Transformation Rules
+ *
+ * Programmatic implementations of TR1-TR22 from the Fu trigonometric
+ * simplification algorithm.
+ *
+ * Reference: Fu, Hongguang, Xiuqin Zhong, and Zhenbing Zeng.
+ * "Automated and readable simplification of trigonometric expressions."
+ * Mathematical and Computer Modelling 44.11 (2006): 1169-1177.
+ *
+ * Each TR function applies a specific transformation to an expression.
+ * Returns the transformed expression, or undefined if the rule doesn't apply.
+ *
+ * IMPORTANT: These functions should NOT call .simplify() on their results
+ * to avoid infinite recursion when called from the simplification pipeline.
+ */
+import type { BoxedExpression } from '../global-types';
+/**
+ * Check if an expression contains any trigonometric functions
+ */
+export declare function hasTrigFunction(expr: BoxedExpression): boolean;
+/**
+ * Check if expression contains specific operators anywhere in the tree
+ */
+export declare function hasOperator(expr: BoxedExpression, ...ops: string[]): boolean;
+export declare function TR1(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR1 to all subexpressions
+ */
+export declare function applyTR1(expr: BoxedExpression): BoxedExpression;
+export declare function TR2(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR2 to all subexpressions
+ */
+export declare function applyTR2(expr: BoxedExpression): BoxedExpression;
+export declare function TR2i(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR2i to all subexpressions
+ */
+export declare function applyTR2i(expr: BoxedExpression): BoxedExpression;
+export declare function TR3(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR3 to all subexpressions
+ */
+export declare function applyTR3(expr: BoxedExpression): BoxedExpression;
+export declare function TR5(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR5 to all subexpressions
+ */
+export declare function applyTR5(expr: BoxedExpression): BoxedExpression;
+export declare function TR6(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR6 to all subexpressions
+ */
+export declare function applyTR6(expr: BoxedExpression): BoxedExpression;
+export declare function TR7(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR7 to all subexpressions
+ */
+export declare function applyTR7(expr: BoxedExpression): BoxedExpression;
+export declare function TR7i(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR7i to all subexpressions
+ */
+export declare function applyTR7i(expr: BoxedExpression): BoxedExpression;
+export declare function TR8(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR8 to all subexpressions
+ */
+export declare function applyTR8(expr: BoxedExpression): BoxedExpression;
+export declare function TR9(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR9 to all subexpressions
+ */
+export declare function applyTR9(expr: BoxedExpression): BoxedExpression;
+export declare function TR10(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR10 to all subexpressions
+ */
+export declare function applyTR10(expr: BoxedExpression): BoxedExpression;
+export declare function TR10i(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR10i to all subexpressions
+ */
+export declare function applyTR10i(expr: BoxedExpression): BoxedExpression;
+export declare function TR11(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR11 to all subexpressions
+ */
+export declare function applyTR11(expr: BoxedExpression): BoxedExpression;
+export declare function TR11i(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR11i to all subexpressions
+ */
+export declare function applyTR11i(expr: BoxedExpression): BoxedExpression;
+export declare function TR12(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR12 to all subexpressions
+ */
+export declare function applyTR12(expr: BoxedExpression): BoxedExpression;
+export declare function TR12i(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR12i to all subexpressions
+ */
+export declare function applyTR12i(expr: BoxedExpression): BoxedExpression;
+export declare function TR13(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR13 to all subexpressions
+ */
+export declare function applyTR13(expr: BoxedExpression): BoxedExpression;
+export declare function TR22(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR22 to all subexpressions
+ */
+export declare function applyTR22(expr: BoxedExpression): BoxedExpression;
+export declare function TR22i(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR22i to all subexpressions
+ */
+export declare function applyTR22i(expr: BoxedExpression): BoxedExpression;
+export declare function TRmorrie(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TRmorrie to all subexpressions
+ */
+export declare function applyTRmorrie(expr: BoxedExpression): BoxedExpression;
+export declare function TRpythagorean(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TRpythagorean to all subexpressions
+ */
+export declare function applyTRpythagorean(expr: BoxedExpression): BoxedExpression;

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

@@ -0,0 +1,48 @@
+/* 0.34.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.34.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.34.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.34.0 */
+export declare function simplifyHyperbolic(x: BoxedExpression): RuleStep | undefined;

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

@@ -0,0 +1,14 @@
+/* 0.34.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.34.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.34.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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.34.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,14 +1,4 @@
-/* 0.32.1 */
-/**
- * @todo: a set to "tidy" an expression. Different from a canonical form, but
- * inline with the user's expectations.
- *
- * Example:
- *
- * - a^n * a^m -> a^(n+m)
- * - a / √b -> (a * √b) / b
- *
- */
+/* 0.34.0 */
 /**
  * A set of simplification rules.
  *

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.34.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

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

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.34.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]>;

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.34.0 */
 /** @category Tensors */
 export declare abstract class AbstractTensor<DT extends keyof DataTypeMap> implements Tensor<DT> {
     private ce;
@@ -60,7 +60,7 @@ export declare abstract class AbstractTensor<DT extends keyof DataTypeMap> imple
      */
     at(...indices: number[]): DataTypeMap[DT];
     diagonal(axis1?: number, axis2?: number): undefined | DataTypeMap[DT][];
-    trace(axis1?: number, axis2?: number): undefined | DataTypeMap[DT];
+    trace(axis1?: number, axis2?: number): undefined | DataTypeMap[DT] | AbstractTensor<DT>;
     /**
      * Change the shape of the tensor
      *
@@ -70,7 +70,7 @@ export declare abstract class AbstractTensor<DT extends keyof DataTypeMap> imple
     slice(index: number): AbstractTensor<DT>;
     flatten(): DataTypeMap[DT][];
     upcast<DT extends keyof DataTypeMap>(dtype: DT): AbstractTensor<DT>;
-    /** Transpose the first and second axis */
+    /** 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>;

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.34.0 */
 export * from '../math-json/types';
 export * from '../common/type/boxed-type';
 export * from '../common/type/types';

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

@@ -1,3 +1,7 @@
-/* 0.32.1 */
+/* 0.34.0 */
 export { ComputeEngine } from './compute-engine/index';
 export * from './compute-engine/types';
+export type { CompileTarget, CompiledOperators, CompiledFunctions, CompilationOptions, CompiledExecutable, LanguageTarget, TargetSource, CompiledFunction, } from './compute-engine/compilation/types';
+export { JavaScriptTarget } from './compute-engine/compilation/javascript-target';
+export { GLSLTarget } from './compute-engine/compilation/glsl-target';
+export { BaseCompiler } from './compute-engine/compilation/base-compiler';

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.34.0 */
  * Return true if the string is a valid symbol.
  *
  * Check for symbols matching a profile of [Unicode UAX31](https://unicode.org/reports/tr31/)

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.34.0 */
  * The following properties can be added to any MathJSON expression
  * to provide additional information about the expression.
  *

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.34.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;

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

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

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.32.1",
+  "version": "0.34.0",
   "scripts": {
     "doc": "bash ./scripts/doc.sh",
     "build": "bash ./scripts/build.sh",
@@ -79,7 +79,7 @@
     "jest-silent-reporter": "^0.6.0",
     "open": "^10.1.2",
     "prettier": "^3.6.2",
-    "prettier-2": "npm:prettier@^2",
+    "prettier-2": "npm:prettier@^2.8.8",
     "serve-http": "^1.0.7",
     "ts-jest": "^29.4.0",
     "ts-node": "^10.9.2",