@cortex-js/compute-engine 0.29.1 → 0.30.1

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

@@ -1,15 +1,16 @@
-/* 0.29.1 */
+/* 0.30.1 */
 import { Decimal } from 'decimal.js';
-import { Expression, MathJsonIdentifier, MathJsonNumber } from '../math-json/types';
-import { SymbolDefinition, FunctionDefinition, AngularUnit, AssignValue, AssumeResult, BoxedExpression, BoxedFunctionDefinition, BoxedRule, BoxedRuleSet, BoxedSubstitution, BoxedSymbolDefinition, CanonicalOptions, ComputeEngineStats, EvaluateOptions, ExpressionMapInterface, IdentifierDefinitions, Metadata, Rule, RuntimeScope, Scope, SemiBoxedExpression, ComputeEngine as IComputeEngine } from './global-types';
-import type { BigNum, Rational } from './numerics/types';
+import { Type, TypeResolver, TypeString } from '../common/type/types';
+import { BoxedType } from '../common/type/boxed-type';
+import type { OneOf } from '../common/one-of';
+import { ConfigurationChangeListener } from '../common/configuration-change';
+import type { Expression, MathJsonSymbol, MathJsonNumberObject } from '../math-json/types';
+import type { ValueDefinition, OperatorDefinition, AngularUnit, AssignValue, AssumeResult, BoxedExpression, BoxedRule, BoxedRuleSet, BoxedSubstitution, CanonicalOptions, SymbolDefinitions, Metadata, Rule, Scope, EvalContext, SemiBoxedExpression, ComputeEngine as IComputeEngine, BoxedDefinition, SymbolDefinition } from './global-types';
+import type { LatexDictionaryEntry, LatexString, LibraryCategory, ParseLatexOptions } from './latex-syntax/types';
 import { type IndexedLatexDictionary } from './latex-syntax/dictionary/definitions';
-import './boxed-expression/serialize';
+import type { BigNum, Rational } from './numerics/types';
 import { ExactNumericValueData, NumericValue, NumericValueData } from './numeric-value/types';
-import type { LatexDictionaryEntry, LatexString, LibraryCategory, ParseLatexOptions } from './latex-syntax/types';
-import type { OneOf } from '../common/one-of';
-import { Type, TypeString } from '../common/type/types';
-import { BoxedType } from '../common/type/boxed-type';
+import './boxed-expression/serialize';
 export * from './global-types';
 /**
  *
@@ -94,9 +95,8 @@ export declare class ComputeEngine implements IComputeEngine {
     private _bignumTolerance;
     private _negBignumTolerance;
     /** @internal */
-    private _cache;
-    /** @internal */
-    private _stats;
+    private __cache;
+    private _configurationChangeTracker;
     /** @internal */
     private _cost?;
     /** @internal */
