@ansh-ui/core 0.2.0

package/dist/math.d.cts

@@ -0,0 +1,120 @@
+export { R as Rng, c as createRng, d as deriveSeed, g as goldenRatioSequence, h as hashString, j as jitter, r as r2Sequence, w as weightedPick } from './random--4mSc5Lp.cjs';
+
+/**
+ * Scalar math primitives.
+ *
+ * Every function here is pure, allocation-free and safe to call inside a frame loop.
+ * They are the vocabulary the rest of the engine is written in — if you find yourself
+ * writing `Math.min(Math.max(...))` anywhere else, use `clamp` instead.
+ */
+declare const PI: number;
+declare const TAU: number;
+declare const HALF_PI: number;
+declare const EPSILON = 0.000001;
+/** Constrain `value` to the inclusive range `[min, max]`. */
+declare function clamp(value: number, min?: number, max?: number): number;
+/** Linear interpolation. `t` is not clamped — pass values outside `[0,1]` to extrapolate. */
+declare function lerp(from: number, to: number, t: number): number;
+/** The inverse of {@link lerp}: where does `value` sit between `from` and `to`? */
+declare function inverseLerp(from: number, to: number, value: number): number;
+/** Map `value` from one range to another. Set `clampOutput` to avoid extrapolation. */
+declare function remap(value: number, inMin: number, inMax: number, outMin: number, outMax: number, clampOutput?: boolean): number;
+/**
+ * Frame-rate independent exponential smoothing.
+ *
+ * A naive `current += (target - current) * 0.1` moves twice as fast at 120 FPS as it does
+ * at 60. `damp` reformulates it in terms of a half-life measured in seconds, so the motion
+ * looks identical on every device.
+ *
+ * @param smoothing Fraction of the remaining distance left after one second. `0.001` is snappy,
+ *                  `0.5` is languid. Must be in `(0, 1)`.
+ * @param dt        Delta time in seconds.
+ */
+declare function damp(current: number, target: number, smoothing: number, dt: number): number;
+/** Hermite interpolation with zero first-derivative at both ends. */
+declare function smoothstep(edge0: number, edge1: number, x: number): number;
+/** Ken Perlin's quintic smoothstep — zero first *and* second derivative at both ends. */
+declare function smootherstep(edge0: number, edge1: number, x: number): number;
+/** Wrap `value` into `[min, max)`, handling negative inputs correctly (unlike `%`). */
+declare function wrap(value: number, min: number, max: number): number;
+/** Bounce `value` back and forth within `[min, max]` — a triangle wave. */
+declare function pingPong(value: number, min: number, max: number): number;
+/** Move `current` toward `target` by at most `maxDelta`. */
+declare function moveTowards(current: number, target: number, maxDelta: number): number;
+/** Shortest signed angular distance from `a` to `b`, in radians. */
+declare function angleDelta(a: number, b: number): number;
+/** Interpolate between two angles along the shortest arc. */
+declare function lerpAngle(from: number, to: number, t: number): number;
+declare function degrees(radians: number): number;
+declare function radians(degrees: number): number;
+/** Round to a fixed number of decimal places, avoiding float dust in serialised output. */
+declare function roundTo(value: number, decimals?: number): number;
+/** Round to the nearest multiple of `step`. */
+declare function snap(value: number, step: number): number;
+/** Float comparison with a tolerance. */
+declare function approximately(a: number, b: number, epsilon?: number): boolean;
+/** Guard against `NaN`/`Infinity` leaking out of a physics step. */
+declare function finite(value: number, fallback?: number): number;
+/** Arithmetic mean of an array. Returns `0` for an empty array. */
+declare function mean(values: readonly number[]): number;
+/**
+ * Percentile of an *already sorted* ascending array, using linear interpolation between
+ * neighbouring ranks. Used by the frame budget to compute p50/p95 costs.
+ */
+declare function percentileSorted(sorted: readonly number[], p: number): number;
+
+/**
+ * A 2D vector.
+ *
+ * Deliberately a plain object rather than a class: it serialises cleanly, is cheap for the
+ * JIT to inline, and can be stored in component props without surprising anyone. Every
+ * operation returns a new object except the `*Into` variants, which write into a target
+ * and are used in hot loops to avoid allocation pressure.
+ */
+interface Vec2 {
+    x: number;
+    y: number;
+}
+declare function vec2(x?: number, y?: number): Vec2;
+declare function cloneVec2(v: Vec2): Vec2;
+declare function addVec2(a: Vec2, b: Vec2): Vec2;
+declare function subVec2(a: Vec2, b: Vec2): Vec2;
+declare function scaleVec2(v: Vec2, s: number): Vec2;
+declare function dotVec2(a: Vec2, b: Vec2): number;
+/** 2D analogue of the cross product — the z component of the 3D result. */
+declare function crossVec2(a: Vec2, b: Vec2): number;
+declare function lengthVec2(v: Vec2): number;
+/** Squared length. Prefer this for comparisons — it avoids a square root. */
+declare function lengthSqVec2(v: Vec2): number;
+declare function distanceVec2(a: Vec2, b: Vec2): number;
+declare function distanceSqVec2(a: Vec2, b: Vec2): number;
+/** Unit vector. A zero-length input returns `(0, 0)` rather than `NaN`. */
+declare function normalizeVec2(v: Vec2): Vec2;
+/** Rotate counter-clockwise by `angle` radians. */
+declare function rotateVec2(v: Vec2, angle: number): Vec2;
+declare function angleOfVec2(v: Vec2): number;
+declare function fromAngle(angle: number, magnitude?: number): Vec2;
+declare function lerpVec2(a: Vec2, b: Vec2, t: number): Vec2;
+/** Clamp the vector's magnitude to `max`, preserving direction. */
+declare function limitVec2(v: Vec2, max: number): Vec2;
+/** Reflect `v` about a unit-length `normal`. */
+declare function reflectVec2(v: Vec2, normal: Vec2): Vec2;
+declare function setVec2(out: Vec2, x: number, y: number): Vec2;
+declare function addVec2Into(out: Vec2, a: Vec2, b: Vec2): Vec2;
+declare function subVec2Into(out: Vec2, a: Vec2, b: Vec2): Vec2;
+declare function scaleVec2Into(out: Vec2, v: Vec2, s: number): Vec2;
+declare function lerpVec2Into(out: Vec2, a: Vec2, b: Vec2, t: number): Vec2;
+/** Add `b * s` to `out` in place — the fused multiply-add of vector code. */
+declare function addScaledVec2(out: Vec2, b: Vec2, s: number): Vec2;
+/** A rectangle in the same coordinate space as its `Vec2` neighbours. */
+interface Rect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+declare function rectContains(rect: Rect, x: number, y: number): boolean;
+/** Position of `(x, y)` within `rect`, normalised to `[0,1]` on each axis. */
+declare function normalizeInRect(rect: Rect, x: number, y: number): Vec2;
+
+export { EPSILON, HALF_PI, PI, type Rect, TAU, type Vec2, addScaledVec2, addVec2, addVec2Into, angleDelta, angleOfVec2, approximately, clamp, cloneVec2, crossVec2, damp, degrees, distanceSqVec2, distanceVec2, dotVec2, finite, fromAngle, inverseLerp, lengthSqVec2, lengthVec2, lerp, lerpAngle, lerpVec2, lerpVec2Into, limitVec2, mean, moveTowards, normalizeInRect, normalizeVec2, percentileSorted, pingPong, radians, rectContains, reflectVec2, remap, rotateVec2, roundTo, scaleVec2, scaleVec2Into, setVec2, smootherstep, smoothstep, snap, subVec2, subVec2Into, vec2, wrap };

