@cortex-js/compute-engine 0.30.1 → 0.31.0

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

@@ -1,3 +1,3 @@
-/* 0.30.1 */
+/* 0.31.0 */
 import type { ComputeEngine, BoxedExpression, JsonSerializationOptions } from '../global-types';
 export declare function serializeJson(ce: ComputeEngine, expr: BoxedExpression, options: Readonly<JsonSerializationOptions>): Expression;

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

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
 export declare function sgn(expr: BoxedExpression): Sign | undefined;
 /**
  * Sign `s` is > 0.

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

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
 type InternalSimplifyOptions = SimplifyOptions & {
     useVariations: boolean;
 };

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

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

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

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
 export declare class Terms {
     private engine;
     private terms;

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

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
 export declare function Fu(exp: BoxedExpression): RuleStep | undefined;
 /** Assuming x in an expression in radians, convert to current angular unit. */
 export declare function radiansToAngle(x: BoxedExpression | undefined): BoxedExpression | undefined;

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

@@ -1,6 +1,16 @@
-/* 0.30.1 */
+/* 0.31.0 */
 import { Type } from '../../common/type/types';
 import { NumericValue } from '../numeric-value/types';
+/**
+ * Check if an expression contains symbolic transcendental functions of constants
+ * (like ln(2), sin(1), etc.) that should not be evaluated numerically.
+ *
+ * This excludes transcendentals that simplify to exact values, such as:
+ * - ln(e) -> 1
+ * - sin(0) -> 0
+ * - cos(0) -> 1
+ */
+export declare function hasSymbolicTranscendental(expr: BoxedExpression): boolean;
 export declare function isDictionary(expr: any | null | undefined): expr is DictionaryInterface;
 export declare function isBoxedExpression(x: unknown): x is BoxedExpression;
 /**

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

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
 import type { BoxedExpression, ComputeEngine } from '../global-types';
 /**
  * Check that the number of arguments is as expected.
@@ -44,6 +44,15 @@ export declare function checkPure(ce: ComputeEngine, arg: BoxedExpression | Boxe
  * Otherwise return a list of expressions indicating the mismatched
  * arguments.
  *
+ * <!--
+ * @todo?:
+ * - Some permutations of operands should perhaps always be treated as invalid. Consider:
+ *   - A sequence wildcard (non-optional, i.e. '__') followed by either a universal wildcard ('_'),
+ *   or another non-optional sequence wildcard. (note that an optional sequence wildcard is
+ *   unproblematic here.)
+ *
+ * -->
+ *
  */
 export declare function validateArguments(ce: ComputeEngine, ops: ReadonlyArray<BoxedExpression>, signature: Type, lazy?: boolean, threadable?: boolean): ReadonlyArray<BoxedExpression> | null;
 export declare function spellCheckMessage(expr: BoxedExpression): string;

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

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
 /** If a collection has fewer than this many elements, eagerly evaluate it.
  *
  * For example, evaluate the Union of two sets with 10 elements each will

package/dist/types/compute-engine/compilation/base-compiler.d.ts

@@ -0,0 +1,31 @@
+/* 0.31.0 */
+import type { CompileTarget, TargetSource } from './types';
+/**
+ * Base compiler class containing language-agnostic compilation logic
+ */
+export declare class BaseCompiler {
+    /**
+     * Compile an expression to target language source code
+     */
+    static compile(expr: BoxedExpression | undefined, target: CompileTarget, prec?: number): TargetSource;
+    /**
+     * Compile a function expression
+     */
+    static compileExpr(engine: ComputeEngine, h: string, args: ReadonlyArray<BoxedExpression>, prec: number, target: CompileTarget): TargetSource;
+    /**
+     * Compile a block expression
+     */
+    private static compileBlock;
+    /**
+     * Compile loop constructs (Sum/Product)
+     */
+    private static compileLoop;
+    /**
+     * Generate a temporary variable name
+     */
+    static tempVar(): string;
+    /**
+     * Inline or wrap expression in IIFE based on complexity
+     */
+    static inlineExpression(body: string, x: string): string;
+}

package/dist/types/compute-engine/{compile.d.ts → compilation/javascript-target.d.ts}

