@cortex-js/compute-engine 0.54.1 → 0.55.2

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

@@ -1,15 +1,19 @@
-/* 0.54.1 */
+/* 0.55.2 */
 import type { Type, TypeString } from '../common/type/types';
-import type { LatexString } from './latex-syntax/types';
+import type { LatexString, ParseLatexOptions } from './latex-syntax/types';
 import { compile as compileExpr } from './compilation/compile-expression';
-import type { CompilationResult } from './compilation/types';
-/** @internal Called by index.ts to register the ComputeEngine class,
- *  avoiding a circular dependency (index.ts re-exports this file). */
-export declare function _setComputeEngineClass(cls: new () => IComputeEngine): void;
+/** @internal Called by the entry point to register a factory that creates
+ *  the default engine with LatexSyntax pre-configured. */
+export declare function _setDefaultEngineFactory(factory: () => IComputeEngine): void;
 export declare function getDefaultEngine(): IComputeEngine;
-export declare function parse(latex: LatexString): Expression;
-export declare function box(expr: ExpressionInput): Expression;
-export declare function simplify(expr: LatexString | ExpressionInput): Expression;
+export declare function parse(latex: LatexString, options?: Partial<ParseLatexOptions> & {
+    form?: FormOption;
+}): Expression;
+export declare function expr(expr: ExpressionInput, options?: {
+    form?: FormOption;
+    scope?: Scope;
+}): Expression;
+export declare function simplify(expr: LatexString | ExpressionInput, options?: Partial<SimplifyOptions>): Expression;
 export declare function evaluate(expr: LatexString | ExpressionInput): Expression;
 export declare function N(expr: LatexString | ExpressionInput): Expression;
 export declare function declare(id: string, def: Type | TypeString | Partial<SymbolDefinition>): void;
@@ -24,10 +28,6 @@ export declare function expand(expr: LatexString | ExpressionInput): Expression;
 export declare function solve(expr: LatexString | ExpressionInput, vars?: string | Iterable<string> | Expression | Iterable<Expression>): null | ReadonlyArray<Expression> | Record<string, Expression> | Array<Record<string, Expression>>;
 export declare function expandAll(expr: LatexString | ExpressionInput): Expression;
 export declare function factor(expr: LatexString | ExpressionInput): Expression;
-export declare function compile<T extends string = 'javascript'>(expr: LatexString | ExpressionInput, options: Parameters<typeof compileExpr>[1] & {
-    to?: T;
-    realOnly: true;
-}): CompilationResult<T, number>;
 export declare function compile<T extends string = 'javascript'>(expr: LatexString | ExpressionInput, options?: Parameters<typeof compileExpr>[1] & {
     to?: T;
-}): CompilationResult<T>;
+}): ReturnType<typeof compileExpr>;

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

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.2 */
 import type { BoxedDefinition, Expression, IComputeEngine as ComputeEngine, Scope } from './global-types';
 /***
  * ### THEORY OF OPERATIONS

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

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.2 */
 export type * from './types-serialization';
 export type { ValueDefinition, SequenceDefinition, SequenceStatus, SequenceInfo, OEISSequenceInfo, OEISOptions, OperatorDefinition, BaseDefinition, SimplifyOptions, SymbolDefinition, SymbolDefinitions, LibraryDefinition, AngularUnit, Sign, BaseCollectionHandlers, IndexedCollectionHandlers, CollectionHandlers, TaggedValueDefinition, TaggedOperatorDefinition, BoxedDefinition, BoxedBaseDefinition, BoxedValueDefinition, OperatorDefinitionFlags, BoxedOperatorDefinition, } from './types-definitions';
 export type * from './types-evaluation';

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

@@ -1,13 +1,12 @@
-/* 0.54.1 */
-import { Decimal } from 'decimal.js';
+/* 0.55.2 */
+import { BigDecimal } from '../big-decimal';
 import { Type, TypeResolver, TypeString } from '../common/type/types';
 import { BoxedType } from '../common/type/boxed-type';
 import type { OneOf } from '../common/one-of';
 import type { ConfigurationChangeListener } from '../common/configuration-change';
 import type { MathJsonExpression, MathJsonSymbol, MathJsonNumberObject } from '../math-json/types';
