@cortex-js/compute-engine 0.26.4 → 0.28.0

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

@@ -1,4 +1,4 @@
-/* 0.26.4 */
+/* 0.28.0 */
 export declare class ExpressionMap<U> implements ExpressionMapInterface<U> {
     readonly _items: Map<BoxedExpression, U>;
     constructor(source?: ExpressionMapInterface<U> | readonly (readonly [BoxedExpression, U])[]);

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

@@ -1,4 +1,4 @@
-/* 0.26.4 */
+/* 0.28.0 */
 import { NumericValue } from '../numeric-value/public';
 /** Combine rational expressions into a single fraction */
 export declare function together(op: BoxedExpression): BoxedExpression;

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

@@ -1,4 +1,4 @@
-/* 0.26.4 */
+/* 0.28.0 */
 /**
  *
  * Make all the arguments canonical.

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

@@ -1,9 +1,10 @@
-/* 0.26.4 */
+/* 0.28.0 */
 /** Apply the function `f` to each operand of the expression `expr`,
- * account for the 'hold' property of the function definition:
+ * account for the 'lazy' property of the function definition:
  *
  * Account for `Hold`, `ReleaseHold`, `Sequence`, `Symbol` and `Nothing`.
  *
  * If `f` returns `null`, the element is not added to the result
  */
 export declare function holdMap(expr: BoxedExpression, f: (x: BoxedExpression) => BoxedExpression | null): ReadonlyArray<BoxedExpression>;
+export declare function holdMapAsync(expr: BoxedExpression, f: (x: BoxedExpression) => Promise<BoxedExpression | null>): Promise<ReadonlyArray<BoxedExpression>>;

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

@@ -1,4 +1,4 @@
-/* 0.26.4 */
+/* 0.28.0 */
 /**
  * The function attempts to match a subject expression to a
  * [pattern](/compute-engine/guides/patterns-and-rules/).

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

@@ -1,4 +1,4 @@
-/* 0.26.4 */
+/* 0.28.0 */
 export declare function canonicalNegate(expr: BoxedExpression): BoxedExpression;
 /**
  * Distribute `Negate` (multiply by -1) if expr is a number literal, an

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

@@ -1,4 +1,4 @@
-/* 0.26.4 */
+/* 0.28.0 */
 import type { Rational } from '../numerics/rationals';
 import type { BoxedExpression } from './public';
 export declare function asRational(expr: BoxedExpression): Rational | undefined;

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

@@ -1,4 +1,4 @@
-/* 0.26.4 */
+/* 0.28.0 */
 export type Order = 'lex' | 'dexlex' | 'grevlex' | 'elim';
 export declare const DEFAULT_COMPLEXITY = 100000;
 /**

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

@@ -1,4 +1,4 @@
-/* 0.26.4 */
+/* 0.28.0 */
 /**
  * Coefficient of a univariate (single variable) polynomial.
  *

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

@@ -1,4 +1,4 @@
-/* 0.26.4 */
+/* 0.28.0 */
 import { Rational } from '../numerics/rationals';
 import { NumericValue } from '../numeric-value/public';
 /**

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

@@ -1,4 +1,4 @@
-/* 0.26.4 */
+/* 0.28.0 */
 import type { Expression, MathJsonNumber, MathJsonString, MathJsonSymbol, MathJsonFunction, MathJsonIdentifier } from '../../math-json';
 import type { SerializeLatexOptions, LatexDictionaryEntry, ParseLatexOptions } from '../latex-syntax/public';
 import type { IndexedLatexDictionary } from '../latex-syntax/dictionary/definitions';
@@ -8,6 +8,8 @@ import { BigNum, IBigNum } from '../numerics/bignum';
 import { Type, TypeString } from '../../common/type/types';
 import { AbstractTensor } from '../tensor/tensors';
 import { OneOf } from '../../common/one-of';
+import { CompiledType, JSSource } from '../compile';
+import { BoxedType } from '../../common/type/boxed-type';
 /**
  * :::info[THEORY OF OPERATIONS]
  *
@@ -899,8 +901,9 @@ export interface BoxedExpression {
      * If the type of this expression is already known, return `false`.
      *
      * If the type was not set, set it to the inferred type, return `true`
-     * If the type was previously inferred, adjust it by widening it,
-     *    return `true`
+     * If the type was previously inferred, widen it and return `true`.
+     *
+     * If the type cannot be inferred, return `false`.
      *
      * @internal
      */
@@ -916,8 +919,8 @@ export interface BoxedExpression {
      *
      * Reset the cached value associated with this expression.
      *
-     * Use when the environment has changed, for example the numeric mode
-     * or precision, to force the expression to be re-evaluated.
+     * Use when the environment, for example the precision, has changed to
+     * force the expression to be re-evaluated.
      *
      * @internal
      */
@@ -972,7 +975,14 @@ export interface BoxedExpression {
      * The result is in canonical form.
      *
      */
-    evaluate(options?: EvaluateOptions): BoxedExpression;
+    evaluate(options?: Partial<EvaluateOptions>): BoxedExpression;
+    /** Asynchronous version of `evaluate()`.
+     *
+     * The `options` argument can include a `signal` property, which is an
+     * `AbortSignal` object. If the signal is aborted, a `CancellationError` is thrown.
+     *
+     */
+    evaluateAsync(options?: Partial<EvaluateOptions>): Promise<BoxedExpression>;
     /** Return a numeric approximation of the canonical form of this expression.
      *
      * Any necessary calculations, including on decimal numbers (non-integers),
@@ -998,13 +1008,18 @@ export interface BoxedExpression {
      *
      * ```javascript
      * const expr = ce.parse('x^2 + y^2');
-     * const f = expr.compile('javascript');
+     * const f = expr.compile();
      * console.log(f({x: 2, y: 3}));
      * ```
      */
-    compile(to?: 'javascript', options?: {
-        optimize: ('simplify' | 'evaluate')[];
-    }): ((args: Record<string, any>) => any | undefined) | undefined;
+    compile(options?: {
+        to?: 'javascript';
+        optimize?: ('simplify' | 'evaluate')[];
+        functions?: Record<MathJsonIdentifier, JSSource | ((...any: any[]) => any)>;
+        vars?: Record<MathJsonIdentifier, CompiledType>;
+        imports?: unknown[];
+        preamble?: string;
+    }): (args?: Record<string, CompiledType>) => CompiledType;
     /**
      * If this is an equation, solve the equation for the variables in vars.
      * Otherwise, solve the equation `this = 0` for the variables in vars.
@@ -1017,7 +1032,7 @@ export interface BoxedExpression {
      *
      *
      */
-    solve(vars: Iterable<string> | string | BoxedExpression | Iterable<BoxedExpression>): null | ReadonlyArray<BoxedExpression>;
+    solve(vars?: Iterable<string> | string | BoxedExpression | Iterable<BoxedExpression>): null | ReadonlyArray<BoxedExpression>;
     /**
      * Return a JavaScript primitive representing the value of this expression.
      *
@@ -1059,8 +1074,8 @@ export interface BoxedExpression {
      * :::
      *
      */
-    get type(): Type;
-    set type(type: Type);
+    get type(): BoxedType;
+    set type(type: Type | TypeString | BoxedType);
     /** `true` if the value of this expression is a number.
      *
      *
@@ -1219,6 +1234,9 @@ export interface BoxedBaseDefinition {
      * This field is usually undefined, but its value is set by `getDefinition()`
      */
     scope: RuntimeScope | undefined;
+    /** If this is the definition of a collection, the set of primitive operations
+     * that can be performed on this collection (counting the number of elements,
+     * enumerating it, etc...). */
     collection?: Partial<CollectionHandlers>;
     /** When the environment changes, for example the numerical precision,
      * call `reset()` so that any cached values can be recalculated.
@@ -1329,7 +1347,14 @@ export type CollectionHandlers = {
  */
 export type FunctionDefinitionFlags = {
     /**
-     * If `true`, the arguments of the functions are held unevaluated.
+     * If `true`, the arguments to this function are not automatically
+     * evaluated. The default is `false` (the arguments are evaluated).
+     *
+     * This can be useful for example for functions that take symbolic
+     * expressions as arguments, such as `D` or `Integrate`.
+     *
+     * This is also useful for functions that take an argument that is
+     * potentially an infinite collection.
      *
      * It will be up to the `evaluate()` handler to evaluate the arguments as
      * needed. This is conveninent to pass symbolic expressions as arguments
@@ -1338,7 +1363,7 @@ export type FunctionDefinitionFlags = {
      * This also applies to the `canonical()` handler.
      *
      */
-    hold: boolean;
+    lazy: boolean;
     /**  If `true`, the function is applied element by element to lists, matrices
      * (`["List"]` or `["Tuple"]` expressions) and equations (relational
      * operators).
@@ -1413,12 +1438,29 @@ export type Hold = 'none' | 'all' | 'first' | 'rest' | 'last' | 'most';
  */
 export type BoxedFunctionDefinition = BoxedBaseDefinition & FunctionDefinitionFlags & {
     complexity: number;
-    hold: boolean;
+    /** If true, the signature was inferred from usage and may be modified
+     * as more information becomes available.
+     */
     inferredSignature: boolean;
-    signature: Type;
+    /** The type of the arguments and return value of this function */
+    signature: BoxedType;
+    /** If present, this handler can be used to more precisely determine the
+     * return type based on the type of the arguments. The arguments themselves
+     * should *not* be evaluated, only their types should be used.
+     */
     type?: (ops: ReadonlyArray<BoxedExpression>, options: {
         engine: IComputeEngine;
-    }) => Type | TypeString | undefined;
+    }) => Type | TypeString | BoxedType | undefined;
+    /** If present, this handler can be used to determine the sign of the
+     *  return value of the function, based on the sign and type of its
+     *  arguments.
+     *
+     * The arguments themselves should *not* be evaluated, only their types and
+     * sign should be used.
+     *
+     * This can be used in some case for example to determine when certain
+     * simplifications are valid.
+     */
     sgn?: (ops: ReadonlyArray<BoxedExpression>, options: {
         engine: IComputeEngine;
     }) => Sign | undefined;
@@ -1427,9 +1469,12 @@ export type BoxedFunctionDefinition = BoxedBaseDefinition & FunctionDefinitionFl
     canonical?: (ops: ReadonlyArray<BoxedExpression>, options: {
         engine: IComputeEngine;
     }) => BoxedExpression | null;
-    evaluate?: (ops: ReadonlyArray<BoxedExpression>, options: EvaluateOptions & {
-        engine: IComputeEngine;
+    evaluate?: (ops: ReadonlyArray<BoxedExpression>, options: Partial<EvaluateOptions> & {
+        engine?: IComputeEngine;
     }) => BoxedExpression | undefined;
+    evaluateAsync?: (ops: ReadonlyArray<BoxedExpression>, options?: Partial<EvaluateOptions> & {
+        engine?: IComputeEngine;
+    }) => Promise<BoxedExpression | undefined>;
     evalDimension?: (ops: ReadonlyArray<BoxedExpression>, options: {
         engine: IComputeEngine;
     }) => BoxedExpression;
@@ -1499,7 +1544,7 @@ export interface BoxedSymbolDefinition extends BoxedBaseDefinition, SymbolAttrib
     neq?: (a: BoxedExpression) => boolean | undefined;
     cmp?: (a: BoxedExpression) => '=' | '>' | '<' | undefined;
     inferredType: boolean;
-    type: Type;
+    type: BoxedType;
 }
 /**
  * Given an expression and set of wildcards, return a new expression.
@@ -1658,7 +1703,8 @@ export type SimplifyOptions = {
  * @category Boxed Expression
  */
 export type EvaluateOptions = {
-    numericApproximation?: boolean;
+    numericApproximation: boolean;
+    signal: AbortSignal;
 };
 /**
  * Metadata that can be associated with a `BoxedExpression`
@@ -1686,7 +1732,7 @@ export type ArrayValue = boolean | number | string | BigNum | BoxedExpression |
 /** @category Assumptions */
 export type AssumeResult = 'internal-error' | 'not-a-predicate' | 'contradiction' | 'tautology' | 'ok';
 /** @category Compute Engine */
-export type AssignValue = boolean | number | string | LatexString | SemiBoxedExpression | ((args: ReadonlyArray<BoxedExpression>, options: EvaluateOptions & {
+export type AssignValue = boolean | number | SemiBoxedExpression | ((args: ReadonlyArray<BoxedExpression>, options: EvaluateOptions & {
     engine: IComputeEngine;
 }) => BoxedExpression) | undefined;
 /** @internal */
@@ -1728,14 +1774,30 @@ export interface IComputeEngine extends IBigNum {
     /** Absolute time beyond which evaluation should not proceed
      * @internal
      */
-    deadline?: number;
+    _deadline?: number;
+    /** Time remaining before _deadline */
+    _timeRemaining: number;
+    /** @private */
     generation: number;
-    /** @hidden */
-    readonly timeLimit: number;
-    /** @hidden */
-    readonly iterationLimit: number;
-    /** @hidden */
-    readonly recursionLimit: number;
+    /** Throw a `CancellationError` when the duration of an evaluation exceeds
+     * the time limit.
+     *
+     * Time in milliseconds, default 2000 ms = 2 seconds.
+     *
+     */
+    timeLimit: number;
+    /** Throw `CancellationError` `iteration-limit-exceeded` when the iteration limit
+     * in a loop is exceeded. Default: no limits.
+     *
+     * @experimental
+     */
+    iterationLimit: number;
+    /** Signal `recursion-depth-exceeded` when the recursion depth for this
+     * scope is exceeded.
+     *
+     * @experimental
+     */
+    recursionLimit: number;
     chop(n: number): number;
     chop(n: BigNum): BigNum | 0;
     chop(n: number | BigNum): number | BigNum;
@@ -1776,10 +1838,11 @@ export interface IComputeEngine extends IBigNum {
     }): BoxedExpression;
     string(s: string, metadata?: Metadata): BoxedExpression;
     error(message: string | string[], where?: string): BoxedExpression;
-    typeError(expectedType: Type, actualType: undefined | Type, where?: SemiBoxedExpression): BoxedExpression;
+    typeError(expectedType: Type, actualType: undefined | Type | BoxedType, where?: SemiBoxedExpression): BoxedExpression;
     hold(expr: SemiBoxedExpression): BoxedExpression;
     tuple(...elements: ReadonlyArray<number>): BoxedExpression;
     tuple(...elements: ReadonlyArray<BoxedExpression>): BoxedExpression;
+    type(type: Type | TypeString | BoxedType): BoxedType;
     rules(rules: Rule | ReadonlyArray<Rule | BoxedRule> | BoxedRuleSet | undefined | null, options?: {
         canonical?: boolean;
     }): BoxedRuleSet;
@@ -1927,11 +1990,11 @@ export type LatexString = string;
  *    value.
  * - `recursive`: if true, match recursively, otherwise match only the top
  *    level.
- * - `exact`: if true, only match expressions that are structurally identical.
- *    If false, match expressions that are structurally identical or equivalent.
+ * - `useVariations`: if false, only match expressions that are structurally identical.
+ *    If true, match expressions that are structurally identical or equivalent.
  *
- *    For example, when false, `["Add", '_a', 2]` matches `2`, with a value of
- *    `_a` of `0`. If true, the expression does not match. **Default**: `true`
+ *    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`
  *
  * @category Pattern Matching
  *
@@ -2040,34 +2103,7 @@ export type RuntimeIdentifierDefinitions = Map<string, OneOf<[BoxedSymbolDefinit
  *
  * @category Compute Engine
  */
-export type Scope = {
-    /** Signal `timeout` when the execution time for this scope is exceeded.
-     *
-     * Time in seconds, default 2s.
-     *
-     * @experimental
-     */
-    timeLimit: number;
-    /** Signal `out-of-memory` when the memory usage for this scope is exceeded.
-     *
-     * Memory is in Megabytes, default: 1Mb.
-     *
-     * @experimental
-     */
-    memoryLimit: number;
-    /** Signal `recursion-depth-exceeded` when the recursion depth for this
-     * scope is exceeded.
-     *
-     * @experimental
-     */
-    recursionLimit: number;
-    /** Signal `iteration-limit-exceeded` when the iteration limit
-     * in a loop is exceeded. Default: no limits.
-     *
-     * @experimental
-     */
-    iterationLimit: number;
-};
+export type Scope = {};
 /** @category Compute Engine */
 export type RuntimeScope = Scope & {
     parentScope?: RuntimeScope;
@@ -2123,7 +2159,7 @@ export type FunctionDefinition = BaseDefinition & Partial<FunctionDefinitionFlag
      */
     type?: (ops: ReadonlyArray<BoxedExpression>, options: {
         engine: IComputeEngine;
-    }) => Type;
+    }) => Type | TypeString | BoxedType | undefined;
     /** Return the sign of the function expression.
      *
      * If the sign cannot be determined, return `undefined`.
@@ -2231,6 +2267,13 @@ export type FunctionDefinition = BaseDefinition & Partial<FunctionDefinitionFlag
     evaluate?: ((ops: ReadonlyArray<BoxedExpression>, options: EvaluateOptions & {
         engine: IComputeEngine;
     }) => BoxedExpression | undefined) | BoxedExpression;
+    /**
+     * An option asynchronous version of `evaluate`.
+     *
+     */
+    evaluateAsync?: (ops: ReadonlyArray<BoxedExpression>, options: EvaluateOptions & {
+        engine: IComputeEngine;
+    }) => Promise<BoxedExpression | undefined>;
     /** Dimensional analysis
      * @experimental
      */
@@ -2239,6 +2282,8 @@ export type FunctionDefinition = BaseDefinition & Partial<FunctionDefinitionFlag
     }) => BoxedExpression;
     /** Return a compiled (optimized) expression. */
     compile?: (expr: BoxedExpression) => CompiledExpression;
+    eq?: (a: BoxedExpression, b: BoxedExpression) => boolean | undefined;
+    neq?: (a: BoxedExpression, b: BoxedExpression) => boolean | undefined;
     collection?: Partial<CollectionHandlers>;
 };
 /**

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

@@ -1,4 +1,4 @@
-/* 0.26.4 */
+/* 0.28.0 */
 export declare const ConditionParent: {
     boolean: string;
     string: string;

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

@@ -1,3 +1,3 @@
-/* 0.26.4 */
+/* 0.28.0 */
 import type { BoxedExpression, IComputeEngine, JsonSerializationOptions } from '../public';
 export declare function serializeJson(ce: IComputeEngine, expr: BoxedExpression, options: Readonly<JsonSerializationOptions>): Expression;

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

@@ -1,4 +1,4 @@
-/* 0.26.4 */
+/* 0.28.0 */
 export declare function sgn(expr: BoxedExpression): Sign | undefined;
 export declare function positiveSign(s: Sign | undefined): boolean | undefined;
 export declare function nonNegativeSign(s: Sign | undefined): boolean | undefined;

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

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

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

@@ -1,4 +1,4 @@
-/* 0.26.4 */
+/* 0.28.0 */
 import { Rule } from '../public';
 export declare const UNIVARIATE_ROOTS: Rule[];
 /**

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

@@ -1,4 +1,4 @@
-/* 0.26.4 */
+/* 0.28.0 */
 import type { BoxedExpression, IComputeEngine } from '../public';
 export type DataTypeMap = {
     float64: number;

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

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

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

@@ -1,4 +1,4 @@
-/* 0.26.4 */
+/* 0.28.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;
@@ -7,4 +7,10 @@ export declare function processInverseFunction(ce: IComputeEngine, xs: ReadonlyA
 export declare function trigSign(operator: string, x: BoxedExpression): Sign | undefined;
 export declare function isConstructible(x: string | BoxedExpression): boolean;
 export declare function constructibleValues(operator: string, x: BoxedExpression | undefined): undefined | BoxedExpression;
+/**
+ * Return the angle in the range [0, 2π) that is equivalent to the given angle.
+ *
+ * @param x
+ * @returns
+ */
 export declare function canonicalAngle(x: BoxedExpression | undefined): BoxedExpression | undefined;

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

@@ -1,4 +1,4 @@
-/* 0.26.4 */
+/* 0.28.0 */
 import { Type } from '../../common/type/types';
 export declare function isBoxedExpression(x: unknown): x is BoxedExpression;
 /**

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

@@ -1,4 +1,4 @@
-/* 0.26.4 */
+/* 0.28.0 */
 import type { IComputeEngine } from '../public';
 import { Type } from '../../common/type/types';
 /**
@@ -28,7 +28,7 @@ export declare function checkNumericArgs(ce: IComputeEngine, ops: ReadonlyArray<
     flatten?: string;
 }): ReadonlyArray<BoxedExpression>;
 /**
- * Check that an argument is of the expected domain.
+ * Check that an argument is of the expected type.
  *
  * Converts the arguments to canonical
  */
@@ -46,4 +46,4 @@ export declare function checkPure(ce: IComputeEngine, arg: BoxedExpression | Box
  * arguments.
  *
  */
-export declare function validateArguments(ce: IComputeEngine, ops: ReadonlyArray<BoxedExpression>, def: BoxedFunctionDefinition): ReadonlyArray<BoxedExpression> | null;
+export declare function validateArguments(ce: IComputeEngine, ops: ReadonlyArray<BoxedExpression>, signature: Type, lazy?: boolean, threadable?: boolean): ReadonlyArray<BoxedExpression> | null;

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

@@ -1,4 +1,4 @@
-/* 0.26.4 */
+/* 0.28.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
@@ -58,6 +58,7 @@ export declare function length(col: BoxedExpression): number | undefined;
  *
  */
 export declare function iterator(expr: BoxedExpression): Iterator<BoxedExpression> | undefined;
+export declare function repeat(value: BoxedExpression, count?: number): Iterator<BoxedExpression>;
 /**
  *
  * @param expr
@@ -66,3 +67,4 @@ export declare function iterator(expr: BoxedExpression): Iterator<BoxedExpressio
  */
 export declare function at(expr: BoxedExpression, index: number): BoxedExpression | undefined;
 export declare function defaultCollectionHandlers(def: undefined | Partial<CollectionHandlers>): Partial<CollectionHandlers> | undefined;
+export declare function zip(items: ReadonlyArray<BoxedExpression>): Iterator<BoxedExpression[]>;

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

@@ -1,30 +1,31 @@
-/* 0.26.4 */
+/* 0.28.0 */
 import type { BoxedExpression } from './public';
 export type CompiledType = boolean | number | string | object;
-type JSSource = string;
+export type JSSource = string;
 export type CompiledOperators = Record<MathJsonIdentifier, [
     op: string,
     prec: number
 ]>;
+export type CompiledFunction = string | ((args: ReadonlyArray<BoxedExpression>, compile: (expr: BoxedExpression) => JSSource, target: CompileTarget) => JSSource);
 export type CompiledFunctions = {
-    [id: MathJsonIdentifier]: string | ((args: ReadonlyArray<BoxedExpression>, compile: (expr: BoxedExpression) => JSSource, target: CompileTarget) => JSSource);
+    [id: MathJsonIdentifier]: CompiledFunction;
 };
 export type CompileTarget = {
     operators?: (op: MathJsonIdentifier) => [op: string, prec: number];
-    functions?: (id: MathJsonIdentifier) => string | ((...args: CompiledType[]) => string);
+    functions?: (id: MathJsonIdentifier) => CompiledFunction | undefined;
     var: (id: MathJsonIdentifier) => 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. */
 export declare class ComputeEngineFunction extends Function {
     private sys;
-    constructor(body: string);
+    constructor(body: string, preamble?: string);
 }
-export declare function compileToTarget(expr: BoxedExpression, target: CompileTarget): ((_: Record<string, CompiledType>) => CompiledType) | undefined;
-export declare function compileToJavascript(expr: BoxedExpression): ((_: Record<string, CompiledType>) => CompiledType) | undefined;
+export declare function compileToTarget(expr: BoxedExpression, target: CompileTarget): (_?: Record<string, CompiledType>) => CompiledType;
+export declare function compileToJavascript(expr: BoxedExpression, functions?: Record<MathJsonIdentifier, JSSource | Function>, vars?: Record<MathJsonIdentifier, JSSource>, imports?: unknown[], preamble?: string): (_?: Record<string, CompiledType>) => CompiledType;
 export declare function compile(expr: BoxedExpression | undefined, target: CompileTarget, prec?: number): JSSource;
-export {};