@cortex-js/compute-engine 0.12.3 → 0.12.5

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

@@ -1,4 +1,4 @@
-/* 0.12.3 */
+/* 0.12.5 */
 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

@@ -0,0 +1,15 @@
+/* 0.12.5 */
+import { Parser } from './public';
+/** For error handling, if we have a identifier prefix, assume
+ * the identifier is invalid (it would have been captured by
+ * `mathIdentifier()` otherwise) and return an error expression */
+export declare function matchInvalidIdentifier(parser: Parser): Expression | null;
+/**
+ * Match an identifier. It can be:
+ * - a sequence of emojis: `👍🏻👍🏻👍🏻`
+ * - a single-letter identifier: `a`
+ * - some LaTeX commands: `\alpha`
+ * - a multi-letter identifier with a prefix: `\mathrm{speed}`
+ * - an identifier with modifiers: `\mathrm{\alpha_{12}}` or `\mathit{speed\unicode{"2012}of\unicode{"2012}sound}`
+ */
+export declare function matchIdentifier(parser: Parser): string | null;

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

@@ -1,5 +1,5 @@
-/* 0.12.3 */
-import { IndexedLatexDictionary, InfixEntry, PostfixEntry, PrefixEntry, SymbolEntry } from './dictionary/definitions';
+/* 0.12.5 */
+import { IndexedLatexDictionary, IndexedInfixEntry, IndexedPostfixEntry, IndexedPrefixEntry, IndexedIdentifierEntry } from './dictionary/definitions';
 import { IComputeEngine } from '../public';
 import { Expression } from '../../math-json/math-json-format';
 export declare const DEFAULT_LATEX_NUMBER_OPTIONS: NumberFormattingOptions;
