@cortex-js/compute-engine 0.6.0 → 0.7.0

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

@@ -1,38 +1,52 @@
-/* 0.6.0 */
+/* 0.7.0 */
 import { AbstractBoxedExpression } from './abstract-boxed-expression';
-import { BoxedExpression, BoxedRuleSet, BoxedSymbolDefinition, IComputeEngine, EvaluateOptions, NOptions, ReplaceOptions, SimplifyOptions, Substitution, Metadata, PatternMatchOption, Domain } from '../public';
+import { BoxedExpression, BoxedRuleSet, BoxedSymbolDefinition, IComputeEngine, EvaluateOptions, NOptions, ReplaceOptions, SimplifyOptions, Substitution, Metadata, PatternMatchOption, BoxedDomain, RuntimeScope, BoxedFunctionDefinition, BoxedBaseDefinition } from '../public';
 /**
  * BoxedSymbol
  *
- * A boxed symbol is a reference to a BoxedSymbolDefinition.
- * The BoxedSymbolDefinition "owns" all the information
+ * A boxed symbol is a reference to a `BoxedSymbolDefinition` or a
+ * `BoxedFunctionDefinition`.
+ *
+ * If a `BoxedSymbolDefinition`, it "owns" all the information
  * about the symbol, its value, domain and various attributes.
+ *
+ * If a `BoxedFunctionDefinition`, it it a reference to a function name,
+ * not a function expression, i.e. `Sin`, not `["Sin", "Pi"]`. This is used
+ * for example in `["InverseFunction", "Sin"]`
  */
 export declare class BoxedSymbol extends AbstractBoxedExpression {
+    private _scope;
     protected _name: string;
     private _hash;
     private _def;
     constructor(ce: IComputeEngine, name: string, metadata?: Metadata);
     get hash(): number;
-    _purge(): undefined;
+    unbind(): undefined;
     get isPure(): boolean;
+    /** A free variable either has no definition, or it has a definition, but no value */
+    get isFree(): boolean;
+    get isConstant(): boolean;
     get isCanonical(): boolean;
     set isCanonical(_va: boolean);
+    get canonical(): BoxedExpression;
     get wikidata(): string;
     get description(): string[];
     get url(): string;
     get complexity(): number;
     get head(): string;
     get symbol(): string;
-    get isMissing(): boolean;
+    get isNothing(): boolean;
     get isLiteral(): boolean;
+    get baseDefinition(): BoxedBaseDefinition | undefined;
     get symbolDefinition(): BoxedSymbolDefinition | undefined;
-    _repairDefinition(): void;
+    get functionDefinition(): BoxedFunctionDefinition | undefined;
+    bind(scope: RuntimeScope | null): void;
     get value(): BoxedExpression | undefined;
     set value(value: BoxedExpression | number | undefined);
     get numericValue(): BoxedExpression | undefined;
-    get domain(): Domain;
-    set domain(d: Domain);
+    get domain(): BoxedDomain;
+    set domain(d: BoxedDomain);
+    get explicitDomain(): BoxedDomain | null;
     get json(): Expression;
     get sgn(): -1 | 0 | 1 | undefined | null;
     has(x: string | string[]): boolean;
@@ -43,6 +57,7 @@ export declare class BoxedSymbol extends AbstractBoxedExpression {
     isLessEqual(rhs: BoxedExpression): boolean | undefined;
     isGreater(rhs: BoxedExpression): boolean | undefined;
     isGreaterEqual(rhs: BoxedExpression): boolean | undefined;
+    get isFunction(): boolean | undefined;
     get isZero(): boolean | undefined;
     get isNotZero(): boolean | undefined;
     get isOne(): boolean | undefined;
@@ -65,7 +80,6 @@ export declare class BoxedSymbol extends AbstractBoxedExpression {
     get isExtendedReal(): boolean | undefined;
     get isComplex(): boolean | undefined;
     get isImaginary(): boolean | undefined;
-    get canonical(): BoxedExpression;
     simplify(options?: SimplifyOptions): BoxedExpression;
     evaluate(options?: EvaluateOptions): BoxedExpression;
     N(options?: NOptions): BoxedExpression;

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

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

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

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

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

@@ -1,4 +1,4 @@
-/* 0.6.0 */
+/* 0.7.0 */
 import Decimal from 'decimal.js';
 import { Expression } from '../../math-json/math-json-format';
 import { BoxedExpression, IComputeEngine, Metadata } from '../public';

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

@@ -1,4 +1,6 @@
-/* 0.6.0 */
+/* 0.7.0 */
+import { Expression } from '../../math-json/math-json-format';
+import { BoxedExpression, IComputeEngine } from '../public';
 export declare function isLatexString(s: unknown): s is string;
 export declare function latexString(s: unknown): string | null;
 /**
@@ -9,18 +11,20 @@ export declare function latexString(s: unknown): string | null;
  * - ['Multiply', 5, 'ImaginaryUnit']
  * - ['Multiply', 'ImaginaryUnit', 5]
  */
-export declare function getImaginaryCoef(expr: BoxedExpression): number;
+export declare function getImaginaryCoef(expr: BoxedExpression): number | null;
 /**
  * Return the free symbols in the expression, recursively.
- * A variable, or free symbol,is a symbol that is not bound to a value.
+ * A variable, or free symbol, is a symbol that is not bound to a value.
  */
 export declare function getVars(expr: BoxedExpression): string[];
+export declare function getSymbols(expr: BoxedExpression, set: Set<string>): Set<string>;
+export declare function getSubexpressions(expr: BoxedExpression, head: string): BoxedExpression[];
 /**
  * For any numeric result, or when boxing numbers,
- * if `ce.useDecimal` is true, create them as Decimal number
- * if `ce.useDecimal` is false, create them as machine number
+ * if `preferDecimal` is true, create them as Decimal number
+ * if `preferDecimal` is false, create them as machine number
  */
-export declare function useDecimal(ce: IComputeEngine): boolean;
+export declare function preferDecimal(ce: IComputeEngine): boolean;
 /** If result of a numeric evaluation is a complex number,
  * return `NaN` if `ce.useComplex` is false
  */
@@ -35,3 +39,16 @@ export declare function complexAllowed(ce: IComputeEngine): boolean;
  */
 export declare function asCanonical(expr: BoxedExpression): BoxedExpression;
 export declare function hashCode(s: string): number;
+export declare function isDictionaryLike(expr: BoxedExpression): boolean;
+export declare function getDictionaryLike(expr: BoxedExpression): {
+    [key: string]: BoxedExpression;
+};
+export declare function isListLike(expr: BoxedExpression): boolean;
+export declare function getListLike(expr: BoxedExpression): BoxedExpression[];
+/**
+ * If `expr` is a number, return it as a Decimal (it might be
+ * in the machine value range or not). Use `isInMachineRange()` to check.
+ *
+ * Use this instead of `machineValue()` when possible, as `machineValue` will truncate decimal numbers to machine numbers
+ */
+export declare function decimalValue(ce: IComputeEngine, expr: Expression | null | undefined): Decimal | null;

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

@@ -1,9 +1,10 @@
-/* 0.6.0 */
+/* 0.7.0 */
 import { Complex } from 'complex.js';
 import { Expression, MathJsonNumber } from '../math-json/math-json-format';
 import { SignalMessage, WarningSignal } from '../common/signals';
-import type { DictionaryCategory, LatexDictionary, LatexDictionaryEntry, LatexString, NumberFormattingOptions, ParseLatexOptions, SerializeLatexOptions } from './latex-syntax/public';
-import { AssumeResult, BoxedExpression, BoxedFunctionDefinition, BoxedSymbolDefinition, IComputeEngine, Dictionary, ExpressionMapInterface, NumericMode as NumericMode, Pattern, RuntimeScope, Scope, SemiBoxedExpression, Substitution, SymbolDefinition, BoxedRuleSet, Rule, JsonSerializationOptions, ComputeEngineStats, Metadata, Domain, DomainExpression } from './public';
+import type { LibraryCategory, LatexDictionary, LatexDictionaryEntry, LatexString, NumberFormattingOptions, ParseLatexOptions, SerializeLatexOptions } from './latex-syntax/public';
+import { AssumeResult, BoxedExpression, BoxedFunctionDefinition, BoxedSymbolDefinition, IComputeEngine, SymbolTable, ExpressionMapInterface, NumericMode as NumericMode, Pattern, RuntimeScope, Scope, SemiBoxedExpression, Substitution, SymbolDefinition, BoxedRuleSet, Rule, JsonSerializationOptions, ComputeEngineStats, Metadata, BoxedDomain, DomainExpression, BoxedLambdaExpression, FunctionDefinition } from './public';
+import { BoxedFunction } from './boxed-expression/boxed-function';
 /**
  *
  * To use the CortexJS Compute Engine, create a `ComputeEngine` instance.
@@ -25,55 +26,70 @@ import { AssumeResult, BoxedExpression, BoxedFunctionDefinition, BoxedSymbolDefi
  */
 export declare class ComputeEngine implements IComputeEngine {
     /** @internal */
-    readonly ZERO: BoxedExpression;
+    readonly _ZERO: BoxedExpression;
     /** @internal */
-    readonly ONE: BoxedExpression;
+    readonly _ONE: BoxedExpression;
     /** @internal */
-    readonly TWO: BoxedExpression;
+    readonly _TWO: BoxedExpression;
     /** @internal */
-    readonly HALF: BoxedExpression;
+    readonly _HALF: BoxedExpression;
     /** @internal */
-    readonly NEGATIVE_ONE: BoxedExpression;
+    readonly _NEGATIVE_ONE: BoxedExpression;
     /** @internal */
-    readonly I: BoxedExpression;
+    readonly _I: BoxedExpression;
     /** @internal */
-    readonly NAN: BoxedExpression;
+    readonly _NAN: BoxedExpression;
     /** @internal */
-    readonly POSITIVE_INFINITY: BoxedExpression;
+    readonly _POSITIVE_INFINITY: BoxedExpression;
     /** @internal */
-    readonly NEGATIVE_INFINITY: BoxedExpression;
+    readonly _NEGATIVE_INFINITY: BoxedExpression;
     /** @internal */
-    readonly COMPLEX_INFINITY: BoxedExpression;
+    readonly _COMPLEX_INFINITY: BoxedExpression;
     /** @internal */
-    DECIMAL_NAN: Decimal;
+    _DECIMAL_NAN: Decimal;
     /** @internal */
-    DECIMAL_ZERO: Decimal;
+    _DECIMAL_ZERO: Decimal;
     /** @internal */
-    DECIMAL_ONE: Decimal;
+    _DECIMAL_ONE: Decimal;
     /** @internal */
-    DECIMAL_TWO: Decimal;
+    _DECIMAL_TWO: Decimal;
     /** @internal */
-    DECIMAL_HALF: Decimal;
+    _DECIMAL_HALF: Decimal;
     /** @internal */
-    DECIMAL_PI: Decimal;
+    _DECIMAL_PI: Decimal;
+    /** @internal */
+    _DECIMAL_NEGATIVE_ONE: Decimal;
     /** @internal */
-    DECIMAL_NEGATIVE_ONE: Decimal;
     private _precision;
+    /** @internal */
     private _numericMode;
+    /** @internal */
     private _latexSyntax?;
+    /** @internal */
     private _tolerance;
+    /** @internal */
     private _decimalTolerance;
+    /** @internal */
     private _cache;
+    /** @internal */
     private _stats;
+    /** @internal */
     private _cost?;
+    /** @internal */
     private _jsonSerializationOptions;
     /** 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 */
     private _commonNumbers;
+    /** @internal */
     private _commonDomains;
+    /** @internal */
     private _latexDictionary?;
     /**
      * The current scope.
@@ -86,20 +102,20 @@ export declare class ComputeEngine implements IComputeEngine {
      * The `ce.context` property represents the current scope.
      *
      */
-    context: RuntimeScope;
+    context: RuntimeScope | null;
     /** Absolute time beyond which evaluation should not proceed.
      * @internal
      */
     deadline?: number;
     /**
-     * Return dictionaries suitable for the specified categories, or `"all"`
+     * Return symbol tables suitable for the specified categories, or `"all"`
      * for all categories (`"arithmetic"`, `"algebra"`, etc...).
      *
-     * A symbol dictionary defines how the symbols and function names in a MathJSON
+     * A symbol table defines how the symbols and function names in a MathJSON
      * expression should be interpreted, i.e. how to evaluate and manipulate them.
      *
      */
-    static getDictionaries(categories?: DictionaryCategory[] | 'all'): Readonly<Dictionary>[];
+    static getSymbolTables(categories?: LibraryCategory[] | LibraryCategory | 'all'): Readonly<SymbolTable>[];
     /**
      * Construct a new `ComputeEngine` instance.
      *
@@ -120,13 +136,13 @@ export declare class ComputeEngine implements IComputeEngine {
      * numeric calculations. Default is 100.
      *
      * @param options.tolerance If the absolute value of the difference of two numbers
-     * is less than `toleranc`, they are considered equal. Used by `chop()` as well.
+     * is less than `tolerance`, they are considered equal. Used by `chop()` as well.
      *
      * @param options.defaultDomain If an unknown symbol is encountered, assume it should
      * be a variable in this domain. **Default** `ExtendedRealNumber`
      */
     constructor(options?: {
-        dictionaries?: Readonly<Dictionary>[];
+        symbolTables?: Readonly<SymbolTable>[];
         latexDictionary?: readonly LatexDictionaryEntry[];
         numericMode?: NumericMode;
         numericPrecision?: number;
@@ -141,18 +157,14 @@ export declare class ComputeEngine implements IComputeEngine {
      *
      * @internal
      */
-    purge(): void;
+    reset(): void;
     /** @internal */
-    _register(expr: BoxedExpression): void;
+    _register(_expr: BoxedExpression): void;
     /** @internal */
-    _unregister(expr: BoxedExpression): void;
+    _unregister(_expr: BoxedExpression): void;
     get stats(): ComputeEngineStats;
     /** @internal */
     _decimal: Decimal.Constructor;
-    /** @internal */
-    decimal: (a: Decimal.Value) => Decimal;
-    /** @internal */
-    complex: (a: number | Complex, b?: number) => Complex;
     /** The precision, or number of significant digits, for numeric calculations
      * such as when calling `ce.N()`.
      *
@@ -180,8 +192,8 @@ export declare class ComputeEngine implements IComputeEngine {
      *
      * **Default:** `"ExtendedRealNumber"`
      */
-    get defaultDomain(): Domain | null;
-    set defaultDomain(domain: Domain | string | null);
+    get defaultDomain(): BoxedDomain | null;
+    set defaultDomain(domain: BoxedDomain | string | null);
     /**
      * Values smaller than the tolerance are considered to be zero for the
      * purpose of comparison, i.e. if `|b - a| <= tolerance`, `b` is considered
@@ -189,6 +201,10 @@ export declare class ComputeEngine implements IComputeEngine {
      */
     get tolerance(): number;
     set tolerance(val: number);
+    /** @internal */
+    decimal(a: Decimal.Value): Decimal;
+    /** @internal */
+    complex(a: number | Complex, b?: number): Complex;
     /** Replace a number that is close to 0 with the exact integer 0.
      *
      * How close to 0 the number has to be to be considered 0 is determined by {@link tolerance}.
@@ -197,25 +213,30 @@ export declare class ComputeEngine implements IComputeEngine {
     chop(n: Decimal): Decimal | 0;
     chop(n: Complex): Complex | 0;
     private get latexSyntax();
-    static getLatexDictionary(domain?: DictionaryCategory | 'all'): Readonly<LatexDictionary>;
+    static getLatexDictionary(domain?: LibraryCategory | 'all'): Readonly<LatexDictionary>;
     set costFunction(fn: ((expr: BoxedExpression) => number) | undefined);
     get costFunction(): (expr: BoxedExpression) => number;
     /**
      * Return a matching symbol definition, starting with the current
-     * scope and going up the scope chain.
+     * scope and going up the scope chain. Prioritize finding a match by
+     * wikidata, if provided.
      */
-    getSymbolDefinition(symbol: string, wikidata?: string): undefined | BoxedSymbolDefinition;
+    lookupSymbol(symbol: string, wikidata?: string, scope?: RuntimeScope): undefined | BoxedSymbolDefinition;
     /**
-     * Return the definition for a function matching this head and
-     * these arguments.
+     * Return the definition for a function matching this head.
+     *
+     * Start looking in the current context, than up the scope chain.
      *
-     * Start looking in the current scope, than up the scope chain.
+     * This is a very rough lookup, since it doesn't account for the domain
+     * of the argument or the codomain. However, it is useful during parsing
+     * to differentiate between symbols that might represent a function application, e.g. `f` vs `x`.
      */
-    getFunctionDefinition(head: string, args?: BoxedExpression[]): undefined | BoxedFunctionDefinition;
+    lookupFunction(head: string, scope?: RuntimeScope): undefined | BoxedFunctionDefinition;
     /**
      * Add (or replace) a definition for a symbol in the current scope.
      */
     defineSymbol(def: SymbolDefinition): BoxedSymbolDefinition;
+    defineFunction(def: FunctionDefinition): BoxedFunctionDefinition;
     /**
      *
      * Create a new scope and add it to the top of the scope stack
@@ -225,7 +246,7 @@ export declare class ComputeEngine implements IComputeEngine {
      *
      */
     pushScope(options?: {
-        dictionary?: Readonly<Dictionary> | Readonly<Dictionary>[];
+        symbolTable?: Readonly<SymbolTable> | Readonly<SymbolTable>[];
         assumptions?: (LatexString | Expression)[];
         scope?: Partial<Scope>;
     }): void;
@@ -263,8 +284,9 @@ export declare class ComputeEngine implements IComputeEngine {
     box(expr: Decimal | Complex | [num: number, denom: number] | SemiBoxedExpression): BoxedExpression;
     fn(head: string, ops: BoxedExpression[], metadata?: Metadata): BoxedExpression;
     /** @internal */
-    _fn(head: string | BoxedExpression, ops: BoxedExpression[], metadata?: Metadata): BoxedExpression;
-    error(val: BoxedExpression, message: string, messageArg: SemiBoxedExpression): BoxedExpression;
+    _fn(head: string | BoxedExpression, ops: BoxedExpression[], metadata?: Metadata): BoxedFunction;
+    error(message: ['invalid-domain', ...SemiBoxedExpression[]], where?: SemiBoxedExpression): BoxedDomain;
+    error(message: string | [string, ...SemiBoxedExpression[]], where?: SemiBoxedExpression): BoxedExpression;
     add(ops: BoxedExpression[], metadata?: Metadata): BoxedExpression;
     mul(ops: BoxedExpression[], metadata?: Metadata): BoxedExpression;
     power(base: BoxedExpression, exponent: number | [number, number] | BoxedExpression, metadata?: Metadata): BoxedExpression;
@@ -274,14 +296,15 @@ export declare class ComputeEngine implements IComputeEngine {
     pair(first: BoxedExpression, second: BoxedExpression, metadata?: Metadata): BoxedExpression;
     tuple(elements: BoxedExpression[], metadata?: Metadata): BoxedExpression;
     string(s: string, metadata?: Metadata): BoxedExpression;
-    symbol(sym: string, metadata?: Metadata): BoxedExpression;
-    domain(domain: BoxedExpression | DomainExpression | Domain, metadata?: Metadata): Domain;
+    symbol(name: string, metadata?: Metadata): BoxedExpression;
+    domain(domain: BoxedExpression | DomainExpression | BoxedDomain, metadata?: Metadata): BoxedDomain;
+    lambda(expr: SemiBoxedExpression, sig: BoxedDomain): BoxedLambdaExpression;
     number(value: number | MathJsonNumber | Decimal | Complex | [num: number, denom: number], metadata?: Metadata): BoxedExpression;
     rules(rules: Rule[]): BoxedRuleSet;
     pattern(expr: LatexString | SemiBoxedExpression): Pattern;
-    parse(s: LatexString | string): BoxedExpression;
+    parse(latex: LatexString | string): BoxedExpression;
     parse(s: null): null;
-    parse(s: LatexString | string | null): null | BoxedExpression;
+    parse(latex: LatexString | string | null): null | BoxedExpression;
     serialize(x: Expression | BoxedExpression): string;
     get latexOptions(): NumberFormattingOptions & ParseLatexOptions & SerializeLatexOptions;
     set latexOptions(opts: Partial<NumberFormattingOptions> & Partial<ParseLatexOptions> & Partial<SerializeLatexOptions>);
@@ -297,7 +320,8 @@ export declare class ComputeEngine implements IComputeEngine {
      * ```
      */
     ask(pattern: LatexString | SemiBoxedExpression): Substitution[];
-    assume(symbol: LatexString | SemiBoxedExpression, domain: string | BoxedExpression): AssumeResult;
+    infer(symbol: BoxedExpression | string, _domain: BoxedDomain | DomainExpression): AssumeResult;
+    assume(symbol: LatexString | SemiBoxedExpression, domainValue: BoxedDomain | DomainExpression | Expression | BoxedExpression): AssumeResult;
     assume(predicate: LatexString | SemiBoxedExpression): AssumeResult;
     forget(symbol: undefined | string | string[]): void;
 }

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

@@ -1,3 +1,3 @@
-/* 0.6.0 */
+/* 0.7.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.6.0 */
+/* 0.7.0 */
 import { Decimal } from 'decimal.js';
 import { BoxedExpression } from './public';
 /** Quickly determine the numeric domain of a number or constant

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

@@ -1,2 +1,2 @@
-/* 0.6.0 */
+/* 0.7.0 */
 export declare const DEFINITIONS_ALGEBRA: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.6.0 */
+/* 0.7.0 */
 export declare const DEFINITIONS_ARITHMETIC: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.6.0 */
+/* 0.7.0 */
 export declare const DEFINITIONS_CALCULUS: LatexDictionary;

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

@@ -1,4 +1,2 @@
-/* 0.6.0 */
-import { LatexDictionary, Serializer } from '../public';
-export declare function serializeLatex(serializer: Serializer, expr: Expression | null): string;
+/* 0.7.0 */
 export declare const DEFINITIONS_CORE: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.6.0 */
+/* 0.7.0 */
 export declare const DEFINITIONS_INEQUALITIES: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.6.0 */
+/* 0.7.0 */
 export declare const DEFINITIONS_LOGIC: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.6.0 */
+/* 0.7.0 */
 export declare const DEFINITIONS_OTHERS: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.6.0 */
+/* 0.7.0 */
 export declare const DEFINITIONS_SETS: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.6.0 */
+/* 0.7.0 */
 export declare const DEFINITIONS_SYMBOLS: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.6.0 */
+/* 0.7.0 */
 export declare const DEFINITIONS_TRIGONOMETRY: LatexDictionary;

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

@@ -1,4 +1,4 @@
-/* 0.6.0 */
+/* 0.7.0 */
 import { WarningSignal } from '../../../common/signals';
 export declare type CommonEntry = {
     name?: string;
@@ -7,10 +7,12 @@ export declare type CommonEntry = {
 export declare type SymbolEntry = CommonEntry & {
     kind: 'symbol';
     precedence: number;
-    optionalLatexArg: number;
-    requiredLatexArg: number;
     parse: SymbolParseHandler;
 };
+export declare type FunctionEntry = CommonEntry & {
+    kind: 'function';
+    parse: FunctionParseHandler;
+};
 export declare type MatchfixEntry = CommonEntry & {
     kind: 'matchfix';
     openDelimiter: Delimiter | LatexToken[];
@@ -35,14 +37,13 @@ export declare type PostfixEntry = CommonEntry & {
 };
 export declare type EnvironmentEntry = CommonEntry & {
     kind: 'environment';
-    optionalLatexArg: number;
-    requiredLatexArg: number;
     parse: EnvironmentParseHandler;
 };
-export declare type IndexedLatexDictionaryEntry = SymbolEntry | MatchfixEntry | InfixEntry | PrefixEntry | PostfixEntry | EnvironmentEntry;
+export declare type IndexedLatexDictionaryEntry = FunctionEntry | SymbolEntry | MatchfixEntry | InfixEntry | PrefixEntry | PostfixEntry | EnvironmentEntry;
 export declare type IndexedLatexDictionary = {
     lookahead: number;
     name: Map<string, IndexedLatexDictionaryEntry>;
+    function: Map<string, FunctionEntry[]>;
     symbol: (Map<LatexString, SymbolEntry[]> | null)[];
     prefix: (Map<LatexString, PrefixEntry[]> | null)[];
     infix: (Map<LatexString, InfixEntry[]> | null)[];
@@ -52,5 +53,5 @@ export declare type IndexedLatexDictionary = {
 };
 export declare function indexLatexDictionary(dic: readonly LatexDictionaryEntry[], onError: (sig: WarningSignal) => void): IndexedLatexDictionary;
 export declare const DEFAULT_LATEX_DICTIONARY: {
-    [category in DictionaryCategory]?: LatexDictionary;
+    [category in LibraryCategory]?: LatexDictionary;
 };

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

@@ -1,4 +1,4 @@
-/* 0.6.0 */
+/* 0.7.0 */
 import { Serializer } from './serializer';
 import { Expression } from '../../math-json/math-json-format';
 import { WarningSignalHandler } from '../../common/signals';
@@ -6,7 +6,7 @@ import { IComputeEngine } from '../public';
 export declare const DEFAULT_SERIALIZE_LATEX_OPTIONS: Required<SerializeLatexOptions>;
 export declare class LatexSyntax {
     onError: WarningSignalHandler;
-    options: NumberFormattingOptions & ParseLatexOptions & SerializeLatexOptions;
+    readonly options: NumberFormattingOptions & ParseLatexOptions & SerializeLatexOptions;
     readonly computeEngine: IComputeEngine;
     private dictionary;
     private _serializer?;
@@ -16,7 +16,7 @@ export declare class LatexSyntax {
         onError?: WarningSignalHandler;
     });
     updateOptions(opt: Partial<NumberFormattingOptions> & Partial<ParseLatexOptions> & Partial<SerializeLatexOptions>): void;
-    static getDictionary(category?: DictionaryCategory | 'all'): Readonly<LatexDictionary>;
+    static getDictionary(category?: LibraryCategory | 'all'): Readonly<LatexDictionary>;
     parse(latex: LatexString): Expression;
     serialize(expr: Expression): LatexString;
     get serializer(): Serializer;