@shopify/klint 0.3.1 → 0.4.0

package/dist/{Klint-CsVzll4n.d.cts → Klint-DqYL-aGU.d.cts}

@@ -10,11 +10,6 @@ declare const KlintCoreFunctions: {
     play: (ctx: KlintContext) => () => void;
     pause: (ctx: KlintContext) => () => void;
     redraw: () => () => void;
-    extend: (ctx: KlintContext) => (name: string, data: unknown, enforceReplace?: boolean) => void;
-    passImage: () => (element: HTMLImageElement) => HTMLImageElement | null;
-    passImages: () => (elements: HTMLImageElement[]) => (HTMLImageElement | null)[];
-    saveConfig: (ctx: KlintContexts) => (from?: KlintContexts) => KlintConfig;
-    restoreConfig: (ctx: KlintContext) => (config: KlintConfig) => void;
     describe: (ctx: KlintContext) => (description: string) => void;
     createOffscreen: (ctx: KlintContext) => (id: string, width: number, height: number, options?: KlintCanvasOptions, callback?: (ctx: KlintOffscreenContext) => void) => KlintOffscreenContext | HTMLImageElement;
     getOffscreen: (ctx: KlintContext) => (id: string) => KlintOffscreenContext | HTMLImageElement;
@@ -89,12 +84,11 @@ declare const KlintFunctions: {
         break?: "words" | "letters";
     }) => void;
     readonly image: (ctx: KlintContexts) => (image: HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | KlintContexts, x: number, y: number, arg3?: number, arg4?: number, arg5?: number, arg6?: number, arg7?: number, arg8?: number) => void;
-    readonly loadPixels: (ctx: KlintContexts) => () => ImageData;
-    readonly updatePixels: (ctx: KlintContexts) => (pixels: Uint8ClampedArray | number[]) => void;
-    readonly readPixels: (ctx: KlintContexts) => (x: number, y: number, w?: number, h?: number) => number[];
     readonly scaleTo: () => (originWidth: number, originHeight: number, destinationWidth: number, destinationHeight: number, cover?: boolean) => number;
     readonly opacity: (ctx: KlintContexts) => (value: number) => void;
     readonly blend: (ctx: KlintContexts) => (blend: GlobalCompositeOperation | "default") => void;
+    readonly smooth: (ctx: KlintContexts) => () => void;
+    readonly noSmooth: (ctx: KlintContexts) => () => void;
     readonly setCanvasOrigin: (ctx: KlintContexts) => (type: "center" | "corner") => void;
     readonly setImageOrigin: (ctx: KlintContexts) => (type: "center" | "corner") => void;
     readonly setRectOrigin: (ctx: KlintContexts) => (type: "center" | "corner") => void;
