@cortex-js/compute-engine 0.29.1 → 0.30.1

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

@@ -1,19 +1,4 @@
-/* 0.29.1 */
- * Return a numerical approximation of the integral
- * of the function `f` from `a` to `b` using Monte Carlo integration.
- *
- * Thoughts for future improvements:
- * - use a MISER algorithm to improve the accuracy
- * - use a stratified sampling to improve the accuracy
- * - use a quasi-Monte Carlo method to improve the accuracy
- * - use a Markov Chain Monte Carlo method to improve the accuracy
- * - use a Metropolis-Hastings algorithm to improve the accuracy
- * - use a Hamiltonian Monte Carlo algorithm to improve the accuracy
- * - use a Gibbs sampling algorithm to improve the accuracy
- *
- *
- * See:
- * - https://64.github.io/monte-carlo/
- *
- */
-export declare function monteCarloEstimate(f: (x: number) => number, a: number, b: number, n?: number): number;
+/* 0.30.1 */
+    estimate: number;
+    error: number;
+};

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

@@ -1,4 +1,4 @@
-/* 0.29.1 */
+/* 0.30.1 */
 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.29.1 */
+/* 0.30.1 */
 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.29.1 */
+/* 0.30.1 */
 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.29.1 */
+/* 0.30.1 */
 export declare const MACHINE_PRECISION_BITS = 53;
 export declare const MACHINE_PRECISION: number;
 export declare const DEFAULT_TOLERANCE = 1e-10;
@@ -50,3 +50,11 @@ export declare function centeredDiff8thOrder(f: (number: any) => number, x: numb
  * @returns
  */
 export declare function limit(f: (x: number) => number, x: number, dir?: number): number;
+export declare function cantorEnumerateRationals(): Generator<[number, number]>;
+export declare function cantorEnumeratePositiveRationals(): Generator<[
+    number,
+    number
+]>;
+export declare function cantorEnumerateComplexNumbers(): Generator<[number, number]>;
+export declare function cantorEnumerateIntegers(): Generator<number>;
+export declare function cantorEnumerateNaturalNumbers(): Generator<number>;

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

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

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

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

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

@@ -1,4 +1,4 @@
-/* 0.29.1 */
+/* 0.30.1 */
 
     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.29.1 */
+/* 0.30.1 */
 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.29.1 */
+/* 0.30.1 */
 import type { BigNum } from './types';
 export declare function mean(values: Iterable<number>): number;
 export declare function bigMean(bignum: BigNumFactory, values: Iterable<BigNum>): BigNum;

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

@@ -1,2 +1,2 @@
-/* 0.29.1 */
+/* 0.30.1 */
 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.29.1 */
+/* 0.30.1 */
 type IsInteger<N extends number> = `${N}` extends `${string}.${string}` ? never : `${N}` extends `-${string}.${string}` ? never : number;
 /** A `SmallInteger` is an integer < 1e6
  * @category Numerics

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

@@ -0,0 +1,3 @@
+/* 0.30.1 */
+/** 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,10 +1,8 @@
-/* 0.29.1 */
+/* 0.30.1 */
 /**
  *
- * @param fn The function to differentiate, a `["Function"]` expression or
- * an identifier for a function name.
+ * @param fn The function to differentiate, a function literal.
  *
- * @param degrees
  * @returns a function expression representing the derivative of `fn` with
  * respect to the variables in `degrees`.
  */

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

@@ -1,4 +1,4 @@
-/* 0.29.1 */
+/* 0.30.1 */
 /**
  *
  */

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

@@ -1,4 +1,4 @@
-/* 0.29.1 */
+/* 0.30.1 */
 /**
  * @todo: a set to "tidy" an expression. Different from a canonical form, but
  * inline with the user's expectations.

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

@@ -1,46 +1,8 @@
-/* 0.29.1 */
-import { BoxedExpression, ComputeEngine, DataTypeMap, TensorDataType } from '../global-types';
+/* 0.30.1 */
+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 interface TensorField<T extends number | Complex | BoxedExpression | boolean | string = number> {
-    readonly one: T;
-    readonly zero: T;
-    readonly nan: T;
-    cast(x: T, dtype: 'float64'): undefined | number;
-    cast(x: T, dtype: 'float32'): undefined | number;
-    cast(x: T, dtype: 'int32'): undefined | number;
-    cast(x: T, dtype: 'uint8'): undefined | number;
-    cast(x: T, dtype: 'complex128'): undefined | Complex;
-    cast(x: T, dtype: 'complex64'): undefined | Complex;
-    cast(x: T, dtype: 'bool'): undefined | boolean;
-    cast(x: T, dtype: 'string'): undefined | string;
-    cast(x: T, dtype: 'expression'): undefined | BoxedExpression;
-    cast(x: T[], dtype: 'float64'): undefined | number[];
-    cast(x: T[], dtype: 'float32'): undefined | number[];
-    cast(x: T[], dtype: 'int32'): undefined | number[];
-    cast(x: T[], dtype: 'uint8'): undefined | number[];
-    cast(x: T[], dtype: 'complex128'): undefined | Complex[];
-    cast(x: T[], dtype: 'complex64'): undefined | Complex[];
-    cast(x: T[], dtype: 'bool'): undefined | boolean[];
-    cast(x: T[], dtype: 'string'): undefined | string[];
-    cast(x: T[], dtype: 'expression'): undefined | BoxedExpression[];
-    cast(x: T | T[], dtype: TensorDataType): undefined | Complex | number | boolean | string | BoxedExpression | Complex[] | number[] | boolean[] | string[] | BoxedExpression[];
-    expression(x: T): BoxedExpression;
-    isZero(x: T): boolean;
-    isOne(x: T): boolean;
-    equals(lhs: T, rhs: T): boolean;
-    add(lhs: T, rhs: T): T;
-    addn(...xs: T[]): T;
-    neg(x: T): T;
-    sub(lhs: T, rhs: T): T;
-    mul(lhs: T, rhs: T): T;
-    muln(...xs: T[]): T;
-    div(lhs: T, rhs: T): T;
-    pow(rhs: T, n: number): T;
-    conjugate(x: T): T;
-}
-/** @category Tensors */
 export declare class TensorFieldNumber implements TensorField<number> {
     private ce;
     one: number;
@@ -54,7 +16,6 @@ export declare class TensorFieldNumber implements TensorField<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: 'string'): undefined | string;
     cast(x: number, dtype: 'expression'): undefined | BoxedExpression;
     cast(x: number[], dtype: 'float64'): undefined | number[];
     cast(x: number[], dtype: 'float32'): undefined | number[];
@@ -63,7 +24,6 @@ export declare class TensorFieldNumber implements TensorField<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: 'string'): undefined | string[];
     cast(x: number[], dtype: 'expression'): undefined | BoxedExpression[];
     expression(x: number): BoxedExpression;
     isZero(x: number): boolean;
