@field/cascade 0.2.22 → 0.3.0

package/dist/runtime/animation/frameRange.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Frame-range evaluation, neutral runtime.
+ *
+ * The loop the engine has always been missing: set the frame, mark the
+ * time-dependent nodes dirty, hand the frame to a caller, repeat. It writes no
+ * files and spawns no encoder — frames are produced where the canvas is, so
+ * what the caller does with each frame is the caller's business.
+ *
+ * The loop owns no graph and no clock of its own. It drives a `FrameClock`,
+ * which a host binds to its own engine state.
+ */
+export interface FrameClock {
+    /** Set the current frame. Fractional frames must be preserved. */
+    setFrame(frame: number): void;
+    /** Dirty every node whose parameters depend on time. */
+    markTimeDependentDirty(): void;
+    /** Integer frame — $F */
+    getFrame(): number;
+    /** Fractional frame — $FF */
+    getFrameFraction(): number;
+    /** Seconds — $T */
+    getTime(): number;
+    /** Rate — $FPS */
+    getFps(): number;
+}
+/** What a caller is told about the frame it has been handed. */
+export interface FrameInfo {
+    /** 0-based position in the range. */
+    index: number;
+    /** Total frames in the range. */
+    total: number;
+    /** Integer frame — $F */
+    frame: number;
+    /** Fractional frame — $FF */
+    fframe: number;
+    /** Seconds — $T */
+    time: number;
+    /** Rate — $FPS */
+    fps: number;
+}
+export interface FrameRangeOptions {
+    /** First frame, inclusive. */
+    start: number;
+    /** Last frame, inclusive when the step lands on it. */
+    end: number;
+    /** Frame increment. Must be > 0; may be fractional for sub-frame stepping. */
+    step?: number;
+    /** Called once per frame, after the frame is set and dirt is marked. */
+    onFrame: (info: FrameInfo) => void | Promise<void>;
+    /** Cooperative cancellation, checked before each frame. */
+    signal?: {
+        readonly aborted: boolean;
+    };
+    /** Restore the clock's frame when the loop finishes. Default true. */
+    restoreFrame?: boolean;
+}
+export interface FrameRangeResult {
+    /** The fractional frames visited, in order. */
+    frames: number[];
+    frameCount: number;
+    /** True if a signal cut the loop short. */
+    aborted: boolean;
+}
+/**
+ * The frames a range visits. Pure — no clock, no side effects — so a caller can
+ * size a progress bar or a sequence without running anything.
+ */
+export declare function frameRange(start: number, end: number, step?: number): number[];
+/**
+ * Walk a frame range against a clock, calling back once per frame.
+ *
+ * Per frame, in this order: set the frame, mark time-dependent nodes dirty,
+ * then call `onFrame`. The callback is where a cook happens — the loop does not
+ * assume one, which is what lets the same loop serve a render, a test, or a
+ * headless evaluation.
+ */
+export declare function runFrameRange(clock: FrameClock, options: FrameRangeOptions): Promise<FrameRangeResult>;
+//# sourceMappingURL=frameRange.d.ts.map

package/dist/runtime/animation/frameRange.js

