@cortex-js/compute-engine 0.20.2 → 0.22.0

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

@@ -1,13 +1,14 @@
-/* 0.20.2 */
+/* 0.22.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, DomainLiteral } 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, ArrayValue, CanonicalForm } from './public';
 /**
  *
- * To use the CortexJS Compute Engine, create a `ComputeEngine` instance.
+ * To use the CortexJS Compute Engine, create a `ComputeEngine` instance, or if using a
+ * mathfield, use the default Compute Engine instance from the `MathfieldElement` class: `ce = MathfieldElement.computeEngine`.
  *
- * Use the instance to create expressions with `ce.parse()` and `ce.box()`.
+ * Use the instance to create boxed expressions with `ce.parse()` and `ce.box()`.
  *
  *
  * ```ts
@@ -19,7 +20,6 @@ import { AssumeResult, BoxedExpression, BoxedFunctionDefinition, BoxedSymbolDefi
  * expr = ce.box(["Expand", ["Power", ["Add", "a", "b"], 2]]);
  * console.log(expr.evaluate().latex);
  * // ➔ "a^2 +  2ab + b^2"
- *
  * ```
  */
 export declare class ComputeEngine implements IComputeEngine {
@@ -82,12 +82,6 @@ export declare class ComputeEngine implements IComputeEngine {
      * @internal */
     private _useRawJsonSerializationOptions;
     private _rawJsonSerializationOptions;
-    /** The domain of unknown symbols. If `null` unknown symbols do not have a
-     * definition automatically associated with them.
-     *
-     *  @internal
-     */
-    private _defaultDomain;
     /** @internal */
     private _commonSymbols;
     /** @internal */
@@ -106,6 +100,13 @@ export declare class ComputeEngine implements IComputeEngine {
      *
      */
     context: RuntimeScope | null;
+    /** In strict mode (the default) the Compute Engine performs
+     * validation of domains and signature and may report errors.
+     *
+     * When strict mode is off, results may be incorrect or generate JavaScript
+     * errors if the input is not valid.
+     *
+     */
     strict: boolean;
     /** Absolute time beyond which evaluation should not proceed.
      * @internal
@@ -205,7 +206,102 @@ export declare class ComputeEngine implements IComputeEngine {
     chop(n: number): number;
     chop(n: Decimal): Decimal | 0;
     chop(n: Complex): Complex | 0;
+    /** Create an arbitrary precision number.
+     *
+     * The return value is an object with methods to perform arithmetic
+     * operations:
+     * - `toNumber()`: convert to a JavaScript `number` with potential loss of precision
+     * - `add()`
+     * - `sub()`
+     * - `neg()` (unary minus)
+     * - `mul()`
+     * - `div()`
+     * - `pow()`
+     * - `sqrt()` (square root)
+     * - `cbrt()` (cube root)
+     * - `exp()`  (e^x)
+     * - `log()`
+     * - `ln()` (natural logarithm)
+     * - `mod()`
+  
+     * - `abs()`
+     * - `ceil()`
+     * - `floor()`
+     * - `round()`
+  
+     * - `equals()`
+     * - `gt()`
+     * - `gte()`
+     * - `lt()`
+     * - `lte()`
+     *
+     * - `cos()`
+     * - `sin()`
+     * - `tanh()`
+     * - `acos()`
+     * - `asin()`
+     * - `atan()`
+     * - `cosh()`
+     * - `sinh()`
+     * - `acosh()`
+     * - `asinh()`
+     * - `atanh()`
+     *
+     * - `isFinite()`
+     * - `isInteger()`
+     * - `isNaN()`
+     * - `isNegative()`
+     * - `isPositive()`
+     * - `isZero()`
+     * - `sign()` (1, 0 or -1)
+     *
+     */
     bignum(a: Decimal.Value | bigint): Decimal;
+    /** Create a complex number.
+     * The return value is an object with methods to perform arithmetic
+     * operations:
+     * - `re` (real part, as a JavaScript `number`)
+     * - `im` (imaginary part, as a JavaScript `number`)
+     * - `add()`
+     * - `sub()`
+     * - `neg()` (unary minus)
+     * - `mul()`
+     * - `div()`
+     * - `pow()`
+     * - `sqrt()` (square root)
+     * - `exp()`  (e^x)
+     * - `log()`
+     * - `ln()` (natural logarithm)
+     * - `mod()`
+  
+     * - `abs()`
+     * - `ceil()`
+     * - `floor()`
+     * - `round()`
+  
+     * - `arg()` the angle of the complex number
+     * - `inverse()` the inverse of the complex number 1/z
+     * - `conjugate()` the conjugate of the complex number
+  
+     * - `equals()`
+     *
+     * - `cos()`
+     * - `sin()`
+     * - `tanh()`
+     * - `acos()`
+     * - `asin()`
+     * - `atan()`
+     * - `cosh()`
+     * - `sinh()`
+     * - `acosh()`
+     * - `asinh()`
+     * - `atanh()`
+     *
+     * - `isFinite()`
+     * - `isNaN()`
+     * - `isZero()`
+     * - `sign()` (1, 0 or -1)
+     */
     complex(a: number | Decimal | Complex, b?: number | Decimal): Complex;
     isBignum(a: unknown): a is Decimal;
     isComplex(a: unknown): a is Complex;
@@ -230,10 +326,26 @@ export declare class ComputeEngine implements IComputeEngine {
      */
     lookupFunction(head: string | BoxedExpression, scope?: RuntimeScope | null): undefined | BoxedFunctionDefinition;
     /**
-     * Add (or replace) a definition for a symbol in the current scope.
+     * Associate a new definition to a symbol in the current context.
+     *
+     * If a definition existed previously, it is replaced.
+     *
+     *
+     * For internal use. Use `ce.declare()` instead.
+     *
+     * @internal
      */
     defineSymbol(name: string, def: SymbolDefinition): BoxedSymbolDefinition;
     _defineSymbol(name: string, def: SymbolDefinition): BoxedSymbolDefinition;
+    /**
+     * Associate a new delookupSymbolfinition to a function in the current context.
+     *
+     * If a definition existed previously, it is replaced.
+     *
+     * For internal use. Use `ce.declare()` instead.
+     *
+     * @internal
+     */
     defineFunction(name: string, def: FunctionDefinition): BoxedFunctionDefinition;
     _defineFunction(name: string, def: FunctionDefinition): BoxedFunctionDefinition;
     /**
@@ -245,38 +357,57 @@ export declare class ComputeEngine implements IComputeEngine {
      *
      *
      */
-    pushScope(scope?: Partial<Scope>): IComputeEngine;
-    /** Remove the topmost scope from the scope stack.
-     */
-    popScope(): IComputeEngine;
+    pushScope(scope?: Partial<Scope>): ComputeEngine;
+    /** Remove the most recent scope from the scope stack, and set its
+     *  parent scope as current. */
+    popScope(): ComputeEngine;
+    /** Set the current scope, return the previous scope. */
     swapScope(scope: RuntimeScope | null): RuntimeScope | null;
+    /**
+     * Reset the value of any identifiers that have been assigned a value
+     * in the current scope.
+     * @internal */
     resetContext(): void;
+    /** @internal */
     _printScope(options?: {
         details?: boolean;
         maxDepth?: number;
     }, scope?: RuntimeScope | null, depth?: number): RuntimeScope | null;
     /**
-     * Declare one or more identifiers:
+     * Declare an identifier: specify their domain, and other attributes,
+     * including optionally a value.
+     *
+     * Once the domain of an identifier has been declared, it cannot be changed.
+     * The domain information is used to calculate the canonical form of
+     * expressions and ensure they are valid. If the domain could be changed
+     * after the fact, previously valid expressions could become invalid.
+     *
+     * Use the `Anyting` domain for a very generic domain.
      *
-     * associate an identifier with a definition, at minimum a domain, optionally
-     * a value and some other flags.
      */
-    declare(id: string, def: BoxedDomain | DomainExpression | SymbolDefinition | FunctionDefinition): IComputeEngine;
+    declare(id: string, def: BoxedDomain | DomainExpression | SymbolDefinition | FunctionDefinition): ComputeEngine;
     declare(identifiers: {
         [id: string]: BoxedDomain | DomainExpression | SymbolDefinition | FunctionDefinition;
-    }): IComputeEngine;
-    /**
-     * Assign a value to one or more identifiers.
+    }): ComputeEngine;
+    /** Assign a value to an identifier in the current scope.
+     * Use `undefined` to reset the identifier to no value.
      *
-     * Domain of value must be compatible with existing domain.
+     * The identifier should be a valid MathJSON identifier
+     * not a LaTeX string.
      *
-     * Declare identifier if it hasn't been declared yet.
+     * The identifier can take the form "f(x, y") to create a function
+     * with two parameters, "x" and "y".
      *
+     * If the id was not previously declared, an automatic declaration
+     * is done. The domain of the identifier is inferred from the value.
+     * To more precisely define the domain of the identifier, use `ce.declare()`
+     * instead, which allows you to specify the domain, value and other
+     * attributes of the identifier.
      */
-    assign(id: string, value: AssignValue): IComputeEngine;
+    assign(id: string, value: AssignValue): ComputeEngine;
     assign(ids: {
         [id: string]: AssignValue;
-    }): IComputeEngine;
+    }): ComputeEngine;
     /**
      * Same as assign(), but for internal use:
      * - skips validity checks
@@ -285,7 +416,7 @@ export declare class ComputeEngine implements IComputeEngine {
      *
      * @internal
      */
-    _assign(id: string, value: AssignValue): IComputeEngine;
+    _assign(id: string, value: AssignValue): ComputeEngine;
     get assumptions(): ExpressionMapInterface<boolean>;
     /**
      * Return false if the execution should stop.
@@ -301,53 +432,143 @@ export declare class ComputeEngine implements IComputeEngine {
     checkContinueExecution(): void;
     /** @internal */
     cache<T>(cacheName: string, build: () => T, purge: (T: any) => T | undefined): T;
+    /**
+     * Return a boxed expression from the input.
+     */
     box(expr: Decimal | Complex | [num: number, denom: number] | SemiBoxedExpression, options?: {
-        canonical?: boolean;
+        canonical?: boolean | CanonicalForm | CanonicalForm[];
     }): BoxedExpression;
     canonical(xs: SemiBoxedExpression[]): BoxedExpression[];
+    /**
+     * Return a function expression.
+     *
+     * Note that the result may not be a function, or may have a different
+     * `head` than the one specified.
+     *
+     * For example:
+     * `ce.fn("Rational", [ce.number(1),  ce.number(2)]))` \( \to \) `ce.number([1,2])`
+     *
+     */
     fn(head: string, ops: BoxedExpression[], options?: {
         canonical: boolean;
     }): BoxedExpression;
     /** @internal */
     _fn(head: string | BoxedExpression, ops: BoxedExpression[], metadata?: Metadata): BoxedExpression;
+    /**
+     *
+     * Shortcut for `this.fn("Error"...)`.
+     *
+     * The result is canonical.
+     */
     error(message: string | [string, ...SemiBoxedExpression[]], where?: SemiBoxedExpression): BoxedExpression;
     domainError(expectedDomain: BoxedDomain | DomainLiteral, actualDomain: undefined | BoxedDomain, where?: SemiBoxedExpression): BoxedExpression;
+    /**
+     * Add a`["Hold"]` wrapper to `expr.
+     */
     hold(expr: SemiBoxedExpression): BoxedExpression;
+    /** Shortcut for `this.fn("Add"...)`.
+     *
+     * The result is canonical.
+     */
     add(ops: BoxedExpression[], metadata?: Metadata): BoxedExpression;
+    /** Shortcut for `this.fn("Negate", [expr])`
+     *
+     * The result is canonical.
+     */
     neg(expr: BoxedExpression, metadata?: Metadata): BoxedExpression;
+    /** Shortcut for `this.fn("Multiply"...)`
+     *
+     * The result is canonical.
+     */
     mul(ops: BoxedExpression[], metadata?: Metadata): BoxedExpression;
+    /** Shortcut for `this.fn("Divide", [num, denom])`
+     *
+     * The result is canonical.
+     */
     div(num: BoxedExpression, denom: BoxedExpression, metadata?: Metadata): BoxedExpression;
-    sqrt(base: BoxedExpression, metadata?: Metadata): BoxedExpression;
+    /** Shortcut for `this.fn("Sqrt"...)`
+     *
+     * The result is canonical.
+     */
+    sqrt(base: BoxedExpression, metadata?: Metadata): any;
+    /** Shortcut for `this.fn("Power"...)`
+     *
+     * The result is canonical.
+     */
     pow(base: BoxedExpression, exponent: number | Rational | BoxedExpression, metadata?: Metadata): BoxedExpression;
+    /** Shortcut for `this.fn("Divide", [1, expr])`
+     *
+     * The result is canonical.
+     */
     inv(expr: BoxedExpression, metadata?: Metadata): BoxedExpression;
+    /** Shortcut for `this.fn("Pair"...)`
+     *
+     * The result is canonical.
+     */
     pair(first: BoxedExpression, second: BoxedExpression, metadata?: Metadata): BoxedExpression;
+    /** Shortcut for `this.fn("Tuple"...)`
+     *
+     * The result is canonical.
+     */
+    tuple(elements: number[], metadata?: Metadata): BoxedExpression;
     tuple(elements: BoxedExpression[], metadata?: Metadata): BoxedExpression;
+    array(elements: ArrayValue[] | ArrayValue[][], metadata?: Metadata): BoxedExpression;
     string(s: string, metadata?: Metadata): BoxedExpression;
+    /** Return a boxed symbol */
     symbol(name: string, options?: {
         metadata?: Metadata;
         canonical?: boolean;
     }): BoxedExpression;
+    /** Return a canonical boxed domain.
+     *
+     * If the domain is invalid, may return an `["Error"]` expression
+     *
+     */
     domain(domain: BoxedDomain | DomainExpression, metadata?: Metadata): BoxedDomain;
+    /**
+     * This function tries to avoid creating a boxed number if `num` corresponds
+     * to a common value for which we have a shared instance (-1, 0, NaN, etc...)
+     */
     number(value: number | bigint | string | MathJsonNumber | Decimal | Complex | Rational, options?: {
         canonical?: boolean;
         metadata?: Metadata;
     }): BoxedExpression;
     rules(rules: Rule[]): BoxedRuleSet;
     pattern(expr: LatexString | SemiBoxedExpression): Pattern;
+    /**
+     * Parse a string of LaTeX and return a corresponding `BoxedExpression`.
+     *
+     * The result may not be canonical.
+     *
+     */
     parse(latex: LatexString | string, options?: {
-        canonical?: boolean;
+        canonical?: boolean | CanonicalForm | CanonicalForm[];
     }): BoxedExpression;
     parse(s: null, options?: {
-        canonical?: boolean;
+        canonical?: boolean | CanonicalForm | CanonicalForm[];
     }): null;
     parse(latex: LatexString | string | null, options?: {
-        canonical?: boolean;
+        canonical?: boolean | CanonicalForm | CanonicalForm[];
     }): null | BoxedExpression;
+    /** Serialize a `BoxedExpression` or a `MathJSON` expression to
+     * a LaTeX string
+     */
     serialize(x: Expression | BoxedExpression, options?: {
         canonical?: boolean;
     }): string;
+    /**
+     * Options to control the serialization of MathJSON expression to LaTeX
+     * when using `this.latex` or `this.engine.serialize()`.
+     *
+     *
+     * {@inheritDoc  NumberFormattingOptions}
+     * {@inheritDoc  ParseLatexOptions}
+     * {@inheritDoc  SerializeLatexOptions}
+     *
+     */
     get latexOptions(): NumberFormattingOptions & ParseLatexOptions & SerializeLatexOptions;
     set latexOptions(opts: Partial<NumberFormattingOptions> & Partial<ParseLatexOptions> & Partial<SerializeLatexOptions>);
+    /** {@inheritDoc  JsonSerializationOptions} */
     get jsonSerializationOptions(): Readonly<JsonSerializationOptions>;
     set jsonSerializationOptions(val: Partial<JsonSerializationOptions>);
     rawJson(expr: BoxedExpression): Expression;
@@ -366,6 +587,22 @@ export declare class ComputeEngine implements IComputeEngine {
      *
      */
     verify(_query: SemiBoxedExpression): boolean;
+    /**
+     * Add an assumption.
+     *
+     * Note that the assumption is put into canonical form before being added.
+     *
+     * @param symbol - The symbol to make an assumption about
+     *
+     * Returns:
+     * - `contradiction` if the new assumption is incompatible with previous
+     * ones.
+     * - `tautology` if the new assumption is redundant with previous ones.
+     * - `ok` if the assumption was successfully added to the assumption set.
+     *
+     *
+     */
     assume(predicate: SemiBoxedExpression): AssumeResult;
+    /** Remove all assumptions about one or more symbols */
     forget(symbol: undefined | string | string[]): void;
 }

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

@@ -1,3 +1,3 @@
-/* 0.20.2 */
+/* 0.22.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,4 +1,4 @@
-/* 0.20.2 */
+/* 0.22.0 */
 import { Decimal } from 'decimal.js';
 import { BoxedDomain, BoxedFunctionSignature, DomainLiteral, FunctionSignature, IComputeEngine, Rational } from './public';
 /**

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

@@ -1,4 +1,4 @@
-/* 0.20.2 */
+/* 0.22.0 */
 /***
  * ## THEORY OF OPERATIONS
  *

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

@@ -1,2 +1,2 @@
-/* 0.20.2 */
+/* 0.22.0 */
 export declare const DEFINITIONS_ALGEBRA: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.20.2 */
+/* 0.22.0 */
 export declare const DEFINITIONS_ARITHMETIC: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.20.2 */
+/* 0.22.0 */
 export declare const DEFINITIONS_CALCULUS: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.20.2 */
+/* 0.22.0 */
 export declare const DEFINITIONS_COMPLEX: LatexDictionary;

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

@@ -1,4 +1,4 @@
-/* 0.20.2 */
+/* 0.22.0 */
 export declare const DEFINITIONS_CORE: LatexDictionary;
 export declare const DELIMITERS_SHORTHAND: {
     '(': string;
@@ -24,3 +24,4 @@ export declare const DELIMITERS_SHORTHAND: {
     '\u23B0': string;
     '\u23B1': string;
 };
+export declare function latexToDelimiterShorthand(s: string): string | undefined;

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

@@ -1,2 +1,2 @@
-/* 0.20.2 */
+/* 0.22.0 */
 export declare const DEFINITIONS_LINEAR_ALGEBRA: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.20.2 */
+/* 0.22.0 */
 export declare const DEFINITIONS_LOGIC: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.20.2 */
+/* 0.22.0 */
 export declare const DEFINITIONS_OTHERS: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/{definitions-inequalities.d.ts → definitions-relational-operators.d.ts}

@@ -1,2 +1,2 @@
-/* 0.20.2 */
+/* 0.22.0 */
 export declare const DEFINITIONS_INEQUALITIES: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.20.2 */
+/* 0.22.0 */
 export declare const DEFINITIONS_SETS: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.20.2 */
+/* 0.22.0 */
 export declare const DEFINITIONS_STATISTICS: LatexDictionary;

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

@@ -1,3 +1,3 @@
-/* 0.20.2 */
+/* 0.22.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.20.2 */
+/* 0.22.0 */
 export declare const DEFINITIONS_TRIGONOMETRY: LatexDictionary;

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

@@ -1,4 +1,4 @@
-/* 0.20.2 */
+/* 0.22.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.20.2 */
+/* 0.22.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.20.2 */
+/* 0.22.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.20.2 */
+/* 0.22.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';
@@ -120,7 +120,7 @@ export declare class _Parser implements Parser {
      */
     parseTabular(): null | Expression[][];
     /** Parse a group as a a string, for example for `\operatorname` or `\begin` */
-    parseStringGroup(): string | null;
+    parseStringGroup(optional?: boolean): string | null;
     /** Parse an environment: `\begin{env}...\end{end}`
      */
     private parseEnvironment;

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

@@ -1,4 +1,4 @@
-/* 0.20.2 */
+/* 0.22.0 */
 import { Expression } from '../../math-json/math-json-format';
 import type { IComputeEngine } from '../public';
 /**
@@ -578,8 +578,11 @@ export interface Parser {
      *
      * LaTeX commands are typically not allowed inside a string group (for example,
      * `\alpha` would result in an error), but we do not enforce this.
+     *
+     * If `optional` is true, this should be an optional group in square brackets
+     * otherwise it is a regular group in braces.
      */
-    parseStringGroup(): string | null;
+    parseStringGroup(optional?: boolean): string | null;
     /**
      * A symbol can be:
      * - a single-letter identifier: `x`

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

@@ -1,4 +1,4 @@
-/* 0.20.2 */
+/* 0.22.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.20.2 */
+/* 0.22.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.20.2 */
+/* 0.22.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.20.2 */
+/* 0.22.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,4 +1,4 @@
-/* 0.20.2 */
+/* 0.22.0 */
 /** The canonical form of `Add`:
  * - removes `0`
  * - capture complex numbers (a + ib or ai +b)
@@ -7,5 +7,5 @@ export declare function canonicalAdd(ce: IComputeEngine, ops: BoxedExpression[])
 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;
-export declare function evalSummation(ce: IComputeEngine, expr: BoxedExpression, range: BoxedExpression | undefined, mode: 'simplify' | 'N' | 'evaluate'): BoxedExpression | undefined;
+export declare function canonicalSummation(ce: IComputeEngine, body: BoxedExpression, indexingSet: BoxedExpression | undefined): BoxedExpression;
+export declare function evalSummation(ce: IComputeEngine, expr: BoxedExpression, indexingSet: BoxedExpression | undefined, mode: 'simplify' | 'N' | 'evaluate'): BoxedExpression | undefined;

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

@@ -1,4 +1,4 @@
-/* 0.20.2 */
+/* 0.22.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.20.2 */
+/* 0.22.0 */
 /** The canonical form of `Multiply`:
  * - remove `1`
  * - combine literal integers and rationals
@@ -14,5 +14,5 @@
 export declare function canonicalMultiply(ce: IComputeEngine, ops: BoxedExpression[]): BoxedExpression;
 export declare function simplifyMultiply(ce: IComputeEngine, ops: BoxedExpression[]): BoxedExpression;
 export declare function evalMultiply(ce: IComputeEngine, ops: BoxedExpression[], mode?: 'N' | 'evaluate'): BoxedExpression | undefined;
-export declare function canonicalProduct(ce: IComputeEngine, body: BoxedExpression | undefined, range: BoxedExpression | undefined): BoxedExpression;
-export declare function evalMultiplication(ce: IComputeEngine, expr: BoxedExpression, range: BoxedExpression | undefined, mode: 'simplify' | 'evaluate' | 'N'): BoxedExpression | undefined;
+export declare function canonicalProduct(ce: IComputeEngine, body: BoxedExpression | undefined, indexingSet: BoxedExpression | undefined): BoxedExpression;
+export declare function evalMultiplication(ce: IComputeEngine, expr: BoxedExpression, indexingSet: BoxedExpression | undefined, mode: 'simplify' | 'evaluate' | 'N'): BoxedExpression | undefined;