@@ -93,7 +53,6 @@ export declare class TensorFieldExpression implements TensorField<BoxedExpressio
     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: 'string'): undefined | string;
     cast(x: BoxedExpression, dtype: 'expression'): undefined | BoxedExpression;
     cast(x: BoxedExpression[], dtype: 'float64'): undefined | number[];
     cast(x: BoxedExpression[], dtype: 'float32'): undefined | number[];
@@ -102,7 +61,6 @@ export declare class TensorFieldExpression implements TensorField<BoxedExpressio
     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: 'string'): undefined | string[];
     cast(x: BoxedExpression[], dtype: 'expression'): undefined | BoxedExpression[];
     expression(x: BoxedExpression): BoxedExpression;
     isZero(x: BoxedExpression): boolean;
@@ -132,7 +90,6 @@ export declare class TensorFieldComplex implements TensorField<Complex> {
     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: 'string'): undefined | string;
     cast(x: Complex, dtype: 'expression'): undefined | BoxedExpression;
     cast(x: Complex[], dtype: 'float64'): undefined | number[];
     cast(x: Complex[], dtype: 'float32'): undefined | number[];
@@ -141,7 +98,6 @@ export declare class TensorFieldComplex implements TensorField<Complex> {
     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: 'string'): undefined | string[];
     cast(x: Complex[], dtype: 'expression'): undefined | BoxedExpression[];
     expression(z: Complex): BoxedExpression;
     isZero(z: Complex): boolean;