package/dist/math.d.ts

@@ -0,0 +1,120 @@
+export { R as Rng, c as createRng, d as deriveSeed, g as goldenRatioSequence, h as hashString, j as jitter, r as r2Sequence, w as weightedPick } from './random--4mSc5Lp.js';
+
+/**
+ * Scalar math primitives.
+ *
+ * Every function here is pure, allocation-free and safe to call inside a frame loop.
+ * They are the vocabulary the rest of the engine is written in — if you find yourself
+ * writing `Math.min(Math.max(...))` anywhere else, use `clamp` instead.
+ */
+declare const PI: number;
+declare const TAU: number;
+declare const HALF_PI: number;
+declare const EPSILON = 0.000001;
+/** Constrain `value` to the inclusive range `[min, max]`. */
+declare function clamp(value: number, min?: number, max?: number): number;
+/** Linear interpolation. `t` is not clamped — pass values outside `[0,1]` to extrapolate. */
+declare function lerp(from: number, to: number, t: number): number;
+/** The inverse of {@link lerp}: where does `value` sit between `from` and `to`? */
+declare function inverseLerp(from: number, to: number, value: number): number;
+/** Map `value` from one range to another. Set `clampOutput` to avoid extrapolation. */
+declare function remap(value: number, inMin: number, inMax: number, outMin: number, outMax: number, clampOutput?: boolean): number;
+/**
+ * Frame-rate independent exponential smoothing.
+ *
+ * A naive `current += (target - current) * 0.1` moves twice as fast at 120 FPS as it does
+ * at 60. `damp` reformulates it in terms of a half-life measured in seconds, so the motion
+ * looks identical on every device.
+ *
+ * @param smoothing Fraction of the remaining distance left after one second. `0.001` is snappy,
+ *                  `0.5` is languid. Must be in `(0, 1)`.
+ * @param dt        Delta time in seconds.
+ */
+declare function damp(current: number, target: number, smoothing: number, dt: number): number;
+/** Hermite interpolation with zero first-derivative at both ends. */
+declare function smoothstep(edge0: number, edge1: number, x: number): number;
+/** Ken Perlin's quintic smoothstep — zero first *and* second derivative at both ends. */
+declare function smootherstep(edge0: number, edge1: number, x: number): number;
+/** Wrap `value` into `[min, max)`, handling negative inputs correctly (unlike `%`). */
+declare function wrap(value: number, min: number, max: number): number;
+/** Bounce `value` back and forth within `[min, max]` — a triangle wave. */
+declare function pingPong(value: number, min: number, max: number): number;
+/** Move `current` toward `target` by at most `maxDelta`. */
+declare function moveTowards(current: number, target: number, maxDelta: number): number;
+/** Shortest signed angular distance from `a` to `b`, in radians. */
+declare function angleDelta(a: number, b: number): number;
+/** Interpolate between two angles along the shortest arc. */
+declare function lerpAngle(from: number, to: number, t: number): number;
+declare function degrees(radians: number): number;
+declare function radians(degrees: number): number;
+/** Round to a fixed number of decimal places, avoiding float dust in serialised output. */
+declare function roundTo(value: number, decimals?: number): number;
+/** Round to the nearest multiple of `step`. */
+declare function snap(value: number, step: number): number;
+/** Float comparison with a tolerance. */
+declare function approximately(a: number, b: number, epsilon?: number): boolean;
+/** Guard against `NaN`/`Infinity` leaking out of a physics step. */
+declare function finite(value: number, fallback?: number): number;
+/** Arithmetic mean of an array. Returns `0` for an empty array. */
+declare function mean(values: readonly number[]): number;
+/**
+ * Percentile of an *already sorted* ascending array, using linear interpolation between
+ * neighbouring ranks. Used by the frame budget to compute p50/p95 costs.
+ */
+declare function percentileSorted(sorted: readonly number[], p: number): number;
+
+/**
+ * A 2D vector.
+ *
+ * Deliberately a plain object rather than a class: it serialises cleanly, is cheap for the
+ * JIT to inline, and can be stored in component props without surprising anyone. Every
+ * operation returns a new object except the `*Into` variants, which write into a target
+ * and are used in hot loops to avoid allocation pressure.
+ */
+interface Vec2 {
+    x: number;
+    y: number;
+}
+declare function vec2(x?: number, y?: number): Vec2;
+declare function cloneVec2(v: Vec2): Vec2;
+declare function addVec2(a: Vec2, b: Vec2): Vec2;
+declare function subVec2(a: Vec2, b: Vec2): Vec2;
+declare function scaleVec2(v: Vec2, s: number): Vec2;
+declare function dotVec2(a: Vec2, b: Vec2): number;
+/** 2D analogue of the cross product — the z component of the 3D result. */
+declare function crossVec2(a: Vec2, b: Vec2): number;
+declare function lengthVec2(v: Vec2): number;
+/** Squared length. Prefer this for comparisons — it avoids a square root. */
+declare function lengthSqVec2(v: Vec2): number;
+declare function distanceVec2(a: Vec2, b: Vec2): number;
+declare function distanceSqVec2(a: Vec2, b: Vec2): number;
+/** Unit vector. A zero-length input returns `(0, 0)` rather than `NaN`. */
+declare function normalizeVec2(v: Vec2): Vec2;
+/** Rotate counter-clockwise by `angle` radians. */
+declare function rotateVec2(v: Vec2, angle: number): Vec2;
+declare function angleOfVec2(v: Vec2): number;
+declare function fromAngle(angle: number, magnitude?: number): Vec2;
+declare function lerpVec2(a: Vec2, b: Vec2, t: number): Vec2;
+/** Clamp the vector's magnitude to `max`, preserving direction. */
+declare function limitVec2(v: Vec2, max: number): Vec2;
+/** Reflect `v` about a unit-length `normal`. */
+declare function reflectVec2(v: Vec2, normal: Vec2): Vec2;
+declare function setVec2(out: Vec2, x: number, y: number): Vec2;
+declare function addVec2Into(out: Vec2, a: Vec2, b: Vec2): Vec2;
+declare function subVec2Into(out: Vec2, a: Vec2, b: Vec2): Vec2;
+declare function scaleVec2Into(out: Vec2, v: Vec2, s: number): Vec2;
+declare function lerpVec2Into(out: Vec2, a: Vec2, b: Vec2, t: number): Vec2;
+/** Add `b * s` to `out` in place — the fused multiply-add of vector code. */
+declare function addScaledVec2(out: Vec2, b: Vec2, s: number): Vec2;
+/** A rectangle in the same coordinate space as its `Vec2` neighbours. */
+interface Rect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+declare function rectContains(rect: Rect, x: number, y: number): boolean;
+/** Position of `(x, y)` within `rect`, normalised to `[0,1]` on each axis. */
+declare function normalizeInRect(rect: Rect, x: number, y: number): Vec2;
+
+export { EPSILON, HALF_PI, PI, type Rect, TAU, type Vec2, addScaledVec2, addVec2, addVec2Into, angleDelta, angleOfVec2, approximately, clamp, cloneVec2, crossVec2, damp, degrees, distanceSqVec2, distanceVec2, dotVec2, finite, fromAngle, inverseLerp, lengthSqVec2, lengthVec2, lerp, lerpAngle, lerpVec2, lerpVec2Into, limitVec2, mean, moveTowards, normalizeInRect, normalizeVec2, percentileSorted, pingPong, radians, rectContains, reflectVec2, remap, rotateVec2, roundTo, scaleVec2, scaleVec2Into, setVec2, smootherstep, smoothstep, snap, subVec2, subVec2Into, vec2, wrap };