@@ -1,28 +1,11 @@
-/* 0.30.1 */
-import { BoxedExpression, JSSource } from './global-types';
-import { chop, factorial, gcd, lcm, limit } from './numerics/numeric';
-import { gamma, gammaln } from './numerics/special-functions';
-import { interquartileRange, kurtosis, mean, median, mode, populationStandardDeviation, populationVariance, quartiles, skewness, standardDeviation, variance } from './numerics/statistics';
-export type CompiledOperators = Record<MathJsonSymbol, [
-    op: string,
-    prec: number
-]>;
-export type CompiledFunction = string | ((args: ReadonlyArray<BoxedExpression>, compile: (expr: BoxedExpression) => JSSource, target: CompileTarget) => JSSource);
-export type CompiledFunctions = {
-    [id: MathJsonSymbol]: CompiledFunction;
-};
-export type CompileTarget = {
-    operators?: (op: MathJsonSymbol) => [op: string, prec: number] | undefined;
-    functions?: (id: MathJsonSymbol) => CompiledFunction | undefined;
-    var: (id: MathJsonSymbol) => string | undefined;
-    string: (str: string) => string;
-    number: (n: number) => string;
-    ws: (s?: string) => string;
-    preamble: string;
-    indent: number;
-};
-/** This is an extension of the Function class that allows us to pass
- * a custom scope for "global" functions. */
+/* 0.31.0 */
+import { chop, factorial, gcd, lcm, limit } from '../numerics/numeric';
+import { gamma, gammaln } from '../numerics/special-functions';
+import { interquartileRange, kurtosis, mean, median, mode, populationStandardDeviation, populationVariance, quartiles, skewness, standardDeviation, variance } from '../numerics/statistics';
+import type { CompileTarget, CompiledOperators, CompiledFunctions, LanguageTarget, CompilationOptions, CompiledExecutable } from './types';
+/**
+ * JavaScript-specific function extension that provides system functions
+ */
 export declare class ComputeEngineFunction extends Function {
     SYS: {
         chop: typeof chop;
@@ -47,6 +30,9 @@ export declare class ComputeEngineFunction extends Function {
     };
     constructor(body: string, preamble?: string);
 }
+/**
+ * JavaScript function literal with parameters
+ */
 export declare class ComputeEngineFunctionLiteral extends Function {
     SYS: {
         chop: typeof chop;
@@ -71,10 +57,12 @@ export declare class ComputeEngineFunctionLiteral extends Function {
     };
     constructor(body: string, args: string[]);
 }
-export declare function compileToTarget(expr: BoxedExpression, target: CompileTarget): ((...args: any[]) => any) & {
-    isCompiled: true;
-};
-export declare function compileToJavaScript(expr: BoxedExpression, functions?: Record<MathJsonSymbol, JSSource | Function>, vars?: Record<MathJsonSymbol, JSSource>, imports?: unknown[], preamble?: string): ((...args: any[]) => any) & {
-    isCompiled: true;
-};
-export declare function compile(expr: BoxedExpression | undefined, target: CompileTarget, prec?: number): JSSource;
+/**
+ * JavaScript language target implementation
+ */
+export declare class JavaScriptTarget implements LanguageTarget {
+    getOperators(): CompiledOperators;
+    getFunctions(): CompiledFunctions;
+    createTarget(options?: Partial<CompileTarget>): CompileTarget;
+    compileToExecutable(expr: BoxedExpression, options?: CompilationOptions): CompiledExecutable;
+}

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

@@ -0,0 +1,83 @@
+/* 0.31.0 */
+import type { BoxedExpression } from '../global-types';
+/**
+ * Source code in the target language
+ */
+export type TargetSource = string;
+/**
+ * A compiled function that can be executed
+ */
+export type CompiledFunction = string | ((args: ReadonlyArray<BoxedExpression>, compile: (expr: BoxedExpression) => TargetSource, target: CompileTarget) => TargetSource);
+/**
+ * Mapping of operators to their target language representation and precedence
+ */
+export type CompiledOperators = Record<MathJsonSymbol, [
+    op: string,
+    prec: number
+]>;
+/**
+ * Mapping of function names to their target language implementation
+ */
+export type CompiledFunctions = {
+    [id: MathJsonSymbol]: CompiledFunction;
+};
+/**
+ * Target language compilation configuration
+ */
+export interface CompileTarget {
+    /** Get operator representation for the target language */
+    operators?: (op: MathJsonSymbol) => [op: string, prec: number] | undefined;
+    /** Get function implementation for the target language */
+    functions?: (id: MathJsonSymbol) => CompiledFunction | undefined;
+    /** Get variable representation for the target language */
+    var: (id: MathJsonSymbol) => string | undefined;
+    /** Format string literals for the target language */
+    string: (str: string) => string;
+    /** Format numeric literals for the target language */
+    number: (n: number) => string;
+    /** Format whitespace for the target language */
+    ws: (s?: string) => string;
+    /** Code to be inserted at the beginning of the compiled output */
+    preamble: string;
+    /** Current indentation level */
+    indent: number;
+    /** Target language identifier (for debugging/logging) */
+    language?: string;
+}
+/**
+ * Base interface for language-specific compilation targets
+ */
+export interface LanguageTarget {
+    /** Get the default operators for this language */
+    getOperators(): CompiledOperators;
+    /** Get the default functions for this language */
+    getFunctions(): CompiledFunctions;
+    /** Create a CompileTarget for this language */
+    createTarget(options?: Partial<CompileTarget>): CompileTarget;
+    /** Compile an expression to executable code in this language */
+    compileToExecutable(expr: BoxedExpression, options?: CompilationOptions): CompiledExecutable;
+}
+/**
+ * Options for compilation
+ */
+export interface CompilationOptions {
+    /** Custom function implementations */
+    functions?: Record<MathJsonSymbol, TargetSource | Function>;
+    /** Variable bindings */
+    vars?: Record<MathJsonSymbol, TargetSource>;
+    /** Additional imports/libraries to include */
+    imports?: unknown[];
+    /** Additional preamble code */
+    preamble?: string;
+}
+/**
+ * A compiled expression that can be executed
+ */
+export interface CompiledExecutable {
+    /** Execute the compiled code */
+    (...args: any[]): any;
+    /** Get the source code */
+    toString(): string;
+    /** Flag indicating this is a compiled expression */
+    isCompiled: true;
+}

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

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
 /**
  * The default cost function, used to determine if a new expression is simpler
  * than the old one.

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

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
 import type { BoxedDefinition, BoxedExpression, ComputeEngine, Scope } from './global-types';
 /***
  * ### THEORY OF OPERATIONS

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

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
 import type { OneOf } from '../common/one-of';
 import type { Expression, MathJsonNumberObject, MathJsonStringObject, MathJsonFunctionObject, MathJsonSymbolObject, MathJsonSymbol, MathJsonDictionaryObject } from '../math-json';
 import type { Type, TypeReference, TypeResolver, TypeString } from '../common/type/types';
@@ -912,6 +912,10 @@ export interface BoxedExpression {
      *
      * :::info[Note]
      * Applicable to canonical and non-canonical expressions.
+     *
+     * If this is a function, an empty substitution is given, and the computed value of `canonical`
+     * does not differ from that of this expr.: then a call this method is analagous to requesting a
+     * *clone*.
      * :::
      *
      */
@@ -949,11 +953,25 @@ export interface BoxedExpression {
      *
      * See also `expr.subs()` for a simple substitution of symbols.
      *
-     * If `options.canonical` is not set, the result is canonical if `this`
-     * is canonical.
+     * Procedure for the determining the canonical-status of the input expression and replacements:
+     *
+     * - If `options.canonical` is set, the *entire expr.* is canonicalized to this degree: whether
+     * the replacement occurs at the top-level, or within/recursively.
+     *
+     * - If otherwise, the *direct replacement will be canonical* if either the 'replaced' expression
+     * is canonical, or the given replacement (- is a BoxedExpression and -) is canonical.
+     * Notably also, if this replacement takes place recursively (not at the top-level), then exprs.
+     * containing the replaced expr. will still however have their (previous) canonical-status
+     * *preserved*... unless this expr. was previously non-canonical, and *replacements have resulted
+     * in canonical operands*. In this case, an expr. meeting this criteria will be updated to
+     * canonical status. (Canonicalization is opportunistic here, in other words).
      *
      * :::info[Note]
      * Applicable to canonical and non-canonical expressions.
+     *
+     * To match a specific symbol (not a wildcard pattern), the `match` must be
+     * a `BoxedExpression` (e.g., `{ match: ce.box('x'), replace: ... }`).
+     * For simple symbol substitution, consider using `subs()` instead.
      * :::
      */
     replace(rules: BoxedRuleSet | Rule | Rule[], options?: Partial<ReplaceOptions>): null | BoxedExpression;
@@ -1304,9 +1322,9 @@ export interface BoxedExpression {
      *
      */
     compile(options?: {
-        to?: 'javascript';
+        to?: 'javascript' | 'wgsl' | 'python' | 'webassembly';
         functions?: Record<MathJsonSymbol, JSSource | ((...any: any[]) => any)>;
-        vars?: Record<MathJsonSymbol, CompiledType>;
+        vars?: Record<MathJsonSymbol, JSSource>;
         imports?: ((...any: any[]) => any)[];
         preamble?: string;
         fallback?: boolean;
@@ -1523,7 +1541,7 @@ export interface BoxedExpression {
      * Return `undefined` if the membership cannot be determined without
      * iterating over the collection.
      */
-    xcontains(rhs: BoxedExpression): boolean | undefined;
+    contains(rhs: BoxedExpression): boolean | undefined;
     /**
      * Check if this collection is a subset of another collection.
      *
@@ -1541,7 +1559,7 @@ export interface BoxedExpression {
      * be determined without iterating over the collection.
      *
      */
-    get xsize(): number | undefined;
+    get count(): number | undefined;
     /** If this is a finite collection, return true. */
     isFiniteCollection: boolean | undefined;
     /** If this is an empty collection, return true.
@@ -1635,7 +1653,7 @@ export type JsonSerializationOptions = {
      *
      * **Default**: `["all"]`
      */
-    shorthands: ('all' | 'number' | 'symbol' | 'function' | 'string')[];
+    shorthands: ('all' | 'number' | 'symbol' | 'function' | 'string' | 'dictionary')[];
     /** A list of space separated keywords indicating which metadata should be
      * included in the MathJSON. If metadata is included, shorthand notation
      * is not used.
@@ -1663,16 +1681,31 @@ export type JsonSerializationOptions = {
 /**
  * Control how a pattern is matched to an expression.
  *
- * - `substitution`: if present, assumes these values for the named wildcards,
- *    and ensure that subsequent occurrence of the same wildcard have the same
- *    value.
+ * ## Wildcards
+ *
+ * Patterns can include wildcards to match parts of expressions:
+ *
+ * - **Universal (`_` or `_name`)**: Matches exactly one element
+ * - **Sequence (`__` or `__name`)**: Matches one or more elements
+ * - **Optional Sequence (`___` or `___name`)**: Matches zero or more elements
+ *
+ * Named wildcards capture values in the returned substitution:
+ * - `['Add', '_a', 1].match(['Add', 'x', 1])` → `{_a: 'x'}`
+ * - `['Add', '__a'].match(['Add', 1, 2, 3])` → `{__a: [1, 2, 3]}`
+ *
+ * ## Options
+ *
+ * - `substitution`: if present, assumes these values for a subset of
+ *    named wildcards, and ensure that subsequent occurrence of the same
+ *    wildcard have the same value.
  * - `recursive`: if true, match recursively, otherwise match only the top
  *    level.
  * - `useVariations`: if false, only match expressions that are structurally identical.
  *    If true, match expressions that are structurally identical or equivalent.
- *
- *    For example, when true, `["Add", '_a', 2]` matches `2`, with a value of
- *    `_a` of `0`. If false, the expression does not match. **Default**: `false`
+ *    For example, when true, `["Add", '_a', 2]` matches `2`, with `_a = 0`.
+ *    **Default**: `false`
+ * - `matchPermutations`: if true (default), for commutative operators, try all
+ *    permutations of pattern operands. If false, match exact order only.
  *
  * @category Pattern Matching
  *
@@ -1681,6 +1714,15 @@ export type PatternMatchOptions = {
     substitution?: BoxedSubstitution;
     recursive?: boolean;
     useVariations?: boolean;
+    /**
+     * If `true` (default), for commutative operators, try all permutations of
+     * the pattern operands to find a match.
+     *
+     * If `false`, only match in the exact order given. This can be useful
+     * when the pattern order is significant or for performance optimization
+     * with large patterns.
+     */
+    matchPermutations?: boolean;
 };
 /**
  * @category Boxed Expression
@@ -1718,6 +1760,17 @@ export type ReplaceOptions = {
      *
      */
     useVariations: boolean;
+    /**
+     * If `true` (default), for commutative operators, try all permutations of
+     * the pattern operands to find a match.
+     *
+     * If `false`, only match in the exact order given. This can be useful
+     * when the pattern order is significant or for performance optimization
+     * with large patterns.
+     *
+     * **Default**: `true`
+     */
+    matchPermutations: boolean;
     /**
      * If `iterationLimit` > 1, the rules will be repeatedly applied
      * until no rules apply, up to `iterationLimit` times.
@@ -2520,18 +2573,22 @@ export type RuleStep = {
 /** @category Rules */
 export type RuleSteps = RuleStep[];
 /**
- * A rule describes how to modify an expressions that matches a pattern `match`
+ * A rule describes how to modify an expression that matches a pattern `match`
  * into a new expression `replace`.
  *
  * - `x-1` \( \to \) `1-x`
  * - `(x+1)(x-1)` \( \to \) `x^2-1
  *
- * The patterns can be expressed as LaTeX strings or a MathJSON expressions.
+ * The patterns can be expressed as LaTeX strings or `SemiBoxedExpression`'s.
+ * Alternatively, match/replace logic may be specified by a `RuleFunction`, allowing both custom
+ * logic/conditions for the match, and either a *BoxedExpression* (or `RuleStep` if being
+ * descriptive) for the replacement.
  *
  * As a shortcut, a rule can be defined as a LaTeX string: `x-1 -> 1-x`.
  * The expression to the left of `->` is the `match` and the expression to the
  * right is the `replace`. When using LaTeX strings, single character variables
- * are assumed to be wildcards.
+ * are assumed to be wildcards. The rule LHS ('match') and RHS ('replace') may also be supplied
+ * separately: in this case following the same rules.
  *
  * When using MathJSON expressions, anonymous wildcards (`_`) will match any
  * expression. Named wildcards (`_x`, `_a`, etc...) will match any expression
@@ -2762,6 +2819,7 @@ export interface ComputeEngine extends IBigNum {
     }): BoxedExpression;
     symbol(sym: string, options?: {
         canonical?: CanonicalOptions;
+        metadata?: Metadata;
     }): BoxedExpression;
     string(s: string, metadata?: Metadata): BoxedExpression;
     error(message: string | string[], where?: string): BoxedExpression;

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

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
 import { Decimal } from 'decimal.js';
 import { Type, TypeResolver, TypeString } from '../common/type/types';
 import { BoxedType } from '../common/type/boxed-type';
@@ -10,8 +10,10 @@ import type { LatexDictionaryEntry, LatexString, LibraryCategory, ParseLatexOpti
 import { type IndexedLatexDictionary } from './latex-syntax/dictionary/definitions';
 import type { BigNum, Rational } from './numerics/types';
 import { ExactNumericValueData, NumericValue, NumericValueData } from './numeric-value/types';
+import { validatePattern } from './boxed-expression/boxed-patterns';
 import './boxed-expression/serialize';
 export * from './global-types';
+export { validatePattern };
 /**
  *
  * To use the Compute Engine, create a `ComputeEngine` instance:
@@ -566,6 +568,7 @@ export declare class ComputeEngine implements IComputeEngine {
     /** Create a boxed symbol */
     symbol(name: string, options?: {
         canonical?: CanonicalOptions;
+        metadata?: Metadata;
     }): BoxedExpression;
     /**
      * This function tries to avoid creating a boxed number if `num` corresponds

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

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

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

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

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

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

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

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

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

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.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.30.1 */
+/* 0.31.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.30.1 */
+/* 0.31.0 */
 export declare const DEFINITIONS_LOGIC: LatexDictionary;

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

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

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

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

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

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

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

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

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

@@ -1,3 +1,3 @@
-/* 0.30.1 */
+/* 0.31.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.30.1 */
+/* 0.31.0 */
 export declare const DEFINITIONS_TRIGONOMETRY: LatexDictionary;

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

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
 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 */

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

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

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

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
 import { ParseLatexOptions, LatexToken, Terminator, Parser, SymbolTable } from './types';
 import type { IndexedLatexDictionary, IndexedLatexDictionaryEntry, IndexedInfixEntry, IndexedPostfixEntry, IndexedPrefixEntry, IndexedSymbolEntry, IndexedExpressionEntry, IndexedFunctionEntry } from './dictionary/definitions';
 import { BoxedType } from '../../common/type/boxed-type';

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

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
 import { NumberSerializationFormat } from './types';
 /**
  * @param expr - A number, can be represented as a string

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

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
 import { DelimiterScale } from './types';
 export declare function getApplyFunctionStyle(_expr: Expression, _level: number): DelimiterScale;
 export declare function getGroupStyle(_expr: Expression, _level: number): DelimiterScale;

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

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
 import { LatexString, SerializeLatexOptions, DelimiterScale } from './types';
 import type { IndexedLatexDictionary, IndexedLatexDictionaryEntry } from './dictionary/definitions';
 export declare class Serializer {

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

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
  * ## Reference
  * TeX source code:
  * {@link  http://tug.org/texlive/devsrc/Build/source/texk/web2c/tex.web | Tex.web}

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

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
 import type { Expression, MathJsonSymbol } from '../../math-json/types';
 import { BoxedType, TypeString } from '../types';
 import type { IndexedLatexDictionary, IndexedLatexDictionaryEntry } from './dictionary/definitions';
@@ -450,7 +450,7 @@ export type NumberSerializationFormat = NumberFormat & {
      * Default: `"auto"`
      */
     fractionalDigits: 'auto' | 'max' | number;
-    notation: 'auto' | 'engineering' | 'scientific';
+    notation: 'auto' | 'engineering' | 'scientific' | 'adaptiveScientific';
     avoidExponentsInRange: undefined | null | [negativeExponent: number, positiveExponent: number];
 };
 /**