@cortex-js/compute-engine 0.12.4 → 0.12.6

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

@@ -1,4 +1,4 @@
-/* 0.12.4 */
+/* 0.12.6 */
 import { Expression } from '../../math-json/math-json-format';
 import type { IComputeEngine } from '../public';
 /**
@@ -50,14 +50,14 @@ export type Terminator = {
  * otherwise.
  *
  */
-export type EnvironmentParseHandler = (parser: Parser, reqArgs: Expression[], optArgs: Expression[]) => Expression | null;
-export type IdentifierParseHandler = (parser: Parser, until?: Terminator) => Expression | null;
+export type ExpressionParseHandler = (parser: Parser, until?: Terminator) => Expression | null;
+export type PrefixParseHandler = (parser: Parser, until?: Terminator) => Expression | null;
+export type SymbolParseHandler = (parser: Parser, until?: Terminator) => Expression | null;
 export type FunctionParseHandler = (parser: Parser, until?: Terminator) => Expression | null;
-export type PostfixParseHandler = (parser: Parser, lhs: Expression) => Expression | null;
-export type PrefixParseHandler = (parser: Parser, until: Terminator) => Expression | null;
-export type InfixParseHandler = (parser: Parser, until: Terminator, lhs: Expression) => Expression | null;
+export type EnvironmentParseHandler = (parser: Parser, reqArgs: Expression[], optArgs: Expression[]) => Expression | null;
+export type PostfixParseHandler = (parser: Parser, lhs: Expression, until?: Terminator) => Expression | null;
+export type InfixParseHandler = (parser: Parser, lhs: Expression, until: Terminator) => Expression | null;
 export type MatchfixParseHandler = (parser: Parser, body: Expression) => Expression | null;
-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.
@@ -93,8 +93,13 @@ export type BaseEntry = {
      * If no `serialize` handler is provided, the `trigger` property is used
      */
     serialize?: LatexString | SerializeHandler;
+    parse?: Expression | ExpressionParseHandler;
+};
+export type ExpressionEntry = Omit<BaseEntry, 'parse'> & {
+    kind: 'expression';
+    parse: Expression | ExpressionParseHandler;
 };