package/dist/math.js

@@ -0,0 +1,5 @@
+export { addScaledVec2, addVec2, addVec2Into, angleOfVec2, cloneVec2, crossVec2, distanceSqVec2, distanceVec2, dotVec2, fromAngle, lengthSqVec2, lengthVec2, lerpVec2, lerpVec2Into, limitVec2, normalizeInRect, normalizeVec2, rectContains, reflectVec2, rotateVec2, scaleVec2, scaleVec2Into, setVec2, subVec2, subVec2Into, vec2 } from './chunk-NSXKCJJ7.js';
+export { createRng, deriveSeed, goldenRatioSequence, hashString, jitter, r2Sequence, weightedPick } from './chunk-YFQXRC5R.js';
+export { EPSILON, HALF_PI, PI, TAU, angleDelta, approximately, clamp, damp, degrees, finite, inverseLerp, lerp, lerpAngle, mean, moveTowards, percentileSorted, pingPong, radians, remap, roundTo, smootherstep, smoothstep, snap, wrap } from './chunk-KU2C6GEA.js';
+//# sourceMappingURL=math.js.map
+//# sourceMappingURL=math.js.map

package/dist/math.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"math.js"}

package/dist/noise.cjs

@@ -0,0 +1,78 @@
+'use strict';
+
+var chunkDXJ63QAR_cjs = require('./chunk-DXJ63QAR.cjs');
+require('./chunk-FNR35HTL.cjs');
+require('./chunk-ILKUL7GD.cjs');
+
+
+
+Object.defineProperty(exports, "FRACTAL_DEFAULTS", {
+  enumerable: true,
+  get: function () { return chunkDXJ63QAR_cjs.FRACTAL_DEFAULTS; }
+});
+Object.defineProperty(exports, "GRAD3", {
+  enumerable: true,
+  get: function () { return chunkDXJ63QAR_cjs.GRAD3; }
+});
+Object.defineProperty(exports, "GRAD4", {
+  enumerable: true,
+  get: function () { return chunkDXJ63QAR_cjs.GRAD4; }
+});
+Object.defineProperty(exports, "clearNoiseTableCache", {
+  enumerable: true,
+  get: function () { return chunkDXJ63QAR_cjs.clearNoiseTableCache; }
+});
+Object.defineProperty(exports, "createNoise", {
+  enumerable: true,
+  get: function () { return chunkDXJ63QAR_cjs.createNoise; }
+});
+Object.defineProperty(exports, "createNoiseTables", {
+  enumerable: true,
+  get: function () { return chunkDXJ63QAR_cjs.createNoiseTables; }
+});
+Object.defineProperty(exports, "createPerlinNoise", {
+  enumerable: true,
+  get: function () { return chunkDXJ63QAR_cjs.createPerlinNoise; }
+});
+Object.defineProperty(exports, "createSimplexNoise", {
+  enumerable: true,
+  get: function () { return chunkDXJ63QAR_cjs.createSimplexNoise; }
+});
+Object.defineProperty(exports, "createValueNoise", {
+  enumerable: true,
+  get: function () { return chunkDXJ63QAR_cjs.createValueNoise; }
+});
+Object.defineProperty(exports, "curl2D", {
+  enumerable: true,
+  get: function () { return chunkDXJ63QAR_cjs.curl2D; }
+});
+Object.defineProperty(exports, "curl2DAnimated", {
+  enumerable: true,
+  get: function () { return chunkDXJ63QAR_cjs.curl2DAnimated; }
+});
+Object.defineProperty(exports, "fbm2D", {
+  enumerable: true,
+  get: function () { return chunkDXJ63QAR_cjs.fbm2D; }
+});
+Object.defineProperty(exports, "fbm3D", {
+  enumerable: true,
+  get: function () { return chunkDXJ63QAR_cjs.fbm3D; }
+});
+Object.defineProperty(exports, "ridged2D", {
+  enumerable: true,
+  get: function () { return chunkDXJ63QAR_cjs.ridged2D; }
+});
+Object.defineProperty(exports, "tileable2D", {
+  enumerable: true,
+  get: function () { return chunkDXJ63QAR_cjs.tileable2D; }
+});
+Object.defineProperty(exports, "turbulence2D", {
+  enumerable: true,
+  get: function () { return chunkDXJ63QAR_cjs.turbulence2D; }
+});
+Object.defineProperty(exports, "warp2D", {
+  enumerable: true,
+  get: function () { return chunkDXJ63QAR_cjs.warp2D; }
+});
+//# sourceMappingURL=noise.cjs.map
+//# sourceMappingURL=noise.cjs.map

