@cortex-js/compute-engine 0.16.0 → 0.18.0

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

@@ -1,8 +1,8 @@
-/* 0.16.0 */
+/* 0.18.0 */
+import { Decimal } from 'decimal.js';
+import { Expression } from '../../math-json/math-json-format';
 import { _BoxedExpression } from './abstract-boxed-expression';
 import { BoxedExpression, BoxedRuleSet, BoxedSymbolDefinition, IComputeEngine, EvaluateOptions, NOptions, ReplaceOptions, SimplifyOptions, Substitution, Metadata, PatternMatchOptions, BoxedDomain, RuntimeScope, BoxedFunctionDefinition, BoxedBaseDefinition, DomainExpression, BoxedSubstitution } from '../public';
-import Complex from 'complex.js';
-import Decimal from 'decimal.js';
 /**
  * BoxedSymbol
  *
@@ -18,7 +18,7 @@ import Decimal from 'decimal.js';
  */
 export declare class BoxedSymbol extends _BoxedExpression {
     private _scope;
-    protected _name: string;
+    protected _id: string;
     private _hash;
     private _def;
     constructor(ce: IComputeEngine, name: string, options?: {
@@ -27,11 +27,15 @@ export declare class BoxedSymbol extends _BoxedExpression {
         def?: BoxedSymbolDefinition | BoxedFunctionDefinition;
     });
     get hash(): number;
-    unbind(): void;
     get isPure(): boolean;
     get json(): Expression;
     get scope(): RuntimeScope | null;
     get isConstant(): boolean;
+    /**
+     * Associate a definition with this symbol
+     */
+    bind(): void;
+    reset(): void;
     get isCanonical(): boolean;
     set isCanonical(val: boolean);
     get canonical(): BoxedExpression;
@@ -49,14 +53,10 @@ export declare class BoxedSymbol extends _BoxedExpression {
      * f(x) => x:integer narrowed from integer to real
      */
     infer(domain: BoxedDomain): boolean;
-    /**
-     * Associate a definition with this symbol, if one is not already available
-     */
-    bind(scope?: RuntimeScope | null): void;
     get value(): BoxedExpression | undefined;
     set value(value: boolean | string | Decimal | Complex | [num: number, denom: number] | BoxedExpression | number | undefined);
-    get domain(): BoxedDomain;
-    set domain(inDomain: BoxedExpression | DomainExpression | BoxedDomain);
+    get domain(): BoxedDomain | undefined;
+    set domain(inDomain: DomainExpression | BoxedDomain);
     get sgn(): -1 | 0 | 1 | undefined | null;
     has(x: string | string[]): boolean;
     isSame(rhs: BoxedExpression): boolean;

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

@@ -1,4 +1,4 @@
-/* 0.16.0 */
+/* 0.18.0 */
 export declare class ExpressionMap<U> implements ExpressionMapInterface<U> {
     readonly _items: Map<BoxedExpression, U>;
     constructor(source?: ExpressionMapInterface<U> | readonly (readonly [BoxedExpression, U])[]);

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

@@ -1,4 +1,4 @@
-/* 0.16.0 */
+/* 0.18.0 */
 export type Order = 'lex' | 'dexlex' | 'grevlex' | 'elim';
 export declare const DEFAULT_COMPLEXITY = 100000;
 /**

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

@@ -1,5 +1,5 @@
-/* 0.16.0 */
-import Decimal from 'decimal.js';
+/* 0.18.0 */
+import { Decimal } from 'decimal.js';
 import { Expression } from '../../math-json/math-json-format';
 import { BoxedExpression, IComputeEngine, Metadata, Rational } from '../public';
 /**

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

@@ -1,4 +1,4 @@
-/* 0.16.0 */
+/* 0.18.0 */
 import { Expression } from '../../math-json/math-json-format';
 import { BoxedExpression, IComputeEngine } from '../public';
 export declare function isLatexString(s: unknown): s is string;

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

@@ -1,19 +1,39 @@
-/* 0.16.0 */
-export declare function validateArgumentCount(ce: IComputeEngine, ops: BoxedExpression[], count: number): BoxedExpression[];
+/* 0.18.0 */
+/**
+ * Check that the number of arguments is as expected.
+ *
+ * Converts the arguments to canonical, and flattens the sequence.
+ */
+export declare function checkArity(ce: IComputeEngine, ops: BoxedExpression[], count: number): BoxedExpression[];
 /**
  * Validation of arguments is normally done by checking the signature of the
  * function vs the arguments of the expression. However, we have a fastpath
  * for some common operations (add, multiply, power, neg, etc...) that bypasses
- * the regular checks. This is its replacements. Since all those fastpath
- * functions are numeric (i.e. have numeric arguments and return a numeric
- * value), we do a simple numeric check of all arguments, and verify we have
- * the number of expected arguments.
+ * the regular checks. This is its replacements.
+ *
+ * Since all those fastpath functions are numeric (i.e. have numeric arguments
+ * and a numeric result), we do a simple numeric check of all arguments, and
+ * verify we have the number of expected arguments.
+ *
+ * Converts the arguments to canonical, and flattens the sequence.
  */
-export declare function validateNumericArgs(ce: IComputeEngine, ops: BoxedExpression[], count?: number): BoxedExpression[];
-/** Return `null` if the `ops` match the sig. Otherwise, return an array
- * of expressions indicating the mismatched arguments.
+export declare function checkNumericArgs(ce: IComputeEngine, ops: BoxedExpression[], options?: number | {
+    count?: number;
+    flatten?: boolean | string;
+}): BoxedExpression[];
+/**
+ * Check that an argument is of the expected domain.
+ *
+ * Converts the arguments to canonical
+ */
+export declare function checkArg(ce: IComputeEngine, arg: BoxedExpression | undefined | null, dom: BoxedDomain | DomainLiteral | undefined): BoxedExpression;
+export declare function checkArgs(ce: IComputeEngine, args: BoxedExpression[], doms: (BoxedDomain | DomainLiteral)[]): BoxedExpression[];
+/**
+ *
+ * If the arguments match the parameters, return null.
+ *
+ * Otherwise return a list of expressions indicating the mismatched
+ * arguments.
  *
  */
-export declare function validateSignature(sig: BoxedDomain, ops: BoxedExpression[], codomain?: BoxedExpression): BoxedExpression[] | null;
-export declare function validateArgument(ce: IComputeEngine, arg: BoxedExpression | undefined, dom: BoxedDomain | DomainLiteral | undefined): BoxedExpression;
-export declare function validateArguments(ce: IComputeEngine, args: BoxedExpression[], doms: (BoxedDomain | DomainLiteral)[]): BoxedExpression[];
+export declare function adjustArguments(ce: IComputeEngine, ops: BoxedExpression[], hold: Hold, params: BoxedDomain[], optParams: BoxedDomain[], restParam: BoxedDomain | null): BoxedExpression[] | null;

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

@@ -1,10 +1,30 @@
-/* 0.16.0 */
+/* 0.18.0 */
+import { BoxedExpression } from './public';
 export type CompiledType = boolean | number | string | object;
+type JSSource = string;
+export type CompiledOperators = Record<MathJsonIdentifier, [
+    op: string,
+    prec: number
+]>;
+export type CompiledFunctions = {
+    [id: MathJsonIdentifier]: string | ((args: BoxedExpression[], compile: (expr: BoxedExpression) => JSSource) => JSSource);
+};
+export type CompileTarget = {
+    operators?: (op: MathJsonIdentifier) => [op: string, prec: number];
+    functions?: (id: MathJsonIdentifier) => string | ((...args: CompiledType[]) => string);
+    var: (id: MathJsonIdentifier) => string | undefined;
+    string: (str: string) => string;
+    number: (n: number) => string;
+    ws: (s?: string) => string;
+    indent: number;
+};
 /** This is an extension of the Function class that allows us to pass
  * a custom scope for "global" functions. */
 export declare class ComputeEngineFunction extends Function {
     private sys;
     constructor(body: any);
 }
+export declare function compileToTarget(expr: BoxedExpression, target: CompileTarget): ((_: Record<string, CompiledType>) => CompiledType) | undefined;
 export declare function compileToJavascript(expr: BoxedExpression): ((_: Record<string, CompiledType>) => CompiledType) | undefined;
-export declare function compile(expr: BoxedExpression, freeVars?: string[], prec?: number): string;
+export declare function compile(expr: BoxedExpression, target: CompileTarget, prec?: number): JSSource;
+export {};

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

@@ -1,8 +1,8 @@
-/* 0.16.0 */
-import { Complex } from 'complex.js';
+/* 0.18.0 */
+import { Decimal } from 'decimal.js';
 import { Expression, MathJsonNumber } from '../math-json/math-json-format';
 import type { LibraryCategory, LatexDictionaryEntry, LatexString, NumberFormattingOptions, ParseLatexOptions, SerializeLatexOptions } from './latex-syntax/public';
-import { AssumeResult, BoxedExpression, BoxedFunctionDefinition, BoxedSymbolDefinition, IComputeEngine, IdentifierDefinitions, ExpressionMapInterface, NumericMode, Pattern, RuntimeScope, Scope, SemiBoxedExpression, SymbolDefinition, BoxedRuleSet, Rule, JsonSerializationOptions, ComputeEngineStats, Metadata, BoxedDomain, DomainExpression, FunctionDefinition, Rational, BoxedSubstitution, AssignValue } from './public';
+import { AssumeResult, BoxedExpression, BoxedFunctionDefinition, BoxedSymbolDefinition, IComputeEngine, IdentifierDefinitions, ExpressionMapInterface, NumericMode, Pattern, RuntimeScope, Scope, SemiBoxedExpression, SymbolDefinition, BoxedRuleSet, Rule, JsonSerializationOptions, ComputeEngineStats, Metadata, BoxedDomain, DomainExpression, FunctionDefinition, Rational, BoxedSubstitution, AssignValue, DomainLiteral } from './public';
 /**
  *
  * To use the CortexJS Compute Engine, create a `ComputeEngine` instance.
@@ -23,24 +23,25 @@ import { AssumeResult, BoxedExpression, BoxedFunctionDefinition, BoxedSymbolDefi
  * ```
  */
 export declare class ComputeEngine implements IComputeEngine {
-    /** @internal */
-    readonly _ZERO: BoxedExpression;
-    /** @internal */
-    readonly _ONE: BoxedExpression;
-    /** @internal */
-    readonly _HALF: BoxedExpression;
-    /** @internal */
-    readonly _NEGATIVE_ONE: BoxedExpression;
-    /** @internal */
-    readonly _I: BoxedExpression;
-    /** @internal */
-    readonly _NAN: BoxedExpression;
-    /** @internal */
-    readonly _POSITIVE_INFINITY: BoxedExpression;
-    /** @internal */
-    readonly _NEGATIVE_INFINITY: BoxedExpression;
-    /** @internal */
-    readonly _COMPLEX_INFINITY: BoxedExpression;
+    readonly Anything: BoxedDomain;
+    readonly Void: BoxedDomain;
+    readonly Strings: BoxedDomain;
+    readonly Booleans: BoxedDomain;
+    readonly Numbers: BoxedDomain;
+    readonly True: BoxedExpression;
+    readonly False: BoxedExpression;
+    readonly Pi: BoxedExpression;
+    readonly E: BoxedExpression;
+    readonly Nothing: BoxedExpression;
+    readonly Zero: BoxedExpression;
+    readonly One: BoxedExpression;
+    readonly Half: BoxedExpression;
+    readonly NegativeOne: BoxedExpression;
+    readonly I: BoxedExpression;
+    readonly NaN: BoxedExpression;
+    readonly PositiveInfinity: BoxedExpression;
+    readonly NegativeInfinity: BoxedExpression;
+    readonly ComplexInfinity: BoxedExpression;
     /** @internal */
     _BIGNUM_NAN: Decimal;
     /** @internal */
@@ -145,16 +146,12 @@ export declare class ComputeEngine implements IComputeEngine {
      * @param options.tolerance If the absolute value of the difference of two
      * numbers is less than `tolerance`, they are considered equal. Used by
      * `chop()` as well.
-     *
-     * @param options.defaultDomain If an unknown symbol is encountered, assume
-     * this is its domain. **Default** `ExtendedRealNumbers`
      */
     constructor(options?: {
         numericMode?: NumericMode;
         numericPrecision?: number;
         ids?: readonly IdentifierDefinitions[];
         tolerance?: number;
-        defaultDomain?: string;
     });
     get latexDictionary(): readonly LatexDictionaryEntry[];
     set latexDictionary(dic: readonly LatexDictionaryEntry[]);
@@ -194,16 +191,6 @@ export declare class ComputeEngine implements IComputeEngine {
     get iterationLimit(): number;
     /** @experimental */
     get recursionLimit(): number;
-    /**
-     * If an unknown symbol is encountered, assume it should
-     * be a variable in this domain.
-     *
-     * If set to `null`, unknown symbols will trigger an error.
-     *
-     * **Default:** `"ExtendedRealNumbers"`
-     */
-    get defaultDomain(): BoxedDomain | null;
-    set defaultDomain(domain: BoxedDomain | string | null);
     /**
      * Values smaller than the tolerance are considered to be zero for the
      * purpose of comparison, i.e. if `|b - a| <= tolerance`, `b` is considered
@@ -263,8 +250,10 @@ export declare class ComputeEngine implements IComputeEngine {
      */
     popScope(): IComputeEngine;
     swapScope(scope: RuntimeScope | null): RuntimeScope | null;
+    resetContext(): void;
     _printScope(options?: {
         details?: boolean;
+        maxDepth?: number;
     }, scope?: RuntimeScope | null, depth?: number): RuntimeScope | null;
     /**
      * Declare one or more identifiers:
@@ -272,9 +261,9 @@ export declare class ComputeEngine implements IComputeEngine {
      * associate an identifier with a definition, at minimum a domain, optionally
      * a value and some other flags.
      */
-    declare(id: string, def: DomainExpression | SymbolDefinition | FunctionDefinition): IComputeEngine;
+    declare(id: string, def: BoxedDomain | DomainExpression | SymbolDefinition | FunctionDefinition): IComputeEngine;
     declare(identifiers: {
-        [id: string]: DomainExpression | SymbolDefinition | FunctionDefinition;
+        [id: string]: BoxedDomain | DomainExpression | SymbolDefinition | FunctionDefinition;
     }): IComputeEngine;
     /**
      * Assign a value to one or more identifiers.
@@ -322,6 +311,7 @@ export declare class ComputeEngine implements IComputeEngine {
     /** @internal */
     _fn(head: string | BoxedExpression, ops: BoxedExpression[], metadata?: Metadata): BoxedExpression;
     error(message: string | [string, ...SemiBoxedExpression[]], where?: SemiBoxedExpression): BoxedExpression;
+    domainError(expectedDomain: BoxedDomain | DomainLiteral, actualDomain: undefined | BoxedDomain, where?: SemiBoxedExpression): BoxedExpression;
     hold(expr: SemiBoxedExpression): BoxedExpression;
     add(ops: BoxedExpression[], metadata?: Metadata): BoxedExpression;
     neg(expr: BoxedExpression, metadata?: Metadata): BoxedExpression;
@@ -337,7 +327,7 @@ export declare class ComputeEngine implements IComputeEngine {
         metadata?: Metadata;
         canonical?: boolean;
     }): BoxedExpression;
-    domain(domain: BoxedExpression | DomainExpression | BoxedDomain, metadata?: Metadata): BoxedDomain;
+    domain(domain: BoxedDomain | DomainExpression, metadata?: Metadata): BoxedDomain;
     number(value: number | bigint | string | MathJsonNumber | Decimal | Complex | Rational, options?: {
         canonical?: boolean;
         metadata?: Metadata;

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

@@ -1,3 +1,3 @@
-/* 0.16.0 */
+/* 0.18.0 */
 export declare function costFunction(expr: BoxedExpression): number;
 export declare const DEFAULT_COST_FUNCTION: typeof costFunction;

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

@@ -1,9 +1,7 @@
-/* 0.16.0 */
+/* 0.18.0 */
 import { Decimal } from 'decimal.js';
-import { DomainLiteral, Rational, SemiBoxedExpression } from './public';
-/** Quickly determine the numeric domain of a number or constant
- * For the symbols, this is a hard-coded optimization that doesn't rely on the
- * dictionaries. The regular path is in `internalDomain()`
+import { DomainLiteral, Rational } from './public';
+/**
+ * Determine the numeric domain of a number.
  */
 export declare function inferNumericDomain(value: number | Decimal | Complex | Rational): DomainLiteral;
-export declare function inferDomain(expr: SemiBoxedExpression): DomainLiteral;

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

@@ -1,4 +1,44 @@
-/* 0.16.0 */
+/* 0.18.0 */
+/***
+ * ## THEORY OF OPERATIONS
+ *
+ * A `["Function"]` expression has its own scope.
+ * This scope includes the parameters and local variables.
+ *
+ * Some expressions with anonymous parameters (e.g. `["Add", "_", 1]`)
+ * are rewritten to a `["Function"]` expression with anonymous parameters
+ * (e.g. `["Function", ["Add", "_", 1], "_"]`).
+ *
+ * The **body** of a `["Function"]` expression may have its own scope
+ * (for example if it's a `["Block"]` expression) or may not have a scope
+ * at all (if it's a number, i.e. `["Function", 1]`). the function body may
+ * be a number, a symbol or (more commonly) an function expression.
+ *
+ *
+ * ### DURING BOXING (in makeLambda())
+ *
+ * During the boxing/canonicalization phase of a function
+ * (`["Function"]` expression or head expression):
+ *
+ * 1/ If not a `["Function"]` expression, the expression is rewritten
+ *    to a `["Function"]` expression with anonymous parameters
+ * 2/ A new scope is created
+ * 3/ The function parameters are declared in the scope
+ * 4/ The function body is boxed in the context of the scope and the scope
+ *    is associated with the function
+ *
+ *
+ * ### DURING EVALUATION (executing the result of makeLambda())
+ *
+ * 1/ The arguments are evaluated in the current scope
+ * 2/ The context is swapped to the function scope
+ * 3/ The values of all the ids in this scope are reset
+ * 4/ The parameters are set to the value of the arguments
+ * 5/ The function body is evaluated in the context of the function scope
+ * 6/ The context is swapped back to the current scope
+ * 7/ The result of the function body is returned
+ *
+ */
 /**
  * From an expression, create an iterator that can be used
  * to enumerate values.

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-algebra.d.ts

@@ -1,2 +1,2 @@
-/* 0.16.0 */
+/* 0.18.0 */
 export declare const DEFINITIONS_ALGEBRA: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-arithmetic.d.ts

@@ -1,2 +1,2 @@
-/* 0.16.0 */
+/* 0.18.0 */
 export declare const DEFINITIONS_ARITHMETIC: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-calculus.d.ts

@@ -1,2 +1,2 @@
-/* 0.16.0 */
+/* 0.18.0 */
 export declare const DEFINITIONS_CALCULUS: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-complex.d.ts

@@ -1,2 +1,2 @@
-/* 0.16.0 */
+/* 0.18.0 */
 export declare const DEFINITIONS_COMPLEX: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-core.d.ts

@@ -1,2 +1,2 @@
-/* 0.16.0 */
+/* 0.18.0 */
 export declare const DEFINITIONS_CORE: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-inequalities.d.ts

@@ -1,2 +1,2 @@
-/* 0.16.0 */
+/* 0.18.0 */
 export declare const DEFINITIONS_INEQUALITIES: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-logic.d.ts

@@ -1,2 +1,2 @@
-/* 0.16.0 */
+/* 0.18.0 */
 export declare const DEFINITIONS_LOGIC: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-other.d.ts

@@ -1,2 +1,2 @@
-/* 0.16.0 */
+/* 0.18.0 */
 export declare const DEFINITIONS_OTHERS: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-sets.d.ts

@@ -1,2 +1,2 @@
-/* 0.16.0 */
+/* 0.18.0 */
 export declare const DEFINITIONS_SETS: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-statistics.d.ts

@@ -1,2 +1,2 @@
-/* 0.16.0 */
+/* 0.18.0 */
 export declare const DEFINITIONS_STATISTICS: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-symbols.d.ts

@@ -1,3 +1,3 @@
-/* 0.16.0 */
+/* 0.18.0 */
 export declare const SYMBOLS: [string, string, number][];
 export declare const DEFINITIONS_SYMBOLS: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-trigonometry.d.ts

@@ -1,2 +1,2 @@
-/* 0.16.0 */
+/* 0.18.0 */
 export declare const DEFINITIONS_TRIGONOMETRY: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions.d.ts

@@ -1,4 +1,4 @@
-/* 0.16.0 */
+/* 0.18.0 */
 import { WarningSignal } from '../../../common/signals';
 export type CommonEntry = {
     /** Note: a name is required if a serialize handler is provided */

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

@@ -1,4 +1,4 @@
-/* 0.16.0 */
+/* 0.18.0 */
 import { Serializer } from './serializer';
 import { Expression } from '../../math-json/math-json-format';
 import { WarningSignalHandler } from '../../common/signals';

package/dist/types/compute-engine/latex-syntax/parse-identifier.d.ts

@@ -1,4 +1,4 @@
-/* 0.16.0 */
+/* 0.18.0 */
 import { Parser } from './public';
 /** For error handling, if we have a identifier prefix, assume
  * the identifier is invalid (it would have been captured by

package/dist/types/compute-engine/latex-syntax/parse.d.ts

@@ -1,4 +1,4 @@
-/* 0.16.0 */
+/* 0.18.0 */
 import { IndexedLatexDictionary, IndexedLatexDictionaryEntry, IndexedInfixEntry, IndexedPostfixEntry, IndexedPrefixEntry, IndexedSymbolEntry, IndexedExpressionEntry, IndexedFunctionEntry } from './dictionary/definitions';
 import { IComputeEngine } from '../public';
 import { Expression } from '../../math-json/math-json-format';

package/dist/types/compute-engine/latex-syntax/public.d.ts

@@ -1,4 +1,4 @@
-/* 0.16.0 */
+/* 0.18.0 */
 import { Expression } from '../../math-json/math-json-format';
 import type { IComputeEngine } from '../public';
 /**
@@ -29,23 +29,27 @@ export type LibraryCategory = 'algebra' | 'arithmetic' | 'calculus' | 'collectio
  * For example, in `1 + 2 * 3`, the `*` operator has a **higher** precedence
  * than the `+` operator, so it is applied first.
  *
- * The precendence range from 0 to 1000. The larger the number, the higher the
+ * The precedence range from 0 to 1000. The larger the number, the higher the
  * precedence, the more "binding" the operator is.
  *
  * Here are some rough ranges for the precedence:
  *
- * - 800: prefix and postfix operators,
- *        e.g. `\lnot`, `!`, `'`, `\degree`, `++`, etc...
- * - 700: some relational operators: `<`
- * - 600: some binary operators: `\div`
+ * - 800: prefix and postfix operators: `\lnot` etc...
+ *    - `POSTFIX_PRECEDENCE` = 810: `!`, `'`
+ * - 700: some arithmetic operators
+ *    - `EXPONENTIATION_PRECEDENCE` = 700: `^`
+ * - 600: some binary operators
+ *    - `DIVISION_PRECEDENCE` = 600: `\div`
  * - 500: not used
  * - 400: not used
  * - 300: some logic and arithmetic operators:
  *        `\land`, `\lor`, `\times`, etc...
+ *   - `MULTIPLICATION_PRECEDENCE` = 390: `\times`
  * - 200: arithmetic operators, inequalities:
- *        `+`, `-`, `=`, `<`, etc...
- *   - 260: `=`
- *   - 245: `\lt`, `\gt`
+ *   - `ADDITION_PRECEDENCE` = 275: `+` `-`
+ *   - `ARROW_PRECEDENCE` = 270: `\to` `\rightarrow`
+ *   - `ASSIGNMENT_PRECEDENCE` = 260: `:=`
+ *   - `COMPARISON_PRECEDENCE` = 245: `\lt` `\gt`
  *   - 241: `\leq`
  * - 100: not used
  * - 0: `,`, `;`, etc...
@@ -53,7 +57,7 @@ export type LibraryCategory = 'algebra' | 'arithmetic' | 'calculus' | 'collectio
  * Some constants are defined below for common precedence values.
  *
  *
- * Note: MathML defines some operator precendence, but it has some
+ * Note: MathML defines some operator precedence, but it has some
  * issues and inconsistencies. However, whenever possible we adopted the
  * MathML precedence. See https://www.w3.org/TR/2009/WD-MathML3-20090924/appendixc.html
  *
@@ -61,14 +65,14 @@ export type LibraryCategory = 'algebra' | 'arithmetic' | 'calculus' | 'collectio
  * here: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_precedence
  */
 export type Precedence = number;
-export declare const COMPARISON_PRECEDENCE = 245;
-export declare const ASSIGNMENT_PRECEDENCE = 260;
-export declare const ARROW_PRECEDENCE = 270;
-export declare const ADDITION_PRECEDENCE = 275;
-export declare const MULTIPLICATION_PRECEDENCE = 390;
-export declare const DIVISION_PRECEDENCE = 600;
-export declare const EXPONENTIATION_PRECEDENCE = 700;
-export declare const POSTFIX_PRECEDENCE = 810;
+export declare const COMPARISON_PRECEDENCE: Precedence;
+export declare const ASSIGNMENT_PRECEDENCE: Precedence;
+export declare const ARROW_PRECEDENCE: Precedence;
+export declare const ADDITION_PRECEDENCE: Precedence;
+export declare const MULTIPLICATION_PRECEDENCE: Precedence;
+export declare const DIVISION_PRECEDENCE: Precedence;
+export declare const EXPONENTIATION_PRECEDENCE: Precedence;
+export declare const POSTFIX_PRECEDENCE: Precedence;
 /**
  * This indicates a condition under which parsing should stop:
  * - an operator of a precedence higher than specified has been encountered
@@ -297,14 +301,23 @@ export type ParseLatexOptions = {
      */
     parseArgumentsOfUnknownLatexCommands: boolean;
     /**
-     * When a number is encountered, parse it.
+     * When parsing a decimal number (e.g. `3.1415`):
      *
-     * Otherwise, return each token making up the number (minus sign, digits,
-     * decimal marker, etc...).
+     * - `"auto"` or `"decimal"`: if a decimal number parse it as an approximate
+     *   decimal number with a whole part and a fractional part
+     * - `"rational"`: if a decimal number, parse it as an exact rational number
+     *   with a numerator  and a denominator. If not a decimal number, parse
+     *   it as a regular number.
+     * - `"never"`: do not parse numbers, instead return each token making up
+     *  the number (minus sign, digits, decimal marker, etc...).
+     *
+     * Note: if the number includes repeating digits (e.g. `1.33(333)`),
+     * it will be parsed as a decimal number even if this setting is `"rational"`.
+     *
+     * **Default**: `"auto"`
      *
-     * **Default**: `true`
      */
-    parseNumbers: boolean;
+    parseNumbers: 'auto' | 'rational' | 'decimal' | 'never';
     /**
      * This handler is invoked when the parser encounters an identifier
      * that does not have a corresponding entry in the dictionary.

package/dist/types/compute-engine/latex-syntax/serialize-number.d.ts

@@ -1,4 +1,4 @@
-/* 0.16.0 */
+/* 0.18.0 */
 import { NumberFormattingOptions } from './public';
 export declare function serializeNumber(expr: Expression | null, options: NumberFormattingOptions): string;
 /**

package/dist/types/compute-engine/latex-syntax/serializer-style.d.ts

@@ -1,4 +1,4 @@
-/* 0.16.0 */
+/* 0.18.0 */
 export declare function getApplyFunctionStyle(_expr: Expression, _level: number): 'paren' | 'leftright' | 'big' | 'none';
 export declare function getGroupStyle(_expr: Expression, _level: number): 'paren' | 'leftright' | 'big' | 'none';
 export declare function getRootStyle(_expr: Expression | null, level: number): 'radical' | 'quotient' | 'solidus';

package/dist/types/compute-engine/latex-syntax/serializer.d.ts

@@ -1,4 +1,4 @@
-/* 0.16.0 */
+/* 0.18.0 */
 import { WarningSignalHandler } from '../../common/signals';
 import { NumberFormattingOptions, LatexString, SerializeLatexOptions } from './public';
 import { IndexedLatexDictionary, IndexedLatexDictionaryEntry } from './dictionary/definitions';

package/dist/types/compute-engine/latex-syntax/tokenizer.d.ts

@@ -1,4 +1,4 @@
-/* 0.16.0 */
+/* 0.18.0 */
  * ## Reference
  * TeX source code:
  * {@link  http://tug.org/texlive/devsrc/Build/source/texk/web2c/tex.web | Tex.web}

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

@@ -1,10 +1,10 @@
-/* 0.16.0 */
+/* 0.18.0 */
 /** The canonical form of `Add`:
  * - removes `0`
  * - capture complex numbers (a + ib or ai +b)
  * */
 export declare function canonicalAdd(ce: IComputeEngine, ops: BoxedExpression[]): BoxedExpression;
-export declare function domainAdd(_ce: IComputeEngine, args: BoxedDomain[]): BoxedDomain | null;
+export declare function domainAdd(_ce: IComputeEngine, args: (undefined | BoxedDomain)[]): BoxedDomain | null | undefined;
 export declare function simplifyAdd(ce: IComputeEngine, args: BoxedExpression[]): BoxedExpression;
 export declare function evalAdd(ce: IComputeEngine, ops: BoxedExpression[], mode?: 'N' | 'evaluate'): BoxedExpression;
 export declare function canonicalSummation(ce: IComputeEngine, body: BoxedExpression, range: BoxedExpression | undefined): BoxedExpression;

package/dist/types/compute-engine/library/arithmetic-divide.d.ts

@@ -1,4 +1,4 @@
-/* 0.16.0 */
+/* 0.18.0 */
 /**
  * Canonical form of 'Divide' (and 'Rational')
  * - remove denominator of 1

package/dist/types/compute-engine/library/arithmetic-multiply.d.ts

@@ -1,4 +1,4 @@
-/* 0.16.0 */
+/* 0.18.0 */
 /** The canonical form of `Multiply`:
  * - remove `1`
  * - combine literal integers and rationals

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

@@ -1,4 +1,4 @@
-/* 0.16.0 */
+/* 0.18.0 */
 /**
  *
  */