@cortex-js/compute-engine 0.24.0 → 0.25.0

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

@@ -1,15 +1,3 @@
-/* 0.24.0 */
-import { Decimal } from 'decimal.js';
-import { Expression } from '../../math-json/math-json-format';
-import { BoxedExpression, IComputeEngine, Metadata, Rational } from '../public';
-/**
- * The canonical version of `serializeJsonFunction()` applies
- * additional transformations to "reverse" some of the effects
- * of canonicalization (or boxing), for example it uses `Divide`
- * instead of `Multiply`/`Power` when applicable.
- */
-export declare function serializeJsonCanonicalFunction(ce: IComputeEngine, head: string | BoxedExpression, args: BoxedExpression[], metadata?: Metadata): Expression;
-export declare function serializeJsonFunction(ce: IComputeEngine, head: string | BoxedExpression, args: (undefined | BoxedExpression)[], metadata?: Metadata): Expression;
-export declare function serializeJsonString(ce: IComputeEngine, s: string): Expression;
-export declare function serializeJsonSymbol(ce: IComputeEngine, sym: string, metadata?: Metadata): Expression;
-export declare function serializeJsonNumber(ce: IComputeEngine, value: number | Decimal | Complex | Rational, metadata?: Metadata): Expression;
+/* 0.25.0 */
+import { BoxedExpression, IComputeEngine, JsonSerializationOptions } from '../public';
+export declare function serializeJson(ce: IComputeEngine, expr: BoxedExpression, options: Readonly<JsonSerializationOptions>): Expression;

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

@@ -1,6 +1,6 @@
-/* 0.24.0 */
+/* 0.25.0 */
 import { Expression } from '../../math-json/math-json-format';
-import { BoxedExpression, IComputeEngine } from '../public';
+import { BoxedExpression, IComputeEngine } from './public';
 export declare function isBoxedExpression(x: unknown): x is BoxedExpression;
 /**
  * For any numeric result, if `bignumPreferred()` is true, calculate using
@@ -23,6 +23,7 @@ export declare function hashCode(s: string): number;
  */
 export declare function bignumValue(ce: IComputeEngine, expr: Expression | null | undefined): Decimal | null;
 export declare function asBigint(expr: BoxedExpression): bigint | null;
+export declare function normalizedUnknownsForSolve(syms: string | Iterable<string> | BoxedExpression | Iterable<BoxedExpression> | null | undefined): string[];
 /** Return the local variables in the expression.
  *
  * A local variable is an identifier that is declared with a `Declare`
@@ -34,3 +35,5 @@ export declare function asBigint(expr: BoxedExpression): bigint | null;
  * hoisted.
  *
  */
+export declare function isRelationalOperator(name: BoxedExpression | string): boolean;
+export declare function isInequality(expr: BoxedExpression): boolean;

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

@@ -1,10 +1,11 @@
-/* 0.24.0 */
+/* 0.25.0 */
+import { BoxedExpression } from './public';
 /**
  * Check that the number of arguments is as expected.
  *
  * Converts the arguments to canonical, and flattens the sequence.
  */
-export declare function checkArity(ce: IComputeEngine, ops: BoxedExpression[], count: number): BoxedExpression[];
+export declare function checkArity(ce: IComputeEngine, ops: ReadonlyArray<BoxedExpression>, count: number): ReadonlyArray<BoxedExpression>;
 /**
  * Validation of arguments is normally done by checking the signature of the
  * function vs the arguments of the expression. However, we have a fastpath
@@ -19,10 +20,10 @@ export declare function checkArity(ce: IComputeEngine, ops: BoxedExpression[], c
  *
  * Converts the arguments to canonical, and flattens the sequence.
  */
-export declare function checkNumericArgs(ce: IComputeEngine, ops: BoxedExpression[], options?: number | {
+export declare function checkNumericArgs(ce: IComputeEngine, ops: ReadonlyArray<BoxedExpression>, options?: number | {
     count?: number;
     flatten?: boolean | string;
-}): BoxedExpression[];
+}): ReadonlyArray<BoxedExpression>;
 /**
  * Check that an argument is of the expected domain.
  *
@@ -33,7 +34,7 @@ export declare function checkDomain(ce: IComputeEngine, arg: BoxedExpression | u
  * Check that the argument is pure.
  */
 export declare function checkPure(ce: IComputeEngine, arg: BoxedExpression | BoxedExpression | undefined | null): BoxedExpression;