-export type MatchfixEntry = BaseEntry & {
+export type MatchfixEntry = Omit<BaseEntry, 'parse'> & {
     kind: 'matchfix';
     /**
      * If `kind` is `'matchfix'`: the `closeDelimiter` and `openDelimiter`
@@ -106,9 +111,9 @@ export type MatchfixEntry = BaseEntry & {
      * The argument of the handler is the body, i.e. the content between
      * the open delimiter and the close delimiter.
      */
-    parse: MatchfixParseHandler;
+    parse?: MatchfixParseHandler;
 };
-export type InfixEntry = BaseEntry & {
+export type InfixEntry = Omit<BaseEntry, 'parse'> & {
     /**
      * Infix position, with an operand before and an operand after: `a ⊛ b`.
      *
@@ -127,11 +132,9 @@ export type InfixEntry = BaseEntry & {
      */
     associativity?: 'right' | 'left' | 'non' | 'both';
     precedence?: number;
-    /**
-     */
-    parse: string | InfixParseHandler;
+    parse?: string | InfixParseHandler;
 };
-export type PostfixEntry = BaseEntry & {
+export type PostfixEntry = Omit<BaseEntry, 'parse'> & {
     /**
      * Postfix position, with an operand before: `a ⊛`
      *
@@ -139,9 +142,9 @@ export type PostfixEntry = BaseEntry & {
      */
     kind: 'postfix';
     precedence?: number;
-    parse: PostfixParseHandler;
+    parse?: PostfixParseHandler;
 };
-export type PrefixEntry = BaseEntry & {
+export type PrefixEntry = Omit<BaseEntry, 'parse'> & {
     /**
      * Prefix position, with an operand after: `⊛ a`
      *
@@ -149,21 +152,21 @@ export type PrefixEntry = BaseEntry & {
      */
     kind: 'prefix';
     precedence: number;
-    parse: PrefixParseHandler;
+    parse?: PrefixParseHandler;
 };
 /**
  * A LaTeX dictionary entry for an environment, that is a LaTeX
  * construct using `\begin{...}...\end{...}`.
  */
-export type EnvironmentEntry = BaseEntry & {
+export type EnvironmentEntry = Omit<BaseEntry, 'parse'> & {
     kind: 'environment';
     parse: EnvironmentParseHandler;
 };
-export type IdentifierEntry = BaseEntry & {
-    kind: 'identifier';
+export type SymbolEntry = Omit<BaseEntry, 'parse'> & {
+    kind: 'symbol';
     /** Used for appropriate wrapping (i.e. when to surround it with parens) */
     precedence?: number;
-    parse: Expression | IdentifierParseHandler;
+    parse: Expression | SymbolParseHandler;
 };
 /**
  * A function has the following form:
@@ -176,21 +179,16 @@ export type IdentifierEntry = BaseEntry & {
  * inverse functions postfix (i.e. ^{-1}), use a custom parse handler with a
  * base entry.
  */
-export type FunctionEntry = BaseEntry & {
+export type FunctionEntry = Omit<BaseEntry, 'parse'> & {
     kind: 'function';
     trigger: string;
-    parse: Expression | FunctionParseHandler;
-};
-/**
- * A simple LaTeX dictionary entry, for example for a command like `\pi`.
- */
-export type DefaultEntry = BaseEntry & {
-    precedence?: number;
-    parse?: Expression | IdentifierParseHandler;
+    parse?: Expression | FunctionParseHandler;
 };
-export type LatexDictionaryEntry = DefaultEntry | MatchfixEntry | InfixEntry | PostfixEntry | PrefixEntry | IdentifierEntry | FunctionEntry | EnvironmentEntry;
+export type LatexDictionaryEntry = BaseEntry | ExpressionEntry | MatchfixEntry | InfixEntry | PostfixEntry | PrefixEntry | SymbolEntry | FunctionEntry | EnvironmentEntry;
 /** @internal */
-export declare function isIdentifierEntry(entry: LatexDictionaryEntry): entry is IdentifierEntry;
+export declare function isExpressionEntry(entry: LatexDictionaryEntry): entry is ExpressionEntry;
+/** @internal */
+export declare function isSymbolEntry(entry: LatexDictionaryEntry): entry is SymbolEntry;
 /** @internal */
 export declare function isFunctionEntry(entry: LatexDictionaryEntry): entry is FunctionEntry;
 /** @internal */
@@ -438,151 +436,140 @@ export type SerializeHandler = (serializer: Serializer, expr: Expression) => str
 export interface Parser {
     readonly options: Required<ParseLatexOptions>;
     readonly computeEngine?: IComputeEngine;
+    /** The index of the current token */
     index: number;
-    /** True if the last token has been reached */
+    /** True if the last token has been reached.
+     * Consider also `atTerminator()`.
+     */
     readonly atEnd: boolean;
+    /** Return true if the terminator condition is met or if the last token
+     * has been reached.
+     */
+    atTerminator(t: Terminator | undefined): boolean;
     /** Return the next token, without advancing the index */
     readonly peek: LatexToken;
-    /** Return true if the terminator condition is met */
-    atTerminator(t: Terminator | undefined): boolean;
+    /** Return the next token and advance the index */
+    nextToken(): LatexToken;
     /** Return an array of string corresponding to tokens ahead.
      * The index is unchanged.
      */
     lookAhead(): string[];
-    /** Return the next token and advance the index */
-    next(): LatexToken;
-    /** Return a LaTeX string before the index */
-    latexBefore(): string;
-    /** Return a LaTeX string after the index */
-    latexAfter(): string;
+    /** Return a string representation of the expression
+     between `start` and `end` (default: the whole expression) */
+    latex(start: number, end?: number): string;
+    /** Return an error expression with the specified code and arguments */
+    error(code: string | [string, ...Expression[]], fromToken: number): Expression;
     /** If there are any space, advance the index until a non-space is encountered */
     skipSpace(): boolean;
-    addBoundary(boundary: LatexToken[]): void;
-    removeBoundary(): void;
-    matchBoundary(): boolean;
-    boundaryError(msg: string | [string, ...Expression[]]): Expression;
+    /** Skip over "visual space" which
+    includes space tokens, empty groups `{}`, and commands such as `\,` and `\!` */
+    skipVisualSpace(): void;
+    /** If the next token matches the target advance and return true. Otherwise
+     * return false */
+    match(token: LatexToken): boolean;
+    /** Return true if the next tokens match the argument, an array of tokens, or null otherwise */
+    matchAll(tokens: LatexToken[]): boolean;
+    /** Return the next token if it matches any of the token in the argument or null otherwise */
+    matchAny(tokens: LatexToken[]): LatexToken;
     /** If the next token is a character, return it and advance the index
      * This includes plain characters (e.g. 'a', '+'...), characters
      * defined in hex (^^ and ^^^^), the `\char` and `\unicode` command.
      */
     matchChar(): string | null;
-    /** Return a CSS color. Handle the various color formats supported by the
-     * `xcolor` package.
-     */
-    matchColor(background?: boolean): string | null;
     /**
-     * Return a LaTeX dimension.
+     * Parse an expression in aLaTeX group enclosed in curly brackets `{}`.
+     * These are often used as arguments to LaTeX commands, for example
+     * `\frac{1}{2}`.
      *
+     * Return `null` if none was found
+     * Return `['Sequence']` if an empty group `{}` was found
      */
-    matchLatexDimension(): string | null;
-    /** If the next token matches the target advance and return true. Otherwise
-     * return false */
-    match(tokens: LatexToken): boolean;
-    matchAll(tokens: LatexToken | LatexToken[]): boolean;
-    matchAny(tokens: LatexToken[]): LatexToken;
-    matchSequence(tokens: LatexToken[]): LatexToken[];
-    /** If the next token matches a `+` or `-` sign, return it and advance the index.
-     * Otherwise return `''` and do not advance */
-    matchOptionalSign(): string;
-    matchDecimalDigits(): string;
-    matchSignedInteger(): string;
-    matchExponent(): string;
-    matchNumber(): string;
-    /** Parse a tabular environment, until `\end{endName}`
-     */
-    matchTabular(endName: string): null | Expression[][];
-    applyInvisibleOperator(terminator: Terminator, lhs: Expression | null): Expression | null;
-    /** Some LaTeX commands (but not all) can accept an argument without braces,
-     *  for example `^` , `\sqrt` or `\frac`.
+    parseGroup(): Expression | null;
+    /**
+     * Some LaTeX commands (but not all) can accept arguments as single
+     * tokens (i.e. without braces), for example `^2`, `\sqrt3` or `\frac12`
      *
-     * 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.
+     * This argument will usually be a single token, but can be a sequence of
+     * tokens (e.g. `\sqrt\frac12` or `\sqrt\mathrm{speed}`).
      *
-     * The excluded tokens are `!"#$%&(),/;:?@[]`|~", `\left` and `\bigl`
+     * The following tokens are excluded from consideration in order 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 include `!"#$%&(),/;:?@[]`|~", `\left`, `\bigl`, etc...
      */
-    matchSingleAtomArgument(): Expression | null;
+    parseToken(): Expression | null;
     /**
+     * Parse an expression enclosed in a LaTeX optional group enclosed in square brackets `[]`.
      *
-     * Match a LaTeX expression enclosed in `[]`
-     *
-     * Otherwise, return `null`.
+     * Return `null` if none was found.
      */
-    matchLatexOptionalGroup(): Expression | null;
+    parseOptionalGroup(): Expression | null;
     /**
-     * Match a LaTeX group enclosed in `{}`
+     * Some LaTeX commands have arguments that are not interpreted as
+     * expressions, but as strings. For example, `\begin{array}{ccc}` (both
+     * `array` and `ccc` are strings), `\color{red}` or `\operatorname{lim sup}`.
      *
-     * Return null if no argument was found
-     * Return `['Sequence']` if an empty argument `{}` was found
+     * If the next token is the start of a group (`{`), return the content
+     * of the group as a string. This may include white space, and it may need
+     * to be trimmed at the start and end of the string.
+     *
+     * LaTeX commands are typically not allowed inside a string group (for example,
+     * `\alpha` would result in an error), but we do not enforce this.
      */
-    matchLatexGroup(): Expression | null;
+    parseStringGroup(): string | 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`)
+     * A symbol can be:
+     * - a single-letter identifier: `x`
+     * - a single LaTeX command: `\pi`
+     * - a multi-letter identifier: `\mathrm{speed}`
      */
-    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.
+    parseSymbol(until?: Partial<Terminator>): Expression | null;
+    /**
+     * Parse an expression in a tabular format, where rows are separated by `\\`
+     * and columns by `&`.
      *
-     * For example, if `openDelim` is `(`, and `closeDelim` is `)` it would match
-     * `\left\lparen` and return `['\right', '\rparen']`, which can be matched
-     * with `matchAll()`
+     * Return rows of sparse columns: empty rows are indicated with `Nothing`,
+     * and empty cells are also indicated with `Nothing`.
      */
-    matchOpenDelimiter(openDelim: Delimiter, closeDelim: Delimiter): LatexToken[] | null;
-    matchMiddleDelimiter(delimiter: '|' | ':' | LatexToken): boolean;
+    parseTabular(): null | Expression[][];
     /**
-     *  Match a sequence superfix/subfix operator, e.g. `^{*}`
-     *
-     * Superfix and subfix need special handling:
+     * Parse an argument list, for example: `(12, x+1)` or `\left(x\right)`
      *
-     * - they act mostly like an infix operator, but they are commutative, i.e.
-     * `x_a^b` should be parsed identically to `x^b_a`.
-     *
-     * - furthermore, in LaTeX `x^a^b` parses the same as `x^a{}^b`.
+     * - 'enclosure' : will look for arguments inside an enclosure
+     *    (an open/close fence) (**default**)
+     * - 'implicit': either an expression inside a pair of `()`, or just a primary
+     *    (i.e. we interpret `\cos x + 1` as `\cos(x) + 1`)
      *
+     * Return an array of expressions, one for each argument, or `null` if no
+     * argument was found.
      */
-    matchSupsub(lhs: Expression | null): Expression | null;
+    parseArguments(kind?: 'implicit' | 'enclosure', until?: Terminator): Expression[] | null;
     /**
+     * Parse a postfix operator, such as `'` or `!`.
      *
-     * ```
-     *    <primary> :=
-     *       (<number> | <symbol> | <latex-command> | <function-call> | <matchfix-expr>)
-     *       (<subsup> | <postfix-operator>)*
-     * ```
-     *
-     * ```
-     *    <matchfix-expr> :=
-     *        <matchfix-op-open> <expression> <matchfix-op-close>
-     *```
+     * Prefix, infix and matchfix operators are handled by `parseExpression()`
      *
-     *```
-     *    <function-call> ::=
-     *      | <function><matchfix-op-group-open><expression>[',' <expression>]<matchfix-op-group-close>
-     *```
-     * If not a primary, return `null` and do not advance the index.
      */
-    matchPrimary(): Expression | null;
-    /**
-     * A symbol can be:
-     * - a single-letter variable: `x`
-     * - a single LaTeX command: `\pi`
-     */
-    matchSymbol(until?: Terminator): Expression | null;
+    parsePostfixOperator(lhs: Expression | null, until?: Partial<Terminator>): Expression | null;
     /**
      * Parse an expression:
      *
      * ```
      * <expression> ::=
+     *  | <primary> ( <infix-op> <expression> )?
      *  | <prefix-op> <expression>
-     *  | <primary>
-     *  | <primary> <infix-op> <expression>
+     *
+     * <primary> :=
+     *   (<number> | <symbol> | <function-call> | <matchfix-expr>)
+     *   (<subsup> | <postfix-operator>)*
+     *
+     * <matchfix-expr> :=
+     *   <matchfix-op-open> <expression> <matchfix-op-close>
+     *
+     * <function-call> ::=
+     *   | <function><matchfix-op-group-open><expression>[',' <expression>]<matchfix-op-group-close>
      * ```
      *
      * This is the top-level parsing entry point.
@@ -592,8 +579,23 @@ 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;
+    parseExpression(until?: Partial<Terminator>): Expression | null;
+    /**
+     * Boundaries are used to detect the end of an expression.
+     *
+     * They are used for unusual syntactic constructs, for example
+     * `\int \sin x dx` where the `dx` is not an argument to the `\sin`
+     * function, but a boundary of the integral.
+     *
+     * They are also useful when handling syntax errors and recovery.
+     *
+     * For example, `\begin{bmatrix} 1 & 2 { \end{bmatrix}` has an
+     * extraneous `{`, but the parser will attempt to recover and continue
+     * parsing when it encounters the `\end{bmatrix}` boundary.
+     */
+    addBoundary(boundary: LatexToken[]): void;
+    removeBoundary(): void;
+    get atBoundary(): boolean;
+    matchBoundary(): boolean;
+    boundaryError(msg: string | [string, ...Expression[]]): Expression;
 }

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

@@ -1,4 +1,4 @@
-/* 0.12.4 */
+/* 0.12.6 */
 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.4 */
+/* 0.12.6 */
 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.4 */
+/* 0.12.6 */
 import { WarningSignalHandler } from '../../common/signals';
 import { NumberFormattingOptions, LatexString, SerializeLatexOptions } from './public';
-import { IndexedLatexDictionary, IndexedIdentifierEntry, IndexedFunctionEntry } from './dictionary/definitions';
+import { IndexedLatexDictionary, IndexedSymbolEntry, IndexedFunctionEntry } from './dictionary/definitions';
 export declare class Serializer {
     readonly onError: WarningSignalHandler;
     options: NumberFormattingOptions & SerializeLatexOptions;
@@ -25,8 +25,8 @@ export declare class Serializer {
     wrapShort(expr: Expression | null): string;
     wrapString(s: string, style: 'paren' | 'leftright' | 'big' | 'none', fence?: string): string;
     wrapArguments(expr: Expression): string;
-    serializeSymbol(expr: Expression, def?: IndexedIdentifierEntry | IndexedFunctionEntry): string;
-    serializeFunction(expr: Expression, def?: IndexedFunctionEntry | IndexedIdentifierEntry): string;
+    serializeSymbol(expr: Expression, def?: IndexedSymbolEntry | IndexedFunctionEntry): string;
+    serializeFunction(expr: Expression, def?: IndexedFunctionEntry | IndexedSymbolEntry): string;
     serializeDictionary(dict: {
         [key: string]: Expression;
     }): string;

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

@@ -1,4 +1,4 @@
-/* 0.12.4 */
+/* 0.12.6 */
  * ## 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.12.4 */
+/* 0.12.6 */
 /** The canonical form of `Add`:
  * - removes `0`
  * - capture complex numbers (a + ib or ai +b)

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

@@ -1,4 +1,4 @@
-/* 0.12.4 */
+/* 0.12.6 */
 /**
  * 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.4 */
+/* 0.12.6 */
 /** 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.12.4 */
+/* 0.12.6 */
 /**
  *
  */

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

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

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

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

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

@@ -1,2 +1,2 @@
-/* 0.12.4 */
+/* 0.12.6 */
 export declare const COLLECTIONS_LIBRARY: IdTable;

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

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

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

@@ -1,4 +1,4 @@
-/* 0.12.4 */
+/* 0.12.6 */
 export declare const DOMAIN_CONSTRUCTORS: string[];
 export declare const DOMAIN_ALIAS: {
     NumericFunction: (string | string[])[];
@@ -13,3 +13,4 @@ export declare function isSubdomainLiteral(lhs: string, rhs: string): boolean;
 /** Return all the domain literals that are an ancestor of `dom`
  */
 export declare function ancestors(dom: string): string[];
+export declare function domainSetsLibrary(): IdTable;

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

@@ -1,4 +1,4 @@
-/* 0.12.4 */
+/* 0.12.6 */
 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.4 */
+/* 0.12.6 */
 export declare const LOGIC_LIBRARY: IdTable;

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

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

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

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

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

@@ -1,2 +1,2 @@
-/* 0.12.4 */
+/* 0.12.6 */
 export declare const RELOP_LIBRARY: IdTable;

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

@@ -1,2 +1,2 @@
-/* 0.12.4 */
+/* 0.12.6 */
 export declare const SETS_LIBRARY: IdTable;

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

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

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

@@ -1,3 +1,3 @@
-/* 0.12.4 */
+/* 0.12.6 */
 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.4 */
+/* 0.12.6 */
 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.4 */
+/* 0.12.6 */
 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.4 */
+/* 0.12.6 */
 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.4 */
+/* 0.12.6 */
 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.4 */
+/* 0.12.6 */
 export declare function isPrime(n: number): boolean | undefined;

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

@@ -1,4 +1,4 @@
-/* 0.12.4 */
+/* 0.12.6 */
 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];