@cortex-js/compute-engine 0.57.0 → 0.59.0

package/dist/types/big-decimal/big-decimal.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
  * BigDecimal: an arbitrary-precision decimal type.
  *
  * Value = significand * 10^exponent

package/dist/types/big-decimal/index.d.ts

@@ -1,2 +1,2 @@
-/* 0.57.0 */
+/* 0.59.0 */
 import './transcendentals';

package/dist/types/big-decimal/transcendentals.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
  * Transcendental / irrational operations for BigDecimal.
  *
  * This module attaches `sqrt()` and `cbrt()` to BigDecimal.prototype

package/dist/types/big-decimal/utils.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
  * Fixed-point BigInt utilities for internal use by transcendental functions.
  *
  * A "fixed-point BigInt" represents a real number as `value = n / scale`,

package/dist/types/common/ansi-codes.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 export declare const DEFAULT_COLOR = "\u001B[39m";
 export declare const DEFAULT_BG = "\u001B[49m";
 export declare const WHITE_BG = "\u001B[47m";

package/dist/types/common/configuration-change.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
     private _listeners;
     private _pending;
     private _version;

package/dist/types/common/fuzzy-string-match.d.ts

@@ -1,2 +1,2 @@
-/* 0.57.0 */
+/* 0.59.0 */
 export declare function fuzzyStringMatch(invalidWord: string, validWords: string[]): string | null;

package/dist/types/common/grapheme-splitter.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 /**
  * Return a string or an array of graphemes.
  *

package/dist/types/common/interruptible.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
     cause: unknown;
     value: T;
     constructor({ message, value, cause, }?: {

package/dist/types/common/one-of.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
     infer Head,
     ...infer Rem
 ] ? MergeTypes<Rem, Res & Head> : Res;

package/dist/types/common/signals.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 export type RuntimeSignalCode = 'timeout' | 'out-of-memory' | 'recursion-depth-exceeded' | 'iteration-limit-exceeded';
 /** @category Error Handling */
 export type SignalCode = RuntimeSignalCode | ('invalid-name' | 'expected-predicate' | 'expected-symbol' | 'operator-requires-one-operand' | 'postfix-operator-requires-one-operand' | 'prefix-operator-requires-one-operand' | 'unbalanced-symbols' | 'expected-argument' | 'unexpected-command' | 'cyclic-definition' | 'invalid-supersets' | 'expected-supersets' | 'unknown-domain' | 'duplicate-wikidata' | 'invalid-dictionary-entry' | 'syntax-error');

package/dist/types/common/type/ast-nodes.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
     kind: string;
     position: number;
     line: number;