@@ -104,25 +104,39 @@ export declare class ComputeEngine implements IComputeEngine {
     /** @internal */
     private _commonNumbers;
     /**
-     * The current scope.
-     *
-     * A **scope** stores the definition of symbols and assumptions.
-     *
-     * Scopes form a stack, and definitions in more recent
-     * scopes can obscure definitions from older scopes.
+     * The stack of evaluation contexts.
      *
-     * The `ce.context` property represents the current scope.
+     * An **evaluation context** contains bindings of symbols to their
+     * values, assumptions, and the matching scope.
      *
      */
-    context: RuntimeScope | null;
+    _evalContextStack: EvalContext[];
+    /** The current evaluation context */
+    get context(): EvalContext;
+    get contextStack(): ReadonlyArray<EvalContext>;
+    set contextStack(stack: ReadonlyArray<EvalContext>);
+    /** @internal */
+    get _typeResolver(): TypeResolver;
     /**
-     * Generation.
+     * Declare a new type in the current scope.
      *
+     * By default, types are nominal. To declare a structural type, set
+     * `alias` to `true`.
+     */
+    declareType(name: string, type: BoxedType | Type | TypeString, { alias }?: {
+        alias?: boolean;
+    }): void;
+    /**
+     * A list of the function calls to the current evaluation context,
+     * most recent first.
+     */
+    get trace(): ReadonlyArray<string>;
+    /**
      * The generation is incremented each time the context changes.
      * It is used to invalidate caches.
      * @internal
      */
-    generation: number;
+    _generation: number;
     /** In strict mode (the default) the Compute Engine performs
      * validation of domains and signature and may report errors.
      *
@@ -138,21 +152,19 @@ export declare class ComputeEngine implements IComputeEngine {
      */
     deadline?: number;
     /**
-     * Return identifier tables suitable for the specified categories, or `"all"`
+     * Return symbol tables suitable for the specified categories, or `"all"`
      * for all categories (`"arithmetic"`, `"algebra"`, etc...).
      *
-     * An identifier table defines how the symbols and function names in a
-     * MathJSON expression should be interpreted, i.e. how to evaluate and
-     * manipulate them.
+     * A symbol table defines how to evaluate and manipulate symbols.
      *
      */
     /** @internal */
     private _latexDictionaryInput;
     /** @internal */
-    _indexedLatexDictionary: IndexedLatexDictionary;
+    __indexedLatexDictionary: IndexedLatexDictionary;
     /** @internal */
     _bignum: Decimal.Constructor;
-    static getStandardLibrary(categories?: LibraryCategory[] | LibraryCategory | 'all'): readonly IdentifierDefinitions[];
+    static getStandardLibrary(categories?: LibraryCategory[] | LibraryCategory | 'all'): readonly SymbolDefinitions[];
     /**
      * Return a LaTeX dictionary suitable for the specified category, or `"all"`
      * for all categories (`"arithmetic"`, `"algebra"`, etc...).
@@ -178,7 +190,7 @@ export declare class ComputeEngine implements IComputeEngine {
      *  ...ce.getLatexDictionary("all"),
      *  {
      *    kind: "function",
-     *    identifierTrigger: "concat",
+     *    symbolTrigger: "concat",
      *    parse: "Concatenate"
      *  }
      * ];
@@ -188,7 +200,7 @@ export declare class ComputeEngine implements IComputeEngine {
     /**
      * Construct a new `ComputeEngine` instance.
      *
-     * Identifier tables define functions and symbols (in `options.ids`).
+     * Symbols tables define functions, constants and variables (in `options.ids`).
      * If no table is provided the MathJSON Standard Library is used (`ComputeEngine.getStandardLibrary()`)
      *
      * The LaTeX syntax dictionary is defined in `options.latexDictionary`.
@@ -207,14 +219,15 @@ export declare class ComputeEngine implements IComputeEngine {
      * `chop()` as well.
      */
     constructor(options?: {
-        ids?: readonly IdentifierDefinitions[];
+        ids?: readonly SymbolDefinitions[];
         precision?: number | 'machine';
         tolerance?: number | 'auto';
     });
-    toString(): string;
+    toJSON(): string;
+    [Symbol.toStringTag]: string;
     get latexDictionary(): Readonly<LatexDictionaryEntry[]>;
     set latexDictionary(dic: Readonly<LatexDictionaryEntry[]>);
-    get indexedLatexDictionary(): IndexedLatexDictionary;
+    get _indexedLatexDictionary(): IndexedLatexDictionary;
     /** After the configuration of the engine has changed, clear the caches
      * so that new values can be recalculated.
      *
@@ -222,13 +235,9 @@ export declare class ComputeEngine implements IComputeEngine {
      *
      * @internal
      */
-    reset(): void;
-    /** @internal */
-    _register(_expr: BoxedExpression): void;
+    _reset(): void;
     /** @internal */
-    _unregister(_expr: BoxedExpression): void;
-    /** @internal */
-    get stats(): ComputeEngineStats;
+    listenToConfigurationChange(tracker: ConfigurationChangeListener): () => void;
     get precision(): number;
     /** The precision, or number of significant digits, of numeric
      * calculations.
@@ -238,6 +247,13 @@ export declare class ComputeEngine implements IComputeEngine {
      *
      * Trigonometric operations are accurate for precision up to 1,000.
      *
+     * If the precision is set to `machine`, floating point numbers
+     * are represented internally as a 64-bit floating point number (as
+     * per IEEE 754-2008), with a 52-bit mantissa, which gives about 15
+     * digits of precision.
+     *
+     * If the precision is set to `auto`, the precision is set to a default value.
+     *
      */
     set precision(p: number | 'machine' | 'auto');
     /**
@@ -252,15 +268,31 @@ export declare class ComputeEngine implements IComputeEngine {
      */
     get angularUnit(): AngularUnit;
     set angularUnit(u: AngularUnit);
+    /** Throw a `CancellationError` when the duration of an evaluation exceeds
+     * the time limit.
+     *
+     * Time in milliseconds, default 2000 ms = 2 seconds.
+     *
+     */
     get timeLimit(): number;
     set timeLimit(t: number);
     private _timeLimit;
     /** The time after which the time limit has been exceeded */
     _deadline: number | undefined;
     get _timeRemaining(): number;
+    /** Throw `CancellationError` `iteration-limit-exceeded` when the iteration limit
+     * in a loop is exceeded. Default: no limits.
+     *
+     * @experimental
+     */
     get iterationLimit(): number;
     set iterationLimit(t: number);
     private _iterationLimit;
+    /** Signal `recursion-depth-exceeded` when the recursion depth for this
+     * scope is exceeded.
+     *
+     * @experimental
+     */
     get recursionLimit(): number;
     set recursionLimit(t: number);
     private _recursionLimit;
@@ -388,118 +420,101 @@ export declare class ComputeEngine implements IComputeEngine {
     get costFunction(): (expr: BoxedExpression) => number;
     set costFunction(fn: ((expr: BoxedExpression) => number) | undefined);
     /**
-     * Return a matching symbol definition, starting with the current
-     * scope and going up the scope chain. Prioritize finding a match by
-     * wikidata, if provided.
-     */
-    lookupSymbol(symbol: string, wikidata?: string, scope?: RuntimeScope): undefined | BoxedSymbolDefinition;
-    /**
-     * Return the definition for a function with this operator name.
-     *
-     * Start looking in the current context, 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`.
+     * Return definition matching the symbol, starting with the current
+     * lexical scope and going up the scope chain.
      */
-    lookupFunction(name: MathJsonIdentifier, scope?: RuntimeScope | null): undefined | BoxedFunctionDefinition;
+    lookupDefinition(id: MathJsonSymbol): undefined | BoxedDefinition;
     /**
      * Associate a new definition to a symbol in the current context.
      *
-     * If a definition existed previously, it is replaced.
-     *
-     *
      * For internal use. Use `ce.declare()` instead.
      *
      * @internal
      */
-    defineSymbol(name: string, def: SymbolDefinition): BoxedSymbolDefinition;
-    _defineSymbol(name: string, def: SymbolDefinition): BoxedSymbolDefinition;
+    _declareSymbolValue(name: MathJsonSymbol, def: Partial<ValueDefinition>, scope?: Scope): BoxedDefinition;
     /**
-     * Associate a new FunctionDefinition to a function in the current context.
-     *
-     * If a definition existed previously, it is replaced.
+     * Associate a new OperatorDefinition to a function in the current context.
      *
      * For internal use. Use `ce.declare()` instead.
      *
      * @internal
      */
-    defineFunction(name: string, def: FunctionDefinition): BoxedFunctionDefinition;
-    _defineFunction(name: string, def: FunctionDefinition): BoxedFunctionDefinition;
+    _declareSymbolOperator(name: string, def: OperatorDefinition, scope?: Scope): BoxedDefinition;
     /**
      *
-     * Create a new scope and add it to the top of the scope stack
+     * Create a new lexical scope and matching evaluation context and add it
+     * to the evaluation context stack.
      *
      */
-    pushScope(scope?: Partial<Scope>): IComputeEngine;
-    /** Remove the most recent scope from the scope stack, and set its
-     *  parent scope as the current scope. */
-    popScope(): IComputeEngine;
-    /** Set the current scope, return the previous scope. */
-    swapScope(scope: RuntimeScope | null): RuntimeScope | null;
+    pushScope(scope?: Scope, name?: string): void;
+    /**
+     * Remove the most recent scope from the scope stack.
+     */
+    popScope(): void;
+    /** @internal */
+    _pushEvalContext(scope: Scope, name?: string): void;
+    /** @internal */
+    _popEvalContext(): void;
+    /** @internal */
+    _inScope<T>(scope: Scope | undefined, f: () => T): T;
     /** @internal */
-    _printScope(options?: {
+    _printStack(options?: {
         details?: boolean;
         maxDepth?: number;
-    }, scope?: RuntimeScope | null, depth?: number): RuntimeScope | null;
+    }): void;
     /**
-     * Reset the value of any identifiers that have been assigned a value
-     * in the current scope.
+     * Use `ce.box(name)` instead
      * @internal */
-    resetContext(): void;
+    _getSymbolValue(id: MathJsonSymbol): BoxedExpression | undefined;
     /**
-     * Declare an identifier: specify their type and other attributes,
-     * including optionally a value.
+     * For internal use. Use `ce.assign(name, value)` instead.
+     * @internal
+     */
+    _setSymbolValue(id: MathJsonSymbol, value: BoxedExpression | boolean | number | undefined): void;
+    /**
+     * Declare a symbol in the current lexical scope: specify their type and
+     * other attributes, including optionally a value.
      *
-     * Once the type of an identifier has been declared, it cannot be changed.
+     * Once the type of a symbol has been declared, it cannot be changed.
      * The type information is used to calculate the canonical form of
      * expressions and ensure they are valid. If the type could be changed
      * after the fact, previously valid expressions could become invalid.
      *
-     * Set the type to `any` type for a very generic type, or use `unknown`
-     * if the type is not known yet. If `unknown`, the type will be inferred
-     * based on usage.
+     * Set the type to `unknown` if the type is not known yet: it will be
+     * inferred based on usage. Use `any` for a very generic type.
      *
-     * An identifier can be redeclared with a different type, but only if
-     * the type of the identifier was inferred. If the domain was explicitly
-     * set, the identifier cannot be redeclared.
      *
      */
-    declare(id: string, def: TypeString | OneOf<[Type, SymbolDefinition, FunctionDefinition]>): IComputeEngine;
-    declare(identifiers: {
-        [id: string]: Type | TypeString | OneOf<[SymbolDefinition, FunctionDefinition]>;
+    declare(id: string, def: Type | TypeString | Partial<SymbolDefinition>, scope?: Scope): IComputeEngine;
+    declare(symbols: {
+        [id: string]: Type | TypeString | Partial<SymbolDefinition>;
     }): IComputeEngine;
-    /** Assign a value to an identifier in the current scope.
-     * Use `undefined` to reset the identifier to no value.
-     *
-     * The identifier should be a valid MathJSON identifier
-     * not a LaTeX string.
+    /**
+     * Return an evaluation context in which the symbol is defined.
+     */
+    lookupContext(id: MathJsonSymbol): EvalContext | undefined;
+    /**  Find the context in the stack frame, and set the stack frame to
+     * it. This is used to evaluate expressions in the context of
+     * a different scope.
+     */
+    _swapContext(context: EvalContext): void;
+    /**
+     * Assign a value to a symbol in the current scope.
+     * Use `undefined` to reset the symbol to no value.
      *
-     * The identifier can take the form "f(x, y") to create a function
-     * with two parameters, "x" and "y".
+     * The symbol should be a valid MathJSON symbol not a LaTeX string.
      *
-     * If the id was not previously declared, assigning a value will declare it.
-     * Its type is inferred from the value.
+     * If the symbol was not previously declared, it will be declared as a
+     * symbol of a type inferred from its value.
      *
-     * To more precisely define the type of the identifier, use `ce.declare()`
+     * To more precisely define the type of the symbol, use `ce.declare()`
      * instead, which allows you to specify the type, value and other
-     * attributes of the identifier.
+     * attributes of the symbol.
      */
     assign(id: string, value: AssignValue): IComputeEngine;
     assign(ids: {
         [id: string]: AssignValue;
     }): IComputeEngine;
-    /**
-     * Same as assign(), but for internal use:
-     * - skips validity checks
-     * - does not auto-declare
-     * - if assigning to a function, must pass a JS function
-     *
-     * @internal
-     */
-    _assign(id: string, value: BoxedExpression | ((ops: ReadonlyArray<BoxedExpression>, options: Partial<EvaluateOptions> & {
-        engine?: IComputeEngine;
-    }) => BoxedExpression | undefined)): void;
     /**
      * Return false if the execution should stop.
      *
@@ -509,22 +524,24 @@ export declare class ComputeEngine implements IComputeEngine {
      *
      * @internal
      */
-    shouldContinueExecution(): boolean;
+    _shouldContinueExecution(): boolean;
     /** @internal */
-    checkContinueExecution(): void;
+    _checkContinueExecution(): void;
     /** @internal */
-    cache<T>(cacheName: string, build: () => T, purge?: (t: T) => T | undefined): T;
+    _cache<T>(cacheName: string, build: () => T, purge?: (t: T) => T | undefined): T;
     /** Return a boxed expression from a number, string or semiboxed expression.
      * Calls `ce.function()`, `ce.number()` or `ce.symbol()` as appropriate.
      */
     box(expr: NumericValue | SemiBoxedExpression, options?: {
         canonical?: CanonicalOptions;
         structural?: boolean;
+        scope?: Scope | undefined;
     }): BoxedExpression;
     function(name: string, ops: ReadonlyArray<BoxedExpression> | ReadonlyArray<Expression>, options?: {
         metadata?: Metadata;
-        canonical: CanonicalOptions;
-        structural: boolean;
+        canonical?: CanonicalOptions;
+        structural?: boolean;
+        scope?: Scope | undefined;
     }): BoxedExpression;
     /**
      *
@@ -546,39 +563,45 @@ export declare class ComputeEngine implements IComputeEngine {
     tuple(...elements: ReadonlyArray<BoxedExpression>): BoxedExpression;
     type(type: Type | TypeString | BoxedType): BoxedType;
     string(s: string, metadata?: Metadata): BoxedExpression;
-    /** Return a boxed symbol */
+    /** Create a boxed symbol */
     symbol(name: string, options?: {
-        metadata?: Metadata;
         canonical?: CanonicalOptions;
     }): BoxedExpression;
     /**
      * This function tries to avoid creating a boxed number if `num` corresponds
      * to a common value for which we have a shared instance (-1, 0, NaN, etc...)
      */
-    number(value: number | bigint | string | NumericValue | MathJsonNumber | Decimal | Complex | Rational, options?: {
+    number(value: number | bigint | string | NumericValue | MathJsonNumberObject | Decimal | Complex | Rational, options?: {
         metadata: Metadata;
         canonical: CanonicalOptions;
     }): BoxedExpression;
     rules(rules: Rule | ReadonlyArray<Rule | BoxedRule> | BoxedRuleSet | undefined | null, options?: {
         canonical?: boolean;
     }): BoxedRuleSet;
+    /**
+     * Return a set of built-in rules.
+     */
     getRuleSet(id?: string): BoxedRuleSet | undefined;
     /**
      * Return a function expression, but the caller is responsible for making
      * sure that the arguments are canonical.
      *
-     * Unlike ce.function(), the operator of the  result is the name argument.
+     * Unlike `ce.function()`, the operator of the result is the name argument.
      * Calling this function directly is potentially unsafe, as it bypasses
      * the canonicalization of the arguments.
      *
      * For example:
      *
-     * - `ce._fn('Multiply', [1, 'x'])` returns `['Multiply', 1, 'x']` as a canonical expression, even though it doesn't follow the canonical form
-     * - `ce.function('Multiply', [1, 'x']` returns `'x'` which is the correct canonical form
+     * - `ce._fn('Multiply', [1, 'x'])` returns `['Multiply', 1, 'x']` as a
+     *   canonical expression, even though it doesn't follow the canonical form
+     * - `ce.function('Multiply', [1, 'x']` returns `'x'` which is the correct
+     *    canonical form
      *
      * @internal */
-    _fn(name: MathJsonIdentifier, ops: ReadonlyArray<BoxedExpression>, options?: Metadata & {
+    _fn(name: MathJsonSymbol, ops: ReadonlyArray<BoxedExpression>, options?: {
+        metadata?: Metadata;
         canonical?: boolean;
+        scope?: Scope;
     }): BoxedExpression;
     /**
      * Parse a string of LaTeX and return a corresponding `BoxedExpression`.
@@ -592,7 +615,6 @@ export declare class ComputeEngine implements IComputeEngine {
     parse(latex: LatexString, options?: Partial<ParseLatexOptions> & {
         canonical?: CanonicalOptions;
     }): BoxedExpression;
-    get assumptions(): ExpressionMapInterface<boolean>;
     /**
      * Return a list of all the assumptions that match a pattern.
      *
@@ -622,6 +644,14 @@ export declare class ComputeEngine implements IComputeEngine {
      *
      */
     assume(predicate: BoxedExpression): AssumeResult;
-    /** Remove all assumptions about one or more symbols */
-    forget(symbol: undefined | string | string[]): void;
+    /**
+     * Remove all assumptions about one or more symbols.
+     *
+     * `ce.forget()` will remove all assumptions.
+     *
+     * Note that assumptions are scoped, so when exiting the current lexical
+     * scope, the previous assumptions will be restored.
+     *
+     * */
+    forget(symbol: undefined | MathJsonSymbol | MathJsonSymbol[]): void;
 }

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

@@ -1,2 +1,2 @@
-/* 0.29.1 */
+/* 0.30.1 */
 export declare const DEFINITIONS_ALGEBRA: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.29.1 */
+/* 0.30.1 */
 export declare const DEFINITIONS_ARITHMETIC: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.29.1 */
+/* 0.30.1 */
 export declare const DEFINITIONS_CALCULUS: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.29.1 */
+/* 0.30.1 */
 export declare const DEFINITIONS_COMPLEX: LatexDictionary;

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

@@ -1,4 +1,4 @@
-/* 0.29.1 */
+/* 0.30.1 */
 export declare const DEFINITIONS_CORE: LatexDictionary;
 export declare const DELIMITERS_SHORTHAND: {
     '(': string;

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

@@ -1,2 +1,2 @@
-/* 0.29.1 */
+/* 0.30.1 */
 export declare const DEFINITIONS_LINEAR_ALGEBRA: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.29.1 */
+/* 0.30.1 */
 export declare const DEFINITIONS_LOGIC: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.29.1 */
+/* 0.30.1 */
 export declare const DEFINITIONS_OTHERS: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.29.1 */
+/* 0.30.1 */
 export declare const DEFINITIONS_INEQUALITIES: LatexDictionaryEntry[];

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

@@ -1,2 +1,2 @@
-/* 0.29.1 */
+/* 0.30.1 */
 export declare const DEFINITIONS_SETS: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.29.1 */
+/* 0.30.1 */
 export declare const DEFINITIONS_STATISTICS: LatexDictionary;

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

@@ -1,3 +1,3 @@
-/* 0.29.1 */
+/* 0.30.1 */
 export declare const SYMBOLS: [string, string, number][];
 export declare const DEFINITIONS_SYMBOLS: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.29.1 */
+/* 0.30.1 */
 export declare const DEFINITIONS_TRIGONOMETRY: LatexDictionary;

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

@@ -1,14 +1,14 @@
-/* 0.29.1 */
+/* 0.30.1 */
 import { Delimiter, EnvironmentParseHandler, ExpressionParseHandler, InfixParseHandler, LatexDictionary, LatexDictionaryEntry, LatexString, LatexToken, LibraryCategory, MatchfixParseHandler, PostfixParseHandler, Precedence, SerializeHandler } from '../types';
 export type CommonEntry = {
     /** Note: a name is required if a serialize handler is provided */
     name?: string;
     serialize?: SerializeHandler;
-    /** Note: not all kinds have a `latexTrigger` or `identifierTrigger`.
+    /** Note: not all kinds have a `latexTrigger` or `symbolTrigger`.
      * For example, matchfix operators use `openTrigger`/`closeTrigger`
      */
     latexTrigger?: LatexString;
-    identifierTrigger?: string;
+    symbolTrigger?: string;
 };
 export type IndexedSymbolEntry = CommonEntry & {
     kind: 'symbol';

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

@@ -0,0 +1,21 @@
+/* 0.30.1 */
+import { Parser } from './types';
+/** For error handling, if we have a symbol prefix, assume
+ * the symbol is invalid (it would have been captured by
+ * `matchSymbol()` otherwise) and return an error expression */
+export declare function parseInvalidSymbol(parser: Parser): Expression | null;
+/**
+ * Match a symbol.
+ *
+ * It can be:
+ * - a sequence of emojis: `👍🏻👍🏻👍🏻`
+ * - a single-letter: `a`
+ * - some LaTeX commands: `\alpha`
+ * - a multi-letter id with a prefix: `\operatorname{speed}`
+ * - an id with multiple prefixes:
+ *  `\mathbin{\mathsf{T}}`
+ * - an id with modifiers:
+ *    - `\mathrm{\alpha_{12}}` or
+ *    - `\mathit{speed\unicode{"2012}of\unicode{"2012}sound}`
+ */
+export declare function parseSymbol(parser: Parser): MathJsonSymbol | null;