@cortex-js/compute-engine 0.12.7 → 0.14.0

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

@@ -1,4 +1,4 @@
-/* 0.12.7 */
+/* 0.14.0 */
 import { Expression } from '../../math-json/math-json-format';
 import type { IComputeEngine } from '../public';
 /**
@@ -19,6 +19,42 @@ export type LatexString = string;
  */
 export type Delimiter = ')' | '(' | ']' | '[' | '{' /** \lbrace */ | '}' /** \rbrace */ | '<' /** \langle  */ | '>' /** \rangle  */ | '|' | '||' | '\\lceil' | '\\rceil' | '\\lfloor' | '\\rfloor';
 export type LibraryCategory = 'algebra' | 'arithmetic' | 'calculus' | 'collections' | 'control-structures' | 'combinatorics' | 'core' | 'data-structures' | 'dimensions' | 'domains' | 'linear-algebra' | 'logic' | 'numeric' | 'other' | 'physics' | 'polynomials' | 'relop' | 'sets' | 'statistics' | 'styling' | 'symbols' | 'trigonometry' | 'units';
+/** Theory of operations:
+ *
+ * The precedence of an operator is a number that indicates the order in which
+ * operators are applied. 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 higher 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`
+ * - 500: not used
+ * - 400: not used
+ * - 300: some logic and arithmetic operators:
+ *        `\land`, `\lor`, `\times`, etc...
+ * - 200: arithmetic operators, inequalities:
+ *        `+`, `-`, `=`, `<`, etc...
+ *   - 260: `=`
+ *   - 245: `\lt`, `\gt`
+ *   - 241: `\leq`
+ * - 100: not used
+ * - 0: `,`, `;`, etc...
+ *
+ *
+ * Note: MathML defines some operator precendence, 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
+ *
+ * For reference, the JavaScript operator precedence is documented
+ * here: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_precedence
+ */
+export type Precedence = number;
 /**
  * This indicates a condition under which parsing should stop:
  * - an operator of a precedence higher than specified has been encountered
@@ -26,7 +62,7 @@ export type LibraryCategory = 'algebra' | 'arithmetic' | 'calculus' | 'collectio
  * - or if a condition is provided, the condition returns true;
  */
 export type Terminator = {
-    minPrec: number;
+    minPrec: Precedence;
     condition?: (parser: Parser) => boolean;
 };
 /**
@@ -50,15 +86,33 @@ export type Terminator = {
  * otherwise.
  *
  */