package/dist/types/common/type/boxed-type.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 /** @category Type */
 export declare class BoxedType {
     static unknown: BoxedType;

package/dist/types/common/type/lexer.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 export interface Token {
     type: TokenType;
     value: string;

package/dist/types/common/type/parse.d.ts

@@ -1,211 +1,4 @@
-/* 0.57.0 */
-/**
- * BNF grammar for the type parser:
- *
-<type> ::= <union_type>
-         | <function_signature>
-
-<union_type> ::= <intersection_type> ( " | " <intersection_type> )*
-
-<intersection_type> ::= <primary_type_with_negation> ( " & " <primary_type_with_negation> )*
-
-<primary_type_with_negation> ::= ( "!" )? <primary_type>
-
-<primary_type> ::= <group>
-                 | <list_type>
-                 | <tuple_type>
-                 | <record_type>
-                 | <dictionary_type>
-                 | <set_type>
-                 | <collection_type>
-                 | <expression_type>
-                 | <symbol_type>
-                 | <numeric_type>
-                 | <primitive_type>
-                 | <value>
-                 | <type_reference>
-
-<group> ::= "(" <type> ")"
-
-(* --- Function Signatures --- *)
-
-<function_signature> ::= <arguments> " -> " <type>
-
-<arguments> ::= "()"
-              | "(" <argument_list>? ")"
-
-(* Note: The parser enforces a semantic rule: required arguments must come before optional and variadic arguments. *)
-<argument_list> ::= <argument_specifier> ( "," <argument_specifier> )*
-
-<argument_specifier> ::= <named_element> ( "?" | "*" | "+" )?
-
-<named_element> ::= ( <name> ":" )? <type>
-
-<name> ::= <identifier> | <verbatim_string>
-
-
-(* --- Collection-like Types --- *)
-
-<list_type> ::= "list" ( "<" <type> ( "^" <dimensions> )? ">" )?
-              | "vector" ( "<" ( <type> ("^" <dimension_specifier>)? | <dimensions> ) ">" )?
-              | "matrix" ( "<" ( <type> ("^" <dimensions>)? | <dimensions> ) ">" )?
-              | "tensor" ( "<" <type> ">" )?
-
-<dimensions> ::= <dimension_specifier> ( "x" <dimension_specifier> )*
-               | "(" <dimension_specifier> ( "x" <dimension_specifier> )* ")"
-
-<dimension_specifier> ::= <positive_integer_literal> | "?"
-
-<tuple_type> ::= "tuple<" ( <named_element> ( "," <named_element> )* )? ">"
-
-<record_type> ::= "record"
-                | "record<" <record_element> ( "," <record_element> )* ">"
-
-<record_element> ::= <key> ":" <type>
-
-<key> ::= <identifier> | <verbatim_string>
-
-<dictionary_type> ::= "dictionary"
-                    | "dictionary<" <type> ">"
-
-<set_type> ::= "set"
-             | "set<" <type> ">"
-
-<collection_type> ::= ( "collection" | "indexed_collection" ) ( "<" <type> ">" )?
-
-
-(* --- Other Constructed Types --- *)
-
-<expression_type> ::= "expression<" <identifier> ">"
-
-<symbol_type> ::= "symbol<" <identifier> ">"
-
-<numeric_type> ::= <numeric_primitive> "<" <bound> ".." <bound> ">"
-
-<bound> ::= <number_literal> | "-oo" | "oo" | ""
-
-
-(* --- Atomic and Primitive Types --- *)
-
-<type_reference> ::= ( "type" )? <identifier>
-
-<value> ::= <string_literal>
-          | <number_literal>
-          | "true" | "false"
-          | "nan" | "infinity" | "+infinity" | "oo" | "∞" | "+oo" | "+∞"
-          | "-infinity" | "-oo" | "-∞"
-
-<primitive_type> ::= <numeric_primitive>
-                   | "any" | "unknown" | "nothing" | "never" | "error"
-                   | "expression" | "symbol" | "function" | "value"
-                   | "scalar" | "boolean" | "string"
-                   | "collection" | "indexed_collection" | "list" | "tuple"
-                   | "set" | "record" | "dictionary"
-
-<numeric_primitive> ::= "number" | "finite_number" | "complex" | "finite_complex"
-                      | "imaginary" | "real" | "finite_real" | "rational"
-                      | "finite_rational" | "integer" | "finite_integer"
-                      | "non_finite_number"
-
-
-(* --- Terminals (Lexical Tokens) --- *)
-
-<identifier> ::= [a-zA-Z_][a-zA-Z0-9_]*
-
-<verbatim_string> ::= "`" ( [^`] | "\`" | "\\" )* "`"
-
-<positive_integer_literal> ::= [1-9][0-9]*
-
-<number_literal> ::= (* As parsed by the valueParser, including integers, decimals, and scientific notation *)
-
-<string_literal> ::= '"' ( [^"] | '\"' )* '"'
- *
- */
-declare class TypeParser {
-    buffer: string;
-    pos: number;
-    _valueParser: (parser: TypeParser) => any;
-    _typeResolver: TypeResolver;
-    constructor(buffer: string, options?: {
-        valueParser?: (parser: TypeParser) => any;
-        typeResolver?: TypeResolver;
-    });
-    error(...messages: (string | undefined)[]): never;
-    peek(): string;
-    consume(): string;
-    /** Check if the upcoming tokens match s, return false if not, consume otherwise */
-    match(s: string): boolean;
-    /** If the next token don't match `>`, error */
-    expectClosingBracket(): void;
-    /** If a white space is allowed, call before `consume()` or `match()` */
-    skipWhitespace(): void;
-    isEOF(): boolean;
-    parseValue(): Type | null;
-    parseTypeReference(): TypeReference | null;
-    parsePrimitiveType(): Type | null;
-    /**
-     * Arguments are `name: type` or `type` separated by commas.
-     * Arguments can be optional, i.e. `name: type?` or `type?`.
-     * Variadic arguments are `name: type+`, `type+`, `name: type*` or `type*`.
-     */
-    parseArguments(): [
-        required: NamedElement[],
-        optional: NamedElement[],
-        variadic: NamedElement | undefined,
-        variadicMin: 0 | 1 | undefined
-    ];
-    parseFunctionSignature(): Type | null;
-    parsePositiveIntegerLiteral(): number | null;
-    parseOptionalDimension(): number | null;
-    parseDimensions(): number[] | undefined;
-    parseList(): Type | null;
-    /**
-     * Parse the name of a named element, i.e. an identifier followed by a colon.
-     * Does special error handling for optional qualifiers.
-     * */
-    parseName(): string | null;
-    parseVerbatimString(): string | null;
-    /**
-     * A general purpose identifier, used for expresion<>, symbol<>, type references, record keys, etc.
-     *
-     * Not used for arguments (they have special error handling with `parseName()`).
-     */
-    parseIdentifier(): string | null;
-    /** Parse:
-     * - "<identifier>: <type>"
-     * - "<type>"
-     *
-     * Does not parse variadic arguments, i.e. `type+` or `name: type+`.
-     */
-    parseNamedElement(): NamedElement | null;
-    parseTupleElements(): NamedElement[];
-    parseTuple(): Type | null;
-    /** Parse a non-optional group, i.e. "(" <type> ")" */
-    parseGroup(): Type | null;
-    parseSet(): Type | null;
-    parseRecordKeyValue(): [string, Type][];
-    parseRecord(): Type | null;
-    parseDictionary(): Type | null;
-    parseCollection(): Type | null;
-    parseExpression(): Type | null;
-    parseSymbol(): Type | null;
-    /** Parse a constructed numeric type with a range */
-    parseNumericType(): Type | null;
-    parseStringType(): Type | null;
-    parsePrimary(): Type;
-    parseUnexpectedToken(): string | undefined;
-    parseMaybePrimary(): Type | null;
-    parseNegationType(): Type | null;
-    parseIntersectionType(): Type | null;
-    parseUnionType(): Type | null;
-    parseType(): Readonly<Type> | null;
-    /** Parse a type, but return null if there's a problem instead
-     * of throwing.
-     */
-    parseTypeMaybe(): Readonly<Type> | null;
-    parse(): Readonly<Type>;
-}
+/* 0.59.0 */
 export declare function parseType(s: undefined, typeResolver?: TypeResolver): undefined;
 export declare function parseType(s: TypeString | Type, typeResolver?: TypeResolver): Type;
 export declare function parseType(s: TypeString | Type | undefined, typeResolver?: TypeResolver): Type | undefined;
-export { TypeParser };

package/dist/types/common/type/parser.d.ts

@@ -1,6 +1,128 @@
-/* 0.57.0 */
+/* 0.59.0 */
 import { TypeNode } from './ast-nodes';
 import { TypeResolver } from './types';
+/**
+ * BNF grammar for the type parser:
+ *
+<type> ::= <union_type>
+         | <function_signature>
+
+<union_type> ::= <intersection_type> ( " | " <intersection_type> )*
+
+<intersection_type> ::= <primary_type_with_negation> ( " & " <primary_type_with_negation> )*
+
+<primary_type_with_negation> ::= ( "!" )? <primary_type>
+
+<primary_type> ::= <group>
+                 | <list_type>
+                 | <tuple_type>
+                 | <record_type>
+                 | <dictionary_type>
+                 | <set_type>
+                 | <collection_type>
+                 | <expression_type>
+                 | <symbol_type>
+                 | <numeric_type>
+                 | <primitive_type>
+                 | <value>
+                 | <type_reference>
+
+<group> ::= "(" <type> ")"
+
+(* --- Function Signatures --- *)
+
+<function_signature> ::= <arguments> " -> " <type>
+
+<arguments> ::= "()"
+              | "(" <argument_list>? ")"
+
+(* Note: The parser enforces a semantic rule: required arguments must come before optional and variadic arguments. *)
+<argument_list> ::= <argument_specifier> ( "," <argument_specifier> )*
+
+<argument_specifier> ::= <named_element> ( "?" | "*" | "+" )?
+
+<named_element> ::= ( <name> ":" )? <type>
+
+<name> ::= <identifier> | <verbatim_string>
+
+
+(* --- Collection-like Types --- *)
+
+<list_type> ::= "list" ( "<" <type> ( "^" <dimensions> )? ">" )?
+              | "vector" ( "<" ( <type> ("^" <dimension_specifier>)? | <dimensions> ) ">" )?
+              | "matrix" ( "<" ( <type> ("^" <dimensions>)? | <dimensions> ) ">" )?
+              | "tensor" ( "<" <type> ">" )?
+
+<dimensions> ::= <dimension_specifier> ( "x" <dimension_specifier> )*
+               | "(" <dimension_specifier> ( "x" <dimension_specifier> )* ")"
+
+<dimension_specifier> ::= <positive_integer_literal> | "?"
+
+<tuple_type> ::= "tuple<" ( <named_element> ( "," <named_element> )* )? ">"
+
+<record_type> ::= "record"
+                | "record<" <record_element> ( "," <record_element> )* ">"
+
+<record_element> ::= <key> ":" <type>
+
+<key> ::= <identifier> | <verbatim_string>
+
+<dictionary_type> ::= "dictionary"
+                    | "dictionary<" <type> ">"
+
+<set_type> ::= "set"
+             | "set<" <type> ">"
+
+<collection_type> ::= ( "collection" | "indexed_collection" ) ( "<" <type> ">" )?
+
+
+(* --- Other Constructed Types --- *)
+
+<expression_type> ::= "expression<" <identifier> ">"
+
+<symbol_type> ::= "symbol<" <identifier> ">"
+
+<numeric_type> ::= <numeric_primitive> "<" <bound> ".." <bound> ">"
+
+<bound> ::= <number_literal> | "-oo" | "oo" | ""
+
+
+(* --- Atomic and Primitive Types --- *)
+
+<type_reference> ::= ( "type" )? <identifier>
+
+<value> ::= <string_literal>
+          | <number_literal>
+          | "true" | "false"
+          | "nan" | "infinity" | "+infinity" | "oo" | "∞" | "+oo" | "+∞"
+          | "-infinity" | "-oo" | "-∞"
+
+<primitive_type> ::= <numeric_primitive>
+                   | "any" | "unknown" | "nothing" | "never" | "error"
+                   | "expression" | "symbol" | "function" | "value"
+                   | "scalar" | "boolean" | "string"
+                   | "collection" | "indexed_collection" | "list" | "tuple"
+                   | "set" | "record" | "dictionary"
+
+<numeric_primitive> ::= "number" | "finite_number" | "complex" | "finite_complex"
+                      | "imaginary" | "real" | "finite_real" | "rational"
+                      | "finite_rational" | "integer" | "finite_integer"
+                      | "non_finite_number"
+
+
+(* --- Terminals (Lexical Tokens) --- *)
+
+<identifier> ::= [a-zA-Z_][a-zA-Z0-9_]*
+
+<verbatim_string> ::= "`" ( [^`] | "\`" | "\\" )* "`"
+
+<positive_integer_literal> ::= [1-9][0-9]*
+
+<number_literal> ::= (* As parsed by the valueParser, including integers, decimals, and scientific notation *)
+
+<string_literal> ::= '"' ( [^"] | '\"' )* '"'
+ *
+ */
 export declare class Parser {
     private lexer;
     private typeResolver;
@@ -36,7 +158,7 @@ export declare class Parser {
     private parseTensorType;
     private parseDimensions;
     private parseDimension;
-    private parseDimensionWithX;
+    private parseCaretDimensions;
     private parseTupleType;
     private parseRecordType;
     private parseRecordEntry;

package/dist/types/common/type/primitive.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 /** All the types representing numeric values */
 export declare const NUMERIC_TYPES: NumericPrimitiveType[];
 export declare const INDEXED_COLLECTION_TYPES: PrimitiveType[];
@@ -7,5 +7,9 @@ export declare const SCALAR_TYPES: PrimitiveType[];
 export declare const VALUE_TYPES: PrimitiveType[];
 export declare const EXPRESSION_TYPES: PrimitiveType[];
 export declare const PRIMITIVE_TYPES: PrimitiveType[];
+export declare const NUMERIC_TYPES_SET: ReadonlySet<NumericPrimitiveType>;
+export declare const COLLECTION_TYPES_SET: ReadonlySet<PrimitiveType>;
+export declare const SCALAR_TYPES_SET: ReadonlySet<PrimitiveType>;
+export declare const PRIMITIVE_TYPES_SET: ReadonlySet<PrimitiveType>;
 export declare function isValidPrimitiveType(s: any): s is PrimitiveType;
 export declare function isValidType(t: any): t is Readonly<Type>;

package/dist/types/common/type/reduce.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 /**
  * Reduce the input type
  *

package/dist/types/common/type/serialize.d.ts

@@ -1,2 +1,2 @@
-/* 0.57.0 */
+/* 0.59.0 */
 export declare function typeToString(type: Type, precedence?: number): string;

package/dist/types/common/type/subtype.d.ts

@@ -1,6 +1,23 @@
-/* 0.57.0 */
+/* 0.59.0 */
 /** Return true if lhs is a subtype of rhs */
 export declare function isPrimitiveSubtype(lhs: PrimitiveType, rhs: PrimitiveType): boolean;
+/**
+ * The *meet* (greatest lower bound) of two primitive types in the primitive
+ * lattice: the maximal primitive types that are subtypes of both `a` and `b`.
+ *
+ * - If `a ⊑ b` (or `b ⊑ a`), the result is `[a]` (resp. `[b]`).
+ * - For incomparable but overlapping types, the result is the set of maximal
+ *   common subtypes, e.g. `meet(integer, finite_real)` = `[finite_integer]`
+ *   (`integer` admits ±∞, so the overlap is the *finite* integers), and
+ *   `meet(real, complex)` = `[finite_real, non_finite_number]` (the lattice
+ *   does not place `real` below `complex`, so the overlap is expressed as a
+ *   union of maximal common subtypes).
+ * - For disjoint types (e.g. `meet(string, integer)`), the result is `[]`.
+ *
+ * The special types `any`, `unknown`, `never`, `nothing` and `error` must be
+ * handled by the caller (they are not meaningful operands here).
+ */
+export declare function meetPrimitiveTypes(a: PrimitiveType, b: PrimitiveType): PrimitiveType[];
 /** Return true if lhs is a subtype of rhs */
 export declare function isSubtype(lhs: Type | TypeString, rhs: Type | TypeString): boolean;
 export declare function isCompatible(lhs: PrimitiveType, rhs: PrimitiveType, compatibility: TypeCompatibility): boolean;

package/dist/types/common/type/type-builder.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 import { Type, TypeResolver } from './types';
 export declare class TypeBuilder implements ASTVisitor<Type> {
     private typeResolver;

package/dist/types/common/type/types.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
  * A primitive type is a simple type that represents a concrete value.
  *
  * - `any`: the top type

package/dist/types/common/type/utils.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 export { isValidType };
 export { widen, narrow } from './subtype';
 import type { Type, FunctionSignature, TypeString } from './types';

package/dist/types/common/utils.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
  *
  * <!--
  * !@consider?

package/dist/types/compile.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 export { compile } from './compute-engine/compilation/compile-expression';
 export { JavaScriptTarget } from './compute-engine/compilation/javascript-target';
 export { GPUShaderTarget } from './compute-engine/compilation/gpu-target';

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

@@ -1,4 +1,5 @@
-/* 0.57.0 */
+/* 0.59.0 */
+import { type Subject } from './boxed-expression/constraint-subject';
 /**
  * Add an assumption, in the form of a predicate, for example:
  *
@@ -25,20 +26,26 @@
  */
 export declare function assume(proposition: Expression): AssumeResult;
 /**
- * Query assumptions to determine the sign of a symbol.
+ * Query assumptions to determine the sign of a subject.
+ *
+ * The subject may be a bare symbol (pass the symbol name, or a `Subject`
+ * with `part: 'self'`) or a part-extractor of a symbol, e.g.
+ * `{ symbol: 's', part: 're' }` for facts about `Real(s)` (see
+ * `boxed-expression/constraint-subject.ts`).
  *
  * Examines inequality assumptions in the current context to determine
- * if a symbol's sign can be inferred. Assumptions are stored in normalized
- * form (Less or LessEqual with lhs-rhs compared to 0), so:
+ * if the subject's sign can be inferred. Assumptions are stored in
+ * normalized form (Less or LessEqual with lhs-rhs compared to 0), so:
  * - `x > 0` is stored as `Less(-x, 0)` meaning `-x < 0`
  * - `x >= 0` is stored as `LessEqual(-x, 0)` meaning `-x <= 0`
  * - `x < 0` is stored as `Less(x, 0)` meaning `x < 0`
  * - `x <= 0` is stored as `LessEqual(x, 0)` meaning `x <= 0`
+ * - `Re(s) > 1` is stored as `Less(Add(Negate(Real(s)), 1), 0)`
  *
  * @param ce - The compute engine instance
- * @param symbol - The symbol name to query
+ * @param subject - The symbol name or `Subject` to query
  * @returns The inferred sign, or undefined if no relevant assumptions found
  */
-export declare function getSignFromAssumptions(ce: ComputeEngine, symbol: string): Sign | undefined;
+export declare function getSignFromAssumptions(ce: ComputeEngine, subject: string | Subject): Sign | undefined;
 import { getInequalityBoundsFromAssumptions } from './boxed-expression/inequality-bounds';
 export { getInequalityBoundsFromAssumptions };

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

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 import type { MathJsonExpression, MathJsonSymbol } from '../../math-json/types';
 import type { Type, TypeString } from '../../common/type/types';
 import { BoxedType } from '../../common/type/boxed-type';
@@ -199,6 +199,8 @@ export declare abstract class _BoxedExpression implements Expression {
     get isInteger(): boolean | undefined;
     get isRational(): boolean | undefined;
     get isReal(): boolean | undefined;
+    toSignedFunction(): Expression | undefined;
+    getInterval(symbol: string): import("../types-expression").IntervalBounds;
     simplify(_options?: Partial<SimplifyOptions>): Expression;
     evaluate(_options?: Partial<EvaluateOptions>): Expression;
     evaluateAsync(_options?: Partial<EvaluateOptions>): Promise<Expression>;

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

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 import { BigDecimal } from '../../big-decimal';
 import type { Expression } from '../global-types';
 export declare function apply(expr: Expression, fn: (x: number) => number | Complex, bigFn?: (x: BigDecimal) => BigDecimal | Complex | number, complexFn?: (x: Complex) => number | Complex): Expression | undefined;

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

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 import { BoxedType } from '../../common/type/boxed-type';
 import type { Expression, IComputeEngine as ComputeEngine } from '../global-types';
 /**

package/dist/types/compute-engine/boxed-expression/arithmetic-mul-div.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 import { NumericValue } from '../numeric-value/types';
 import type { Rational } from '../numerics/types';
 /**

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

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 import type { Rational } from '../numerics/types';
 export declare function asRadical(expr: Expression): Rational | null;
 /**

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

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 export type AsciiMathSerializer = (expr: Expression, precedence?: number) => string;
 export type AsciiMathOptions = {
     symbols: Record<string, string>;

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

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 import type { FormOption } from '../types-serialization';
 import type { MathJsonSymbol } from '../../math-json/types';
 import { NumericValue } from '../numeric-value/types';

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

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 import { _BoxedExpression } from './abstract-boxed-expression';
 import { BoxedType } from '../../common/type/boxed-type';
 import { DictionaryValue, MathJsonExpression } from '../../math-json/types';

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

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 import type { SimplifyOptions, ReplaceOptions, PatternMatchOptions, Expression, BoxedBaseDefinition, BoxedOperatorDefinition, BoxedRuleSet, BoxedSubstitution, CanonicalOptions, EvaluateOptions, IComputeEngine as ComputeEngine, Metadata, Rule, Sign, Substitution, Scope, BoxedValueDefinition, ExpressionInput, FunctionInterface } from '../global-types';
 import { Type } from '../../common/type/types';
 import { BoxedType } from '../../common/type/boxed-type';