@cortex-js/compute-engine 0.32.1 → 0.34.0

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

@@ -1,19 +1,26 @@
-/* 0.32.1 */
+/* 0.34.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 { ValueDefinition, OperatorDefinition, AngularUnit, AssignValue, AssumeResult, BoxedExpression, BoxedRule, BoxedRuleSet, BoxedSubstitution, CanonicalOptions, SymbolDefinitions, Metadata, Rule, Scope, EvalContext, SemiBoxedExpression, ComputeEngine as IComputeEngine, BoxedDefinition, SymbolDefinition, SequenceDefinition, SequenceStatus, SequenceInfo, OEISSequenceInfo, OEISOptions } 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 { factor, factorPerfectSquare, factorDifferenceOfSquares, factorQuadratic, factorPolynomial } from './boxed-expression/factor';
 import './boxed-expression/serialize';
 export * from './global-types';
 export { validatePattern };
+export { factor, factorPerfectSquare, factorDifferenceOfSquares, factorQuadratic, factorPolynomial, };
+export type { CompileTarget, CompiledOperators, CompiledFunctions, CompilationOptions, CompiledExecutable, LanguageTarget, TargetSource, CompiledFunction, } from './compilation/types';
+export { JavaScriptTarget } from './compilation/javascript-target';
+export { GLSLTarget } from './compilation/glsl-target';
+export { BaseCompiler } from './compilation/base-compiler';
+import type { LanguageTarget } from './compilation/types';
 /**
  *
  * To use the Compute Engine, create a `ComputeEngine` instance:
@@ -101,6 +108,8 @@ export declare class ComputeEngine implements IComputeEngine {
     private _configurationChangeTracker;
     /** @internal */
     private _cost?;
+    /** @internal Registry of compilation targets */
+    private _compilationTargets;
     /** @internal */
     private _commonSymbols;
     /** @internal */