-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 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 ExpressionParseHandler = (parser: Parser, until?: Readonly<Terminator>) => Expression | null;
+export type PrefixParseHandler = (parser: Parser, until?: Readonly<Terminator>) => Expression | null;
+export type SymbolParseHandler = (parser: Parser, until?: Readonly<Terminator>) => Expression | null;
+export type FunctionParseHandler = (parser: Parser, until?: Readonly<Terminator>) => Expression | null;
+export type EnvironmentParseHandler = (parser: Parser, until?: Readonly<Terminator>) => Expression | null;
+export type PostfixParseHandler = (parser: Parser, lhs: Expression, until?: Readonly<Terminator>) => Expression | null;
+export type InfixParseHandler = (parser: Parser, lhs: Expression, until: Readonly<Terminator>) => Expression | null;
 export type MatchfixParseHandler = (parser: Parser, body: Expression) => Expression | null;
 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` */
+/**
+ * The trigger is the set of tokens that will make this record eligible to
+ * parse the stream and generate an expression. If the trigger matches,
+ * the `parse` handler is called, if available.
+ *
+ * The trigger can be specified either as a LaTeX string (`latexTrigger`) or
+ * as an identifier (`identifierTrigger`), which can be wrapped in a LaTeX
+ * command, for example `\operatorname{mod}` or `\mathbin{gcd}`, with `"gcd"`
+ *  being the `identifierTrigger`.
+ *
+ *
+ * `matchfix` operators use `openDelimiter` and `closeDelimiter` instead.
+ *
+ */
+export type Trigger = {
+    latexTrigger?: LatexString | LatexToken[];
+    identifierTrigger?: string;
+};
 /**
  * Maps a string of LaTeX tokens to a function or symbol and vice-versa.
  *
@@ -79,41 +133,34 @@ export type BaseEntry = {
      * token, the `parse` handler is invoked.
      */
     name?: string;
-    /**
-     * The trigger is the set of tokens that will make this record eligible for
-     * attempting to parse the stream and generate an expression. After the
-     * trigger matches, the `parse` handler is called, if available.
-     *
-     * `matchfix` operators use `openDelimiter` and `closeDelimiter` instead.
-     *
-     */
-    trigger?: LatexString | LatexToken[];
     /**
      * Transform an expression into a LaTeX string.
      * If no `serialize` handler is provided, the `trigger` property is used
      */
     serialize?: LatexString | SerializeHandler;
-    parse?: Expression | ExpressionParseHandler;
 };
-export type ExpressionEntry = Omit<BaseEntry, 'parse'> & {
+export type DefaultEntry = BaseEntry & Trigger & {
+    parse: Expression | ExpressionParseHandler;
+};
+export type ExpressionEntry = BaseEntry & Trigger & {
     kind: 'expression';
     parse: Expression | ExpressionParseHandler;
 };
-export type MatchfixEntry = Omit<BaseEntry, 'parse'> & {
+export type MatchfixEntry = BaseEntry & {
     kind: 'matchfix';
     /**
      * If `kind` is `'matchfix'`: the `closeDelimiter` and `openDelimiter`
      * property are required
      */
-    openDelimiter?: Delimiter | LatexToken[];
-    closeDelimiter?: Delimiter | LatexToken[];
+    openTrigger?: Delimiter | LatexToken[];
+    closeTrigger?: Delimiter | LatexToken[];
     /** When invoked, the parser is pointing after the close delimiter.
      * The argument of the handler is the body, i.e. the content between
      * the open delimiter and the close delimiter.
      */
     parse?: MatchfixParseHandler;
 };
-export type InfixEntry = Omit<BaseEntry, 'parse'> & {
+export type InfixEntry = BaseEntry & Trigger & {
     /**
      * Infix position, with an operand before and an operand after: `a ⊛ b`.
      *
@@ -131,60 +178,58 @@ export type InfixEntry = Omit<BaseEntry, 'parse'> & {
      *
      */
     associativity?: 'right' | 'left' | 'non' | 'both';
-    precedence?: number;
+    precedence?: Precedence;
     parse?: string | InfixParseHandler;
 };
-export type PostfixEntry = Omit<BaseEntry, 'parse'> & {
+export type PostfixEntry = BaseEntry & Trigger & {
     /**
      * Postfix position, with an operand before: `a ⊛`
      *
      * Example: `!`.
      */
     kind: 'postfix';
-    precedence?: number;
+    precedence?: Precedence;
     parse?: PostfixParseHandler;
 };
-export type PrefixEntry = Omit<BaseEntry, 'parse'> & {
+export type PrefixEntry = BaseEntry & Trigger & {
     /**
      * Prefix position, with an operand after: `⊛ a`
      *
      * Example: `-`, `\not`.
      */
     kind: 'prefix';
-    precedence: number;
+    precedence: Precedence;
     parse?: PrefixParseHandler;
 };
 /**
  * A LaTeX dictionary entry for an environment, that is a LaTeX
  * construct using `\begin{...}...\end{...}`.
  */
-export type EnvironmentEntry = Omit<BaseEntry, 'parse'> & {
+export type EnvironmentEntry = BaseEntry & {
     kind: 'environment';
     parse: EnvironmentParseHandler;
+    identifierTrigger: string;
 };
-export type SymbolEntry = Omit<BaseEntry, 'parse'> & {
+export type SymbolEntry = BaseEntry & Trigger & {
     kind: 'symbol';
     /** Used for appropriate wrapping (i.e. when to surround it with parens) */
-    precedence?: number;
+    precedence?: Precedence;
     parse: Expression | SymbolParseHandler;
 };
 /**
- * A function has the following form:
- * - a prefix such as `\mathrm` or `\operatorname`
- * - a trigger string, such as `gcd`
+ * A function is an identifier followed by:
  * - 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.
+ * entry of kind `expression`.
  */
-export type FunctionEntry = Omit<BaseEntry, 'parse'> & {
+export type FunctionEntry = BaseEntry & Trigger & {
     kind: 'function';
-    trigger: string;
     parse?: Expression | FunctionParseHandler;
 };
-export type LatexDictionaryEntry = BaseEntry | ExpressionEntry | MatchfixEntry | InfixEntry | PostfixEntry | PrefixEntry | SymbolEntry | FunctionEntry | EnvironmentEntry;
+export type LatexDictionaryEntry = DefaultEntry | ExpressionEntry | MatchfixEntry | InfixEntry | PostfixEntry | PrefixEntry | SymbolEntry | FunctionEntry | EnvironmentEntry;
 /** @internal */
 export declare function isExpressionEntry(entry: LatexDictionaryEntry): entry is ExpressionEntry;
 /** @internal */
@@ -201,7 +246,7 @@ export declare function isPrefixEntry(entry: LatexDictionaryEntry): entry is Pre
 export declare function isPostfixEntry(entry: LatexDictionaryEntry): entry is PostfixEntry;
 /** @internal */
 export declare function isEnvironmentEntry(entry: LatexDictionaryEntry): entry is EnvironmentEntry;
-export type LatexDictionary = LatexDictionaryEntry[];
+export type LatexDictionary = Array<object>;
 export type ParseLatexOptions = {
     /**
      * This function is invoked when a number is followed by a symbol,
@@ -339,7 +384,7 @@ export type NumberFormattingOptions = {
      *
      * If you change it to another value, be aware that this may lead to
      * unexpected results. For example, if changing it to `,` the expression
-     * `\mathrm{Hypot}(1,2)` will parse as `["Hypot", 1.2]` rather than
+     * `\operatorname{Hypot}(1,2)` will parse as `["Hypot", 1.2]` rather than
      * `["Hypot", 1, 2]`.
      *
      * **Default**: `"\\,"` (thin space, 3/18mu) (Resolution 7 of the 1948 CGPM)
@@ -431,6 +476,8 @@ export interface Serializer {
     logicStyle: (expr: Expression, level: number) => 'word' | 'boolean' | 'uppercase-word' | 'punctuation';
     powerStyle: (expr: Expression, level: number) => 'root' | 'solidus' | 'quotient';
     numericSetStyle: (expr: Expression, level: number) => 'compact' | 'regular' | 'interval' | 'set-builder';
+    serializeFunction(expr: Expression): LatexString;
+    serializeSymbol(expr: Expression): LatexString;
 }
 export type SerializeHandler = (serializer: Serializer, expr: Expression) => string;
 export interface Parser {
@@ -450,10 +497,6 @@ export interface Parser {
     readonly peek: LatexToken;
     /** 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 a string representation of the expression
      between `start` and `end` (default: the whole expression) */
     latex(start: number, end?: number): string;
@@ -490,7 +533,7 @@ export interface Parser {
      * tokens (i.e. without braces), for example `^2`, `\sqrt3` or `\frac12`
      *
      * This argument will usually be a single token, but can be a sequence of
-     * tokens (e.g. `\sqrt\frac12` or `\sqrt\mathrm{speed}`).
+     * tokens (e.g. `\sqrt\frac12` or `\sqrt\operatorname{speed}`).
      *
      * The following tokens are excluded from consideration in order to fail
      * early when encountering a likely syntax error, for example `x^(2)`
@@ -523,7 +566,7 @@ export interface Parser {
      * A symbol can be:
      * - a single-letter identifier: `x`
      * - a single LaTeX command: `\pi`
-     * - a multi-letter identifier: `\mathrm{speed}`
+     * - a multi-letter identifier: `\operatorname{speed}`
      */
     parseSymbol(until?: Partial<Terminator>): Expression | null;
     /**

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

@@ -1,4 +1,4 @@
-/* 0.12.7 */
+/* 0.14.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.12.7 */
+/* 0.14.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,7 +1,7 @@
-/* 0.12.7 */
+/* 0.14.0 */
 import { WarningSignalHandler } from '../../common/signals';
 import { NumberFormattingOptions, LatexString, SerializeLatexOptions } from './public';
-import { IndexedLatexDictionary, IndexedSymbolEntry, IndexedFunctionEntry } from './dictionary/definitions';
+import { IndexedLatexDictionary, IndexedLatexDictionaryEntry } 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?: IndexedSymbolEntry | IndexedFunctionEntry): string;
-    serializeFunction(expr: Expression, def?: IndexedFunctionEntry | IndexedSymbolEntry): string;
+    serializeSymbol(expr: Expression, def?: IndexedLatexDictionaryEntry): LatexString;
+    serializeFunction(expr: Expression, def?: IndexedLatexDictionaryEntry): LatexString;
     serializeDictionary(dict: {
         [key: string]: Expression;
     }): string;
@@ -40,8 +40,3 @@ export declare class Serializer {
     numericSetStyle(expr: Expression, level: number): 'compact' | 'regular' | 'interval' | 'set-builder';
 }
 export declare function appendLatex(src: string, s: string): string;
-/**
- * Replace '#1', '#2' in the LaTeX template stings with the corresponding
- * values from `replacement`, in a LaTeX syntax safe manner (i.e. inserting spaces when needed)
- */
-export declare function replaceLatex(template: string, replacement: string[]): string;

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

@@ -1,4 +1,4 @@
-/* 0.12.7 */
+/* 0.14.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.12.7 */
+/* 0.14.0 */
 /** The canonical form of `Add`:
  * - removes `0`
  * - capture complex numbers (a + ib or ai +b)
@@ -9,4 +9,3 @@ export declare function simplifyAdd(ce: IComputeEngine, args: 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.7 */
+/* 0.14.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.12.7 */
+/* 0.14.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.12.7 */
+/* 0.14.0 */
 /**
  *
  */

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

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

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

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

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

@@ -1,2 +1,2 @@
-/* 0.12.7 */
+/* 0.14.0 */
 export declare const COLLECTIONS_LIBRARY: IdTable;

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

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

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

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

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

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

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

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

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

@@ -1,2 +1,2 @@
-/* 0.12.7 */
+/* 0.14.0 */
 export declare const RELOP_LIBRARY: IdTable;

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

@@ -1,2 +1,2 @@
-/* 0.12.7 */
+/* 0.14.0 */
 export declare const SETS_LIBRARY: IdTable;

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

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

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

@@ -1,3 +1,4 @@
-/* 0.12.7 */
+/* 0.14.0 */
 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;
+export declare function normalizeLimits(range: BoxedExpression): [index: string, lower: number, upper: number, isFinite: boolean];

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

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

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

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

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

@@ -1,4 +1,4 @@
-/* 0.12.7 */
+/* 0.14.0 */
  * The most important classes are {@link ComputeEngine} and
  * {@link BoxedExpression}.
  *
@@ -863,6 +863,9 @@ export interface BoxedExpression {
      * The result is in canonical form.
      */
     N(options?: NOptions): BoxedExpression;
+    compile(to?: 'javascript', options?: {
+        optimize: ('simplify' | 'evaluate')[];
+    }): ((args: Record<string, any>) => any | undefined) | undefined;
     solve(vars: Iterable<string>): null | BoxedExpression[];
     /**
      * Synonym for `evaluate()`. If the expression is pure, the value may be

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

@@ -1,4 +1,4 @@
-/* 0.12.7 */
+/* 0.14.0 */
 /**
  * Go through all the rules in the rule set, and for all the rules that match
  * return the rhs of the rule applied to `expr`.

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

@@ -1,4 +1,4 @@
-/* 0.12.7 */
+/* 0.14.0 */
 /**
  * A set of simplification rules.
  *

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

@@ -1,4 +1,4 @@
-/* 0.12.7 */
+/* 0.14.0 */
 export declare const UNIVARIATE_ROOTS: Rule[];
 /**
  * Expression is a function of a single variable (`x`) or an Equality

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

@@ -1,4 +1,4 @@
-/* 0.12.7 */
+/* 0.14.0 */
 export declare function distribute(expr: BoxedExpression[]): BoxedExpression;
 /** Use the multinomial theorem (https://en.wikipedia.org/wiki/Multinomial_theorem) to expand the expression.
  * The expression must be a power of a sum of terms.

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

@@ -1,4 +1,4 @@
-/* 0.12.7 */
+/* 0.14.0 */
 /**
  * Flatten the arguments.
  * If `expr` was canonical, the result it canonical.

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

@@ -1,4 +1,4 @@
-/* 0.12.7 */
+/* 0.14.0 */
 /**
  * Distribute `Negate` (multiply by -1) if expr is a number literal, an
  * addition or multiplication or another `Negate`.

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

@@ -1,4 +1,4 @@
-/* 0.12.7 */
+/* 0.14.0 */
 /**
  * Coefficient of a univariate (single variable) polynomial.
  *

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

@@ -1,4 +1,4 @@
-/* 0.12.7 */
+/* 0.14.0 */
 /**
  * Group terms in a product by common term.
  *

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

@@ -1,4 +1,4 @@
-/* 0.12.7 */
+/* 0.14.0 */
 export declare class Sum {
     private engine;
     private _isCanonical;

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

@@ -1,4 +1,4 @@
-/* 0.12.7 */
+/* 0.14.0 */
 import Decimal from 'decimal.js';
 import { BoxedExpression, Rational } from '../public';
 /**

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

@@ -1,3 +1,3 @@
-/* 0.12.7 */
-export declare const version = "0.12.7";
+/* 0.14.0 */
+export declare const version = "0.14.0";
 export { ComputeEngine } from './compute-engine/compute-engine';

package/dist/types/math-json/math-json-format.d.ts

@@ -1,4 +1,4 @@
-/* 0.12.7 */
+/* 0.14.0 */
     /** A human readable string to annotate this expression, since JSON does not
      * allow comments in its encoding */
     comment?: string;

package/dist/types/math-json/utils.d.ts

@@ -1,4 +1,4 @@
-/* 0.12.7 */
+/* 0.14.0 */
 export declare const MISSING: Expression;
 export declare function isNumberExpression(expr: Expression | null): expr is number | string | MathJsonNumber;
 export declare function isNumberObject(expr: Expression | null): expr is MathJsonNumber;
@@ -39,7 +39,13 @@ export declare function op1(expr: Expression | null | undefined): Expression | n
 export declare function op2(expr: Expression | null | undefined): Expression | null;
 export declare function nops(expr: Expression | null | undefined): number;
 export declare function symbol(expr: Expression | null | undefined): string | null;
+export declare function isListLike(expr: Expression | null): boolean;
+export declare function isMatrixLike(expr: Expression | null): boolean;
 export declare function dictionary(expr: Expression | null): null | Record<string, Expression>;
+/**
+ *  CAUTION: `machineValue()` will return a truncated value if the number
+ *  has a precision outside of the machine range.
+ */
 export declare function machineValue(expr: Expression | null | undefined): number | null;
 /**
  * Return a rational (numer over denom) representation of the expression,

package/dist/types/math-json.d.ts

@@ -1,3 +1,3 @@
-/* 0.12.7 */
+/* 0.14.0 */
 export { isSymbolObject, isStringObject, isFunctionObject, isDictionaryObject, stringValue as getStringValue, head, headName, symbol, applyRecursively, mapArgs, op, nops, dictionary as getDictionary, } from './math-json/utils';
-export declare const version = "0.12.7";
+export declare const version = "0.14.0";

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.12.7",
+  "version": "0.14.0",
   "scripts": {
     "build": "bash ./scripts/build.sh",
     "clean": "bash ./scripts/clean.sh",