@@ -104,6 +98,22 @@ declare const KlintFunctions: {
     readonly restoreConfig: (ctx: KlintContexts) => (config: KlintConfig) => void;
     readonly resizeCanvas: (ctx: KlintContexts) => (width: number, height: number) => void;
     readonly clipTo: (ctx: KlintContexts) => (callback: (K: KlintContexts | KlintContext) => void, fillRule?: CanvasFillRule) => void;
+    readonly screenToWorld: (ctx: KlintContexts) => (screenX: number, screenY: number) => {
+        x: number;
+        y: number;
+    };
+    readonly worldToScreen: (ctx: KlintContexts) => (worldX: number, worldY: number) => {
+        x: number;
+        y: number;
+    };
+    readonly getVisibleBounds: (ctx: KlintContexts) => () => {
+        left: number;
+        top: number;
+        right: number;
+        bottom: number;
+        width: number;
+        height: number;
+    };
     readonly canIuseFilter: (ctx: KlintContexts) => () => boolean;
     readonly blur: (ctx: KlintContexts) => (radius: number) => void;
     readonly SVGfilter: (ctx: KlintContexts) => (url: string) => void;
@@ -362,6 +372,18 @@ interface KlintEasing {
     overshootIn: (val: number) => number;
     overshootOut: (val: number) => number;
     overshootInOut: (val: number) => number;
+    bounceIn: (val: number) => number;
+    bounceOut: (val: number) => number;
+    bounceInOut: (val: number) => number;
+    elasticIn: (val: number) => number;
+    elasticOut: (val: number) => number;
+    elasticInOut: (val: number) => number;
+    smoothstep: (val: number, x0?: number, x1?: number) => number;
+    spring: (val: number, tension?: number, friction?: number) => number;
+    steps: (val: number, n?: number) => number;
+    damp: (current: number, target: number, smoothing: number, deltaTime: number) => number;
+    impulse: (val: number, k?: number) => number;
+    parabola: (val: number, k?: number) => number;
 }
 declare class Easing implements KlintEasing {
     private zeroOut;
@@ -380,6 +402,40 @@ declare class Easing implements KlintEasing {
     elasticOut: (val: number) => number;
     elasticInOut: (val: number) => number;
     smoothstep: (val: number, x0?: number, x1?: number) => number;
+    /**
+     * Damped spring easing. Physically expressive oscillation.
+     * @param val - Progress value (0 to 1)
+     * @param tension - Spring tension (0 to 1, default 0.5). Higher = faster oscillation.
+     * @param friction - Spring friction (0 to 1, default 0.5). Higher = less damping (more bouncy).
+     */
+    spring: (val: number, tension?: number, friction?: number) => number;
+    /**
+     * Staircase easing. Quantizes to N discrete steps.
+     * @param val - Progress value (0 to 1)
+     * @param n - Number of steps (default 4)
+     */
+    steps: (val: number, n?: number) => number;
+    /**
+     * Frame-rate independent exponential smoothing.
+     * Use instead of naive `lerp(a, b, 0.1)` which breaks at different FPS.
+     * @param current - Current value
+     * @param target - Target value
+     * @param smoothing - Smoothing factor (higher = faster convergence)
+     * @param deltaTime - Time since last frame in seconds
+     */
+    damp: (current: number, target: number, smoothing: number, deltaTime: number) => number;
+    /**
+     * Quick rise then decay. Great for hit effects, flashes.
+     * @param val - Progress value (0 to 1)
+     * @param k - Sharpness (default 6). Higher = sharper peak.
+     */
+    impulse: (val: number, k?: number) => number;
+    /**
+     * Symmetric arc. Useful for jumps, throw curves.
+     * @param val - Progress value (0 to 1)
+     * @param k - Steepness (default 1)
+     */
+    parabola: (val: number, k?: number) => number;
     log: () => void;
 }
 
@@ -543,7 +599,7 @@ declare class Vector implements KlintVector {
     static fromAngle(center: Vector, a: number, r: number): Vector;
 }
 
-type TextMetrics$1 = {
+type TextMetrics = {
     width: number;
     height: number;
     baseline: number;
@@ -551,7 +607,7 @@ type TextMetrics$1 = {
 interface KlintText {
     context: KlintContexts;
     findTextSize: (text: string, dist: number, estimate?: number, direction?: "x" | "y") => number;
-    getTextMetrics: (text: string) => TextMetrics$1;
+    getTextMetrics: (text: string) => TextMetrics;
     splitTo: (text: string, kind: "letters" | "words" | "lines" | "all", options?: {
         maxWidth?: number;
         lineSpacing?: number;
@@ -561,7 +617,7 @@ interface KlintText {
         char: string;
         x: number;
         y: number;
-        metrics: TextMetrics$1;
+        metrics: TextMetrics;
         letterIndex?: number;
         wordIndex?: number;
         lineIndex?: number;
@@ -579,7 +635,7 @@ declare class Text implements KlintText {
     context: KlintContexts;
     constructor(ctx: KlintContexts);
     findTextSize: (text: string, dist: number, estimate?: number, direction?: "x" | "y") => number;
-    getTextMetrics: (text: string) => TextMetrics$1;
+    getTextMetrics: (text: string) => TextMetrics;
     splitTo: (text: string, kind: "letters" | "words" | "lines" | "all", options?: {
         maxWidth?: number;
         lineSpacing?: number;
@@ -592,7 +648,7 @@ declare class Text implements KlintText {
         char: string;
         x: number;
         y: number;
-        metrics: TextMetrics$1;
+        metrics: TextMetrics;
     }[];
     circularText: (text: string, radius?: number, fill?: "fill" | "kerned" | "words", offset?: number, arc?: number) => void;
     textBounds: (text: string) => {
@@ -604,16 +660,6 @@ declare class Text implements KlintText {
     log: () => void;
 }
 
-interface KlintThing {
-    context: KlintContexts;
-    log(): void;
-}
-declare class Thing implements KlintThing {
-    context: KlintContexts;
-    constructor(ctx: KlintContexts);
-    log(): void;
-}
-
 /**
  * Grid point interface
  */
@@ -868,204 +914,56 @@ declare class Strip {
     }) => string | void): void;
 }
 
-type FbmOptions = {
-    octaves?: number;
-    lacunarity?: number;
-    gain?: number;
-    amplitude?: number;
-    frequency?: number;
-};
-type TurbulenceOptions = {
-    octaves?: number;
-};
-type RidgeOptions = {
-    octaves?: number;
-    amplitude?: number;
-    frequency?: number;
-    lacunarity?: number;
-    gain?: number;
-};
-type CellularOptions = {
-    distance?: "euclidean" | "manhattan";
-};
 /**
- * Noise Element for Klint
- *
- * Provides Perlin noise, Simplex noise, and hash functions for procedural generation
- * Based on implementations by Stefan Gustavson and others
+ * Noise — Perlin (1-4D), Simplex (1-4D), Hash (1-4D), Gaussian random
  *
  * @example
  * ```tsx
  * const draw = (K) => {
- *   K.Noise.seed(42); // Optional: set seed for reproducibility
- *
- *   // Generate terrain
- *   for (let x = 0; x < K.width; x += 5) {
- *     for (let y = 0; y < K.height; y += 5) {
- *       const n = K.Noise.perlin(x * 0.01, y * 0.01);
- *       const brightness = (n + 1) * 127;
- *       K.fillColor(`rgb(${brightness}, ${brightness}, ${brightness})`);
- *       K.rectangle(x, y, 5, 5);
- *     }
- *   }
+ *   K.Noise.seed(42);
+ *   const n = K.Noise.perlin(x * 0.01, y * 0.01);
  * };
  * ```
  */
 declare class Noise {
-    private context;
-    private perm;
-    private permMod12;
-    private grad3;
-    private grad4;
-    private currentSeed;
-    private F2;
-    private G2;
-    private F3;
-    private G3;
-    private F4;
-    private G4;
-    /**
-     * Creates a new Noise instance
-     * @param ctx - The Klint context
-     */
-    constructor(ctx: KlintContext);
-    /**
-     * Build permutation table for noise generation
-     */
-    private buildPermutationTable;
-    /**
-     * Seeded random number generator
-     */
-    private random;
-    /**
-     * Set seed for noise generation
-     * @param seed - Seed value for reproducible noise
-     */
-    seed(seed?: number): void;
-    /**
-     * Fade function for Perlin noise
-     */
-    private fade;
-    /**
-     * Linear interpolation
-     */
-    private lerp;
-    /**
-     * 1D Perlin noise
-     * @param x - X coordinate
-     * @returns Noise value between -1 and 1
-     */
+    private p;
+    private _seed;
+    private static readonly F2;
+    private static readonly G2;
+    private static readonly F3;
+    private static readonly G3;
+    private static readonly F4;
+    private static readonly G4;
+    constructor(_ctx: KlintContext);
+    private rng;
+    private buildPerm;
+    /** Set seed for reproducible noise */
+    seed(s?: number): void;
+    private static fade;
+    private static lerp;
+    /** Improved Perlin gradient — maps 4-bit hash to one of 12 gradient directions */
+    private static grad3;
     perlin(x: number): number;
-    /**
-     * 2D Perlin noise
-     * @param x - X coordinate
-     * @param y - Y coordinate
-     * @returns Noise value between -1 and 1
-     */
     perlin(x: number, y: number): number;
-    /**
-     * 3D Perlin noise
-     * @param x - X coordinate
-     * @param y - Y coordinate
-     * @param z - Z coordinate
-     * @returns Noise value between -1 and 1
-     */
     perlin(x: number, y: number, z: number): number;
-    /**
-     * 4D Perlin noise
-     * @param x - X coordinate
-     * @param y - Y coordinate
-     * @param z - Z coordinate
-     * @param w - W coordinate
-     * @returns Noise value between -1 and 1
-     */
     perlin(x: number, y: number, z: number, w: number): number;
-    /**
-     * 1D Simplex noise
-     * @param x - X coordinate
-     * @returns Noise value between -1 and 1
-     */
+    private perlin1;
+    private perlin2;
+    private perlin3;
+    private perlin4;
     simplex(x: number): number;
-    /**
-     * 2D Simplex noise
-     * @param x - X coordinate
-     * @param y - Y coordinate
-     * @returns Noise value between -1 and 1
-     */
     simplex(x: number, y: number): number;
-    /**
-     * 3D Simplex noise
-     * @param x - X coordinate
-     * @param y - Y coordinate
-     * @param z - Z coordinate
-     * @returns Noise value between -1 and 1
-     */
     simplex(x: number, y: number, z: number): number;
-    /**
-     * 4D Simplex noise
-     * @param x - X coordinate
-     * @param y - Y coordinate
-     * @param z - Z coordinate
-     * @param w - W coordinate
-     * @returns Noise value between -1 and 1
-     */
     simplex(x: number, y: number, z: number, w: number): number;
-    /**
-     * Dot product for 2D
-     */
-    private dot2;
-    /**
-     * Dot product for 3D
-     */
-    private dot3;
-    /**
-     * 1D hash function
-     * @param x - X coordinate
-     * @returns Hash value between 0 and 1
-     */
+    private simplex2;
+    private simplex3;
+    private simplex4;
     hash(x: number): number;
-    /**
-     * 2D hash function
-     * @param x - X coordinate
-     * @param y - Y coordinate
-     * @returns Hash value between 0 and 1
-     */
     hash(x: number, y: number): number;
-    /**
-     * 3D hash function
-     * @param x - X coordinate
-     * @param y - Y coordinate
-     * @param z - Z coordinate
-     * @returns Hash value between 0 and 1
-     */
     hash(x: number, y: number, z: number): number;
-    /**
-     * 4D hash function
-     * @param x - X coordinate
-     * @param y - Y coordinate
-     * @param z - Z coordinate
-     * @param w - W coordinate
-     * @returns Hash value between 0 and 1
-     */
     hash(x: number, y: number, z: number, w: number): number;
-    /**
-     * Fractal Brownian Motion (fBm) noise
-     * Supports options object for amplitude/frequency/lacunarity/gain/octaves.
-     */
-    fbm(x: number, y?: number | FbmOptions, z?: number | FbmOptions, options?: FbmOptions): number;
-    /**
-     * Turbulence noise (absolute value of noise)
-     * Supports options object for octaves.
-     */
-    turbulence(x: number, y?: number | TurbulenceOptions, z?: number | TurbulenceOptions, options?: TurbulenceOptions): number;
-    /**
-     * Ridged multifractal noise (simple implementation)
-     */
-    ridge(x: number, y?: number | RidgeOptions, options?: RidgeOptions): number;
-    /**
-     * Cellular / Worley noise (2D simple implementation)
-     */
-    cellular(x: number, y?: number | CellularOptions, options?: CellularOptions): number;
+    /** Box-Muller transform — returns normally distributed random number (seeded) */
+    gaussianRandom(mean?: number, stddev?: number): number;
 }
 
 /**
@@ -1153,136 +1051,121 @@ declare class Hotspot {
 }
 
 /**
- * Performance monitoring and optimization utilities for Klint
+ * Point with at least x, y — can carry any extra data.
  */
-
-interface KlintPerformance {
-    batchDraw: (drawFn: () => void) => void;
-    useOffscreenCache: (id: string, width: number, height: number, renderFn: (offscreenCtx: KlintContext) => void) => void;
-    throttleFrame: <T>(interval: number, fn: () => T) => T;
-    useLeakDetection: () => {
-        track: (type: string) => void;
-        check: () => void;
-    };
-    getCachedTextMetrics: (text: string, font: string) => TextMetrics;
-    clearCaches: () => void;
-    render: (options?: PerformanceWidgetOptions) => void;
-    show: (options?: PerformanceWidgetOptions) => void;
-    getMetrics: () => KlintPerformanceMetrics | null;
+interface QuadtreePoint {
+    x: number;
+    y: number;
+    [key: string]: any;
 }
-interface PerformanceWidgetOptions {
-    x?: number;
-    y?: number;
-    width?: number;
-    height?: number;
-    backgroundColor?: string;
-    textColor?: string;
-    accentColor?: string;
-    showGraph?: boolean;
-    graphHeight?: number;
-    fontSize?: number;
-    showMemory?: boolean;
+/**
+ * Center-based rectangular bounds (x, y = center, w, h = half-extents).
+ */
+declare class Rectangle {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    constructor(x: number, y: number, w: number, h: number);
+    contains(point: QuadtreePoint): boolean;
+    intersects(range: Rectangle): boolean;
+    intersectsCircle(cx: number, cy: number, r: number): boolean;
 }
-declare class Performance implements KlintPerformance {
-    private context;
-    private textMetricsCache;
-    private frameTimeHistory;
-    private readonly MAX_HISTORY;
-    constructor(ctx: KlintContext);
-    /**
-     * Batch multiple canvas operations together for better performance
-     */
-    batchDraw(drawFn: () => void): void;
-    /**
-     * Optimize drawing by using offscreen canvas for static elements
-     */
-    useOffscreenCache(id: string, width: number, height: number, renderFn: (offscreenCtx: KlintContext) => void): void;
-    /**
-     * Throttle expensive operations to run less frequently
-     */
-    throttleFrame<T>(interval: number, fn: () => T): T;
-    /**
-     * Detect potential memory leaks by tracking object creation
-     */
-    useLeakDetection(): {
-        track: (type: string) => void;
-        check: () => void;
-    };
-    /**
-     * Optimize text rendering by caching text measurements
-     */
-    getCachedTextMetrics(text: string, font: string): TextMetrics;
-    /**
-     * Clear all performance caches
-     */
-    clearCaches(): void;
-    /**
-     * Get current performance metrics
-     */
-    getMetrics(): KlintPerformanceMetrics | null;
-    /**
-     * Render performance widget on canvas
-     */
-    render(options?: PerformanceWidgetOptions): void;
-    /**
-     * Alias for render() - shows performance widget
-     */
-    show(options?: PerformanceWidgetOptions): void;
+/**
+ * Quadtree — spatial partitioning for efficient neighbor queries.
+ *
+ * Uses center-based bounds. Create with `Quadtree.create()`.
+ *
+ * @example
+ * ```tsx
+ * const qt = K.Quadtree.create(0, 0, K.width, K.height);
+ * particles.forEach(p => qt.insert(p));
+ * const nearby = qt.queryRadius(mouseX, mouseY, 100);
+ * ```
+ */
+declare class Quadtree<T extends QuadtreePoint = QuadtreePoint> {
+    private boundary;
+    private capacity;
+    private maxDepth;
+    private depth;
+    private points;
+    private divided;
+    private ne;
+    private nw;
+    private se;
+    private sw;
+    constructor(boundary: Rectangle, capacity?: number, maxDepth?: number, depth?: number);
+    /**
+     * Create a Quadtree from corner-based bounds (top-left + size).
+     * Internally converts to center-based representation.
+     */
+    static create<T extends QuadtreePoint = QuadtreePoint>(x: number, y: number, width: number, height: number, options?: {
+        capacity?: number;
+        maxDepth?: number;
+    }): Quadtree<T>;
+    insert(point: T): boolean;
+    private subdivide;
+    query(range: Rectangle, found?: T[]): T[];
+    queryRadius(cx: number, cy: number, radius: number, found?: T[]): T[];
+    clear(): void;
+    get size(): number;
 }
 
 /**
- * Server-Side Rendering (SSR) utilities for Klint
- * Provides utilities for rendering Klint sketches on the server
- * or generating static images without requiring a browser environment.
+ * Pixels Element for Klint
+ *
+ * Provides pixel-level read/write access to the canvas.
+ *
+ * @example
+ * ```tsx
+ * const draw = (K) => {
+ *   // Read all pixels
+ *   const imageData = K.Pixels.load();
+ *
+ *   // Read a single pixel
+ *   const [r, g, b, a] = K.Pixels.read(100, 100);
+ *
+ *   // Modify and write back
+ *   K.Pixels.update(imageData.data);
+ * };
+ * ```
  */
-
-interface KlintServerRenderOptions {
-    width: number;
-    height: number;
-    dpr?: number;
-    format?: "png" | "jpeg" | "webp";
-    quality?: number;
-}
-interface KlintSSR {
+declare class Pixels {
+    private ctx;
+    constructor(ctx: KlintContexts);
     /**
-     * Render a Klint sketch to a static image (base64 data URL)
-     * Useful for Server Components, static site generation, or previews
+     * Read all pixels from the canvas as ImageData.
      */
-    renderToImage: (draw: (ctx: KlintContext) => void, options: KlintServerRenderOptions) => Promise<string>;
+    load(): ImageData;
     /**
-     * Generate a static image URL for a Klint sketch
-     * This can be used in Server Components to generate images at build time
+     * Write pixel data back to the canvas.
+     * Accepts a Uint8ClampedArray or a plain number array of RGBA values.
      */
-    generateImageUrl: (draw: (ctx: KlintContext) => void, options: KlintServerRenderOptions) => Promise<string>;
+    update(pixels: Uint8ClampedArray | number[]): void;
     /**
-     * Check if Klint can run in the current environment
+     * Read pixel values at a position.
+     * Returns an array of [r, g, b, a] values (0-255).
+     *
+     * @param x - X coordinate
+     * @param y - Y coordinate
+     * @param w - Width of region (default: 1)
+     * @param h - Height of region (default: 1)
      */
-    canRender: () => boolean;
+    read(x: number, y: number, w?: number, h?: number): number[];
 }
-declare class SSR implements KlintSSR {
-    private context;
-    constructor(ctx?: KlintContext);
-    /**
-     * Render a Klint sketch to a static image (base64 data URL)
-     */
-    renderToImage(draw: (ctx: KlintContext) => void, options: KlintServerRenderOptions): Promise<string>;
-    /**
-     * Generate a static image URL for a Klint sketch
-     */
-    generateImageUrl(draw: (ctx: KlintContext) => void, options: KlintServerRenderOptions): Promise<string>;
-    /**
-     * Check if Klint can run in the current environment
-     */
-    canRender(): boolean;
-    /**
-     * Render in browser environment (client-side)
-     */
-    private renderInBrowser;
-    /**
-     * Create a minimal KlintContext for server rendering
-     * This provides basic functionality without full Klint features
-     */
-    private createMinimalContext;
+
+declare class Timeline {
+    private callbacks;
+    constructor();
+    onStart(fn: () => void): void;
+    onEnd(fn: () => void): void;
+    onLoop(fn: () => void): void;
+    create<T extends Record<string, any>>(setup: (timeline: any) => T, options?: {
+        defaultEasing?: (t: number) => number;
+        defaultLoop?: number;
+    }): T & {
+        update: (progress: number) => void;
+    };
 }
 
 interface KlintElements {
@@ -1290,13 +1173,13 @@ interface KlintElements {
     Easing: Easing;
     Vector: Vector;
     Text: Text;
-    Thing: Thing;
     Grid: Grid;
     Strip: Strip;
     Noise: Noise;
     Hotspot: Hotspot;
-    Performance: Performance;
-    SSR: SSR;
+    Quadtree: typeof Quadtree;
+    Pixels: Pixels;
+    Timeline: Timeline;
 }
 
 declare const EPSILON = 0.0001;
@@ -1355,15 +1238,6 @@ interface KlintOffscreenContext extends CanvasRenderingContext2D, KlintFunctions
     createVector: (x: number, y: number) => Vector;
     [key: string]: any;
 }
-interface KlintPerformanceMetrics {
-    fps: number;
-    frameTime: number;
-    averageFrameTime: number;
-    minFrameTime: number;
-    maxFrameTime: number;
-    droppedFrames: number;
-    memoryUsage?: number;
-}
 interface KlintContext extends KlintOffscreenContext, KlintCoreFunctions {
     frame: number;
     time: number;
@@ -1373,7 +1247,6 @@ interface KlintContext extends KlintOffscreenContext, KlintCoreFunctions {
     __lastRealTime: number;
     __isPlaying: boolean;
     __offscreens: Map<string, KlintOffscreenContext | HTMLImageElement>;
-    __performance?: KlintPerformanceMetrics;
 }
 interface KlintCanvasOptions {
     alpha?: string;
@@ -1403,8 +1276,7 @@ interface KlintProps {
     options?: KlintCanvasOptions;
     onResize?: (ctx: KlintContext) => void;
     onVisible?: (ctx: KlintContext) => void;
-    enablePerformanceTracking?: boolean;
 }
-declare function Klint({ context, setup, draw, options, preload, onVisible, enablePerformanceTracking, }: KlintProps): React.JSX.Element;
+declare function Klint({ context, setup, draw, options, preload, onVisible, }: KlintProps): React.JSX.Element;
 
-export { CONFIG_PROPS as C, EPSILON as E, Grid as G, Hotspot as H, type KlintContext as K, Noise as N, Performance as P, SSR as S, Text as T, Vector as V, type KlintCanvasOptions as a, type KlintPerformanceMetrics as b, Color as c, type CurveVertex as d, Easing as e, Klint as f, type KlintConfig as g, type KlintContextWrapper as h, type KlintContexts as i, KlintCoreFunctions as j, type KlintElements as k, KlintFunctions as l, type KlintOffscreenContext as m, type KlintProps as n, type KlintServerRenderOptions as o, type PerformanceWidgetOptions as p, Strip as q, Thing as r };
+export { CONFIG_PROPS as C, EPSILON as E, Grid as G, Hotspot as H, type KlintContext as K, Noise as N, Pixels as P, Quadtree as Q, Rectangle as R, Strip as S, Text as T, Vector as V, type KlintCanvasOptions as a, Color as b, type CurveVertex as c, Easing as d, Klint as e, type KlintConfig as f, type KlintContextWrapper as g, type KlintContexts as h, KlintCoreFunctions as i, type KlintElements as j, KlintFunctions as k, type KlintOffscreenContext as l, type KlintProps as m, type QuadtreePoint as n, Timeline as o };