@cortex-js/compute-engine 0.31.0 → 0.32.0

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

@@ -1,660 +0,0 @@
-/* 0.31.0 */
-import { Decimal } from 'decimal.js';
-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 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:
- *
- * ```js
- * ce = new ComputeEngine();
- * ```
- *
- * If using a mathfield, use the default Compute Engine instance from the
- * `MathfieldElement` class:
- *
- * ```js
- * ce = MathfieldElement.computeEngine
- * ```
- *
- * Use the instance to create boxed expressions with `ce.parse()` and `ce.box()`.
- *
- * ```js
- * const ce = new ComputeEngine();
- *
- * let expr = ce.parse("e^{i\\pi}");
- * console.log(expr.N().latex);
- * // ➔ "-1"
- *
- * expr = ce.box(["Expand", ["Power", ["Add", "a", "b"], 2]]);
- * console.log(expr.evaluate().latex);
- * // ➔ "a^2 +  2ab + b^2"
- * ```
- *
- * @category Compute Engine
- *
- */
-export declare class ComputeEngine implements IComputeEngine {
-    readonly True: BoxedExpression;
-    readonly False: BoxedExpression;
-    readonly Pi: BoxedExpression;
-    readonly E: BoxedExpression;
-    readonly Nothing: BoxedExpression;
-    readonly Zero: BoxedExpression;
-    readonly One: BoxedExpression;
-    readonly Half: BoxedExpression;
-    readonly NegativeOne: BoxedExpression;
-    readonly Two: BoxedExpression;
-    readonly I: BoxedExpression;
-    readonly NaN: BoxedExpression;
-    readonly PositiveInfinity: BoxedExpression;
-    readonly NegativeInfinity: BoxedExpression;
-    readonly ComplexInfinity: BoxedExpression;
-    /** 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 */
-    _BIGNUM_NAN: Decimal;
-    /** @internal */
-    _BIGNUM_ZERO: Decimal;
-    /** @internal */
-    _BIGNUM_ONE: Decimal;
-    /** @internal */
-    _BIGNUM_TWO: Decimal;
-    /** @internal */
-    _BIGNUM_HALF: Decimal;
-    /** @internal */
-    _BIGNUM_PI: Decimal;
-    /** @internal */
-    _BIGNUM_NEGATIVE_ONE: Decimal;
-    /** @internal */
-    private _precision;
-    /** @ internal */
-    private _angularUnit;
-    /** @internal */
-    private _tolerance;
-    /** @internal */
-    private _bignumTolerance;
-    private _negBignumTolerance;
-    /** @internal */
-    private __cache;
-    private _configurationChangeTracker;
-    /** @internal */
-    private _cost?;
-    /** @internal */
-    private _commonSymbols;
-    /** @internal */
-    private _commonNumbers;
-    /**
-     * The stack of evaluation contexts.
-     *
-     * An **evaluation context** contains bindings of symbols to their
-     * values, assumptions, and the matching scope.
-     *
-     */
-    _evalContextStack: EvalContext[];
-    /** The current evaluation context */
-    get context(): EvalContext;
-    get contextStack(): ReadonlyArray<EvalContext>;
-    set contextStack(stack: ReadonlyArray<EvalContext>);
-    /** @internal */
-    get _typeResolver(): TypeResolver;
-    /**
-     * 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;
-    /** In strict mode (the default) the Compute Engine performs
-     * validation of domains and signature and may report errors.
-     *
-     * These checks may impact performance
-     *
-     * When strict mode is off, results may be incorrect or generate JavaScript
-     * errors if the input is not valid.
-     *
-     */
-    strict: boolean;
-    /** Absolute time beyond which evaluation should not proceed.
-     * @internal
-     */
-    deadline?: number;
-    /**
-     * Return symbol tables suitable for the specified categories, or `"all"`
-     * for all categories (`"arithmetic"`, `"algebra"`, etc...).
-     *
-     * A symbol table defines how to evaluate and manipulate symbols.
-     *
-     */
-    /** @internal */
-    private _latexDictionaryInput;
-    /** @internal */
-    __indexedLatexDictionary: IndexedLatexDictionary;
-    /** @internal */
-    _bignum: Decimal.Constructor;
-    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...).
-     *
-     * 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.
-     *
-     * @param options.tolerance If the absolute value of the difference of two
-     * numbers is less than `tolerance`, they are considered equal. Used by
-     * `chop()` as well.
-     */
-    constructor(options?: {
-        ids?: readonly SymbolDefinitions[];
-        precision?: number | 'machine';
-        tolerance?: number | 'auto';
-    });
-    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.
-     *
-     * This needs to happen for example when the numeric precision changes.
-     *
-     * @internal
-     */
-    _reset(): void;
-    /** @internal */
-    listenToConfigurationChange(tracker: ConfigurationChangeListener): () => void;
-    get precision(): number;
-    /** The precision, or number of significant digits, of numeric
-     * calculations.
-     *
-     * To make calculations using more digits, at the cost of expanded memory
-     * usage and slower computations, set the `precision` higher.
-     *
-     * 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');
-    /**
-     * The unit used for unitless angles in trigonometric functions.
-     *
-     * - `rad`: radian, $2\pi$ radians is a full circle
-     * - `deg`: degree, 360 degrees is a full circle
-     * - `grad`: gradians, 400 gradians is a full circle
-     * - `turn`: turn, 1 turn is a full circle
-     *
-     * Default is `"rad"` (radians).
-     */
-    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;
-    get tolerance(): number;
-    /**
-     * Values smaller than the tolerance are considered to be zero for the
-     * purpose of comparison, i.e. if `|b - a| <= tolerance`, `b` is considered
-     * equal to `a`.
-     */
-    set tolerance(val: number | 'auto');
-    /** Replace a number that is close to 0 with the exact integer 0.
-     *
-     * How close to 0 the number has to be to be considered 0 is determined by {@linkcode tolerance}.
-     */
-    chop(n: number): number;
-    chop(n: Decimal): Decimal | 0;
-    chop(n: Complex): Complex | 0;
-    /** Create an arbitrary precision number.
-     *
-     * The return value is an object with methods to perform arithmetic
-     * operations:
-     * - `toNumber()`: convert to a JavaScript `number` with potential loss of precision
-     * - `add()`
-     * - `sub()`
-     * - `neg()` (unary minus)
-     * - `mul()`
-     * - `div()`
-     * - `pow()`
-     * - `sqrt()` (square root)
-     * - `cbrt()` (cube root)
-     * - `exp()`  (e^x)
-     * - `log()`
-     * - `ln()` (natural logarithm)
-     * - `mod()`
-  
-     * - `abs()`
-     * - `ceil()`
-     * - `floor()`
-     * - `round()`
-  
-     * - `equals()`
-     * - `gt()`
-     * - `gte()`
-     * - `lt()`
-     * - `lte()`
-     *
-     * - `cos()`
-     * - `sin()`
-     * - `tanh()`
-     * - `acos()`
-     * - `asin()`
-     * - `atan()`
-     * - `cosh()`
-     * - `sinh()`
-     * - `acosh()`
-     * - `asinh()`
-     * - `atanh()`
-     *
-     * - `isFinite()`
-     * - `isInteger()`
-     * - `isNaN()`
-     * - `isNegative()`
-     * - `isPositive()`
-     * - `isZero()`
-     * - `sign()` (1, 0 or -1)
-     *
-     */
-    bignum(a: Decimal.Value | bigint): Decimal;
-    /** Create a complex number.
-     * The return value is an object with methods to perform arithmetic
-     * operations:
-     * - `re` (real part, as a JavaScript `number`)
-     * - `im` (imaginary part, as a JavaScript `number`)
-     * - `add()`
-     * - `sub()`
-     * - `neg()` (unary minus)
-     * - `mul()`
-     * - `div()`
-     * - `pow()`
-     * - `sqrt()` (square root)
-     * - `exp()`  (e^x)
-     * - `log()`
-     * - `ln()` (natural logarithm)
-     * - `mod()`
-  
-     * - `abs()`
-     * - `ceil()`
-     * - `floor()`
-     * - `round()`
-  
-     * - `arg()` the angle of the complex number
-     * - `inverse()` the inverse of the complex number 1/z
-     * - `conjugate()` the conjugate of the complex number
-  
-     * - `equals()`
-     *
-     * - `cos()`
-     * - `sin()`
-     * - `tanh()`
-     * - `acos()`
-     * - `asin()`
-     * - `atan()`
-     * - `cosh()`
-     * - `sinh()`
-     * - `acosh()`
-     * - `asinh()`
-     * - `atanh()`
-     *
-     * - `isFinite()`
-     * - `isNaN()`
-     * - `isZero()`
-     * - `sign()` (1, 0 or -1)
-     */
-    complex(a: number | Decimal | Complex, b?: number | Decimal): Complex;
-    /**
-     *
-     * Create a Numeric Value.
-     *
-     * @internal
-     */
-    _numericValue(value: number | bigint | Complex | OneOf<[BigNum | NumericValueData | ExactNumericValueData]>): NumericValue;
-    /**
-     * 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.
-     */
-    get costFunction(): (expr: BoxedExpression) => number;
-    set costFunction(fn: ((expr: BoxedExpression) => number) | undefined);
-    /**
-     * Return definition matching the symbol, starting with the current
-     * lexical scope and going up the scope chain.
-     */
-    lookupDefinition(id: MathJsonSymbol): undefined | BoxedDefinition;
-    /**
-     * Associate a new definition to a symbol in the current context.
-     *
-     * For internal use. Use `ce.declare()` instead.
-     *
-     * @internal
-     */
-    _declareSymbolValue(name: MathJsonSymbol, def: Partial<ValueDefinition>, scope?: Scope): BoxedDefinition;
-    /**
-     * Associate a new OperatorDefinition to a function in the current context.
-     *
-     * For internal use. Use `ce.declare()` instead.
-     *
-     * @internal
-     */
-    _declareSymbolOperator(name: string, def: OperatorDefinition, scope?: Scope): BoxedDefinition;
-    /**
-     *
-     * Create a new lexical scope and matching evaluation context and add it
-     * to the evaluation context stack.
-     *
-     */
-    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 */
-    _printStack(options?: {
-        details?: boolean;
-        maxDepth?: number;
-    }): void;
-    /**
-     * Use `ce.box(name)` instead
-     * @internal */
-    _getSymbolValue(id: MathJsonSymbol): BoxedExpression | undefined;
-    /**
-     * 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 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 `unknown` if the type is not known yet: it will be
-     * inferred based on usage. Use `any` for a very generic type.
-     *
-     *
-     */
-    declare(id: string, def: Type | TypeString | Partial<SymbolDefinition>, scope?: Scope): IComputeEngine;
-    declare(symbols: {
-        [id: string]: Type | TypeString | Partial<SymbolDefinition>;
-    }): IComputeEngine;
-    /**
-     * 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 symbol should be a valid MathJSON symbol not a LaTeX string.
-     *
-     * 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 symbol, use `ce.declare()`
-     * instead, which allows you to specify the type, value and other
-     * attributes of the symbol.
-     */
-    assign(id: string, value: AssignValue): IComputeEngine;
-    assign(ids: {
-        [id: string]: AssignValue;
-    }): IComputeEngine;
-    /**
-     * Return false if the execution should stop.
-     *
-     * This can occur if:
-     * - an error has been signaled
-     * - the time limit or memory limit has been exceeded
-     *
-     * @internal
-     */
-    _shouldContinueExecution(): boolean;
-    /** @internal */
-    _checkContinueExecution(): void;
-    /** @internal */
-    _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;
-        scope?: Scope | undefined;
-    }): BoxedExpression;
-    /**
-     *
-     * Shortcut for `this.box(["Error",...])`.
-     *
-     * The result is canonical.
-     */
-    error(message: string | string[], where?: string): BoxedExpression;
-    typeError(expected: Type, actual: undefined | Type | BoxedType, where?: string): BoxedExpression;
-    /**
-     * Add a `["Hold"]` wrapper to `expr`.
-     */
-    hold(expr: SemiBoxedExpression): BoxedExpression;
-    /** Shortcut for `this.box(["Tuple", ...])`
-     *
-     * The result is canonical.
-     */
-    tuple(...elements: ReadonlyArray<number>): BoxedExpression;
-    tuple(...elements: ReadonlyArray<BoxedExpression>): BoxedExpression;
-    type(type: Type | TypeString | BoxedType): BoxedType;
-    string(s: string, metadata?: Metadata): BoxedExpression;
-    /** 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
-     * 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?: {
-        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.
-     * 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
-     *
-     * @internal */
-    _fn(name: MathJsonSymbol, ops: ReadonlyArray<BoxedExpression>, options?: {
-        metadata?: Metadata;
-        canonical?: boolean;
-        scope?: Scope;
-    }): BoxedExpression;
-    /**
-     * Parse a string of LaTeX and return a corresponding `BoxedExpression`.
-     *
-     * If the `canonical` option is set to `true`, the result will be canonical
-     *
-     */
-    parse(latex: null, options?: Partial<ParseLatexOptions> & {
-        canonical?: CanonicalOptions;
-    }): null;
-    parse(latex: LatexString, options?: Partial<ParseLatexOptions> & {
-        canonical?: CanonicalOptions;
-    }): BoxedExpression;
-    /**
-     * Return a list of all the assumptions that match a pattern.
-     *
-     * ```js
-     *  ce.assume(['Element', 'x', 'PositiveIntegers');
-     *  ce.ask(['Greater', 'x', '_val'])
-     *  //  -> [{'val': 0}]
-     * ```
-     */
-    ask(pattern: BoxedExpression): BoxedSubstitution[];
-    /**
-     * Answer a query based on the current assumptions.
-     *
-     */
-    verify(_query: BoxedExpression): boolean;
-    /**
-     * Add an assumption.
-     *
-     * Note that the assumption is put into canonical form before being added.
-     *
-     * Returns:
-     * - `contradiction` if the new assumption is incompatible with previous
-     * ones.
-     * - `tautology` if the new assumption is redundant with previous ones.
-     * - `ok` if the assumption was successfully added to the assumption set.
-     *
-     *
-     */
-    assume(predicate: BoxedExpression): AssumeResult;
-    /**
-     * 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 +0,0 @@
-/* 0.31.0 */
-export declare const DEFINITIONS_ALGEBRA: LatexDictionary;

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

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

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

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

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

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

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

@@ -1,27 +0,0 @@
-/* 0.31.0 */
-export declare const DEFINITIONS_CORE: LatexDictionary;
-export declare const DELIMITERS_SHORTHAND: {
-    '(': string;
-    ')': string;
-    '[': string;
-    ']': string;
-    '\u27E6': string;
-    '\u27E7': string;
-    '{': string;
-    '}': string;
-    '<': string;
-    '>': string;
-    '\u2016': string;
-    '\\': string;
-    '\u2308': string;
-    '\u2309': string;
-    '\u230A': string;
-    '\u230B': string;
-    '\u231C': string;
-    '\u231D': string;
-    '\u231E': string;
-    '\u231F': string;
-    '\u23B0': string;
-    '\u23B1': string;
-};
-export declare function latexToDelimiterShorthand(s: string): string | undefined;