@@ -163,6 +119,9 @@ export declare class TensorFieldComplex implements TensorField<Complex> {
  */
 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
  */

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

@@ -1,11 +1,6 @@
-/* 0.29.1 */
-import type { BoxedExpression, ComputeEngine, DataTypeMap, TensorData, TensorDataType } from '../global-types';
-/** @internal */
-export type NestedArray<T> = NestedArray_<T>[];
-/** @internal */
-export type NestedArray_<T> = T | NestedArray_<T>[];
+/* 0.30.1 */
 /** @category Tensors */
-export declare abstract class AbstractTensor<DT extends keyof DataTypeMap> implements TensorData<DT> {
+export declare abstract class AbstractTensor<DT extends keyof DataTypeMap> implements Tensor<DT> {
     private ce;
     /**
      * Return a tuple of tensors that have the same dtype.
@@ -72,6 +67,7 @@ export declare abstract class AbstractTensor<DT extends keyof DataTypeMap> imple
      * 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 first and second axis */
@@ -94,10 +90,4 @@ export declare abstract class AbstractTensor<DT extends keyof DataTypeMap> imple
     equals(rhs: AbstractTensor<DT>): boolean;
 }
 /** @category Tensors */
-export declare function makeTensor<T extends TensorDataType>(ce: ComputeEngine, data: TensorData<T> | {
-    operator: string;
-    ops: BoxedExpression[];
-    dtype: T;
-    shape: number[];
-}): AbstractTensor<T>;
-export { TensorData };
+export declare function makeTensor<T extends TensorDataType>(ce: ComputeEngine, data: TensorData<T>): AbstractTensor<T>;

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

@@ -1,11 +1,8 @@
-/* 0.29.1 */
+/* 0.30.1 */
 export * from '../math-json/types';
 export * from '../common/type/boxed-type';
 export * from '../common/type/types';
 export type * from './latex-syntax/types';
-export * from './latex-syntax/dictionary/definitions';
 export * from './numerics/types';
 export * from './numeric-value/types';
-export * from './tensor/tensors';
-export * from './tensor/tensor-fields';
 export * from './global-types';

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

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

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

@@ -0,0 +1,11 @@
+/* 0.30.1 */
+ * 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

@@ -1,4 +1,8 @@
-/* 0.29.1 */
+/* 0.30.1 */
+ * 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 */
@@ -56,7 +60,7 @@ export type MathJsonAttributes = {
     sourceOffsets?: [start: number, end: number];
 };
 /** @category MathJSON */
-export type MathJsonIdentifier = string;
+export type MathJsonSymbol = string;
 /**
  * A MathJSON numeric quantity.
  *
@@ -69,7 +73,7 @@ export type MathJsonIdentifier = string;
  * - 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 value `NaN`, `-Infinity` and `+Infinity` to
+ * 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
@@ -82,25 +86,29 @@ export type MathJsonIdentifier = string;
  * - `123456789123456789.123(4567)e999`
  * @category MathJSON
  */
-export type MathJsonNumber = {
+export type MathJsonNumberObject = {
     num: 'NaN' | '-Infinity' | '+Infinity' | string;
 } & MathJsonAttributes;
 /** @category MathJSON */
-export type MathJsonSymbol = {
-    sym: MathJsonIdentifier;
+export type MathJsonSymbolObject = {
+    sym: MathJsonSymbol;
 } & MathJsonAttributes;
 /** @category MathJSON */
-export type MathJsonString = {
+export type MathJsonStringObject = {
     str: string;
 } & MathJsonAttributes;
 /** @category MathJSON */
-export type MathJsonFunction = {
-    fn: [MathJsonIdentifier, ...Expression[]];
+export type MathJsonFunctionObject = {
+    fn: [MathJsonSymbol, ...Expression[]];
+} & MathJsonAttributes;
+/** @category MathJSON */
+export type MathJsonDictionaryObject = {
+    dict: Record<string, Expression>;
 } & MathJsonAttributes;
 /**
  * @category MathJSON
  */
-export type ExpressionObject = MathJsonNumber | MathJsonString | MathJsonSymbol | MathJsonFunction;
+export type ExpressionObject = MathJsonNumberObject | MathJsonStringObject | MathJsonSymbolObject | MathJsonFunctionObject | MathJsonDictionaryObject;
 /**
  * A MathJSON expression is a recursive data structure.
  *
@@ -109,4 +117,4 @@ export type ExpressionObject = MathJsonNumber | MathJsonString | MathJsonSymbol
  *
  * @category MathJSON
  */
-export type Expression = ExpressionObject | number | MathJsonIdentifier | string | readonly [MathJsonIdentifier, ...Expression[]];
+export type Expression = ExpressionObject | number | MathJsonSymbol | string | readonly [MathJsonSymbol, ...Expression[]];

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

@@ -1,10 +1,11 @@
-/* 0.29.1 */
+/* 0.30.1 */
 export declare const MISSING: Expression;
-export declare function isNumberExpression(expr: Expression | null): expr is number | string | MathJsonNumber;
-export declare function isNumberObject(expr: Expression | null): expr is MathJsonNumber;
-export declare function isSymbolObject(expr: Expression | null): expr is MathJsonSymbol;
-export declare function isStringObject(expr: Expression | null): expr is MathJsonString;
-export declare function isFunctionObject(expr: Expression | null): expr is MathJsonFunction;
+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;
 /**  If expr is a string literal, return it.
  *
  * A string literal is a JSON string that begins and ends with
@@ -13,14 +14,14 @@ export declare function isFunctionObject(expr: Expression | null): expr is MathJ
 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 an identifier
+ * 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): MathJsonIdentifier;
+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.
@@ -31,7 +32,7 @@ export declare function operand(expr: Expression | null, n: 1 | 2 | 3): Expressi
 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 | Record<string, Expression>;
+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
@@ -51,6 +52,9 @@ export declare function machineValue(expr: Expression | null | undefined): numbe
  * 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;
@@ -70,3 +74,8 @@ export declare function isEmptySequence(expr: Expression | null | undefined): ex
 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

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

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.29.1",
+  "version": "0.30.1",
   "scripts": {
     "doc": "bash ./scripts/doc.sh",
     "build": "bash ./scripts/build.sh",
@@ -43,13 +43,15 @@
   "exports": {
     ".": {
       "types": "./dist/types/compute-engine.d.ts",
-      "require": "./dist/compute-engine.min.cjs",
+      "browser": "./dist/compute-engine.min.umd.js",
       "import": "./dist/compute-engine.min.esm.js",
-      "default": "./dist/compute-engine.min.cjs"
+      "require": "./dist/compute-engine.min.umd.js",
+      "default": "./dist/compute-engine.min.esm.js"
     }
   },
-  "main": "./dist/compute-engine.min.cjs",
+  "main": "./dist/compute-engine.min.umd.js",
   "module": "./dist/compute-engine.min.esm.js",
+  "browser": "./dist/compute-engine.min.umd.js",
   "types": "./dist/types/compute-engine.d.ts",
   "engines": {
     "npm": ">=10.5.0",
@@ -59,14 +61,14 @@
     "@cortex-js/prettier-config": "^1.2.0",
     "@jest/console": "^29.7.0",
     "@types/jest": "^29.5.5",
-    "@types/node": "^20.6.3",
+    "@types/node": "^24.0.13",
     "@typescript-eslint/eslint-plugin": "^7.14.1",
     "@typescript-eslint/parser": "^7.14.1",
     "@typescript-eslint/typescript-estree": "^7.14.1",
     "chalk": "^5.3.0",
     "check-node-version": "^4.2.1",
     "concat-md": "^0.5.1",
-    "esbuild": "^0.24.0",
+    "esbuild": "^0.25.6",
     "eslint": "^8.56.0",
     "eslint-config-prettier": "^9.0.0",
     "eslint-plugin-import": "^2.28.1",
@@ -74,21 +76,21 @@
     "eslint-plugin-prettier": "^5.0.0",
     "jest": "^29.7.0",
     "jest-silent-reporter": "^0.6.0",
-    "open": "^10.1.0",
-    "prettier": "^3.0.3",
+    "open": "^10.1.2",
+    "prettier": "^3.6.2",
     "prettier-2": "npm:prettier@^2",
     "serve-http": "^1.0.7",
-    "ts-jest": "^29.1.1",
+    "ts-jest": "^29.4.0",
     "ts-node": "^10.9.1",
     "typedoc": "^0.27.6",
     "typedoc-plugin-markdown": "^4.4.1",
     "typedoc-plugin-no-inherit": "^1.5.0",
-    "typescript": "^5.2.2",
+    "typescript": "^5.8.3",
     "update-notifier": "^7.0.0"
   },
   "prettier": "@cortex-js/prettier-config",
   "dependencies": {
     "complex-esm": "^2.1.1-esm1",
-    "decimal.js": "^10.4.3"
+    "decimal.js": "^10.6.0"
   }
 }