-export declare function checkDomains(ce: IComputeEngine, args: BoxedExpression[], doms: (BoxedDomain | DomainLiteral)[]): BoxedExpression[];
+export declare function checkDomains(ce: IComputeEngine, args: ReadonlyArray<BoxedExpression>, doms: (BoxedDomain | DomainLiteral)[]): ReadonlyArray<BoxedExpression>;
 /**
  *
  * If the arguments match the parameters, return null.
@@ -42,4 +43,4 @@ export declare function checkDomains(ce: IComputeEngine, args: BoxedExpression[]
  * arguments.
  *
  */
-export declare function adjustArguments(ce: IComputeEngine, ops: BoxedExpression[], hold: Hold, threadable: boolean, params: BoxedDomain[], optParams: BoxedDomain[], restParam: BoxedDomain | undefined): BoxedExpression[] | null;
+export declare function adjustArguments(ce: IComputeEngine, ops: ReadonlyArray<BoxedExpression>, hold: Hold, threadable: boolean, params: BoxedDomain[], optParams: BoxedDomain[], restParam: BoxedDomain | undefined): ReadonlyArray<BoxedExpression> | null;

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

@@ -1,4 +1,4 @@
-/* 0.24.0 */
+/* 0.25.0 */
 export declare function isCollection(col: BoxedExpression): boolean;
 export declare function isFiniteCollection(col: BoxedExpression): boolean;
 export declare function isIndexableCollection(col: BoxedExpression): boolean;

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

@@ -1,4 +1,4 @@
-/* 0.24.0 */
+/* 0.25.0 */
 import { BoxedExpression } from './public';
 export type CompiledType = boolean | number | string | object;
 type JSSource = string;