-import type { ValueDefinition, OperatorDefinition, AngularUnit, AssignValue, AssumeResult, Expression, BoxedRule, BoxedRuleSet, BoxedSubstitution, CanonicalOptions, Metadata, Rule, Scope, EvalContext, ExpressionInput, IComputeEngine, BoxedDefinition, SymbolDefinition, SequenceDefinition, SequenceStatus, SequenceInfo, OEISSequenceInfo, OEISOptions, LibraryDefinition } from './global-types';
-import type { LatexDictionaryEntry, LatexString, LibraryCategory } from './latex-syntax/types';
-import { type IndexedLatexDictionary } from './latex-syntax/dictionary/definitions';
+import type { ValueDefinition, OperatorDefinition, AngularUnit, AssignValue, AssumeResult, Expression, BoxedRule, BoxedRuleSet, BoxedSubstitution, CanonicalOptions, Metadata, Rule, Scope, EvalContext, ExpressionInput, IComputeEngine, ILatexSyntax, BoxedDefinition, SymbolDefinition, SequenceDefinition, SequenceStatus, SequenceInfo, OEISSequenceInfo, OEISOptions, LibraryDefinition } from './global-types';
+import type { LibraryCategory, ParseLatexOptions } from './latex-syntax/types';
 import type { BigNum, Rational } from './numerics/types';
 import { ExactNumericValueData, NumericValue, NumericValueData } from './numeric-value/types';
 import type { FormOption } from './types-serialization';
@@ -15,9 +14,8 @@ import { validatePattern } from './boxed-expression/boxed-patterns';
 import './boxed-expression/init-lazy-refs';
 import { factorPerfectSquare, factorDifferenceOfSquares, factorQuadratic, factorPolynomial } from './boxed-expression/factor';
 import './boxed-expression/serialize';
-import { type ParseEntrypointOptions } from './engine-parse-entrypoint';
 export type * from './global-types';
-export { parse, box, simplify, evaluate, N, declare, assign, expand, expandAll, factor, solve, compile, getDefaultEngine, } from './free-functions';
+export { parse, expr, simplify, evaluate, N, declare, assign, expand, expandAll, factor, solve, compile, getDefaultEngine, } from './free-functions';
 export { validatePattern };
 export { factorPerfectSquare, factorDifferenceOfSquares, factorQuadratic, factorPolynomial, };
 export type { CompileTarget, CompiledOperators, CompiledFunctions, CompilationOptions, CompilationResult, LanguageTarget, TargetSource, CompiledFunction, } from './compilation/types';
@@ -44,24 +42,28 @@ import { fu as _fu } from './symbolic/fu';
  * ce = MathfieldElement.computeEngine
  * ```
  *
- * Use the instance to create boxed expressions with `ce.parse()` and `ce.box()`.
+ * Use the instance to create boxed expressions with `ce.expr()`.
  *
  * ```js
  * const ce = new ComputeEngine();
  *
- * let expr = ce.parse("e^{i\\pi}");
- * console.log(expr.N().latex);
+ * let expr = ce.expr(["Power", "ExponentialE", ["Multiply", "ImaginaryUnit", "Pi"]]);
+ * console.log(expr.N().toString());
  * // ➔ "-1"
  *