@@ -240,6 +249,43 @@ 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 = expr.compile({ to: 'python' });
+     * ```
+     */
+    registerCompilationTarget(name: string, target: LanguageTarget): void;
+    /**
+     * Get a registered compilation target by name.
+     *
+     * @param name - The name of the target (e.g., 'javascript', 'glsl')
+     * @returns The LanguageTarget implementation, or undefined if not found
+     *
+     * @internal
+     */
+    _getCompilationTarget(name: string): LanguageTarget | undefined;
     get precision(): number;
     /** The precision, or number of significant digits, of numeric
      * calculations.
@@ -298,6 +344,35 @@ export declare class ComputeEngine implements IComputeEngine {
     get recursionLimit(): number;
     set recursionLimit(t: number);
     private _recursionLimit;
+    /**
+     * Flag to prevent infinite recursion in the verify/ask/equality checking cycle.
+     *
+     * **The Problem:**
+     * When verifying equality predicates, a recursion loop can occur:
+     * 1. `verify(Equal(x, 0))` evaluates the expression
+     * 2. `Equal.evaluate()` calls `eq(x, 0)` to check equality
+     * 3. `eq()` calls `ask(['NotEqual', x, 0])` to check assumptions
+     * 4. `ask()` calls `verify(NotEqual(x, 0))` as a fallback
+     * 5. `verify()` evaluates, calling `eq()` again → infinite loop
+     *
+     * **The Solution:**
+     * - Set `_isVerifying = true` when entering `verify()`
+     * - `ask()` skips the `verify()` fallback when `_isVerifying` is true
+     * - `Equal/NotEqual` evaluate handlers check this flag to preserve 3-valued
+     *   logic in verification mode while still returning False/True in normal mode
+     *
+     * @see verify() in index.ts
+     * @see ask() in index.ts
+     * @see eq() in compare.ts
+     * @see Equal/NotEqual operators in relational-operator.ts
+     */
+    private _isVerifying;
+    /**
+     * @internal
+     * Indicates whether we're currently inside a verify() call.
+     * Used to prevent recursion and to enable 3-valued logic in verification mode.
+     */
+    get isVerifying(): boolean;
     get tolerance(): number;
     /**
      * Values smaller than the tolerance are considered to be zero for the
@@ -473,6 +548,13 @@ export declare class ComputeEngine implements IComputeEngine {
      * @internal
      */
     _setSymbolValue(id: MathJsonSymbol, value: BoxedExpression | boolean | number | undefined): void;
+    /**
+     * Set a value directly in the current context's values map.
+     * This is used for assumptions so that the value is scoped to the current
+     * evaluation context and is automatically removed when the scope is popped.
+     * @internal
+     */
+    _setCurrentContextValue(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.
@@ -491,6 +573,107 @@ export declare class ComputeEngine implements IComputeEngine {
     declare(symbols: {
         [id: string]: Type | TypeString | Partial<SymbolDefinition>;
     }): IComputeEngine;
+    /**
+     * Declare a sequence with a recurrence relation.
+     *
+     * @example
+     * ```typescript
+     * // Fibonacci sequence
+     * ce.declareSequence('F', {
+     *   base: { 0: 0, 1: 1 },
+     *   recurrence: 'F_{n-1} + F_{n-2}',
+     * });
+     * ce.parse('F_{10}').evaluate();  // → 55
+     * ```
+     */
+    declareSequence(name: string, def: SequenceDefinition): IComputeEngine;
+    /**
+     * Get the status of a sequence definition.
+     *
+     * @example
+     * ```typescript
+     * ce.parse('F_0 := 0').evaluate();
+     * ce.getSequenceStatus('F');
+     * // → { status: 'pending', hasBase: true, hasRecurrence: false, baseIndices: [0] }
+     * ```
+     */
+    getSequenceStatus(name: string): SequenceStatus;
+    /**
+     * Get information about a defined sequence.
+     * Returns `undefined` if the symbol is not a sequence.
+     */
+    getSequence(name: string): SequenceInfo | undefined;
+    /**
+     * List all defined sequences.
+     */
+    listSequences(): string[];
+    /**
+     * Check if a symbol is a defined sequence.
+     */
+    isSequence(name: string): boolean;
+    /**
+     * Clear the memoization cache for a sequence.
+     * If no name is provided, clears caches for all sequences.
+     */
+    clearSequenceCache(name?: string): void;
+    /**
+     * Get the memoization cache for a sequence.
+     * Returns a Map of index → value, or `undefined` if not a sequence or memoization is disabled.
+     *
+     * For single-index sequences, keys are numbers.
+     * For multi-index sequences, keys are comma-separated strings (e.g., '5,2').
+     */
+    getSequenceCache(name: string): Map<number | string, BoxedExpression> | undefined;
+    /**
+     * Generate a list of sequence terms from start to end (inclusive).
+     *
+     * @param name - The sequence name
+     * @param start - Starting index (inclusive)
+     * @param end - Ending index (inclusive)
+     * @param step - Step size (default: 1)
+     * @returns Array of BoxedExpressions, or undefined if not a sequence
+     *
+     * @example
+     * ```typescript
+     * ce.declareSequence('F', { base: { 0: 0, 1: 1 }, recurrence: 'F_{n-1} + F_{n-2}' });
+     * ce.getSequenceTerms('F', 0, 10);
+     * // → [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
+     * ```
+     */
+    getSequenceTerms(name: string, start: number, end: number, step?: number): BoxedExpression[] | undefined;
+    /**
+     * Look up sequences in OEIS by their terms.
+     *
+     * @param terms - Array of sequence terms to search for
+     * @param options - Optional configuration (timeout, maxResults)
+     * @returns Promise resolving to array of matching sequences
+     *
+     * @example
+     * ```typescript
+     * const results = await ce.lookupOEIS([0, 1, 1, 2, 3, 5, 8, 13]);
+     * // → [{ id: 'A000045', name: 'Fibonacci numbers', ... }]
+     * ```
+     */
+    lookupOEIS(terms: (number | BoxedExpression)[], options?: OEISOptions): Promise<OEISSequenceInfo[]>;
+    /**
+     * Check if a defined sequence matches an OEIS sequence.
+     *
+     * @param name - Name of the defined sequence
+     * @param count - Number of terms to check (default: 10)
+     * @param options - Optional configuration
+     * @returns Promise with match results including OEIS matches and generated terms
+     *
+     * @example
+     * ```typescript
+     * ce.declareSequence('F', { base: { 0: 0, 1: 1 }, recurrence: 'F_{n-1} + F_{n-2}' });
+     * const result = await ce.checkSequenceOEIS('F', 10);
+     * // → { matches: [{ id: 'A000045', name: 'Fibonacci numbers', ... }], terms: [0, 1, 1, ...] }
+     * ```
+     */
+    checkSequenceOEIS(name: string, count?: number, options?: OEISOptions): Promise<{
+        matches: OEISSequenceInfo[];
+        terms: number[];
+    }>;
     /**
      * Return an evaluation context in which the symbol is defined.
      */
@@ -632,7 +815,7 @@ export declare class ComputeEngine implements IComputeEngine {
      * Answer a query based on the current assumptions.
      *
      */
-    verify(_query: BoxedExpression): boolean;
+    verify(query: BoxedExpression): boolean | undefined;
     /**
      * Add an assumption.
      *

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

@@ -1,2 +1,2 @@
-/* 0.32.1 */
+/* 0.34.0 */
 export declare const DEFINITIONS_ALGEBRA: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.32.1 */
+/* 0.34.0 */
 export declare const DEFINITIONS_ARITHMETIC: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.32.1 */
+/* 0.34.0 */
 export declare const DEFINITIONS_CALCULUS: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.32.1 */
+/* 0.34.0 */
 export declare const DEFINITIONS_COMPLEX: LatexDictionary;

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.34.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.32.1 */
+/* 0.34.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.32.1 */
+/* 0.34.0 */
 export declare const DEFINITIONS_LOGIC: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.32.1 */
+/* 0.34.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.32.1 */
+/* 0.34.0 */
 export declare const DEFINITIONS_INEQUALITIES: LatexDictionaryEntry[];

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

@@ -1,2 +1,2 @@
-/* 0.32.1 */
+/* 0.34.0 */
 export declare const DEFINITIONS_SETS: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.32.1 */
+/* 0.34.0 */
 export declare const DEFINITIONS_STATISTICS: LatexDictionary;

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

@@ -1,3 +1,3 @@
-/* 0.32.1 */
+/* 0.34.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.32.1 */
+/* 0.34.0 */
 export declare const DEFINITIONS_TRIGONOMETRY: LatexDictionary;

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.34.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 */
@@ -75,11 +75,20 @@ export type IndexedEnvironmentEntry = CommonEntry & {
 };
 /** @internal */
 export declare function isIndexedEnvironmentEntry(entry: IndexedLatexDictionaryEntry): entry is IndexedEnvironmentEntry;
+/** @internal */
 export type IndexedLatexDictionaryEntry = IndexedExpressionEntry | IndexedFunctionEntry | IndexedSymbolEntry | IndexedMatchfixEntry | IndexedInfixEntry | IndexedPrefixEntry | IndexedPostfixEntry | IndexedEnvironmentEntry;
+/** @internal */
 export type IndexedLatexDictionary = {
     ids: Map<string, IndexedLatexDictionaryEntry>;
     lookahead: number;
     defs: IndexedLatexDictionaryEntry[];
+    matchfixByOpen: Map<string, IndexedMatchfixEntry[]>;
+    infixByTrigger: Map<string, IndexedInfixEntry[]>;
+    prefixByTrigger: Map<string, IndexedPrefixEntry[]>;
+    postfixByTrigger: Map<string, IndexedPostfixEntry[]>;
+    functionByTrigger: Map<string, IndexedFunctionEntry[]>;
+    symbolByTrigger: Map<string, IndexedSymbolEntry[]>;
+    expressionByTrigger: Map<string, IndexedExpressionEntry[]>;
 };
 export declare function indexLatexDictionary(dic: Readonly<Partial<LatexDictionaryEntry>[]>, onError: (sig: WarningSignal) => void): IndexedLatexDictionary;
 export declare const DEFAULT_LATEX_DICTIONARY: {

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.34.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.32.1 */
+/* 0.34.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';
@@ -69,6 +69,7 @@ export declare class _Parser implements Parser {
     private _peekCounter;
     constructor(tokens: LatexToken[], dictionary: IndexedLatexDictionary, options: Readonly<ParseLatexOptions>);
     getSymbolType(id: MathJsonSymbol): BoxedType;
+    hasSubscriptEvaluate(id: MathJsonSymbol): boolean;
     get peek(): LatexToken;
     nextToken(): LatexToken;
     get atEnd(): boolean;
@@ -88,6 +89,18 @@ export declare class _Parser implements Parser {
     removeBoundary(): void;
     matchBoundary(): boolean;
     boundaryError(msg: string | [string, ...Expression[]]): Expression;
+    /**
+     * Performance optimization: determines if we can skip expensive re-parsing
+     * for matchfix boundary mismatches.
+     *
+     * We skip re-parsing only for specific non-ambiguous cases where we know
+     * the boundary mismatch is due to trying interval notation on regular parens.
+     * For example, trying (] on input () - we can safely skip without re-parsing.
+     *
+     * All other cases (including |, [, and other delimiters) require re-parsing
+     * to handle nested delimiters correctly.
+     */
+    private canSkipMatchfixReparsing;
     latex(start: number, end?: number): string;
     private latexAhead;
     /**
@@ -235,6 +248,13 @@ export declare class _Parser implements Parser {
      */
     private parseFunction;
     parseSymbol(until?: Readonly<Terminator>): Expression | null;
+    /**
+     * In non-strict mode, try to parse a bare function name followed by parentheses.
+     * This allows syntax like `sin(x)` instead of requiring `\sin(x)`.
+     *
+     * Returns the parsed function call or null if not a bare function.
+     */
+    private tryParseBareFunction;
     /**
      * Parse a sequence superfix/subfix operator, e.g. `^{*}`
      *

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.34.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.32.1 */
+/* 0.34.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.32.1 */
+/* 0.34.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.32.1 */
+/* 0.34.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.32.1 */
+/* 0.34.0 */
 import type { Expression, MathJsonSymbol } from '../../math-json/types';
 import { BoxedType, TypeString } from '../types';
 import type { IndexedLatexDictionary, IndexedLatexDictionaryEntry } from './dictionary/definitions';
@@ -365,7 +365,7 @@ export type FunctionEntry = BaseEntry & Trigger & {
  * A dictionary entry is a record that maps a LaTeX token or string of tokens
  * ( a trigger) to a MathJSON expression or to a parsing handler.
  *
- * Set the {@linkcode ComputeEngine.latexDictionary} property to an array of
+ * Set the `ComputeEngine.latexDictionary` property to an array of
  * dictionary entries to define custom LaTeX parsing and serialization.
  *
  * @category Latex Parsing and Serialization
@@ -480,6 +480,16 @@ export type NumberSerializationFormat = NumberFormat & {
  * @category Latex Parsing and Serialization
  */
 export type ParseLatexOptions = NumberFormat & {
+    /**
+     * Controls the strictness of LaTeX parsing:
+     *
+     * - `true`: Strict LaTeX syntax required (e.g., `\sin{x}`, `x^{n+1}`)
+     * - `false`: Accept relaxed Math-ASCII/Typst-like syntax in addition to
+     *   LaTeX (e.g., `sin(x)`, `x^(n+1)`)
+     *
+     * **Default**: `true`
+     */
+    strict: boolean;
     /**
      * If true, ignore space characters in math mode.
      *
@@ -513,6 +523,13 @@ export type ParseLatexOptions = NumberFormat & {
      *
      */
     getSymbolType: (symbol: MathJsonSymbol) => BoxedType;
+    /**
+     * This handler is invoked when the parser needs to determine if a symbol
+     * has a custom subscript evaluation handler. If true, subscripts on this
+     * symbol will be kept as `Subscript` expressions rather than being absorbed
+     * into a compound symbol name.
+     */
+    hasSubscriptEvaluate?: (symbol: MathJsonSymbol) => boolean;
     /** This handler is invoked when the parser encounters an unexpected token.
      *
      * The `lhs` argument is the left-hand side of the token, if any.
@@ -563,6 +580,15 @@ export type ParseLatexOptions = NumberFormat & {
      * // parses as: ∀x. (P(x) → Q(x))
      */
     quantifierScope: 'tight' | 'loose';
+    /**
+     * The variable used for time derivatives in Newton notation
+     * (`\dot{x}`, `\ddot{x}`, etc.).
+     *
+     * When parsing `\dot{x}`, it will be interpreted as `["D", "x", timeDerivativeVariable]`.
+     *
+     * **Default:** `"t"`
+     */
+    timeDerivativeVariable: string;
 };
 /**
  *
@@ -578,8 +604,12 @@ export type ParseLatexOptions = NumberFormat & {
  * @category Latex Parsing and Serialization
  */
 export interface Parser {
-    readonly options: Required<ParseLatexOptions>;
+    readonly options: Readonly<ParseLatexOptions>;
     getSymbolType(id: MathJsonSymbol): BoxedType;
+    /**
+     * Check if a symbol has a custom subscript evaluation handler.
+     */
+    hasSubscriptEvaluate(id: MathJsonSymbol): boolean;
     pushSymbolTable(): void;
     popSymbolTable(): void;
     addSymbol(id: MathJsonSymbol, type: BoxedType | TypeString): void;

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.34.0 */
 export declare function asLatexString(s: unknown): string | null;
 export declare function isRelationalOperator(name: string | undefined): boolean;
 export declare function isInequalityOperator(operator: string | undefined): boolean;

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.34.0 */
 export type CanonicalArithmeticOperators = 'Add' | 'Negate' | 'Multiply' | 'Divide' | 'Power' | 'Sqrt' | 'Root' | 'Ln';
 export declare const ARITHMETIC_LIBRARY: SymbolDefinitions[];
 export declare function isPrime(expr: BoxedExpression): boolean | undefined;

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

@@ -1,2 +1,2 @@
-/* 0.32.1 */
+/* 0.34.0 */
 export declare const CALCULUS_LIBRARY: SymbolDefinitions[];

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.34.0 */
 export declare const DEFAULT_LINSPACE_COUNT = 50;
 export declare const COLLECTIONS_LIBRARY: SymbolDefinitions;
 /**

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

@@ -1,2 +1,2 @@
-/* 0.32.1 */
+/* 0.34.0 */
 export declare const COMBINATORICS_LIBRARY: SymbolDefinitions[];

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

@@ -1,2 +1,2 @@
-/* 0.32.1 */
+/* 0.34.0 */
 export declare const COMPLEX_LIBRARY: SymbolDefinitions[];

package/dist/types/compute-engine/library/control-structures.d.ts

@@ -1,2 +1,2 @@
-/* 0.32.1 */
+/* 0.34.0 */
 export declare const CONTROL_STRUCTURES_LIBRARY: SymbolDefinitions[];

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

@@ -1,2 +1,2 @@
-/* 0.32.1 */
+/* 0.34.0 */
 export declare const CORE_LIBRARY: SymbolDefinitions[];

package/dist/types/compute-engine/library/invisible-operator.d.ts

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.34.0 */
 export declare function canonicalInvisibleOperator(ops: ReadonlyArray<BoxedExpression>, { engine: ce }: {
     engine: ComputeEngine;
 }): BoxedExpression | null;

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.34.0 */
 import type { SymbolDefinitions, ComputeEngine } from '../global-types';
 export declare function getStandardLibrary(categories: LibraryCategory[] | LibraryCategory | 'all'): readonly SymbolDefinitions[];
 export declare const LIBRARIES: {

package/dist/types/compute-engine/library/linear-algebra.d.ts

@@ -1,2 +1,2 @@
-/* 0.32.1 */
+/* 0.34.0 */
 export declare const LINEAR_ALGEBRA_LIBRARY: SymbolDefinitions[];