@@ -7,7 +7,7 @@ export type CompiledOperators = Record<MathJsonIdentifier, [
     prec: number
 ]>;
 export type CompiledFunctions = {
-    [id: MathJsonIdentifier]: string | ((args: BoxedExpression[], compile: (expr: BoxedExpression) => JSSource) => JSSource);
+    [id: MathJsonIdentifier]: string | ((args: ReadonlyArray<BoxedExpression>, compile: (expr: BoxedExpression) => JSSource, target: CompileTarget) => JSSource);
 };
 export type CompileTarget = {
     operators?: (op: MathJsonIdentifier) => [op: string, prec: number];

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

@@ -1,8 +1,12 @@
-/* 0.24.0 */
+/* 0.25.0 */
 import { Decimal } from 'decimal.js';
-import { Expression, MathJsonNumber } from '../math-json/math-json-format';
-import type { LibraryCategory, LatexDictionaryEntry, LatexString, NumberFormattingOptions, ParseLatexOptions, SerializeLatexOptions } from './latex-syntax/public';
-import { AssumeResult, BoxedExpression, BoxedFunctionDefinition, BoxedSymbolDefinition, IComputeEngine, IdentifierDefinitions, ExpressionMapInterface, NumericMode, RuntimeScope, Scope, SemiBoxedExpression, SymbolDefinition, BoxedRuleSet, Rule, JsonSerializationOptions, ComputeEngineStats, Metadata, BoxedDomain, DomainExpression, FunctionDefinition, Rational, BoxedSubstitution, AssignValue, DomainLiteral, ArrayValue, CanonicalForm } from './public';
+import { MathJsonIdentifier, MathJsonNumber } from '../math-json/math-json-format';
+import type { LibraryCategory, LatexDictionaryEntry, LatexString, ParseLatexOptions } from './latex-syntax/public';
+import { AssumeResult, BoxedFunctionDefinition, BoxedSymbolDefinition, IComputeEngine, IdentifierDefinitions, ExpressionMapInterface, NumericMode, RuntimeScope, Scope, SymbolDefinition, BoxedRuleSet, Rule, ComputeEngineStats, Metadata, BoxedDomain, DomainExpression, FunctionDefinition, BoxedSubstitution, AssignValue, DomainLiteral, ArrayValue, AngularUnit, CanonicalOptions } from './public';
+import { Rational } from './numerics/rationals';
+import { IndexedLatexDictionary } from './latex-syntax/dictionary/definitions';
+import { BoxedExpression, SemiBoxedExpression } from './boxed-expression/public';
+import './boxed-expression/serialize';
 /**
  *
  * To use the Compute Engine, create a `ComputeEngine` instance:
@@ -55,6 +59,17 @@ export declare class ComputeEngine implements IComputeEngine {
     readonly PositiveInfinity: BoxedExpression;
     readonly NegativeInfinity: BoxedExpression;
     readonly ComplexInfinity: BoxedExpression;
+    /** The symbol separating the whole part of a number from its fractional
+     *  part.
+     *
+     * Commonly a period (`.`) in English, but a comma (`,`) in many European
+     * languages. For the comma, use `"{,}"` so that the spacing is correct.
+     *
+     * Note that this is a LaTeX string and is used when parsing or serializing
+     * LaTeX. MathJSON always uses a period.
+     *
+     * */
+    decimalSeparator: LatexString;
     /** @internal */
     _BIGNUM_NAN: Decimal;
     /** @internal */
@@ -73,8 +88,8 @@ export declare class ComputeEngine implements IComputeEngine {
     private _precision;
     /** @internal */
     private _numericMode;
-    /** @internal */
-    private _latexSyntax?;
+    /** @ internal */
+    private _angularUnit;
     /** @internal */
     private _tolerance;
     /** @internal */
@@ -86,16 +101,6 @@ export declare class ComputeEngine implements IComputeEngine {
     /** @internal */
     private _cost?;
     /** @internal */
-    private _jsonSerializationOptions;
-    /**
-     * During certain operations  (serializing to LaTeX, constructing error
-     * messages) we need to use a "raw" JSON serialization without any customization. Setting the `_useRawJsonSerializationOptions` will bypass
-     * the `_jsonSerializationOptions` and use `_rawJsonSerializationOptions`
-     * instead
-     * @internal */
-    private _useRawJsonSerializationOptions;
-    private _rawJsonSerializationOptions;
-    /** @internal */
     private _commonSymbols;
     /** @internal */
     private _commonNumbers;
@@ -136,6 +141,10 @@ export declare class ComputeEngine implements IComputeEngine {
      * manipulate them.
      *
      */
+    /** @private */
+    private _latexDictionaryInput;
+    /** @private */
+    _indexedLatexDictionary: IndexedLatexDictionary;
     static getStandardLibrary(categories?: LibraryCategory[] | LibraryCategory | 'all'): readonly IdentifierDefinitions[];
     /**
      * Construct a new `ComputeEngine` instance.
@@ -164,13 +173,14 @@ export declare class ComputeEngine implements IComputeEngine {
      * `chop()` as well.
      */
     constructor(options?: {
+        ids?: readonly IdentifierDefinitions[];
         numericMode?: NumericMode;
         numericPrecision?: number;
-        ids?: readonly IdentifierDefinitions[];
         tolerance?: number;
     });
-    get latexDictionary(): readonly LatexDictionaryEntry[];
-    set latexDictionary(dic: readonly LatexDictionaryEntry[]);
+    get latexDictionary(): Readonly<LatexDictionaryEntry[]>;
+    set latexDictionary(dic: Readonly<LatexDictionaryEntry[]>);
+    get indexedLatexDictionary(): IndexedLatexDictionary;
     /** After the configuration of the engine has changed, clear the caches
      * so that new values can be recalculated.
      *
@@ -203,6 +213,12 @@ export declare class ComputeEngine implements IComputeEngine {
     get numericMode(): NumericMode;
     /** {@inheritDoc  NumericMode} */
     set numericMode(f: NumericMode);
+    /**
+     * The unit used for angles in trigonometric functions.
+     * Default is `"rad"` (radians).
+     */
+    get angularUnit(): AngularUnit;
+    set angularUnit(u: AngularUnit);
     /** @experimental */
     get timeLimit(): number;
     /** @experimental */
@@ -322,9 +338,38 @@ export declare class ComputeEngine implements IComputeEngine {
     complex(a: number | Decimal | Complex, b?: number | Decimal): Complex;
     isBignum(a: unknown): a is Decimal;
     isComplex(a: unknown): a is Complex;
-    /** @internal */
-    private get latexSyntax();
-    static getLatexDictionary(domain?: LibraryCategory | 'all'): readonly Readonly<object>[];
+    /**
+     * Return a LaTeX dictionary suitable for the specified category, or `"all"`
+     * for all categories (`"arithmetic"`, `"algebra"`, etc...).
+     *
+     * A LaTeX dictionary is needed to translate between LaTeX and MathJSON.
+     *
+     * Each entry in the dictionary indicate how a LaTeX token (or string of
+     * tokens) should be parsed into a MathJSON expression.
+     *
+     * For example an entry can define that the `\pi` LaTeX token should map to the
+     * symbol `"Pi"`, or that the token `-` should map to the function
+     * `["Negate",...]` when in a prefix position and to the function
+     * `["Subtract", ...]` when in an infix position.
+     *
+     * Furthermore, the information in each dictionary entry is used to serialize
+     * the LaTeX string corresponding to a MathJSON expression.
+     *
+     * Use with `ce.latexDictionary` to set the dictionary. You can complement
+     * it with your own definitions, for example with:
+     *
+     * ```ts
+     * ce.latexDictionary = [
+     *  ...ce.getLatexDictionary("all"),
+     *  {
+     *    kind: "function",
+     *    identifierTrigger: "concat",
+     *    parse: "Concatenate"
+     *  }
+     * ];
+     * ```
+     */
+    static getLatexDictionary(domain?: LibraryCategory | 'all'): readonly Readonly<LatexDictionaryEntry>[];
     /**
      * The cost function is used to determine the "cost" of an expression. For example, when simplifying an expression, the simplification that results in the lowest cost is chosen.
      */
@@ -453,17 +498,15 @@ export declare class ComputeEngine implements IComputeEngine {
     checkContinueExecution(): void;
     /** @internal */
     cache<T>(cacheName: string, build: () => T, purge: (T: any) => T | undefined): T;
-    /** Return a canonical version of an array of semi-boxed-expressions. */
-    canonical(xs: SemiBoxedExpression[]): BoxedExpression[];
     /** Return a boxed expression from a number, string or semiboxed expression.
-     * Calls `function()`, `number()` or `symbol()` as appropriate.
+     * Calls `ce.function()`, `ce.number()` or `ce.symbol()` as appropriate.
      */
     box(expr: Decimal | Complex | [num: number, denom: number] | SemiBoxedExpression, options?: {
-        canonical?: boolean | CanonicalForm | CanonicalForm[];
+        canonical?: CanonicalOptions;
     }): BoxedExpression;
     function(head: string, ops: SemiBoxedExpression[], options?: {
         metadata?: Metadata;
-        canonical?: boolean;
+        canonical?: CanonicalOptions;
     }): BoxedExpression;
     /**
      *
@@ -471,7 +514,7 @@ export declare class ComputeEngine implements IComputeEngine {
      *
      * The result is canonical.
      */
-    error(message: string | [string, ...SemiBoxedExpression[]], where?: SemiBoxedExpression): BoxedExpression;
+    error(message: MathJsonIdentifier | [MathJsonIdentifier, ...SemiBoxedExpression[]], where?: SemiBoxedExpression): BoxedExpression;
     domainError(expectedDomain: BoxedDomain | DomainLiteral, actualDomain: undefined | BoxedDomain, where?: SemiBoxedExpression): BoxedExpression;
     /**
      * Add a`["Hold"]` wrapper to `expr.
@@ -493,7 +536,7 @@ export declare class ComputeEngine implements IComputeEngine {
      * Shortcut for `this.box(["Multiply", ...]).evaluate()`
      *
      */
-    mul(...ops: BoxedExpression[]): BoxedExpression;
+    mul(...ops: ReadonlyArray<BoxedExpression>): BoxedExpression;
     /**
      *
      * Shortcut for `this.box(["Divide", num, denom]).evaluate()`
@@ -535,7 +578,7 @@ export declare class ComputeEngine implements IComputeEngine {
     /** Return a boxed symbol */
     symbol(name: string, options?: {
         metadata?: Metadata;
-        canonical?: boolean;
+        canonical?: CanonicalOptions;
     }): BoxedExpression;
     /** Return a canonical boxed domain.
      *
@@ -548,8 +591,8 @@ export declare class ComputeEngine implements IComputeEngine {
      * to a common value for which we have a shared instance (-1, 0, NaN, etc...)
      */
     number(value: number | bigint | string | MathJsonNumber | Decimal | Complex | Rational, options?: {
-        canonical?: boolean;
         metadata?: Metadata;
+        canonical?: CanonicalOptions;
     }): BoxedExpression;
     rules(rules: Rule[]): BoxedRuleSet;
     /**
@@ -557,41 +600,21 @@ export declare class ComputeEngine implements IComputeEngine {
      * sure that the arguments are canonical.
      *
      * @internal */
-    _fn(head: string | BoxedExpression, ops: BoxedExpression[], metadata?: Metadata): BoxedExpression;
+    _fn(head: string | BoxedExpression, ops: BoxedExpression[], options?: Metadata & {
+        canonical?: boolean;
+    }): BoxedExpression;
     /**
      * Parse a string of LaTeX and return a corresponding `BoxedExpression`.
      *
-     * The result may not be canonical.
+     * If the `canonical` option is set to `true`, the result will be canonical
      *
      */
-    parse(latex: LatexString | string, options?: {
-        canonical?: boolean | CanonicalForm | CanonicalForm[];
-    }): BoxedExpression;
-    parse(s: null, options?: {
-        canonical?: boolean | CanonicalForm | CanonicalForm[];
+    parse(latex: null, options?: Partial<ParseLatexOptions> & {
+        canonical?: CanonicalOptions;
     }): null;
-    parse(latex: LatexString | string | null, options?: {
-        canonical?: boolean | CanonicalForm | CanonicalForm[];
-    }): null | BoxedExpression;
-    /** Serialize a `BoxedExpression` or a `MathJSON` expression to
-     * a LaTeX string
-     */
-    serialize(x: Expression | BoxedExpression, options?: {
-        canonical?: boolean;
-    }): string;
-    get latexOptions(): NumberFormattingOptions & ParseLatexOptions & SerializeLatexOptions;
-    /**
-     * Options to control the serialization of MathJSON expression to LaTeX
-     * when using `expr.latex` or `ce.serialize()`.
-     *
-     */
-    /** {@inheritDoc  NumberFormattingOptions} */
-    /** {@inheritDoc  ParseLatexOptions} */
-    /** {@inheritDoc  SerializeLatexOptions} */
-    set latexOptions(opts: Partial<NumberFormattingOptions> & Partial<ParseLatexOptions> & Partial<SerializeLatexOptions>);
-    get jsonSerializationOptions(): Readonly<JsonSerializationOptions>;
-    set jsonSerializationOptions(val: Partial<JsonSerializationOptions>);
-    rawJson(expr: BoxedExpression): Expression;
+    parse(latex: LatexString, options?: Partial<ParseLatexOptions> & {
+        canonical?: CanonicalOptions;
+    }): BoxedExpression;
     /**
      * Return a list of all the assumptions that match a pattern.
      *

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

@@ -1,3 +1,3 @@
-/* 0.24.0 */
+/* 0.25.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,6 +1,7 @@
-/* 0.24.0 */
+/* 0.25.0 */
 import { Decimal } from 'decimal.js';
-import { BoxedDomain, BoxedFunctionSignature, DomainLiteral, FunctionSignature, IComputeEngine, Rational } from './public';
+import { Rational } from './numerics/rationals';
+import type { BoxedDomain, BoxedFunctionSignature, DomainLiteral, FunctionSignature, IComputeEngine } from './public';
 /**
  * Determine the numeric domain of a number.
  */

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

@@ -1,4 +1,4 @@
-/* 0.24.0 */
+/* 0.25.0 */
 /***
  * ### THEORY OF OPERATIONS
  *
@@ -71,7 +71,7 @@ export declare function canonicalFunctionExpression(expr: BoxedExpression): Boxe
  * - an expression with anonymous parameters, e.g. ["Add", "_", 1]
  * - the identifier for a function, e.g. "Sin".
  */
-export declare function apply(fn: BoxedExpression, args: BoxedExpression[]): BoxedExpression;
+export declare function apply(fn: BoxedExpression, args: ReadonlyArray<BoxedExpression>): BoxedExpression;
 /**
  * Return a lambda function, assuming a scoped environment has been
  * created and there is a single numeric argument

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

@@ -1,2 +1,2 @@
-/* 0.24.0 */
+/* 0.25.0 */
 export declare const DEFINITIONS_ALGEBRA: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.24.0 */
+/* 0.25.0 */
 export declare const DEFINITIONS_ARITHMETIC: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.24.0 */
+/* 0.25.0 */
 export declare const DEFINITIONS_CALCULUS: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.24.0 */
+/* 0.25.0 */
 export declare const DEFINITIONS_COMPLEX: LatexDictionary;

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

@@ -1,4 +1,4 @@
-/* 0.24.0 */
+/* 0.25.0 */
 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.24.0 */
+/* 0.25.0 */
 export declare const DEFINITIONS_LINEAR_ALGEBRA: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.24.0 */
+/* 0.25.0 */
 export declare const DEFINITIONS_LOGIC: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.24.0 */
+/* 0.25.0 */
 export declare const DEFINITIONS_OTHERS: LatexDictionary;

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

@@ -1,4 +1,2 @@
-/* 0.24.0 */
-import { LatexDictionaryEntry } from '../public';
+/* 0.25.0 */
 export declare const DEFINITIONS_INEQUALITIES: LatexDictionaryEntry[];
-export declare function isRelationalOperator(name: BoxedExpression | string): boolean;

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

@@ -1,2 +1,2 @@
-/* 0.24.0 */
+/* 0.25.0 */
 export declare const DEFINITIONS_SETS: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.24.0 */
+/* 0.25.0 */
 export declare const DEFINITIONS_STATISTICS: LatexDictionary;

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

@@ -1,3 +1,3 @@
-/* 0.24.0 */
+/* 0.25.0 */
 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.24.0 */
+/* 0.25.0 */
 export declare const DEFINITIONS_TRIGONOMETRY: LatexDictionary;

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

@@ -1,5 +1,5 @@
-/* 0.24.0 */
-import { WarningSignal } from '../../../common/signals';
+/* 0.25.0 */
+import { Delimiter, EnvironmentParseHandler, ExpressionParseHandler, InfixParseHandler, LatexDictionary, LatexDictionaryEntry, LatexString, LatexToken, LibraryCategory, MatchfixParseHandler, PostfixParseHandler, Precedence, SerializeHandler } from '../public';
 export type CommonEntry = {
     /** Note: a name is required if a serialize handler is provided */
     name?: string;
@@ -49,7 +49,7 @@ export type IndexedMatchfixEntry = CommonEntry & {
 export declare function isIndexedMatchfixEntry(entry: IndexedLatexDictionaryEntry): entry is IndexedMatchfixEntry;
 export type IndexedInfixEntry = CommonEntry & {
     kind: 'infix';
-    associativity: 'right' | 'left' | 'non' | 'both';
+    associativity: 'right' | 'left' | 'none' | 'any';
     precedence: Precedence;
     parse: InfixParseHandler;
 };
@@ -81,7 +81,8 @@ export type IndexedLatexDictionary = {
     lookahead: number;
     defs: IndexedLatexDictionaryEntry[];
 };
-export declare function indexLatexDictionary(dic: readonly Partial<LatexDictionaryEntry>[], onError: (sig: WarningSignal) => void): IndexedLatexDictionary;
+export declare function indexLatexDictionary(dic: Readonly<Partial<LatexDictionaryEntry>[]>, onError: (sig: WarningSignal) => void): IndexedLatexDictionary;
 export declare const DEFAULT_LATEX_DICTIONARY: {
     [category in LibraryCategory]?: LatexDictionary;
 };
+export declare function getLatexDictionary(category?: LibraryCategory | 'all'): readonly Readonly<LatexDictionaryEntry>[];

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

@@ -1,4 +1,4 @@
-/* 0.24.0 */
+/* 0.25.0 */
 import { Parser } from './public';
 /** For error handling, if we have a identifier prefix, assume
  * the identifier is invalid (it would have been captured by