- * expr = ce.box(["Expand", ["Power", ["Add", "a", "b"], 2]]);
- * console.log(expr.evaluate().latex);
- * // ➔ "a^2 +  2ab + b^2"
+ * expr = ce.expr(["Expand", ["Power", ["Add", "a", "b"], 2]]);
+ * console.log(expr.evaluate().toString());
+ * // ➔ "a^2 + 2ab + b^2"
  * ```
  *
  * @category Compute Engine
  *
  */
 export declare class ComputeEngine implements IComputeEngine {
+    /** @internal Factory for creating LatexSyntax instances. Registered by the
+     *  full entry point (compute-engine.ts). When set, `new ComputeEngine()`
+     *  lazily creates a LatexSyntax if none was provided in options. */
+    static _latexSyntaxFactory: (() => ILatexSyntax) | null;
     readonly True: Expression;
     readonly False: Expression;
     readonly Pi: Expression;
@@ -77,17 +79,6 @@ export declare class ComputeEngine implements IComputeEngine {
     readonly PositiveInfinity: Expression;
     readonly NegativeInfinity: Expression;
     readonly ComplexInfinity: Expression;
-    /** The symbol separating the whole part of a number from its fractional
-     *  part in a LaTeX string.
-     *
-     * 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 */
     private _numericConfiguration;
     /** @internal */
@@ -120,20 +111,6 @@ export declare class ComputeEngine implements IComputeEngine {
     get contextStack(): ReadonlyArray<EvalContext>;
     set contextStack(stack: ReadonlyArray<EvalContext>);
     /** @internal */
-    get _BIGNUM_NAN(): Decimal;
-    /** @internal */
-    get _BIGNUM_ZERO(): Decimal;
-    /** @internal */
-    get _BIGNUM_ONE(): Decimal;
-    /** @internal */
-    get _BIGNUM_TWO(): Decimal;
-    /** @internal */
-    get _BIGNUM_HALF(): Decimal;
-    /** @internal */
-    get _BIGNUM_PI(): Decimal;
-    /** @internal */
-    get _BIGNUM_NEGATIVE_ONE(): Decimal;
-    /** @internal */
     get _typeResolver(): TypeResolver;
     /**
      * Declare a new type in the current scope.
@@ -173,55 +150,13 @@ export declare class ComputeEngine implements IComputeEngine {
      * A symbol table defines how to evaluate and manipulate symbols.
      *
      */
-    /** @internal */
-    private _latexDictionaryState;
     static getStandardLibrary(categories?: LibraryCategory[] | LibraryCategory | 'all'): readonly LibraryDefinition[];
-    /**
-     * 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",
-     *    symbolTrigger: "concat",
-     *    parse: "Concatenate"
-     *  }
-     * ];
-     * ```
-     */
-    static getLatexDictionary(domain?: LibraryCategory | 'all'): readonly Readonly<LatexDictionaryEntry>[];
     /**
      * Construct a new `ComputeEngine` instance.
      *
      * 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`.
-     *
-     * The order of the dictionaries matter: the definitions from the later ones
-     * override the definitions from earlier ones. The first dictionary should
-     * be the `'core'` dictionary which include basic definitions that are used
-     * by later dictionaries.
-     *
-     *
      * @param options.precision Specific how many digits of precision
      * for the numeric calculations. Default is 300.
      *
@@ -237,12 +172,10 @@ export declare class ComputeEngine implements IComputeEngine {
         libraries?: readonly (string | LibraryDefinition)[];
         precision?: number | 'machine';
         tolerance?: number | 'auto';
+        latexSyntax?: ILatexSyntax;
     });
     toJSON(): string;
     [Symbol.toStringTag]: string;
-    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.
      *
@@ -253,64 +186,16 @@ export declare class ComputeEngine implements IComputeEngine {
     _reset(): void;
     /** @internal */
     listenToConfigurationChange(tracker: ConfigurationChangeListener): () => void;
-    /**
-     * Register a custom compilation target.
-     *
-     * This allows you to compile mathematical expressions to different target
-     * languages beyond the built-in JavaScript and GLSL targets.
-     *
-     * @param name - The name of the target (e.g., 'python', 'wgsl', 'matlab')
-     * @param target - The LanguageTarget implementation
-     *
-     * @example
-     * ```typescript
-     * import { ComputeEngine, GLSLTarget } from '@cortex-js/compute-engine';
-     *
-     * const ce = new ComputeEngine();
-     *
-     * // Register a custom target
-     * class PythonTarget implements LanguageTarget {
-     *   // Implementation...
-     * }
-     *
-     * ce.registerCompilationTarget('python', new PythonTarget());
-     *
-     * // Use the custom target
-     * const expr = ce.parse('x^2 + y^2');
-     * const code = compile(expr, { to: 'python' });
-     * ```
-     *
-     * Throws if:
-     * - `name` is empty or contains whitespace
-     * - `target` does not implement the required `LanguageTarget` methods
-     */
-    registerCompilationTarget(name: string, target: LanguageTarget<Expression>): void;
-    /**
-     * Get a registered compilation target by name.
-     *
-     * @param name - The name of the target (e.g., 'javascript', 'glsl', 'python')
-     * @returns The LanguageTarget implementation, or undefined if not found
-     */
+    /** @internal Compile a boxed expression. */
+    _compile(expr: Expression, options?: Parameters<typeof _compile>[1]): ReturnType<typeof _compile>;
+    /** @internal Get a registered compilation target by name. */
     getCompilationTarget(name: string): LanguageTarget<Expression> | undefined;
