@photonviz/core 0.1.0 → 0.2.0

package/dist/index.d.ts

@@ -40,12 +40,29 @@ interface Bounds {
 /** RGBA in 0..1. */
 type Color = readonly [number, number, number, number];
 
+/**
+ * Shared data→clip transform used by every layer's vertex shader.
+ *
+ * Two subtleties it handles:
+ *  - **Log axes** — when `uLogX/uLogY` is set, the real coordinate is
+ *    log10-transformed on the GPU.
+ *  - **Float32 precision** — vertex buffers are float32 (~7 significant digits),
+ *    which is not enough for large values like epoch-millisecond timestamps.
+ *    Layers upload coordinates *relative to a reference* (`x - xRef`) and pass
+ *    `uXRef`; the domain is passed in the same offset space, so the subtraction
+ *    that computes the normalized position never suffers catastrophic
+ *    cancellation. For log axes the reference is added back before log10.
+ */
+declare const TRANSFORM_GLSL = "\nuniform vec2 uDomainX;   // linear: (lo-ref, hi-ref) ; log: (log10 lo, log10 hi)\nuniform vec2 uDomainY;\nuniform float uXRef;\nuniform float uYRef;\nuniform float uLogX;     // >0.5 => log axis\nuniform float uLogY;\n\nvec2 dataToNorm(vec2 p) {\n  float cx = (uLogX > 0.5) ? log(p.x + uXRef) / 2.302585092994046 : p.x;\n  float cy = (uLogY > 0.5) ? log(p.y + uYRef) / 2.302585092994046 : p.y;\n  float nx = (cx - uDomainX.x) / (uDomainX.y - uDomainX.x);\n  float ny = (cy - uDomainY.x) / (uDomainY.y - uDomainY.x);\n  return vec2(nx, ny);\n}\n\nvec2 dataToClip(vec2 p) {\n  return dataToNorm(p) * 2.0 - 1.0;\n}\n";
 /** Per-axis view state handed to a layer each frame. `lo`/`hi` are raw data-space. */
 interface AxisFrame {
     lo: number;
     hi: number;
     log: boolean;
 }
+declare const TRANSFORM_UNIFORMS: readonly ["uDomainX", "uDomainY", "uXRef", "uYRef", "uLogX", "uLogY"];
+/** Set the shared transform uniforms for a layer given its per-axis references. */
+declare function setTransformUniforms(gl: WebGL2RenderingContext, u: Record<string, WebGLUniformLocation | null>, x: AxisFrame, y: AxisFrame, xRef: number, yRef: number): void;
 
 /** State handed to a layer each frame so it can transform data to clip space. */
 interface DrawState {
@@ -196,6 +213,51 @@ declare class BoxLayer implements Layer {
     dispose(): void;
 }
 
+interface CandlestickOptions {
+    /** Candle positions (data space — e.g. epoch ms on a time axis). */
+    x: ArrayLike<number>;
+    open: ArrayLike<number>;
+    high: ArrayLike<number>;
+    low: ArrayLike<number>;
+    close: ArrayLike<number>;
+    /** Body width in data units. Defaults to 70% of the median spacing. */
+    width?: number;
+    /** Close ≥ open color. Default green. */
+    upColor?: string | Color;
+    /** Close < open color. Default red. */
+    downColor?: string | Color;
+    /** Wick thickness in CSS px. Default 1.5. */
+    wickWidth?: number;
+    name?: string;
+    yAxis?: string;
+}
+declare class CandlestickLayer implements Layer {
+    readonly id: string;
+    readonly name: string;
+    readonly colorCss: string;
+    readonly yAxis: string;
+    private gl;
+    private progs;
+    private bodyVao;
+    private wickVao;
+    private buffers;
+    private uBody;
+    private uWick;
+    private wickWidth;
+    private count;
+    private xRef;
+    private yRef;
+    private xBounds;
+    private yBounds;
+    constructor(gl: WebGL2RenderingContext, opts: CandlestickOptions);
+    bounds(): {
+        x: Range;
+        y: Range;
+    } | null;
+    draw(state: DrawState): void;
+    dispose(): void;
+}
+
 type RGB = [number, number, number];
 type ColormapName = "viridis" | "plasma" | "coolwarm" | "grayscale";
 /** Returns a `(t in 0..1) => RGB` sampler for the named colormap. */
@@ -238,6 +300,68 @@ declare class ContourLayer implements Layer {
     dispose(): void;
 }
 
+/** A per-point error, given as one value for all points or an array. */
+type ErrInput = ArrayLike<number> | number;
+interface ErrorBarOptions {
+    x: ArrayLike<number>;
+    y: ArrayLike<number>;
+    /** Symmetric y error (half-height). Scalar or per-point. */
+    yerr?: ErrInput;
+    /** Asymmetric y error below/above `y` (overrides `yerr`). */
+    yerrLow?: ErrInput;
+    yerrHigh?: ErrInput;
+    /** Symmetric x error (half-width). Scalar or per-point. */
+    xerr?: ErrInput;
+    color?: string | Color;
+    /** Whisker/cap thickness in CSS px. Default 1.5. */
+    width?: number;
+    /** Cap length in CSS px (0 hides caps). Default 6. */
+    capSize?: number;
+    /** Draw I-beam whiskers. Default true. */
+    whiskers?: boolean;
+    /** Fill a shaded band between the low/high y bounds. Default false. */
+    band?: boolean;
+    /** Band fill opacity. Default 0.2. */
+    bandOpacity?: number;
+    name?: string;
+    yAxis?: string;
+}
+declare class ErrorBarLayer implements Layer {
+    readonly id: string;
+    readonly name: string;
+    readonly colorCss: string;
+    readonly yAxis: string;
+    private gl;
+    private progs;
+    private segVao;
+    private capVao;
+    private bandVao;
+    private buffers;
+    private uSeg;
+    private uCap;
+    private uBand;
+    private color;
+    private width;
+    private capSize;
+    private bandOpacity;
+    private showWhiskers;
+    private showBand;
+    private segCount;
+    private capCount;
+    private bandVerts;
+    private xRef;
+    private yRef;
+    private xBounds;
+    private yBounds;
+    constructor(gl: WebGL2RenderingContext, opts: ErrorBarOptions);
+    bounds(): {
+        x: Range;
+        y: Range;
+    } | null;
+    draw(state: DrawState): void;
+    dispose(): void;
+}
+
 interface HeatmapOptions {
     /** Row-major grid values, length `cols * rows` (row 0 at the bottom). */
     values: ArrayLike<number>;
@@ -309,6 +433,28 @@ declare class HexbinLayer implements Layer {
     dispose(): void;
 }
 
+/**
+ * Shared hover-picking used by point/series layers (line, scatter, stem).
+ *
+ * The mode decides which pixel-space distance is minimized:
+ *  - `"x"`  — nearest by horizontal distance (classic crosshair-along-x)
+ *  - `"y"`  — nearest by vertical distance
+ *  - `"xy"` — nearest by true 2D distance (checks both axes; right for point
+ *             clouds / maps, where an x-only match would highlight the wrong
+ *             point)
+ *
+ * Distances are computed in pixels via `project`, so x and y are compared on
+ * the same footing regardless of each axis's data range.
+ */
+type PickMode = "x" | "y" | "xy";
+interface Picked {
+    x: number;
+    y: number;
+    index: number;
+}
+
+/** How adjacent segments meet at a vertex. */
+type LineJoin = "round" | "miter" | "bevel" | "butt";
 interface LineOptions {
     x: ArrayLike<number>;
     y: ArrayLike<number>;
@@ -318,8 +464,20 @@ interface LineOptions {
     name?: string;
     yAxis?: string;
     step?: "before" | "after" | "center";
-    /** Round joins/caps (default) or square/butt ends. */
-    join?: "round" | "butt";
+    /**
+     * How segments meet at each vertex:
+     *  - `round` (default) — round caps and joins via an SDF; no seams.
+     *  - `miter` — sharp mitered corners, clamped to {@link LineOptions.miterLimit}.
+     *  - `bevel` — corners cut flat.
+     *  - `butt` — flat ends with no join fill (segments may gap at sharp angles).
+     */
+    join?: LineJoin;
+    /**
+     * For `join: "miter"`, the max ratio of miter length to half line-width before
+     * a corner falls back to a bevel (prevents spikes at very sharp angles).
+     * Default 4.
+     */
+    miterLimit?: number;
     /**
      * Min/max decimate very large series to ~2 points per pixel column when
      * zoomed out (preserves peaks). Requires monotonic x; auto-detected. Default true.
@@ -333,18 +491,25 @@ declare class LineLayer implements Layer {
     readonly yAxis: string;
     private gl;
     private program;
+    private joinProgram;
     private fullVao;
     private decVao;
+    private joinFullVao;
+    private joinDecVao;
     private cornerBuf;
     private posBuf;
     private decBuf;
     private uniforms;
+    private joinUniforms;
     private count;
     private color;
     private width;
     private round;
+    private joinStyle;
+    private miterLimit;
     private decimateOn;
     private monotonic;
+    private gpuDec;
     private step?;
     private xRef;
     private yRef;
@@ -355,16 +520,15 @@ declare class LineLayer implements Layer {
     private decKey;
     private decSegments;
     constructor(gl: WebGL2RenderingContext, opts: LineOptions);
+    private syncGpu;
+    private disposeGpu;
     private configureVao;
+    private configureJoinVao;
     bounds(): {
         x: Range;
         y: Range;
     } | null;
-    nearestByX(x: number): {
-        x: number;
-        y: number;
-        index: number;
-    } | null;
+    pick(mode: PickMode, cursorPx: number, cursorPy: number, project: (x: number, y: number) => [number, number]): Picked | null;
     /** Replace the series data and re-upload the GPU buffer (for streaming). */
     setData(x: ArrayLike<number>, y: ArrayLike<number>): void;
     /**
@@ -376,6 +540,60 @@ declare class LineLayer implements Layer {
     dispose(): void;
 }
 
+interface QuiverOptions {
+    /** Arrow anchor positions (data space). */
+    x: ArrayLike<number>;
+    y: ArrayLike<number>;
+    /** Vector components at each anchor. */
+    u: ArrayLike<number>;
+    v: ArrayLike<number>;
+    /** Multiplier applied to (u,v) in data units. Default auto-fits the field. */
+    scale?: number;
+    color?: string | Color;
+    /** Shaft thickness in CSS px. Default 1.5. */
+    width?: number;
+    /** Arrowhead length in CSS px. Default 9. */
+    headSize?: number;
+    /** Color each arrow by a value (default: its magnitude) through a colormap. */
+    colorBy?: {
+        values?: ArrayLike<number>;
+        colormap?: ColormapName;
+        domain?: Range;
+    };
+    name?: string;
+    yAxis?: string;
+}
+declare class QuiverLayer implements Layer {
+    readonly id: string;
+    readonly name: string;
+    readonly colorCss: string;
+    readonly yAxis: string;
+    private gl;
+    private progs;
+    private shaftVao;
+    private headVao;
+    private buffers;
+    private uShaft;
+    private uHead;
+    private color;
+    private width;
+    private headSize;
+    private useVertexColor;
+    private count;
+    private xRef;
+    private yRef;
+    private xBounds;
+    private yBounds;
+    constructor(gl: WebGL2RenderingContext, opts: QuiverOptions);
+    private bindInstanceAttribs;
+    bounds(): {
+        x: Range;
+        y: Range;
+    } | null;
+    draw(state: DrawState): void;
+    dispose(): void;
+}
+
 interface ScatterOptions {
     x: ArrayLike<number>;
     y: ArrayLike<number>;
@@ -384,6 +602,12 @@ interface ScatterOptions {
     size?: number;
     name?: string;
     yAxis?: string;
+    /**
+     * Optional per-point text shown when a point is clicked (one entry per point,
+     * parallel to `x`/`y`). Lets you attach your own info instead of the default
+     * coordinate readout.
+     */
+    labels?: ArrayLike<string>;
     /** Color each point by a value through a colormap. */
     colorBy?: {
         values: ArrayLike<number>;
@@ -406,6 +630,7 @@ declare class ScatterLayer implements Layer {
     private size;
     private color;
     private useVertexColor;
+    private labels?;
     private xRef;
     private yRef;
     private xs;
@@ -417,17 +642,61 @@ declare class ScatterLayer implements Layer {
         x: Range;
         y: Range;
     } | null;
-    nearestByX(x: number): {
-        x: number;
-        y: number;
-        index: number;
-    } | null;
+    pick(mode: PickMode, cursorPx: number, cursorPy: number, project: (x: number, y: number) => [number, number]): Picked | null;
+    /** User-supplied text for a point, shown when it is clicked. */
+    infoAt(index: number): string[] | null;
     /** Replace point positions and re-upload (for streaming). Keeps uniform color. */
     setData(x: ArrayLike<number>, y: ArrayLike<number>): void;
     draw(state: DrawState): void;
     dispose(): void;
 }
 
+interface StemOptions {
+    x: ArrayLike<number>;
+    y: ArrayLike<number>;
+    /** Where stems start. Default 0. */
+    baseline?: number;
+    color?: string | Color;
+    /** Stem thickness in CSS px. Default 1.5. */
+    width?: number;
+    /** Tip marker diameter in CSS px (0 hides). Default 6. */
+    markerSize?: number;
+    name?: string;
+    yAxis?: string;
+}
+declare class StemLayer implements Layer {
+    readonly id: string;
+    readonly name: string;
+    readonly colorCss: string;
+    readonly yAxis: string;
+    private gl;
+    private progs;
+    private stemVao;
+    private markerVao;
+    private buffers;
+    private uStem;
+    private uMarker;
+    private color;
+    private width;
+    private markerSize;
+    private count;
+    private baseline;
+    private xRef;
+    private yRef;
+    private xs;
+    private ys;
+    private xBounds;
+    private yBounds;
+    constructor(gl: WebGL2RenderingContext, opts: StemOptions);
+    bounds(): {
+        x: Range;
+        y: Range;
+    } | null;
+    pick(mode: PickMode, cursorPx: number, cursorPy: number, project: (x: number, y: number) => [number, number]): Picked | null;
+    draw(state: DrawState): void;
+    dispose(): void;
+}
+
 /**
  * A scale maps data-space values to normalized [0,1] and back, and knows how to
  * generate its own "nice" ticks + default label format. `log` tells layers to
@@ -516,6 +785,11 @@ interface YAxisOptions extends AxisConfig {
     /** Axis + label color (secondary axes often match their series). */
     color?: string;
 }
+/** One line of the hover tooltip header, produced by {@link PlotOptions.hoverReadout}. */
+interface HoverReadoutRow {
+    label: string;
+    value: string;
+}
 interface PlotOptions {
     scales?: {
         x?: AxisScaleOptions;
@@ -530,11 +804,47 @@ interface PlotOptions {
     /** Enable wheel-zoom and drag interaction. Default true. */
     interactive?: boolean;
     /** Show the built-in toolbar (home + pan/box/X/Y zoom modes). Default true. */
-    toolbar?: boolean;
-    /** Initial interaction mode. Default `"box"`. */
+    showToolbar?: boolean;
+    /** Initial interaction mode. Default `"pan"`. */
     mode?: InteractionMode;
     /** Enable hover crosshair + tooltip. Default true. */
     hover?: boolean;
+    /**
+     * How hover selects the highlighted point: `"x"` nearest by x (classic),
+     * `"y"` nearest by y, or `"xy"` nearest by 2D distance — the last checks both
+     * axes, which is what a scatter/map needs. Default `"x"`.
+     */
+    pick?: PickMode;
+    /**
+     * When a point's pinned detail box appears: `"click"` pins it on click (until
+     * you click empty space), `"hover"` shows it while the cursor is over a point.
+     * Default `"click"`.
+     */
+    pointInfo?: "hover" | "click";
+    /**
+     * Show dashed guide lines on *both* the X and Y axes at the cursor — on hover
+     * and while the pointer is pressed. When false, hover shows only the vertical
+     * (X) line and there are no press guides. Default true.
+     */
+    crosshair?: boolean;
+    /**
+     * Keep data-units-per-pixel equal on both axes so nothing is distorted (the
+     * looser axis is expanded to match). Essential for maps. Default false.
+     */
+    equalAspect?: boolean;
+    /**
+     * Constrain panning/zooming so the view can't move outside the data bounds
+     * (the union of all layers' extents). Zoom still works; the view is just
+     * kept inside the limits. Default false (a map turns it on).
+     */
+    boundedPan?: boolean;
+    /**
+     * Customize the tooltip header shown on hover. Given the cursor's data-space
+     * X and Y (primary y axis), return the lines to display above the series
+     * rows — e.g. a map converts world coords to `lon`/`lat`. When omitted, the
+     * header is the default single `x = …` line. Default undefined.
+     */
+    hoverReadout?: (dataX: number, dataY: number) => HoverReadoutRow[];
 }
 /**
  * The imperative core plot. Owns a stack of three canvases (grid / WebGL data /
@@ -570,7 +880,18 @@ declare class Plot {
     private toolbarHandle;
     private hoverEnabled;
     private hoverPx;
+    private pickMode;
+    private pointInfo;
+    private crosshair;
+    private equalAspect;
+    private boundedPan;
+    private hoverReadout?;
+    /** Cursor position while the pointer is pressed, when `crosshair`. */
+    private pressPx;
     private tooltip;
+    /** A point clicked to pin its details, until another click clears it. */
+    private selected;
+    private infoBox;
     constructor(container: HTMLElement, options?: PlotOptions);
     private makeCanvas;
     /** Margins grow to make room for extra y axes on each side. */
@@ -579,6 +900,22 @@ declare class Plot {
     /** Pixel x-position (and title x) for each y axis, by draw order per side. */
     private yAxisPositions;
     private register;
+    /**
+     * Register a layer built outside core (e.g. `@photonviz/map`). Use with
+     * {@link context} to construct the layer against this plot's WebGL2 context.
+     */
+    add<T extends Layer>(layer: T): T;
+    /** The shared WebGL2 context, for constructing custom layers. */
+    get context(): WebGL2RenderingContext;
+    /**
+     * Convert a client (screen) coordinate to data space — the shared x and the
+     * primary y. Returns null if the point is outside the plot region. Useful for
+     * custom hit-testing (e.g. map feature picking on click).
+     */
+    dataAt(clientX: number, clientY: number): {
+        x: number;
+        y: number;
+    } | null;
     addLine(opts: LineOptions): LineLayer;
     addScatter(opts: ScatterOptions): ScatterLayer;
     addBar(opts: BarOptions): BarLayer;
@@ -587,6 +924,10 @@ declare class Plot {
     addBox(opts: BoxOptions): BoxLayer;
     addHexbin(opts: HexbinOptions): HexbinLayer;
     addContour(opts: ContourOptions): ContourLayer;
+    addErrorBar(opts: ErrorBarOptions): ErrorBarLayer;
+    addStem(opts: StemOptions): StemLayer;
+    addQuiver(opts: QuiverOptions): QuiverLayer;
+    addCandlestick(opts: CandlestickOptions): CandlestickLayer;
     /** Compute an STFT of `signal` and render it as a heatmap (time × frequency). */
     addHeatmapSpectrogram(signal: ArrayLike<number>, opts?: {
         fftSize?: number;
@@ -640,6 +981,26 @@ declare class Plot {
     private panY;
     private attachInteraction;
     private setHover;
+    /** Update the press-crosshair position and redraw. */
+    private setPress;
+    /** Nearest point (2D, within a small radius) under the cursor, or null. */
+    private pickPoint;
+    /** Click handler: in `pointInfo:"click"` mode, pin the point under the cursor. */
+    private handleClick;
+    /** Draw the pinned point's marker and position its info box (or hide it). */
+    private updateInfoBox;
+    /** Data-space x extent across all layers, or null if empty. */
+    private layerBoundsX;
+    /** Data-space y extent across the layers bound to axis `id`, or null. */
+    private layerBoundsY;
+    /** Keep the view inside the data bounds (used when `boundedPan`). */
+    private clampView;
+    /**
+     * Expand the looser axis so both axes share the same data-units-per-pixel,
+     * preventing distortion (maps set `equalAspect`). Linear axes only; balances
+     * the primary y against x, and is idempotent once balanced.
+     */
+    private applyAspect;
     private drawSelection;
     private applySelection;
     private zoomAround;
@@ -673,6 +1034,18 @@ interface PolarOptions {
     /** Fixed max radius. If omitted, autoscales to the data. */
     maxRadius?: number;
     margin?: number;
+    /** Enable wheel-zoom (r scale) and drag-rotate interaction. Default true. */
+    interactive?: boolean;
+    /** Enable hover: highlight the nearest point + show a tooltip. Default true. */
+    hover?: boolean;
+    /** Show the built-in home (reset) button. Default true. */
+    showToolbar?: boolean;
+    /**
+     * How the pinned point-info box is triggered: `"click"` pins a point until
+     * empty space is clicked; `"hover"` shows the point under the cursor
+     * automatically (no click). Default `"click"`.
+     */
+    pointInfo?: "hover" | "click";
 }
 interface PolarLineOptions {
     theta: ArrayLike<number>;
@@ -687,6 +1060,8 @@ interface PolarScatterOptions {
     r: ArrayLike<number>;
     color?: string | Color;
     size?: number;
+    /** Optional per-point labels (one per point), shown as the title of the click-pinned info box. */
+    labels?: ArrayLike<string>;
 }
 /** A live handle to update a polar series with new (theta, r) data. */
 interface PolarSeries {
@@ -697,19 +1072,37 @@ declare class PolarPlot {
     private container;
     private gridCanvas;
     private dataCanvas;
+    private overlayCanvas;
     private gridCtx;
     private dataCtx;
+    private overlayCtx;
     private gl;
     private sharedCanvas;
     private theme;
+    private isDark;
     private toRad;
     private fixedR?;
     private margin;
     private entries;
     private R;
+    private baseR;
     private dpr;
     private resizeObserver;
     private frameRequested;
+    private interactive;
+    private hoverEnabled;
+    /** Multiplier on the fitted radius: <1 zooms in (smaller r-domain), >1 out. */
+    private zoom;
+    /** Angular offset (radians, CCW) applied to all series + gridlines. */
+    private rotation;
+    private hoverPx;
+    private tooltip;
+    private homeButton;
+    /** A point clicked to pin its details, until another click clears it. */
+    private selected;
+    private infoBox;
+    /** Whether the info box is triggered by `"click"` (pinned) or `"hover"`. */
+    private pointInfo;
     constructor(container: HTMLElement, options?: PolarOptions);
     private makeCanvas;
     private toXY;
@@ -717,6 +1110,14 @@ declare class PolarPlot {
     addScatter(opts: PolarScatterOptions): PolarSeries;
     private handle;
     private refit;
+    /** Re-project every series with the current rotation (called when rotation changes). */
+    private retransform;
+    /** Reset zoom (r-domain) and rotation back to the initial view. */
+    home(): void;
+    /** Current rotation offset in radians (CCW). */
+    getRotation(): number;
+    /** Set the rotation offset (radians, CCW) and redraw. */
+    setRotation(rad: number): void;
     destroy(): void;
     private resize;
     requestRender(): void;
@@ -724,6 +1125,19 @@ declare class PolarPlot {
     private square;
     render(): void;
     private drawGrid;
+    private setHover;
+    /** Nearest data point (across all series) to a cursor position, in CSS px. */
+    private pickNearest;
+    /** Draw a filled, white-ringed marker on the overlay at a screen position. */
+    private drawPointMarker;
+    private renderHover;
+    /** Click handler: pin the nearest point's details, or clear on empty space. */
+    private handleClick;
+    /** Draw the pinned point's marker and position its info box (or hide it). */
+    private updateInfoBox;
+    private updateTooltip;
+    private attachInteraction;
+    private makeHomeButton;
 }
 
 /** Minimal column-major 4×4 matrix helpers for the 3D plots (WebGL convention). */
@@ -953,9 +1367,14 @@ interface Density {
  */
 declare function kde(values: ArrayLike<number>, lo: number, hi: number, points?: number, bandwidth?: number): Density;
 
+/** Compile + link a vertex/fragment program. */
+declare function createProgram(gl: WebGL2RenderingContext, vert: string, frag: string): WebGLProgram;
+/** Cache uniform locations for a program by name. */
+declare function uniformLocations(gl: WebGL2RenderingContext, program: WebGLProgram, names: string[]): Record<string, WebGLUniformLocation | null>;
+
 /** Parse a CSS hex/rgb color string into normalized RGBA (0..1). */
 declare function parseColor(input: string): [number, number, number, number];
 /** Normalized RGBA (0..1) back to a CSS `rgba(...)` string. */
 declare function toColorCss(c: readonly [number, number, number, number]): string;
 
-export { AreaLayer, type AreaOptions, Axis, type AxisConfig, type AxisFrame, type AxisScaleOptions, BarLayer, type BarOptions, type Bounds, type Bounds3, type BoxGroup, BoxLayer, type BoxOptions, type BoxStats, type Color, type ColormapName, ContourLayer, type ContourOptions, type Density, type Dim, type DrawState, HeatmapLayer, type HeatmapOptions, HexbinLayer, type HexbinOptions, type Histogram, type InteractionMode, type Layer, type Layer3D, type Layout, LineLayer, type LineOptions, LinearScale, LogScale, Plot, Plot3D, type Plot3DOptions, type PlotOptions, PointCloudLayer, type PointCloudOptions, type PolarLineOptions, type PolarOptions, PolarPlot, type PolarScatterOptions, type PolarSeries, type RGB, type Range, type Scale, type ScaleType, ScatterLayer, type ScatterOptions, type Spectrogram, SurfaceLayer, type SurfaceOptions, type Theme, type Tick, type TicksSpec, TimeScale, type ToolbarHost, type ToolbarTheme, type YAxisOptions, autoTicks, boxStats, colormap, createToolbar, darkTheme, defaultFormat, fft, histogram, kde, lightTheme, makeScale, parseColor, quantileSorted, resolveTicks, spectrogram, toColorCss, withMinorTicks };
+export { AreaLayer, type AreaOptions, Axis, type AxisConfig, type AxisFrame, type AxisScaleOptions, BarLayer, type BarOptions, type Bounds, type Bounds3, type BoxGroup, BoxLayer, type BoxOptions, type BoxStats, CandlestickLayer, type CandlestickOptions, type Color, type ColormapName, ContourLayer, type ContourOptions, type Density, type Dim, type DrawState, ErrorBarLayer, type ErrorBarOptions, HeatmapLayer, type HeatmapOptions, HexbinLayer, type HexbinOptions, type Histogram, type HoverReadoutRow, type InteractionMode, type Layer, type Layer3D, type Layout, LineLayer, type LineOptions, LinearScale, LogScale, type PickMode, Plot, Plot3D, type Plot3DOptions, type PlotOptions, PointCloudLayer, type PointCloudOptions, type PolarLineOptions, type PolarOptions, PolarPlot, type PolarScatterOptions, type PolarSeries, QuiverLayer, type QuiverOptions, type RGB, type Range, type Scale, type ScaleType, ScatterLayer, type ScatterOptions, type Spectrogram, StemLayer, type StemOptions, SurfaceLayer, type SurfaceOptions, TRANSFORM_GLSL, TRANSFORM_UNIFORMS, type Theme, type Tick, type TicksSpec, TimeScale, type ToolbarHost, type ToolbarTheme, type YAxisOptions, autoTicks, boxStats, colormap, createProgram, createToolbar, darkTheme, defaultFormat, fft, histogram, kde, lightTheme, makeScale, parseColor, quantileSorted, resolveTicks, setTransformUniforms, spectrogram, toColorCss, uniformLocations, withMinorTicks };