@@ -33,11 +33,10 @@ export declare class _Parser implements Parser {
     /**
      * Return true if
      * - at end of the token stream
-     * - the upcoming tokens match `t.tokens`
      * - the `t.condition` function returns true
      * Note: the `minPrec` condition is not checked. It should be checked separately.
      */
-    atTerminator(t?: Terminator): boolean;
+    atTerminator(t?: Partial<Terminator>): boolean;
     /** True if the current token matches any of the boundaries we are waiting for */
     get atBoundary(): boolean;
     addBoundary(boundary: LatexToken[]): void;
@@ -62,11 +61,11 @@ export declare class _Parser implements Parser {
     lookAhead(): string[];
     /** Return all the definitions that potentially match the tokens ahead */
     peekDefinitions(kind: 'function'): [FunctionEntry, number][] | null;
-    peekDefinitions(kind: 'symbol'): [SymbolEntry, number][] | null;
-    peekDefinitions(kind: 'postfix'): [PostfixEntry, number][] | null;
-    peekDefinitions(kind: 'infix'): [InfixEntry, number][] | null;
-    peekDefinitions(kind: 'prefix'): [PrefixEntry, number][] | null;
-    peekDefinitions(kind: 'operator'): [InfixEntry | PrefixEntry | PostfixEntry, number][] | null;
+    peekDefinitions(kind: 'identifier'): [IndexedIdentifierEntry, number][] | null;
+    peekDefinitions(kind: 'postfix'): [IndexedPostfixEntry, number][] | null;
+    peekDefinitions(kind: 'infix'): [IndexedInfixEntry, number][] | null;
+    peekDefinitions(kind: 'prefix'): [IndexedPrefixEntry, number][] | null;
+    peekDefinitions(kind: 'operator'): [IndexedInfixEntry | IndexedPrefixEntry | IndexedPostfixEntry, number][] | null;
     /** Skip strictly `<space>` tokens.
      * To also skip `{}` see `skipSpace()`.
      * To skip visual space (e.g. `\,`) see `skipVisualSpace()`.
@@ -113,15 +112,21 @@ export declare class _Parser implements Parser {
      * - 'enclosure' : will look for an argument inside an enclosure (open/close fence)
      * - 'implicit': either an expression inside a pair of `()`, or just a product
      *  (i.e. we interpret `\cos 2x + 1` as `\cos(2x) + 1`)
+     *
+     * This returns an array of arguments, or null if there is no match.
      */
-    matchArguments(kind: undefined | '' | 'enclosure' | 'implicit'): Expression[] | null;
+    matchArguments(kind: undefined | '' | 'enclosure' | 'implicit', until?: Terminator): Expression[] | null;
     /**
      * A function can be followed by the following suffixes:
      * - a `\prime`, `\doubleprime`, `'`, `(n)` to indicate a derivative
      * - a subscript to indicate an argument
      * - an argument, optionally inside an enclosure
      */
-    matchFunctionSuffix(): Expression | null;
+    matchFunctionSuffix(id: string): Expression;
+    /** A prime suffix is a sequence of `'`, `\prime` or `\doubleprime`
+     * after a function or in a superscript.
+     */
+    matchPrimeSuffix(): number;
     /** If matches the normalized open delimiter, return the
      * expected closing delimiter.
      *
@@ -143,33 +148,25 @@ export declare class _Parser implements Parser {
      * and finally a closing matching operator.
      */
     matchEnclosure(): Expression | null;
+    matchIdentifier(): string | null;
     /**
-     * Match an identifier. It can be:
-     * - a symbol
-     * - a simple multi-letter identifier: `\mathrm{speed}`
-     * - a complex multi-letter identifier: `\mathrm{\alpha_{12}}` or `\mathit{speed\unicode{"2012}of\unicode{"2012}sound}`
-     * - a command: `\alpha`  @todo
-     */
-    matchIdentifier(): string | Expression | null;
-    /**
-     * A function is a function identifier followed by arguments
-     * - a function with explicit arguments `f(x)`
-     * - a function with explicit arguments `\mathrm{floor}(x)`
-     * - a function name: `\mathrm{floor}`
-     * - a function with implicit arguments: `\cos x` (via a  custom parser)
+     * A function is an identifier followed by arguments
+     * - a single letter identifier with explicit arguments `f(x)`
+     * - a multiletter identifier with explicit arguments `\mathrm{floor}(x)`
+     * - an identifier: `\mathrm{floor}`
+     * - a command with implicit arguments: `\cos x` (via a  custom parser)
      *
      */
-    matchFunction(): Expression | null;
+    matchFunction(until?: Partial<Terminator>): Expression | null;
     /**
-     * A symbol can be:
-     * - a single-letter variable: `x`
-     * - a single LaTeX command: `\pi`
+     * A symbol is an identifier or a custom definition
      */
-    matchSymbol(): Expression | null;
-    matchOptionalLatexArgument(): Expression | null;
-    matchRequiredLatexArgument(excluding?: string[]): Expression | null;
+    matchSymbol(until?: Partial<Terminator>): Expression | null;
+    matchLatexOptionalGroup(): Expression | null;
+    matchSingleAtomArgument(): Expression | null;
+    matchLatexGroup(): Expression | null;
     matchSupsub(lhs: Expression | null): Expression | null;
-    matchPostfix(lhs: Expression | null): Expression | null;
+    matchPostfix(lhs: Expression | null, until?: Partial<Terminator>): Expression | null;
     /** Match a string used as a LaTeX identifier, for example an environment
      * name.
      * Not suitable for general purpose text, e.g. argument of a `\text{}
@@ -208,7 +205,7 @@ export declare class _Parser implements Parser {
      * - x2 -> no
      * => lhs is a number, rhs is a number, but not a literal
      */
-    applyInvisibleOperator(terminator: Terminator, lhs: Expression | null): Expression | null;
+    applyInvisibleOperator(until: Terminator, lhs: Expression | null): Expression | null;
     matchUnexpectedLatexCommand(): Expression | null;
     /**
      * <primary> :=
@@ -220,7 +217,7 @@ export declare class _Parser implements Parser {
      *  <matchfix-op-open> <expression> [<matchfix-op-separator> <expression>] <matchfix-op-close>
      *
      */
-    matchPrimary(): Expression | null;
+    matchPrimary(until?: Partial<Terminator>): Expression | null;
     /**
      *  Parse an expression:
      *

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

@@ -1,4 +1,4 @@
-/* 0.12.3 */
+/* 0.12.5 */
 import { Expression } from '../../math-json/math-json-format';
 import type { IComputeEngine } from '../public';
 /**
@@ -23,7 +23,7 @@ export type LibraryCategory = 'algebra' | 'arithmetic' | 'calculus' | 'collectio
  * This indicates a condition under which parsing should stop:
  * - an operator of a precedence higher than specified has been encountered
  * - the last token has been reached
- * - or if a function is provided, the function returns true;
+ * - or if a condition is provided, the condition returns true;
  */
 export type Terminator = {
     minPrec: number;
@@ -51,13 +51,13 @@ export type Terminator = {
  *
  */
 export type EnvironmentParseHandler = (parser: Parser, reqArgs: Expression[], optArgs: Expression[]) => Expression | null;
-export type SymbolParseHandler = (parser: Parser) => Expression | null;
-export type FunctionParseHandler = (parser: Parser) => Expression | null;
-export type PostfixParseHandler = (parser: Parser, lhs: Expression) => Expression | null;
+export type IdentifierParseHandler = (parser: Parser, until?: Terminator) => Expression | null;
+export type FunctionParseHandler = (parser: Parser, until?: Terminator) => Expression | null;
+export type PostfixParseHandler = (parser: Parser, lhs: Expression, until?: Terminator) => Expression | null;
 export type PrefixParseHandler = (parser: Parser, until: Terminator) => Expression | null;
 export type InfixParseHandler = (parser: Parser, until: Terminator, lhs: Expression) => Expression | null;
 export type MatchfixParseHandler = (parser: Parser, body: Expression) => Expression | null;
-export type ParseHandler = SymbolParseHandler | FunctionParseHandler | EnvironmentParseHandler | PostfixParseHandler | PrefixParseHandler | InfixParseHandler | MatchfixParseHandler;
+export type ParseHandler = IdentifierParseHandler | FunctionParseHandler | EnvironmentParseHandler | PostfixParseHandler | PrefixParseHandler | InfixParseHandler | MatchfixParseHandler;
 export type LatexArgumentType = '{expression}' /** A required math mode expression */ | '[expression]' /** An optional math mode expression */ | '{text}' /** A required expression in text mode */ | '[text]' /** An optional expression in text mode */ | '{unit}' /** A required unit expression, e.g. `3em` */ | '[unit]' /** An optional unit expression, e.g. `3em` */ | '{glue}' /** A required glue expression, e.g. `25 mu plus 3em ` */ | '[glue]' /** An optional glue expression, e.g. `25 mu plus 3em ` */ | '{string}' /** A required text string, terminated by a non-literal token */ | '[string]' /** An optional text string, terminated by a non-literal token */ | '{color}' /** A required color expression, e.g. `red` or `#00ff00` */ | '[color]'; /** An optional color expression, e.g. `red` or `#00ff00` */
 /**
  * Maps a string of LaTeX tokens to a function or symbol and vice-versa.
@@ -74,7 +74,7 @@ export type BaseEntry = {
      * However, an entry with no `name` can be used to define a synonym (for example
      * for the symbol `\varnothing` which is a synonym for `\emptyset`).
      *
-     * If not `parse` handler is provided, only the trigger is used to select this
+     * If no `parse` handler is provided, only the trigger is used to select this
      * entry. Otherwise, if the trigger of the entry matches the current
      * token, the `parse` handler is invoked.
      */
@@ -159,39 +159,26 @@ export type EnvironmentEntry = BaseEntry & {
     kind: 'environment';
     parse: EnvironmentParseHandler;
 };
-export type SymbolEntry = BaseEntry & {
-    kind: 'symbol';
+export type IdentifierEntry = BaseEntry & {
+    kind: 'identifier';
     /** Used for appropriate wrapping (i.e. when to surround it with parens) */
     precedence?: number;
-    parse: Expression | SymbolParseHandler;
+    parse: Expression | IdentifierParseHandler;
 };
+/**
+ * A function has the following form:
+ * - a prefix such as `\mathrm` or `\operatorname`
+ * - a trigger string, such as `gcd`
+ * - some postfix operators such as `\prime`
+ * - an optional list of arguments in an enclosure (parentheses)
+ *
+ * For more complex situations, for example implicit arguments or
+ * inverse functions postfix (i.e. ^{-1}), use a custom parse handler with a
+ * base entry.
+ */
 export type FunctionEntry = BaseEntry & {
     kind: 'function';
-    /**
-     * Indicate if this symbol can be followed by arguments.
-     *
-     * The presence of arguments will indicate that the arguments should be
-     * applied to the symbol. Otherwise, the invisible operator is applied
-     * to the symbol and the arguments.
-     *
-     * If `arguments` is `"group"`:
-     *
-     * "f(x)" -> `["f", "x"]`
-     * "f x" -> `["Multiply", "f", "x"]`
-     *
-     * If `arguments` is `""`:
-     *
-     * "f(x)" -> `["Multiply", "f", "x"]`
-     * "f x" -> `["Multiply", "f", "x"]`
-     *
-     * If `arguments` is `"implicit"` and the symbol is followed either
-     * by a group or by a primary (prefix + symbol + subsupfix + postfix).
-     * Used for trig functions. i.e. `\sin x` vs `\sin(x)`:
-     *
-     * "f(x)" -> `["f", "x"]`
-     * "f x" -> `["f", "x"]`
-     *
-     */
+    trigger: string;
     parse: Expression | FunctionParseHandler;
 };
 /**
@@ -199,11 +186,11 @@ export type FunctionEntry = BaseEntry & {
  */
 export type DefaultEntry = BaseEntry & {
     precedence?: number;
-    parse?: Expression | SymbolParseHandler;
+    parse?: Expression | IdentifierParseHandler;
 };
-export type LatexDictionaryEntry = DefaultEntry | MatchfixEntry | InfixEntry | PostfixEntry | PrefixEntry | SymbolEntry | FunctionEntry | EnvironmentEntry;
+export type LatexDictionaryEntry = DefaultEntry | MatchfixEntry | InfixEntry | PostfixEntry | PrefixEntry | IdentifierEntry | FunctionEntry | EnvironmentEntry;
 /** @internal */
-export declare function isSymbolEntry(entry: LatexDictionaryEntry): entry is SymbolEntry;
+export declare function isIdentifierEntry(entry: LatexDictionaryEntry): entry is IdentifierEntry;
 /** @internal */
 export declare function isFunctionEntry(entry: LatexDictionaryEntry): entry is FunctionEntry;
 /** @internal */
@@ -222,7 +209,8 @@ export type ParseLatexOptions = {
      * This function is invoked when a number is followed by a symbol,
      * an open delimiter or a function.
      *
-     * If this function is set to `null`, the lhs and rhs are joined as a `Sequence`.
+     * If this function is set to `null`, the lhs and rhs are joined as a
+     * `Sequence`.
      *
      * If this function is set to `undefined` it behaves in the following way:
      * - a number followed by a numeric expression is considered as separated
@@ -236,7 +224,7 @@ export type ParseLatexOptions = {
      */
     applyInvisibleOperator: 'auto' | null | ((parser: Parser, lhs: Expression, rhs: Expression) => Expression | null);
     /**
-     * If true, ignore space characters.
+     * If true, ignore space characters in math mode.
      *
      * **Default**: `true`
      *
@@ -261,22 +249,24 @@ export type ParseLatexOptions = {
      */
     parseNumbers: boolean;
     /**
-     * This handler is invoked when the parser encounter a set of tokens
-     * at a position that could be a symbol or function.
+     * This handler is invoked when the parser encounters an identifier
+     * that does not have a corresponding entry in the dictionary.
      *
-     * The `symbol` argument is one or more tokens.
+     * The `identifier` argument is a valid identifier
+     * (see https://cortexjs.io/math-json/#identifiers for the definition of a
+     * valid identifier).
      *
      * The handler can return:
      *
-     * - `symbol` to indicate the string represent a constant or variable.
+     * - `"symbol"`: the identifier is a constant or variable name.
      *
-     * - `function` to indicate the string is a function name. If an apply
-     * function operator (typically, parentheses) follow, parse them as arguments
-     * to the function.
+     * - `"function"`: the identifier is a function name. If an apply
+     * function operator (typically, parentheses) follow, they will be parsed
+     * as arguments to the function.
      *
-     * - `error`, an error condition is raised.
+     * - `"unknown"`: the identifier is not recognized.
      */
-    parseUnknownIdentifier: (symbol: string, parser: Parser) => 'symbol' | 'function' | 'unknown';
+    parseUnknownIdentifier: (identifier: string, parser: Parser) => 'symbol' | 'function' | 'unknown';
     /**
      * If true, the expression will be decorated with the LaTeX
      * fragments corresponding to each elements of the expression.
@@ -454,7 +444,7 @@ export interface Parser {
     /** Return the next token, without advancing the index */
     readonly peek: LatexToken;
     /** Return true if the terminator condition is met */
-    atTerminator(t: Terminator): boolean;
+    atTerminator(t: Terminator | undefined): boolean;
     /** Return an array of string corresponding to tokens ahead.
      * The index is unchanged.
      */
@@ -502,36 +492,42 @@ export interface Parser {
      */
     matchTabular(endName: string): null | Expression[][];
     applyInvisibleOperator(terminator: Terminator, lhs: Expression | null): Expression | null;
-    /** If the next tokens correspond to an optional LaTeX argument,
-     * enclosed with `[` and `]` return the content of the argument
-     * as an expression and advance the index past the closing `]`.
+    /** Some LaTeX commands (but not all) can accept an argument without braces,
+     *  for example `^` , `\sqrt` or `\frac`.
      *
-     * Otherwise, return `null`.
+     * The following tokens are excluded from consideration to fail early when
+     * encountering a likely syntax error, for example `x^(2)` (instead of
+     * `x^{2}`). With `(` in the list of excluded tokens, the match will fail
+     * and the error can be recovered.
+     *
+     * The excluded tokens are `!"#$%&(),/;:?@[]`|~", `\left` and `\bigl`
      */
-    matchOptionalLatexArgument(): Expression | null;
+    matchSingleAtomArgument(): Expression | null;
     /**
-     * Match a required LaTeX argument:
-     * - either enclosed in `{}`
-     * - or a single token (except if token is in `excluding`)
      *
-     * The `excluding` option is useful to fail early when encountering a likely
-     * syntax error, for example `x^(2)` (instead of `x^{2}`). With `(` in the list
-     * of excluded tokens, the match will fail and the error can be recovered.
-     *
-     * If none is provided, `excluding` is `!"#$%&(),/;:?@[]`|~", `\left` and `\bigl`
+     * Match a LaTeX expression enclosed in `[]`
      *
+     * Otherwise, return `null`.
+     */
+    matchLatexOptionalGroup(): Expression | null;
+    /**
+     * Match a LaTeX group enclosed in `{}`
      *
      * Return null if no argument was found
      * Return `['Sequence']` if an empty argument `{}` was found
      */
-    matchRequiredLatexArgument(excluding?: string[]): Expression | null;
+    matchLatexGroup(): Expression | null;
     /**
      * - 'enclosure' : will look for an argument inside an enclosure (an open/close fence)
      * - 'implicit': either an expression inside a pair of `()`, or just a primary
      *    (i.e. we interpret `\cos x + 1` as `\cos(x) + 1`)
      */
-    matchArguments(kind: '' | 'implicit' | 'enclosure'): Expression[] | null;
+    matchArguments(kind: '' | 'implicit' | 'enclosure', until?: Terminator): Expression[] | null;
     matchStringArgument(): string | null;
+    matchPrimeSuffix(): number;
+    /** Parse function 'id' followed optionally by some prefix (primes, etc
+     * and an argument list in an enclosure. */
+    matchFunctionSuffix(id: string): Expression;
     /** If matches the normalized open delimiter, returns the
      * expected closing delimiter.
      *
@@ -578,7 +574,7 @@ export interface Parser {
      * - a single-letter variable: `x`
      * - a single LaTeX command: `\pi`
      */
-    matchSymbol(): Expression | null;
+    matchSymbol(until?: Terminator): Expression | null;
     /**
      * Parse an expression:
      *
@@ -597,6 +593,7 @@ export interface Parser {
      * `until` is `{ minPrec:0 }` by default.
      */
     matchExpression(until?: Partial<Terminator>): Expression | null;
+    latex(start: number, end?: number): string;
     /** Return an error expression with the specified code and arguments */
     error(code: string | [string, ...Expression[]], fromToken: number): Expression;
 }

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

@@ -1,4 +1,4 @@
-/* 0.12.3 */
+/* 0.12.5 */
 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.12.3 */
+/* 0.12.5 */
 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,7 +1,7 @@
-/* 0.12.3 */
+/* 0.12.5 */
 import { WarningSignalHandler } from '../../common/signals';
-import { NumberFormattingOptions, LatexString, SerializeLatexOptions, FunctionEntry } from './public';
-import { IndexedLatexDictionary, SymbolEntry } from './dictionary/definitions';
+import { NumberFormattingOptions, LatexString, SerializeLatexOptions } from './public';
+import { IndexedLatexDictionary, IndexedIdentifierEntry, IndexedFunctionEntry } from './dictionary/definitions';
 export declare class Serializer {
     readonly onError: WarningSignalHandler;
     options: NumberFormattingOptions & SerializeLatexOptions;
@@ -15,14 +15,18 @@ export declare class Serializer {
      * @todo: don't wrap Abs, Floor, Ceil, Delimiter
      */
     wrap(expr: Expression | null, prec?: number): string;
-    /** If this is a "short" expression (atomic), wrap it.
+    /**
+     * If this is a "short" expression, wrap it.
+     * Do not wrap identifiers, positive numbers or functions.
+     *
+     * This is called by the serializer for power and division (i.e. "(a+1)/b")
      *
      */
     wrapShort(expr: Expression | null): string;
     wrapString(s: string, style: 'paren' | 'leftright' | 'big' | 'none', fence?: string): string;
     wrapArguments(expr: Expression): string;
-    serializeSymbol(expr: Expression, def?: SymbolEntry | FunctionEntry): string;
-    serializeFunction(expr: Expression, def?: FunctionEntry | SymbolEntry): string;
+    serializeSymbol(expr: Expression, def?: IndexedIdentifierEntry | IndexedFunctionEntry): string;
+    serializeFunction(expr: Expression, def?: IndexedFunctionEntry | IndexedIdentifierEntry): string;
     serializeDictionary(dict: {
         [key: string]: Expression;
     }): string;

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

@@ -1,4 +1,4 @@
-/* 0.12.3 */
+/* 0.12.5 */
  * ## Reference
  * TeX source code:
  * {@link  http://tug.org/texlive/devsrc/Build/source/texk/web2c/tex.web | Tex.web}
@@ -12,5 +12,6 @@ export type Token = string;
  * marker) and multiple lines.
  */
 export declare function tokenize(s: string, args: string[]): Token[];
+export declare function countTokens(s: string): number;
 export declare function joinLatex(segments: Iterable<string>): string;
 export declare function tokensToString(tokens: Token | Token[] | [Token[] | Token][]): string;

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

@@ -1,11 +1,12 @@
-/* 0.12.3 */
+/* 0.12.5 */
 /** 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 simplifyAdd(ce: IComputeEngine, args: BoxedExpression[]): BoxedExpression | 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, mode: 'simplify' | 'N' | 'evaluate'): BoxedExpression | undefined;
+export declare function normalizeLimits(range: BoxedExpression): [string, number, number, boolean];

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

@@ -1,4 +1,4 @@
-/* 0.12.3 */
+/* 0.12.5 */
 /**
  * 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.12.3 */
+/* 0.12.5 */
 /** 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 canonicalMultiplication(ce: IComputeEngine, body: BoxedExpression | undefined, range: BoxedExpression | undefined): BoxedExpression;
+export declare function canonicalProduct(ce: IComputeEngine, body: BoxedExpression | undefined, range: BoxedExpression | undefined): BoxedExpression;
 export declare function evalMultiplication(ce: IComputeEngine, expr: BoxedExpression, range: BoxedExpression, mode: 'simplify' | 'evaluate' | 'N'): BoxedExpression | undefined;

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

@@ -1,4 +1,4 @@
-/* 0.12.3 */
+/* 0.12.5 */
 /**
  *
  */

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

@@ -1,2 +1,2 @@
-/* 0.12.3 */
+/* 0.12.5 */
 export declare const ARITHMETIC_LIBRARY: IdTable[];

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

@@ -1,2 +1,2 @@
-/* 0.12.3 */
+/* 0.12.5 */
 export declare const CALCULUS_LIBRARY: IdTable[];

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

@@ -1,2 +1,2 @@
-/* 0.12.3 */
+/* 0.12.5 */
 export declare const COLLECTIONS_LIBRARY: IdTable;

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

@@ -1,2 +1,2 @@
-/* 0.12.3 */
+/* 0.12.5 */
 export declare const CORE_LIBRARY: IdTable[];

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

@@ -1,4 +1,4 @@
-/* 0.12.3 */
+/* 0.12.5 */
 export declare const DOMAIN_CONSTRUCTORS: string[];
 export declare const DOMAIN_ALIAS: {
     NumericFunction: (string | string[])[];

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

@@ -1,4 +1,4 @@
-/* 0.12.3 */
+/* 0.12.5 */
 import { IComputeEngine, IdTable } from '../public';
 export declare function getStandardLibrary(categories: LibraryCategory[] | LibraryCategory | 'all'): Readonly<IdTable>[];
 export declare const LIBRARIES: {

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

@@ -1,2 +1,2 @@
-/* 0.12.3 */
+/* 0.12.5 */
 export declare const LOGIC_LIBRARY: IdTable;

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

@@ -1,2 +1,2 @@
-/* 0.12.3 */
+/* 0.12.5 */
 export declare const POLYNOMIALS_LIBRARY: IdTable[];

package/dist/types/compute-engine/library/random-expression.d.ts

@@ -1,2 +1,2 @@
-/* 0.12.3 */
+/* 0.12.5 */
 export declare function randomExpression(level?: number): Expression;

package/dist/types/compute-engine/library/relational-operator.d.ts

@@ -1,2 +1,2 @@
-/* 0.12.3 */
+/* 0.12.5 */
 export declare const RELOP_LIBRARY: IdTable;

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

@@ -1,2 +1,2 @@
-/* 0.12.3 */
+/* 0.12.5 */
 export declare const SETS_LIBRARY: IdTable;

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

@@ -1,2 +1,2 @@
-/* 0.12.3 */
+/* 0.12.5 */
 export declare const TRIGONOMETRY_LIBRARY: IdTable[];

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

@@ -1,3 +1,3 @@
-/* 0.12.3 */
+/* 0.12.5 */
 export declare function isSymbolDefinition(def: BoxedSymbolDefinition | BoxedFunctionDefinition | SymbolDefinition | FunctionDefinition | undefined | null): def is BoxedSymbolDefinition;
 export declare function isFunctionDefinition(def: BoxedSymbolDefinition | BoxedFunctionDefinition | SymbolDefinition | FunctionDefinition | undefined | null): def is BoxedFunctionDefinition;

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

@@ -1,4 +1,4 @@
-/* 0.12.3 */
+/* 0.12.5 */
 export declare function bigint(a: Decimal | number | bigint | string): bigint;
 export declare function gcd(a: bigint, b: bigint): bigint;
 export declare function lcm(a: bigint, b: bigint): bigint;

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

@@ -1,4 +1,4 @@
-/* 0.12.3 */
+/* 0.12.5 */
 import { IComputeEngine } from '../public';
 export declare function gcd(a: Decimal, b: Decimal): Decimal;
 export declare function lcm(a: Decimal, b: Decimal): Decimal;

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

@@ -1,3 +1,3 @@
-/* 0.12.3 */
+/* 0.12.5 */
 export declare function gamma(c: Complex): Complex;
 export declare function lngamma(c: Complex): Complex;

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

@@ -1,4 +1,4 @@
-/* 0.12.3 */
+/* 0.12.5 */
 import Decimal from 'decimal.js';
 import { BoxedExpression } from '../public';
 export declare const MACHINE_PRECISION_BITS = 53;

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

@@ -1,2 +1,2 @@
-/* 0.12.3 */
+/* 0.12.5 */
 export declare function isPrime(n: number): boolean | undefined;

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

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