-    /**
-     * Return the names of all registered compilation targets.
-     *
-     * @example
-     * ```typescript
-     * const ce = new ComputeEngine();
-     * console.log(ce.listCompilationTargets());
-     * // → ['javascript', 'glsl', 'wgsl', 'interval-js']
-     * ```
-     */
+    /** @internal Return the names of all registered compilation targets. */
     listCompilationTargets(): string[];
-    /**
-     * Remove a registered compilation target.
-     *
-     * @param name - The name of the target to remove
-     */
+    /** @internal Register a compilation target. */
+    registerCompilationTarget(name: string, target: LanguageTarget<Expression>): void;
+    /** @internal Remove a registered compilation target. */
     unregisterCompilationTarget(name: string): void;
-    /** @internal Compile a boxed expression. */
-    _compile(expr: Expression, options?: Parameters<typeof _compile>[1]): ReturnType<typeof _compile>;
     get precision(): number;
     /** The precision, or number of significant digits, of numeric
      * calculations.
@@ -415,7 +300,7 @@ export declare class ComputeEngine implements IComputeEngine {
      * How close to 0 the number has to be to be considered 0 is determined by {@linkcode tolerance}.
      */
     chop(n: number): number;
-    chop(n: Decimal): Decimal | 0;
+    chop(n: BigDecimal): BigDecimal | 0;
     chop(n: Complex): Complex | 0;
     /** Create an arbitrary precision number.
      *
@@ -467,7 +352,7 @@ export declare class ComputeEngine implements IComputeEngine {
     * - `sign()` (1, 0 or -1)
     *
     */
-    bignum(a: Decimal.Value | bigint): Decimal;
+    bignum(a: string | number | bigint | BigDecimal): BigDecimal;
     /** Create a complex number.
      * The return value is an object with methods to perform arithmetic
      * operations:
@@ -513,7 +398,7 @@ export declare class ComputeEngine implements IComputeEngine {
      * - `isZero()`
      * - `sign()` (1, 0 or -1)
      */
-    complex(a: number | Decimal | Complex, b?: number | Decimal): Complex;
+    complex(a: number | BigDecimal | Complex, b?: number | BigDecimal): Complex;
     /**
      *
      * Create a Numeric Value.
@@ -586,7 +471,7 @@ export declare class ComputeEngine implements IComputeEngine {
         maxDepth?: number;
     }): void;
     /**
-     * Use `ce.box(name)` instead
+     * Use `ce.expr(name)` instead
      * @internal */
     _getSymbolValue(id: MathJsonSymbol): Expression | undefined;
     /**
@@ -747,10 +632,35 @@ export declare class ComputeEngine implements IComputeEngine {
     /** Return a boxed expression from a number, string or expression input.
      * Calls `ce.function()`, `ce.number()` or `ce.symbol()` as appropriate.
      */
+    expr(expr: NumericValue | ExpressionInput, options?: {
+        form?: FormOption;
+        scope?: Scope | undefined;
+    }): Expression;
+    /** @deprecated Use `expr()` instead. */
     box(expr: NumericValue | ExpressionInput, options?: {
         form?: FormOption;
         scope?: Scope | undefined;
     }): Expression;