package/dist/noise.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"noise.cjs"}

package/dist/noise.d.cts

@@ -0,0 +1,190 @@
+/**
+ * Fractal composition of a base noise function.
+ *
+ * A single octave of simplex noise is smooth and featureless. Real natural texture comes from
+ * summing octaves at increasing frequency and decreasing amplitude — fractional Brownian
+ * motion. This module provides the standard family of summations, all parameterised so that
+ * no frequency, amplitude, or octave count is hardcoded inside an effect.
+ */
+type Noise2DFn = (x: number, y: number) => number;
+type Noise3DFn = (x: number, y: number, z: number) => number;
+interface FractalOptions {
+    /**
+     * Number of summed layers. Each octave roughly doubles the cost, and beyond ~6 the added
+     * detail is below a pixel for typical scales. Default `4`.
+     */
+    octaves?: number;
+    /** Frequency multiplier per octave. `2` is the classic choice. Default `2`. */
+    lacunarity?: number;
+    /**
+     * Amplitude multiplier per octave. Also called persistence. `0.5` gives the pink-noise
+     * falloff that reads as natural. Default `0.5`.
+     */
+    gain?: number;
+    /** Frequency of the first octave. Default `1`. */
+    frequency?: number;
+    /** Amplitude of the first octave. Default `1`. */
+    amplitude?: number;
+    /**
+     * Normalise the result back into `[-1, 1]` by dividing by the total amplitude.
+     * Without this, more octaves means a quieter signal. Default `true`.
+     */
+    normalize?: boolean;
+}
+declare const FRACTAL_DEFAULTS: {
+    readonly octaves: 4;
+    readonly lacunarity: 2;
+    readonly gain: 0.5;
+    readonly frequency: 1;
+    readonly amplitude: 1;
+    readonly normalize: true;
+};
+/** Standard fBm over a 2D noise source. Output in `[-1, 1]` when normalised. */
+declare function fbm2D(noise: Noise2DFn, options?: FractalOptions): Noise2DFn;
+/** Standard fBm over a 3D noise source — use the third axis as time for animated fields. */
+declare function fbm3D(noise: Noise3DFn, options?: FractalOptions): Noise3DFn;
+/**
+ * Ridged multifractal. Inverts and sharpens each octave (`1 - |n|`, squared), producing crisp
+ * ridge lines instead of rolling hills. This is what makes convincing mountain silhouettes,
+ * lightning, and the filament structure in aurora curtains.
+ *
+ * Output is in `[0, 1]`.
+ */
+declare function ridged2D(noise: Noise2DFn, options?: FractalOptions): Noise2DFn;
+/**
+ * Turbulence: fBm over the absolute value of each octave. Produces the billowing,
+ * smoke-like structure used for clouds and flame.
+ *
+ * Output is in `[0, 1]`.
+ */
+declare function turbulence2D(noise: Noise2DFn, options?: FractalOptions): Noise2DFn;
+/**
+ * Domain warping — feed noise through itself.
+ *
+ * `warp(p) = noise(p + strength * noise(p))`. This single trick is responsible for most of
+ * the "organic liquid" look in modern generative backgrounds: it turns the isotropic blobs of
+ * plain fBm into flowing, marbled filaments.
+ *
+ * @param strength How far the domain is displaced, in noise-space units. `0.5`–`2` is useful.
+ */
+declare function warp2D(noise: Noise2DFn, strength?: number, offset?: number): Noise2DFn;
+interface CurlResult {
+    x: number;
+    y: number;
+}
+/**
+ * Curl (divergence-free) noise for 2D flow fields.
+ *
+ * A particle advected by raw noise will pool in sinks and thin out in sources, because the
+ * field has non-zero divergence. Taking the perpendicular gradient of a scalar potential —
+ * `(∂N/∂y, −∂N/∂x)` — yields a field with zero divergence, so particle density is preserved
+ * and the motion looks like real fluid.
+ *
+ * The derivative is a central difference; `epsilon` trades accuracy against smoothness.
+ */
+declare function curl2D(noise: Noise2DFn, epsilon?: number): (x: number, y: number) => CurlResult;
+/** The 3D-source variant of {@link curl2D}, letting you animate the field over time. */
+declare function curl2DAnimated(noise: Noise3DFn, epsilon?: number): (x: number, y: number, t: number) => CurlResult;
+/**
+ * Make a 2D noise field seamlessly tileable over `[0, width) × [0, height)`.
+ *
+ * Works by sampling 4D noise on the surface of a torus: each axis becomes a circle, so the
+ * field wraps exactly with no seam. This is the correct way to do it — blending mirrored
+ * copies leaves visible symmetry artefacts.
+ */
+declare function tileable2D(noise4D: (x: number, y: number, z: number, w: number) => number, width: number, height: number): Noise2DFn;
+
+/**
+ * Gradient tables and permutation setup shared by every noise variant.
+ *
+ * The permutation table is a shuffled `0..255` sequence duplicated to 512 entries. Doubling
+ * it lets the noise functions index `perm[i + perm[j]]` without a modulo on every lookup,
+ * which matters when these run millions of times per second.
+ *
+ * The table is derived from the effect's seed, so noise fields are reproducible — the same
+ * seed always produces the same landscape.
+ */
+/** 12 edge-midpoint gradients of a cube. Used by 2D and 3D noise. */
+declare const GRAD3: Float32Array<ArrayBuffer>;
+/** 32 gradients for 4D noise — the edge midpoints of a hypercube. */
+declare const GRAD4: Float32Array<ArrayBuffer>;
+interface NoiseTables {
+    /** 512-entry doubled permutation table. */
+    readonly perm: Uint8Array;
+    /** `perm[i] % 12`, precomputed — saves a modulo in the inner loop of 2D/3D noise. */
+    readonly permMod12: Uint8Array;
+    /** `perm[i] % 32`, precomputed for 4D noise. */
+    readonly permMod32: Uint8Array;
+}
+/**
+ * Build (or reuse) permutation tables for a seed.
+ *
+ * Tables are 1.5 KB each and construction costs a shuffle, so we memoise them. The cache is
+ * bounded because a page that animates its seed would otherwise grow it without limit; we
+ * evict oldest-first, which suits the access pattern (a handful of stable seeds per page).
+ */
+declare function createNoiseTables(seed?: number): NoiseTables;
+/** Clear the memoised permutation tables. Exposed for tests and long-lived workers. */
+declare function clearNoiseTableCache(): void;
+
+interface SimplexNoise {
+    noise2D(x: number, y: number): number;
+    noise3D(x: number, y: number, z: number): number;
+    noise4D(x: number, y: number, z: number, w: number): number;
+}
+declare function createSimplexNoise(seed?: number): SimplexNoise;
+
+interface PerlinNoise {
+    noise2D(x: number, y: number): number;
+    noise3D(x: number, y: number, z: number): number;
+}
+declare function createPerlinNoise(seed?: number): PerlinNoise;
+/**
+ * Value noise: interpolates hashed *values* at lattice points rather than gradients.
+ *
+ * Cheaper than gradient noise and blockier in character. Good for film grain, dithering and
+ * any place you want visible cell structure rather than smooth flow.
+ */
+declare function createValueNoise(seed?: number): {
+    noise2D(x: number, y: number): number;
+};
+
+/**
+ * The one-stop noise factory.
+ *
+ * Effects generally want several related fields from a single seed — a base simplex, an fBm
+ * for the large structure, and a curl field for advection. Creating them individually would
+ * rebuild the permutation table each time (it is cached, but the wiring is still repetitive),
+ * so `createNoise(seed)` hands back a coherent bundle.
+ *
+ * ```ts
+ * const noise = createNoise('hero')
+ * const height = noise.fbm2D({ octaves: 5, gain: 0.55 })
+ * const flow = noise.curl({ octaves: 2 })
+ * ```
+ */
+declare function createNoise(seed?: number | string): {
+    seed: number;
+    /** Raw single-octave sources. */
+    simplex2D: (x: number, y: number) => number;
+    simplex3D: (x: number, y: number, z: number) => number;
+    simplex4D: (x: number, y: number, z: number, w: number) => number;
+    perlin2D: (x: number, y: number) => number;
+    perlin3D: (x: number, y: number, z: number) => number;
+    value2D: (x: number, y: number) => number;
+    /** Fractal compositions over simplex. */
+    fbm2D: (options?: FractalOptions) => Noise2DFn;
+    fbm3D: (options?: FractalOptions) => Noise3DFn;
+    ridged2D: (options?: FractalOptions) => Noise2DFn;
+    turbulence2D: (options?: FractalOptions) => Noise2DFn;
+    /** Domain-warped fBm — the organic, marbled look. */
+    warped2D: (strength?: number, options?: FractalOptions) => Noise2DFn;
+    /** Divergence-free flow field for particle advection. */
+    curl: (options?: FractalOptions) => (x: number, y: number) => CurlResult;
+    curlAnimated: (options?: FractalOptions) => (x: number, y: number, t: number) => CurlResult;
+    /** Seamlessly tiling field over the given extent. */
+    tileable: (width: number, height: number) => Noise2DFn;
+};
+type Noise = ReturnType<typeof createNoise>;
+
+export { type CurlResult, FRACTAL_DEFAULTS, type FractalOptions, GRAD3, GRAD4, type Noise, type Noise2DFn, type Noise3DFn, type NoiseTables, type PerlinNoise, type SimplexNoise, clearNoiseTableCache, createNoise, createNoiseTables, createPerlinNoise, createSimplexNoise, createValueNoise, curl2D, curl2DAnimated, fbm2D, fbm3D, ridged2D, tileable2D, turbulence2D, warp2D };