@@ -0,0 +1,76 @@
+/**
+ * Frame-range evaluation, neutral runtime.
+ *
+ * The loop the engine has always been missing: set the frame, mark the
+ * time-dependent nodes dirty, hand the frame to a caller, repeat. It writes no
+ * files and spawns no encoder — frames are produced where the canvas is, so
+ * what the caller does with each frame is the caller's business.
+ *
+ * The loop owns no graph and no clock of its own. It drives a `FrameClock`,
+ * which a host binds to its own engine state.
+ */
+/**
+ * The frames a range visits. Pure — no clock, no side effects — so a caller can
+ * size a progress bar or a sequence without running anything.
+ */
+export function frameRange(start, end, step = 1) {
+    if (!Number.isFinite(start) || !Number.isFinite(end)) {
+        throw new Error(`frameRange: start and end must be finite (got ${start}, ${end})`);
+    }
+    if (!Number.isFinite(step) || step <= 0) {
+        throw new Error(`frameRange: step must be a finite number greater than 0 (got ${step})`);
+    }
+    if (end < start) {
+        throw new Error(`frameRange: end (${end}) must not be before start (${start})`);
+    }
+    // Count from the span rather than accumulating, so a fractional step does not
+    // drift and an inclusive end lands exactly.
+    const span = end - start;
+    const count = Math.floor(span / step + 1e-9) + 1;
+    const frames = new Array(count);
+    for (let i = 0; i < count; i++)
+        frames[i] = start + i * step;
+    return frames;
+}
+/**
+ * Walk a frame range against a clock, calling back once per frame.
+ *
+ * Per frame, in this order: set the frame, mark time-dependent nodes dirty,
+ * then call `onFrame`. The callback is where a cook happens — the loop does not
+ * assume one, which is what lets the same loop serve a render, a test, or a
+ * headless evaluation.
+ */
+export async function runFrameRange(clock, options) {
+    const { start, end, step = 1, onFrame, signal, restoreFrame = true } = options;
+    const frames = frameRange(start, end, step);
+    const previousFrame = clock.getFrameFraction();
+    const visited = [];
+    let aborted = false;
+    try {
+        for (let index = 0; index < frames.length; index++) {
+            if (signal?.aborted) {
+                aborted = true;
+                break;
+            }
+            clock.setFrame(frames[index]);
+            clock.markTimeDependentDirty();
+            await onFrame({
+                index,
+                total: frames.length,
+                frame: clock.getFrame(),
+                fframe: clock.getFrameFraction(),
+                time: clock.getTime(),
+                fps: clock.getFps()
+            });
+            visited.push(clock.getFrameFraction());
+        }
+    }
+    finally {
+        if (restoreFrame) {
+            clock.setFrame(previousFrame);
+            clock.markTimeDependentDirty();
+        }
+    }
+    return { frames: visited, frameCount: visited.length, aborted };
+}
+//# sourceMappingURL=frameRange.js.map

package/dist/runtime/animation/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Animation: keyframe channels, and frame-range evaluation over a host-bound
+ * clock. Neither holds a clock of its own — the host owns time, which is what
+ * keeps a cook deterministic.
+ */
+export { DEFAULT_INTERPOLATION, EMPTY_CHANNEL, createChannel, deleteKey, deserializeChannel, isChannel, isEmptyChannel, isInterpolation, keyAt, sampleChannel, serializeChannel, setKey, setKeyInterpolation } from "./channel.js";
+export type { Channel, Interpolation, Keyframe, KeyframeInput, SerializedChannel, SerializedKeyframe } from "./channel.js";
+export { frameRange, runFrameRange } from "./frameRange.js";
+export type { FrameClock, FrameInfo, FrameRangeOptions, FrameRangeResult } from "./frameRange.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/animation/index.js

@@ -0,0 +1,8 @@
+/**
+ * Animation: keyframe channels, and frame-range evaluation over a host-bound
+ * clock. Neither holds a clock of its own — the host owns time, which is what
+ * keeps a cook deterministic.
+ */
+export { DEFAULT_INTERPOLATION, EMPTY_CHANNEL, createChannel, deleteKey, deserializeChannel, isChannel, isEmptyChannel, isInterpolation, keyAt, sampleChannel, serializeChannel, setKey, setKeyInterpolation } from "./channel.js";
+export { frameRange, runFrameRange } from "./frameRange.js";
+//# sourceMappingURL=index.js.map

package/dist/runtime/builtins/core/random.d.ts