+    /** @internal LatexSyntax instance for parse/serialize. */
+    private _latexSyntax?;
+    /** The LatexSyntax instance, lazily created if a factory is registered.
+     *  `undefined` only when no LatexSyntax was provided and no factory exists. */
+    get latexSyntax(): ILatexSyntax | undefined;
+    /** @internal Returns the LatexSyntax instance, lazily creating one
+     *  if a factory is registered. Throws if no LatexSyntax is available. */
+    _requireLatexSyntax(): ILatexSyntax;
+    /**
+     * Parse a LaTeX string and return a boxed expression.
+     *
+     * Uses the engine's symbol definitions for accurate parsing
+     * (e.g., recognizing `f` as a function).
+     */
+    parse(latex: string, options?: Partial<ParseLatexOptions> & {
+        form?: FormOption;
+    }): Expression;
+    parse(latex: string | null, options?: Partial<ParseLatexOptions> & {
+        form?: FormOption;
+    }): Expression | null;
     function(name: string, ops: ReadonlyArray<Expression> | ReadonlyArray<MathJsonExpression>, options?: {
         metadata?: Metadata;
         form?: FormOption;
@@ -758,7 +668,7 @@ export declare class ComputeEngine implements IComputeEngine {
     }): Expression;
     /**
      *
-     * Shortcut for `this.box(["Error",...])`.
+     * Shortcut for `this.expr(["Error",...])`.
      *
      * The result is canonical.
      */
@@ -768,7 +678,7 @@ export declare class ComputeEngine implements IComputeEngine {
      * Add a `["Hold"]` wrapper to `expr`.
      */
     hold(expr: ExpressionInput): Expression;
-    /** Shortcut for `this.box(["Tuple", ...])`
+    /** Shortcut for `this.expr(["Tuple", ...])`
      *
      * The result is canonical.
      */
@@ -785,7 +695,7 @@ export declare class ComputeEngine implements IComputeEngine {
      * 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 | MathJsonNumberObject | Decimal | Complex | Rational, options?: {
+    number(value: number | bigint | string | NumericValue | MathJsonNumberObject | BigDecimal | Complex | Rational, options?: {
         metadata: Metadata;
         canonical: CanonicalOptions;
     }): Expression;
@@ -817,15 +727,6 @@ export declare class ComputeEngine implements IComputeEngine {
         canonical?: boolean;
         scope?: Scope;
     }): Expression;
-    /**
-     * Parse a string of LaTeX and return a corresponding `Expression`.
-     *
-     * If the `form` option is set to `'canonical'` (the default), the result
-     * will be canonical.
-     *
-     */
-    parse(latex: null, options?: ParseEntrypointOptions): null;
-    parse(latex: LatexString, options?: ParseEntrypointOptions): Expression;
     /**
      * Return a list of all the assumptions that match a pattern.
      *

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

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.2 */
  * Basic interval arithmetic operations
  *
  * @module interval/arithmetic

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

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.2 */
  * Comparison and conditional interval operations
  *
  * @module interval/comparison

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

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.2 */
  * Elementary interval functions (sqrt, pow, exp, ln, abs, floor, ceil, min, max, mod)
  *
  * @module interval/elementary

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

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.2 */
  * Interval arithmetic library for reliable function evaluation
  *
  * This module provides interval versions of mathematical operations

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

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.2 */
  * Trigonometric interval functions
  *
  * @module interval/trigonometric

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

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.2 */
  * Interval arithmetic types for reliable function evaluation
  *
  * @module interval/types

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

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.2 */
  * Utility functions for interval arithmetic
  *
  * @module interval/util

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

@@ -0,0 +1,37 @@
+/* 0.55.2 */
+ * Default LaTeX dictionary assembly.
+ *
+ * This file imports all individual domain dictionaries and assembles them
+ * into a single `LATEX_DICTIONARY` constant. The dictionaries are
+ * independently importable -- they do not depend on the engine's library
+ * system.
+ */
+import type { LatexDictionary } from '../types';
+import { DEFINITIONS_CORE } from './definitions-core';
+import { DEFINITIONS_SYMBOLS } from './definitions-symbols';
+import { DEFINITIONS_ALGEBRA } from './definitions-algebra';
+import { DEFINITIONS_LOGIC } from './definitions-logic';
+import { DEFINITIONS_SETS } from './definitions-sets';
+import { DEFINITIONS_INEQUALITIES } from './definitions-relational-operators';
+import { DEFINITIONS_ARITHMETIC } from './definitions-arithmetic';
+import { DEFINITIONS_COMPLEX } from './definitions-complex';
+import { DEFINITIONS_TRIGONOMETRY } from './definitions-trigonometry';
+import { DEFINITIONS_CALCULUS } from './definitions-calculus';
+import { DEFINITIONS_LINEAR_ALGEBRA } from './definitions-linear-algebra';
+import { DEFINITIONS_STATISTICS } from './definitions-statistics';
+import { DEFINITIONS_UNITS } from './definitions-units';
+import { DEFINITIONS_OTHERS } from './definitions-other';
+export { DEFINITIONS_CORE, DEFINITIONS_SYMBOLS, DEFINITIONS_ALGEBRA, DEFINITIONS_LOGIC, DEFINITIONS_SETS, DEFINITIONS_INEQUALITIES, DEFINITIONS_ARITHMETIC, DEFINITIONS_COMPLEX, DEFINITIONS_TRIGONOMETRY, DEFINITIONS_CALCULUS, DEFINITIONS_LINEAR_ALGEBRA, DEFINITIONS_STATISTICS, DEFINITIONS_UNITS, DEFINITIONS_OTHERS, };
+export { DEFINITIONS_CORE as CORE_DICTIONARY, DEFINITIONS_SYMBOLS as SYMBOLS_DICTIONARY, DEFINITIONS_ALGEBRA as ALGEBRA_DICTIONARY, DEFINITIONS_LOGIC as LOGIC_DICTIONARY, DEFINITIONS_SETS as SETS_DICTIONARY, DEFINITIONS_INEQUALITIES as INEQUALITIES_DICTIONARY, DEFINITIONS_ARITHMETIC as ARITHMETIC_DICTIONARY, DEFINITIONS_COMPLEX as COMPLEX_DICTIONARY, DEFINITIONS_TRIGONOMETRY as TRIGONOMETRY_DICTIONARY, DEFINITIONS_CALCULUS as CALCULUS_DICTIONARY, DEFINITIONS_LINEAR_ALGEBRA as LINEAR_ALGEBRA_DICTIONARY, DEFINITIONS_STATISTICS as STATISTICS_DICTIONARY, DEFINITIONS_UNITS as UNITS_DICTIONARY, DEFINITIONS_OTHERS as OTHERS_DICTIONARY, };
+/**
+ * LaTeX dictionary entries for physics constants that have LaTeX triggers.
+ * These were previously inline in the physics library definition.
+ */
+export declare const DEFINITIONS_PHYSICS: LatexDictionary;
+export { DEFINITIONS_PHYSICS as PHYSICS_DICTIONARY };
+/**
+ * The complete default LaTeX dictionary, combining all domain dictionaries.
+ *
+ * This is used as the default dictionary when no custom dictionary is provided.
+ */
+export declare const LATEX_DICTIONARY: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.54.1 */
+/* 0.55.2 */
 export declare const DEFINITIONS_ALGEBRA: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.54.1 */
+/* 0.55.2 */
 export declare const DEFINITIONS_ARITHMETIC: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.54.1 */
+/* 0.55.2 */
 export declare const DEFINITIONS_CALCULUS: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.54.1 */
+/* 0.55.2 */
 export declare const DEFINITIONS_COMPLEX: LatexDictionary;

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

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.2 */
 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.54.1 */
+/* 0.55.2 */
 export declare const DEFINITIONS_LINEAR_ALGEBRA: LatexDictionary;

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

@@ -1,2 +1,4 @@
-/* 0.54.1 */
+/* 0.55.2 */
+import type { MathJsonExpression } from '../../../math-json';
 export declare const DEFINITIONS_LOGIC: LatexDictionary;
+export declare function parseQuantifier(kind: 'NotForAll' | 'NotExists' | 'ForAll' | 'Exists' | 'ExistsUnique'): (parser: Parser, terminator: Readonly<Terminator>) => MathJsonExpression | null;

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

@@ -1,2 +1,2 @@
-/* 0.54.1 */
+/* 0.55.2 */
 export declare const DEFINITIONS_OTHERS: LatexDictionary;

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

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

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

@@ -1,2 +1,2 @@
-/* 0.54.1 */
+/* 0.55.2 */
 export declare const DEFINITIONS_SETS: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.54.1 */
+/* 0.55.2 */
 export declare const DEFINITIONS_STATISTICS: LatexDictionary;

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

@@ -1,3 +1,3 @@
-/* 0.54.1 */
+/* 0.55.2 */
 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.54.1 */
+/* 0.55.2 */
 export declare const DEFINITIONS_TRIGONOMETRY: LatexDictionary;

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

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.2 */
  * LaTeX dictionary entries for parsing and serializing physical quantities
  * with units.
  *

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

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.2 */
 import { LatexDictionaryEntry } from '../types';
 export type { CommonEntry, IndexedSymbolEntry, IndexedExpressionEntry, IndexedFunctionEntry, IndexedMatchfixEntry, IndexedInfixEntry, IndexedPrefixEntry, IndexedPostfixEntry, IndexedEnvironmentEntry, IndexedLatexDictionaryEntry, IndexedLatexDictionary, } from './indexed-types';
 import type { IndexedSymbolEntry, IndexedExpressionEntry, IndexedFunctionEntry, IndexedMatchfixEntry, IndexedInfixEntry, IndexedPostfixEntry, IndexedEnvironmentEntry, IndexedLatexDictionaryEntry, IndexedLatexDictionary } from './indexed-types';

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

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.2 */
  * Type definitions for the indexed LaTeX dictionary.
  *
  * These are separated from definitions.ts to break a circular dependency: