@cortex-js/compute-engine 0.33.0 → 0.35.0

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

@@ -1,4 +1,4 @@
-/* 0.33.0 */
+/* 0.35.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.33.0 */
+/* 0.35.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.33.0 */
+/* 0.35.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.33.0 */
+/* 0.35.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.33.0 */
+/* 0.35.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.33.0 */
+/* 0.35.0 */
 import type { Expression, MathJsonSymbol } from '../../math-json/types';
 import { BoxedType, TypeString } from '../types';
 import type { IndexedLatexDictionary, IndexedLatexDictionaryEntry } from './dictionary/definitions';
@@ -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.
@@ -587,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.33.0 */
+/* 0.35.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.33.0 */
+/* 0.35.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.33.0 */
+/* 0.35.0 */
 export declare const CALCULUS_LIBRARY: SymbolDefinitions[];

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

@@ -1,4 +1,4 @@
-/* 0.33.0 */
+/* 0.35.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.33.0 */
+/* 0.35.0 */
 export declare const COMBINATORICS_LIBRARY: SymbolDefinitions[];

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

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

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

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

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

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

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

@@ -1,4 +1,4 @@
-/* 0.33.0 */
+/* 0.35.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.33.0 */
+/* 0.35.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.33.0 */
+/* 0.35.0 */
 export declare const LINEAR_ALGEBRA_LIBRARY: SymbolDefinitions[];

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

@@ -1,4 +1,4 @@
-/* 0.33.0 */
+/* 0.35.0 */
 /**
  * Quantifier domain helpers and boolean analysis functions.
  * Extracted from logic.ts for better code organization.
@@ -79,16 +79,171 @@ export declare function evaluateExistsCartesian(domains: {
 }[], body: BoxedExpression, ce: ComputeEngine): BoxedExpression | undefined;
 /**
  * Check if a boolean expression is satisfiable.
- * Returns True if there exists an assignment that makes the expression true.
+ *
+ * Returns `True` if there exists an assignment of truth values to variables
+ * that makes the expression true, `False` if no such assignment exists.
+ *
+ * ## Algorithm
+ *
+ * Uses brute-force enumeration of all possible truth assignments.
+ * This has **O(2^n) time complexity** where n is the number of variables.
+ *
+ * ## Performance Characteristics
+ *
+ * | Variables | Assignments | Approximate Time |
+ * |-----------|-------------|------------------|
+ * | 10        | 1,024       | < 1ms            |
+ * | 15        | 32,768      | ~10ms            |
+ * | 20        | 1,048,576   | ~100ms-1s        |
+ * | > 20      | (rejected)  | N/A              |
+ *
+ * ## Limits
+ *
+ * - **Maximum 20 variables**: Expressions with more than 20 distinct boolean
+ *   variables will return the unevaluated `IsSatisfiable` expression rather
+ *   than attempting evaluation (to prevent blocking the thread).
+ *
+ * ## Future Improvements
+ *
+ * For better performance on larger expressions, a DPLL-based SAT solver
+ * could be implemented. The current brute-force approach is suitable for
+ * small expressions typically encountered in educational and verification
+ * contexts.
+ *
+ * @param expr - A boolean expression to check for satisfiability
+ * @param ce - The ComputeEngine instance
+ * @returns `True` if satisfiable, `False` if unsatisfiable, or the
+ *          unevaluated expression if the variable limit is exceeded
  */
 export declare function isSatisfiable(expr: BoxedExpression, ce: ComputeEngine): BoxedExpression;
 /**
  * Check if a boolean expression is a tautology.
- * Returns True if the expression is true for all possible assignments.
+ *
+ * Returns `True` if the expression evaluates to true for all possible
+ * assignments of truth values to variables, `False` otherwise.
+ *
+ * ## Algorithm
+ *
+ * Uses brute-force enumeration of all possible truth assignments.
+ * This has **O(2^n) time complexity** where n is the number of variables.
+ *
+ * ## Performance Characteristics
+ *
+ * | Variables | Assignments | Approximate Time |
+ * |-----------|-------------|------------------|
+ * | 10        | 1,024       | < 1ms            |
+ * | 15        | 32,768      | ~10ms            |
+ * | 20        | 1,048,576   | ~100ms-1s        |
+ * | > 20      | (rejected)  | N/A              |
+ *
+ * ## Limits
+ *
+ * - **Maximum 20 variables**: Expressions with more than 20 distinct boolean
+ *   variables will return the unevaluated `IsTautology` expression rather
+ *   than attempting evaluation (to prevent blocking the thread).
+ *
+ * ## Future Improvements
+ *
+ * For better performance on larger expressions, a DPLL-based approach
+ * (checking unsatisfiability of the negation) could be implemented.
+ *
+ * @param expr - A boolean expression to check
+ * @param ce - The ComputeEngine instance
+ * @returns `True` if a tautology, `False` if not, or the unevaluated
+ *          expression if the variable limit is exceeded
  */
 export declare function isTautology(expr: BoxedExpression, ce: ComputeEngine): BoxedExpression;
 /**
  * Generate a truth table for a boolean expression.
- * Returns a List of Lists with headers and rows.
+ *
+ * Returns a `List` of `List`s where the first row contains column headers
+ * (variable names followed by "Result") and subsequent rows contain the
+ * truth values for each assignment.
+ *
+ * ## Algorithm
+ *
+ * Generates all 2^n possible truth assignments and evaluates the expression
+ * for each. This has **O(2^n) time and space complexity**.
+ *
+ * ## Performance Characteristics
+ *
+ * | Variables | Rows Generated | Output Size |
+ * |-----------|----------------|-------------|
+ * | 5         | 32             | ~1 KB       |
+ * | 8         | 256            | ~8 KB       |
+ * | 10        | 1,024          | ~32 KB      |
+ * | > 10      | (rejected)     | N/A         |
+ *
+ * ## Limits
+ *
+ * - **Maximum 10 variables**: Expressions with more than 10 distinct boolean
+ *   variables will return the unevaluated `TruthTable` expression. This
+ *   stricter limit (compared to `IsSatisfiable`/`IsTautology`) accounts for
+ *   the memory required to store all rows.
+ *
+ * @param expr - A boolean expression to generate a truth table for
+ * @param ce - The ComputeEngine instance
+ * @returns A `List` of `List`s representing the truth table, or the
+ *          unevaluated expression if the variable limit is exceeded
  */
 export declare function generateTruthTable(expr: BoxedExpression, ce: ComputeEngine): BoxedExpression;
+/**
+ * Find all prime implicants using the Quine-McCluskey algorithm.
+ *
+ * ## Algorithm
+ *
+ * 1. Generate minterms from the truth table (assignments where expression is true)
+ * 2. Group minterms by number of 1s
+ * 3. Combine terms differing in exactly one position, marking combined terms
+ * 4. Repeat until no more combinations possible
+ * 5. Return terms that were never combined (prime implicants)
+ *
+ * ## Performance Characteristics
+ *
+ * | Variables | Max Minterms | Approximate Time |
+ * |-----------|--------------|------------------|
+ * | 5         | 32           | < 1ms            |
+ * | 8         | 256          | ~10ms            |
+ * | 10        | 1,024        | ~100ms           |
+ * | > 12      | (rejected)   | N/A              |
+ *
+ * ## Limits
+ *
+ * - **Maximum 12 variables**: Larger expressions return unevaluated.
+ *
+ * @param expr - A boolean expression
+ * @param ce - The ComputeEngine instance
+ * @returns A Set of expressions representing prime implicants
+ */
+export declare function findPrimeImplicants(expr: BoxedExpression, ce: ComputeEngine): BoxedExpression[] | null;
+/**
+ * Find all prime implicates using the Quine-McCluskey algorithm.
+ *
+ * Prime implicates are the dual of prime implicants - they are the minimal
+ * clauses in CNF. We find them by finding prime implicants of the negation
+ * and then negating the result.
+ *
+ * @param expr - A boolean expression
+ * @param ce - The ComputeEngine instance
+ * @returns A Set of expressions representing prime implicates (clauses)
+ */
+export declare function findPrimeImplicates(expr: BoxedExpression, ce: ComputeEngine): BoxedExpression[] | null;
+/**
+ * Find a minimal DNF (sum of products) using prime implicants.
+ *
+ * This uses the Quine-McCluskey algorithm followed by a greedy covering
+ * algorithm to select a minimal set of prime implicants.
+ *
+ * @param expr - A boolean expression
+ * @param ce - The ComputeEngine instance
+ * @returns The minimal DNF, or null if too many variables
+ */
+export declare function minimalDNF(expr: BoxedExpression, ce: ComputeEngine): BoxedExpression | null;
+/**
+ * Find a minimal CNF (product of sums) using prime implicates.
+ *
+ * @param expr - A boolean expression
+ * @param ce - The ComputeEngine instance
+ * @returns The minimal CNF, or null if too many variables
+ */
+export declare function minimalCNF(expr: BoxedExpression, ce: ComputeEngine): BoxedExpression | null;

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

@@ -1,4 +1,4 @@
-/* 0.33.0 */
+/* 0.35.0 */
 export declare function evaluateAnd(args: ReadonlyArray<BoxedExpression>, { engine: ce }: {
     engine: ComputeEngine;
 }): BoxedExpression | undefined;

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

@@ -1,4 +1,4 @@
-/* 0.33.0 */
+/* 0.35.0 */
 export declare const LOGIC_LIBRARY: SymbolDefinitions;
 export declare function simplifyLogicFunction(x: BoxedExpression): {
     value: BoxedExpression;

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

@@ -1,2 +1,2 @@
-/* 0.33.0 */
+/* 0.35.0 */
 export declare const NUMBER_THEORY_LIBRARY: SymbolDefinitions[];

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

@@ -1,2 +1,2 @@
-/* 0.33.0 */
+/* 0.35.0 */
 export declare const POLYNOMIALS_LIBRARY: SymbolDefinitions[];

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

@@ -1,2 +1,2 @@
-/* 0.33.0 */
+/* 0.35.0 */
 export declare function randomExpression(level?: number): Expression;

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

@@ -1,2 +1,2 @@
-/* 0.33.0 */
+/* 0.35.0 */
 export declare const RELOP_LIBRARY: SymbolDefinitions;

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

@@ -1,2 +1,2 @@
-/* 0.33.0 */
+/* 0.35.0 */
 export declare const SETS_LIBRARY: SymbolDefinitions;

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

@@ -1,2 +1,2 @@
-/* 0.33.0 */
+/* 0.35.0 */
 export declare const STATISTICS_LIBRARY: SymbolDefinitions[];

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

@@ -1,2 +1,2 @@
-/* 0.33.0 */
+/* 0.35.0 */
 export declare const TRIGONOMETRY_LIBRARY: SymbolDefinitions[];

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

@@ -1,4 +1,4 @@
-/* 0.33.0 */
+/* 0.35.0 */
 /**
  * EL-4: Convert known infinite integer sets to their equivalent Limits bounds.
  * Returns undefined if the set cannot be converted to a Limits form.

package/dist/types/compute-engine/numeric-value/big-numeric-value.d.ts

@@ -1,4 +1,4 @@
-/* 0.33.0 */
+/* 0.35.0 */
 import { BigNumFactory, NumericValue, NumericValueData } from './types';
 import { ExactNumericValue } from './exact-numeric-value';
 import { Expression } from '../../math-json/types';

package/dist/types/compute-engine/numeric-value/exact-numeric-value.d.ts

@@ -1,4 +1,4 @@
-/* 0.33.0 */
+/* 0.35.0 */
 import { Rational, SmallInteger } from '../numerics/types';
 import { BigNumFactory, ExactNumericValueData, NumericValue, NumericValueFactory } from './types';
 import { Expression } from '../../math-json/types';

package/dist/types/compute-engine/numeric-value/machine-numeric-value.d.ts

@@ -1,4 +1,4 @@
-/* 0.33.0 */
+/* 0.35.0 */
 import { BigNumFactory, NumericValue, NumericValueData } from './types';
 import type { Expression } from '../../math-json/types';
 import type { SmallInteger } from '../numerics/types';

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

@@ -1,4 +1,4 @@
-/* 0.33.0 */
+/* 0.35.0 */
  *
  * ## THEORY OF OPERATIONS
  *

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

@@ -1,2 +1,2 @@
-/* 0.33.0 */
+/* 0.35.0 */
 export declare function bigint(a: Decimal | number | bigint | string): bigint | null;

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

@@ -1,4 +1,4 @@
-/* 0.33.0 */
+/* 0.35.0 */
 export declare function bigintValue(expr: Expression | null | undefined): bigint | null;
 /** Output a shorthand if possible */
 export declare function numberToExpression(num: number | bigint, fractionalDigits?: string | number): Expression;

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

@@ -1,4 +1,4 @@
-/* 0.33.0 */
+/* 0.35.0 */
 /** An interval is a continuous set of real numbers */
 export type Interval = {
     start: number;

package/dist/types/compute-engine/numerics/monte-carlo.d.ts

@@ -1,4 +1,4 @@
-/* 0.33.0 */
+/* 0.35.0 */
     estimate: number;
     error: number;
 };

package/dist/types/compute-engine/numerics/numeric-bigint.d.ts

@@ -1,4 +1,4 @@
-/* 0.33.0 */
+/* 0.35.0 */
 export declare function lcm(a: bigint, b: bigint): bigint;
 /** Return `[factor, root]` such that
  * pow(n, 1/exponent) = factor * pow(root, 1/exponent)

package/dist/types/compute-engine/numerics/numeric-bignum.d.ts

@@ -1,4 +1,4 @@
-/* 0.33.0 */
+/* 0.35.0 */
 export declare function gcd(a: BigNum, b: BigNum): BigNum;
 export declare function lcm(a: BigNum, b: BigNum): BigNum;
 export declare function factorial2(ce: IBigNum, n: BigNum): BigNum;

package/dist/types/compute-engine/numerics/numeric-complex.d.ts

@@ -1,3 +1,3 @@
-/* 0.33.0 */
+/* 0.35.0 */
 export declare function gamma(c: Complex): Complex;
 export declare function gammaln(c: Complex): Complex;

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

@@ -1,4 +1,4 @@
-/* 0.33.0 */
+/* 0.35.0 */
 export declare const MACHINE_PRECISION_BITS = 53;
 export declare const MACHINE_PRECISION: number;
 export declare const DEFAULT_TOLERANCE = 1e-10;

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

@@ -1,4 +1,4 @@
-/* 0.33.0 */
+/* 0.35.0 */
 export declare function primeFactors(n: number): {
     [factor: number]: number;
 };

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

@@ -1,4 +1,4 @@
-/* 0.33.0 */
+/* 0.35.0 */
 export declare function isRational(x: any | null): x is Rational;
 export declare function isMachineRational(x: any | null): x is [SmallInteger, SmallInteger];
 export declare function isBigRational(x: any | null): x is [bigint, bigint];

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

@@ -1,4 +1,4 @@
-/* 0.33.0 */
+/* 0.35.0 */
 
     Translated from https://github.com/JuliaMath/Richardson.jl/blob/master/src/Richardson.jl
 

package/dist/types/compute-engine/numerics/special-functions.d.ts

@@ -1,4 +1,4 @@
-/* 0.33.0 */
+/* 0.35.0 */
 import type { BigNum } from './types';
 export declare function gammaln(z: number): number;
 export declare function gamma(z: number): number;

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

@@ -1,4 +1,4 @@
-/* 0.33.0 */
+/* 0.35.0 */
 import type { BigNum } from './types';
 export declare function mean(values: Iterable<number>): number;
 export declare function bigMean(bignum: BigNumFactory, values: Iterable<BigNum>): BigNum;

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

@@ -1,2 +1,2 @@
-/* 0.33.0 */
+/* 0.35.0 */
 export declare function numberToString(num: number | bigint, fractionalDigits?: number | string): string;

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

@@ -1,4 +1,4 @@
-/* 0.33.0 */
+/* 0.35.0 */
 /** @internal */
 type IsInteger<N extends number> = `${N}` extends `${string}.${string}` ? never : `${N}` extends `-${string}.${string}` ? never : number;
 /** A `SmallInteger` is an integer < 1e6