@@ -1,4 +1,4 @@
-import type { NodeExecutionContext } from "cascade/contracts";
+import type { NodeExecutionContext } from "@field/cascade/contracts";
 export declare const randomDefinition: {
     readonly apiVersion: 1;
     readonly label: "Random";

package/dist/runtime/builtins/core/remap.d.ts

@@ -1,4 +1,4 @@
-import type { NodeExecutionContext } from "cascade/contracts";
+import type { NodeExecutionContext } from "@field/cascade/contracts";
 export declare const remapDefinition: {
     readonly apiVersion: 1;
     readonly label: "Remap";

package/dist/runtime/builtins/geo/copyToPoints.d.ts

@@ -1,4 +1,4 @@
-import type { NodeExecutionContext } from "cascade/contracts";
+import type { NodeExecutionContext } from "@field/cascade/contracts";
 import { copyToPointsDefinition } from "./definitions.js";
 /**
  * Copy to Points SOP: the source instanced onto every point of the target.

package/dist/runtime/builtins/geo/copyToPoints.js

@@ -1,4 +1,4 @@
-import { emptyGeometry } from "cascade/contracts";
+import { emptyGeometry } from "@field/cascade/contracts";
 import { copyToPoints } from "../../geometry/copy.js";
 import { copyToPointsDefinition } from "./definitions.js";
 import { geoModuleId } from "./namespace.js";

package/dist/runtime/builtins/geo/generators.d.ts

@@ -1,4 +1,4 @@
-import type { NodeExecutionContext } from "cascade/contracts";
+import type { NodeExecutionContext } from "@field/cascade/contracts";
 import { circleDefinition, rectangleDefinition } from "./definitions.js";
 /**
  * The two generators. Houdini has no Rectangle and its Grid with two rows does

package/dist/runtime/builtins/geo/merge.d.ts

@@ -1,4 +1,4 @@
-import type { NodeExecutionContext } from "cascade/contracts";
+import type { NodeExecutionContext } from "@field/cascade/contracts";
 import { mergeDefinition } from "./definitions.js";
 /**
  * Merge SOP: N geometries concatenated, with points, vertices and primitives

package/dist/runtime/builtins/geo/svgExport.d.ts

@@ -1,4 +1,4 @@
-import type { NodeExecutionContext } from "cascade/contracts";
+import type { NodeExecutionContext } from "@field/cascade/contracts";
 import { svgExportDefinition } from "./definitions.js";
 /**
  * The output end: an SVG document, as a string and as a written asset.

package/dist/runtime/builtins/geo/svgExport.js

@@ -1,4 +1,4 @@
-import { emptyGeometry } from "cascade/contracts";
+import { emptyGeometry } from "@field/cascade/contracts";
 import { geometryToSvg, utf8Bytes } from "../../geometry/svg.js";
 import { svgExportDefinition } from "./definitions.js";
 import { geoModuleId } from "./namespace.js";

package/dist/runtime/builtins/geo/transform.d.ts

@@ -1,4 +1,4 @@
-import type { NodeExecutionContext } from "cascade/contracts";
+import type { NodeExecutionContext } from "@field/cascade/contracts";
 import { transformDefinition } from "./definitions.js";
 /**
  * Transform SOP's parameters, by its names: translate, rotate, scale, pivot,

package/dist/runtime/builtins/geo/transform.js

@@ -1,4 +1,4 @@
-import { emptyGeometry } from "cascade/contracts";
+import { emptyGeometry } from "@field/cascade/contracts";
 import { transformMatrix } from "../../geometry/matrix.js";
 import { transformGeometry } from "../../geometry/transform.js";
 import { transformDefinition } from "./definitions.js";

package/dist/runtime/definition/architecture.d.ts

@@ -1,5 +1,5 @@
 import type * as TypeScript from "typescript";
-import type { Diagnostic } from "cascade/contracts";
+import type { Diagnostic } from "@field/cascade/contracts";
 /**
  * Enforces the statically inspectable node-module boundary. This is an
  * architecture check for trusted project code, not a security sandbox.

package/dist/runtime/definition/extract.d.ts

@@ -1,5 +1,5 @@
 import type * as TypeScript from "typescript";
-import { type Diagnostic, type NodeDefinition } from "cascade/contracts";
+import { type Diagnostic, type NodeDefinition } from "@field/cascade/contracts";
 export type DefinitionExtractionResult = {
     readonly ok: true;
     readonly definition: NodeDefinition;

package/dist/runtime/definition/extract.js

@@ -1,4 +1,4 @@
-import { validateNodeDefinition, } from "cascade/contracts";
+import { validateNodeDefinition, } from "@field/cascade/contracts";
 const MAX_DEPTH = 32;
 const MAX_NODES = 10_000;
 export function extractNodeDefinition(source, fileName, ts) {

package/dist/runtime/error.d.ts

@@ -1,4 +1,4 @@
-import type { Diagnostic } from "cascade/contracts";
+import type { Diagnostic } from "@field/cascade/contracts";
 export declare class CascadeRuntimeError extends Error {
     readonly code: string;
     readonly diagnostics: readonly Diagnostic[];

package/dist/runtime/expressions/evaluator.d.ts

@@ -0,0 +1,53 @@
+/**
+ * The neutral expression evaluator.
+ *
+ * Compiles parameter expressions and evaluates them against a time state and a
+ * host-supplied scope. It imports nothing from Studio and touches no platform
+ * API, so a headless cook can resolve `sin($T)` on a parameter exactly as the
+ * editor does.
+ *
+ * Determinism: an expression is a parameter resolved *before* execute runs, so
+ * the node receives a plain number and stays pure. Same graph plus same frame
+ * gives the same output.
+ */
+import type { ExpressionScope, Node as NodeShape } from "./scope.js";
+import { TimeState } from "./time.js";
+import type { CompiledExpression, ExpressionContext, ExpressionResult } from "./types.js";
+export declare class ExpressionEvaluator<TNode extends NodeShape = NodeShape> {
+    protected readonly timeState: TimeState;
+    private readonly compiledCache;
+    private scope;
+    constructor(scope?: ExpressionScope<TNode> | null);
+    /** Bind (or rebind) the host scope. Clears nothing: compilation is scope-free. */
+    setScope(scope: ExpressionScope<TNode> | null): void;
+    getScope(): ExpressionScope<TNode> | null;
+    /** Set the current frame. Fractional frames are preserved. */
+    setFrame(frame: number): void;
+    /** Set the current time in seconds, keeping the sub-frame remainder. */
+    setTime(seconds: number): void;
+    setFps(fps: number): void;
+    /** seconds — $T */
+    get time(): number;
+    /** integer frame — $F */
+    get frame(): number;
+    /** fractional frame — $FF */
+    get fframe(): number;
+    /** rate — $FPS */
+    get fps(): number;
+    compile(expression: string): CompiledExpression<TNode>;
+    evaluate(expression: string, node: TNode): ExpressionResult;
+    /** Build the context an expression sees. */
+    createContext(node: TNode): ExpressionContext<TNode>;
+    ch(node: TNode, path: string): number;
+    chs(node: TNode, path: string): string;
+    chv(node: TNode, path: string): number[];
+    private resolveParam;
+    /** True if a referenced path resolves from this node. */
+    validatePath(fromNode: TNode, path: string): boolean;
+    /** Parameter paths referenced through ch/chs/chv. */
+    extractDependencies(expression: string): string[];
+    /** True if the expression references time, in either the bare or `$` spelling. */
+    hasTimeReference(expression: string): boolean;
+    clearCache(): void;
+}
+//# sourceMappingURL=evaluator.d.ts.map

package/dist/runtime/expressions/evaluator.js

@@ -0,0 +1,193 @@
+/**
+ * The neutral expression evaluator.
+ *
+ * Compiles parameter expressions and evaluates them against a time state and a
+ * host-supplied scope. It imports nothing from Studio and touches no platform
+ * API, so a headless cook can resolve `sin($T)` on a parameter exactly as the
+ * editor does.
+ *
+ * Determinism: an expression is a parameter resolved *before* execute runs, so
+ * the node receives a plain number and stays pure. Same graph plus same frame
+ * gives the same output.
+ */
+import { clamp, fit, fit01, lerp, MATH_SCOPE, noise, padzero, random, smooth } from "./math.js";
+import { hasTimeReference, preprocessExpression } from "./preprocess.js";
+import { TimeState } from "./time.js";
+const DEPENDENCY_PATTERN = /\b(?:ch|chs|chv)\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+export class ExpressionEvaluator {
+    timeState = new TimeState();
+    compiledCache = new Map();
+    scope;
+    constructor(scope = null) {
+        this.scope = scope;
+    }
+    /** Bind (or rebind) the host scope. Clears nothing: compilation is scope-free. */
+    setScope(scope) {
+        this.scope = scope;
+    }
+    getScope() {
+        return this.scope;
+    }
+    // ============ Time ============
+    /** Set the current frame. Fractional frames are preserved. */
+    setFrame(frame) {
+        this.timeState.setFrame(frame);
+    }
+    /** Set the current time in seconds, keeping the sub-frame remainder. */
+    setTime(seconds) {
+        this.timeState.setTime(seconds);
+    }
+    setFps(fps) {
+        this.timeState.setFps(fps);
+    }
+    /** seconds — $T */
+    get time() {
+        return this.timeState.time;
+    }
+    /** integer frame — $F */
+    get frame() {
+        return this.timeState.frame;
+    }
+    /** fractional frame — $FF */
+    get fframe() {
+        return this.timeState.frameFraction;
+    }
+    /** rate — $FPS */
+    get fps() {
+        return this.timeState.fps;
+    }
+    // ============ Compile / evaluate ============
+    compile(expression) {
+        const cached = this.compiledCache.get(expression);
+        if (cached)
+            return cached;
+        const dependencies = this.extractDependencies(expression);
+        const isTimeDependent = hasTimeReference(expression);
+        const compiledSource = preprocessExpression(expression);
+        try {
+            const fnBody = `
+        with (context) {
+          return (${compiledSource});
+        }
+      `;
+            const evaluator = new Function("context", fnBody);
+            const compiled = {
+                source: expression,
+                compiledSource,
+                evaluate: evaluator,
+                dependencies,
+                isTimeDependent
+            };
+            this.compiledCache.set(expression, compiled);
+            return compiled;
+        }
+        catch (err) {
+            return {
+                source: expression,
+                compiledSource,
+                evaluate: () => undefined,
+                dependencies,
+                isTimeDependent,
+                error: err instanceof Error ? err.message : String(err)
+            };
+        }
+    }
+    evaluate(expression, node) {
+        const compiled = this.compile(expression);
+        if (compiled.error)
+            return { value: undefined, error: compiled.error };
+        try {
+            return { value: compiled.evaluate(this.createContext(node)) };
+        }
+        catch (err) {
+            return {
+                value: undefined,
+                error: err instanceof Error ? err.message : String(err)
+            };
+        }
+    }
+    /** Build the context an expression sees. */
+    createContext(node) {
+        return {
+            time: this.timeState.time,
+            frame: this.timeState.frame,
+            fframe: this.timeState.frameFraction,
+            fps: this.timeState.fps,
+            self: node,
+            ch: (path) => this.ch(node, path),
+            chs: (path) => this.chs(node, path),
+            chv: (path) => this.chv(node, path),
+            opexist: (path) => (this.scope?.nodeExists(node, path) ? 1 : 0),
+            opinput: (index) => this.scope?.inputNode(node, index) ?? null,
+            fit,
+            fit01,
+            clamp,
+            lerp,
+            smooth,
+            noise,
+            random,
+            padzero,
+            // Bare maths — `sin($FF * 0.5)` rather than `Math.sin(...)`. Spread
+            // before `Math` so nothing here can shadow the namespace itself.
+            ...MATH_SCOPE,
+            Math
+        };
+    }
+    // ============ Channel functions ============
+    ch(node, path) {
+        const resolved = this.resolveParam(node, path);
+        if (!resolved)
+            return 0;
+        const value = resolved.value;
+        if (typeof value === "number")
+            return value;
+        if (typeof value === "string")
+            return parseFloat(value) || 0;
+        if (typeof value === "boolean")
+            return value ? 1 : 0;
+        return 0;
+    }
+    chs(node, path) {
+        const resolved = this.resolveParam(node, path);
+        if (!resolved)
+            return "";
+        return String(resolved.value ?? "");
+    }
+    chv(node, path) {
+        const resolved = this.resolveParam(node, path);
+        if (!resolved)
+            return [];
+        const value = resolved.value;
+        if (Array.isArray(value)) {
+            return value.map((v) => (typeof v === "number" ? v : parseFloat(String(v)) || 0));
+        }
+        if (typeof value === "number")
+            return [value];
+        return [];
+    }
+    resolveParam(node, path) {
+        return this.scope?.resolveParam(node, path) ?? null;
+    }
+    /** True if a referenced path resolves from this node. */
+    validatePath(fromNode, path) {
+        return this.resolveParam(fromNode, path) !== null;
+    }
+    /** Parameter paths referenced through ch/chs/chv. */
+    extractDependencies(expression) {
+        const deps = [];
+        DEPENDENCY_PATTERN.lastIndex = 0;
+        let match;
+        while ((match = DEPENDENCY_PATTERN.exec(expression)) !== null) {
+            deps.push(match[1]);
+        }
+        return deps;
+    }
+    /** True if the expression references time, in either the bare or `$` spelling. */
+    hasTimeReference(expression) {
+        return hasTimeReference(expression);
+    }
+    clearCache() {
+        this.compiledCache.clear();
+    }
+}
+//# sourceMappingURL=evaluator.js.map

package/dist/runtime/expressions/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Parameter expressions, neutral runtime.
+ *
+ * Compilation, `$` time variables, math utilities and the host scope binding.
+ * Depends on nothing outside this folder, so both Studio and a headless host
+ * evaluate parameters with the same engine.
+ */
+export { ExpressionEvaluator } from "./evaluator.js";
+export { clamp, fit, fit01, lerp, noise, padzero, random, smooth } from "./math.js";
+export { TIME_IDENTIFIERS, TIME_TOKENS, hasTimeReference, preprocessExpression } from "./preprocess.js";
+export { DEFAULT_FPS, MIN_FRAME, TimeState } from "./time.js";
+export type { TimeVariables } from "./time.js";
+export type { ExpressionScope, Node as ExpressionNode } from "./scope.js";
+export type { CompiledExpression, ExpressionContext, ExpressionResult, PathWarning } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/expressions/index.js

@@ -0,0 +1,12 @@
+/**
+ * Parameter expressions, neutral runtime.
+ *
+ * Compilation, `$` time variables, math utilities and the host scope binding.
+ * Depends on nothing outside this folder, so both Studio and a headless host
+ * evaluate parameters with the same engine.
+ */
+export { ExpressionEvaluator } from "./evaluator.js";
+export { clamp, fit, fit01, lerp, noise, padzero, random, smooth } from "./math.js";
+export { TIME_IDENTIFIERS, TIME_TOKENS, hasTimeReference, preprocessExpression } from "./preprocess.js";
+export { DEFAULT_FPS, MIN_FRAME, TimeState } from "./time.js";
+//# sourceMappingURL=index.js.map

package/dist/runtime/expressions/math.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Expression math utilities.
+ *
+ * Pure functions, no ambient state, deterministic for a given input — the same
+ * contract the rest of the runtime holds. `noise` and `random` are seeded
+ * closed forms rather than anything drawn from process state.
+ */
+/** Remap a value from one range to another. */
+export declare function fit(value: number, oldMin: number, oldMax: number, newMin: number, newMax: number): number;
+/** Remap a 0..1 value into a new range. */
+export declare function fit01(value: number, newMin: number, newMax: number): number;
+export declare function clamp(value: number, min: number, max: number): number;
+export declare function lerp(a: number, b: number, t: number): number;
+/** Smooth hermite interpolation (smoothstep). */
+export declare function smooth(value: number, min: number, max: number): number;
+/**
+ * Perlin-like noise in -1..1. Not true Perlin — a deterministic sum of sines.
+ */
+export declare function noise(...coords: number[]): number;
+/** Deterministic random in 0..1 from a seed. */
+export declare function random(seed: number): number;
+/** Zero-pad a number to a given number of digits. */
+export declare function padzero(digits: number, value: number): string;
+/** Degrees to radians. */
+export declare function radians(degrees: number): number;
+/** Radians to degrees. */
+export declare function degrees(radians: number): number;
+/** Sine of an angle in degrees — Houdini's `sin()`. */
+export declare function sind(degrees: number): number;
+/** Cosine of an angle in degrees — Houdini's `cos()`. */
+export declare function cosd(degrees: number): number;
+/** Tangent of an angle in degrees — Houdini's `tan()`. */
+export declare function tand(degrees: number): number;
+/**
+ * The bare maths names available to every expression. Spread into the
+ * evaluation scope; kept as one object so adding a function is a one-line
+ * change here rather than a change in two files.
+ */
+export declare const MATH_SCOPE: {
+    readonly sin: (x: number) => number;
+    readonly cos: (x: number) => number;
+    readonly tan: (x: number) => number;
+    readonly asin: (x: number) => number;
+    readonly acos: (x: number) => number;
+    readonly atan: (x: number) => number;
+    readonly atan2: (y: number, x: number) => number;
+    readonly sinh: (x: number) => number;
+    readonly cosh: (x: number) => number;
+    readonly tanh: (x: number) => number;
+    readonly sind: typeof sind;
+    readonly cosd: typeof cosd;
+    readonly tand: typeof tand;
+    readonly radians: typeof radians;
+    readonly degrees: typeof degrees;
+    readonly sqrt: (x: number) => number;
+    readonly cbrt: (x: number) => number;
+    readonly pow: (x: number, y: number) => number;
+    readonly exp: (x: number) => number;
+    readonly log: (x: number) => number;
+    readonly log2: (x: number) => number;
+    readonly log10: (x: number) => number;
+    readonly hypot: (...values: number[]) => number;
+    readonly abs: (x: number) => number;
+    readonly sign: (x: number) => number;
+    readonly floor: (x: number) => number;
+    readonly ceil: (x: number) => number;
+    readonly round: (x: number) => number;
+    readonly trunc: (x: number) => number;
+    readonly min: (...values: number[]) => number;
+    readonly max: (...values: number[]) => number;
+    readonly PI: number;
+    readonly TAU: number;
+    readonly E: number;
+};
+//# sourceMappingURL=math.d.ts.map