@photonviz/core 0.3.2 → 0.4.1

package/README.md

@@ -6,6 +6,14 @@
 
 **GPU-accelerated scientific plotting for the web — WebGL2, zero dependencies.**
 
+<p>
+  <a href="https://www.npmjs.com/package/@photonviz/core"><img src="https://img.shields.io/npm/v/@photonviz/core?color=cb3837&logo=npm" alt="npm"/></a>
+  <a href="https://www.npmjs.com/package/@photonviz/core"><img src="https://img.shields.io/npm/dm/@photonviz/core?color=cb3837" alt="downloads"/></a>
+  <a href="https://bundlephobia.com/package/@photonviz/core"><img src="https://img.shields.io/bundlephobia/minzip/@photonviz/core?label=minzip" alt="size"/></a>
+  · <a href="https://coredumpdev.github.io/photon/">▶ Live demo</a>
+  · <a href="https://coredumpdev.github.io/photon/llms-full.txt">Docs for AI agents</a>
+</p>
+
 <p align="center">
   <img src="https://raw.githubusercontent.com/coredumpdev/photon/master/assets/streaming.gif" alt="Live streaming WebGL2 charts at 60fps" width="100%" />
 </p>
@@ -24,8 +32,6 @@ npm i @photonviz/core
 ```
 
 > Framework bindings: [`@photonviz/react`](https://www.npmjs.com/package/@photonviz/react) · [`@photonviz/vue`](https://www.npmjs.com/package/@photonviz/vue) · [`@photonviz/svelte`](https://www.npmjs.com/package/@photonviz/svelte) · [`@photonviz/solid`](https://www.npmjs.com/package/@photonviz/solid) · [`@photonviz/gea`](https://www.npmjs.com/package/@photonviz/gea) · framework-free [`@photonviz/wc`](https://www.npmjs.com/package/@photonviz/wc) Web Components
-> Vector maps: [`@photonviz/map`](https://www.npmjs.com/package/@photonviz/map)
-
 ## Quick start
 
 ```ts

package/dist/index.d.ts

@@ -1713,7 +1713,7 @@ declare class Plot {
     describe(): string;
     private updateAria;
     /**
-     * Register a layer built outside core (e.g. `@photonviz/map`). Use with
+     * Register a layer built outside core (a custom WebGL2 `Layer`). Use with
      * {@link context} to construct the layer against this plot's WebGL2 context.
      */
     add<T extends Layer>(layer: T): T;
@@ -3171,6 +3171,387 @@ declare function lttb(x: ArrayLike<number>, y: ArrayLike<number>, threshold: num
     y: Float64Array;
 };
 
+/**
+ * Pure ML classification-evaluation metrics: confusion matrix, ROC + AUC,
+ * precision–recall + average precision, calibration (reliability) + ECE, plus
+ * TensorBoard-style EMA smoothing for training curves. All array→struct, zero
+ * deps, unit-tested. Import from `@photonviz/core`; the `addX` builders in
+ * `ml/charts.ts` render these onto a {@link Plot}.
+ */
+/** A confusion matrix: raw counts plus a row-normalized (recall) view. */
+interface ConfusionMatrix {
+    /** Row-major counts, length `classes*classes`; row = true label, col = predicted. */
+    counts: Float64Array;
+    /** Row-normalized: every row sums to 1 (a row with no support stays all-zero). */
+    normalized: Float64Array;
+    /** Per-true-class support (row totals). */
+    support: Float64Array;
+    classes: number;
+}
+/**
+ * Confusion matrix of integer class labels. `classes` defaults to
+ * `max(label) + 1`; out-of-range labels are ignored.
+ */
+declare function confusionMatrix(yTrue: ArrayLike<number>, yPred: ArrayLike<number>, classes?: number): ConfusionMatrix;
+/** A receiver-operating-characteristic curve and its area. */
+interface RocCurve {
+    /** False-positive rate (x), starting at 0. */
+    fpr: Float64Array;
+    /** True-positive rate (y), starting at 0. */
+    tpr: Float64Array;
+    /** Score threshold at each vertex (`+Inf` for the origin). */
+    thresholds: Float64Array;
+    /** Area under the curve (`NaN` when a class is absent). */
+    auc: number;
+}
+/**
+ * ROC curve for binary `labels` (0/1) ranked by `scores` (higher = more positive).
+ * Ties at equal scores are collapsed to a single vertex; AUC by the trapezoid rule.
+ */
+declare function rocCurve(scores: ArrayLike<number>, labels: ArrayLike<number>): RocCurve;
+/** A precision–recall curve and its average precision. */
+interface PrCurve {
+    /** Recall (x), starting at 0. */
+    recall: Float64Array;
+    /** Precision (y), starting at 1. */
+    precision: Float64Array;
+    /** Score threshold at each vertex (`+Inf` for the leading point). */
+    thresholds: Float64Array;
+    /** Average precision — Σ (Rₙ − Rₙ₋₁)·Pₙ (`NaN` with no positives). */
+    ap: number;
+    /** Positive base rate (a no-skill classifier's precision). */
+    baseline: number;
+}
+/** Precision–recall curve for binary `labels` (0/1) ranked by `scores`. */
+declare function prCurve(scores: ArrayLike<number>, labels: ArrayLike<number>): PrCurve;
+/** A reliability diagram: predicted confidence vs. observed frequency, per bin. */
+interface CalibrationCurve {
+    /** Mean predicted probability in each bin (`NaN` if empty). */
+    meanPredicted: Float64Array;
+    /** Observed positive fraction in each bin (`NaN` if empty). */
+    fractionPositive: Float64Array;
+    /** Sample count per bin. */
+    binCount: Float64Array;
+    /** Expected Calibration Error — Σ (nᵦ/N)·|accᵦ − confᵦ|. */
+    ece: number;
+}
+/**
+ * Reliability diagram of predicted probabilities `scores` (in [0,1]) against
+ * binary `labels`, using `bins` equal-width confidence buckets. Empty bins are
+ * `NaN` (skip them when plotting).
+ */
+declare function calibrationCurve(scores: ArrayLike<number>, labels: ArrayLike<number>, bins?: number): CalibrationCurve;
+/**
+ * TensorBoard-style debiased EMA smoothing of a noisy training curve. `weight`
+ * in [0,1) is the momentum (0 = raw, →1 = very smooth). Non-finite inputs pass
+ * through untouched and don't advance the average.
+ */
+declare function emaSmooth(values: ArrayLike<number>, weight?: number): Float64Array;
+
+/**
+ * Pure, dependency-free dimensionality reduction for embedding projections.
+ * {@link pca} projects an `n×d` matrix onto its top-`k` principal components via
+ * covariance power-iteration with deflation — deterministic (no RNG), so tests
+ * and re-renders are stable. Pair with {@link addEmbedding}. For t-SNE/UMAP,
+ * feed precomputed 2-D coordinates straight into the builder.
+ */
+/** The result of {@link pca}: projected scores + the components they project onto. */
+interface PcaResult {
+    /** Projected coordinates, row-major `n×k`. */
+    scores: Float64Array;
+    /** Principal-component directions, row-major `k×d` (unit vectors). */
+    components: Float64Array;
+    /** Explained-variance ratio per component, length `k`. */
+    explained: Float64Array;
+    /** Per-column mean subtracted before projection, length `d`. */
+    mean: Float64Array;
+    n: number;
+    d: number;
+    k: number;
+}
+/** Z-score each of the `d` columns of a row-major `n×d` matrix (unit variance). */
+declare function standardize(data: ArrayLike<number>, n: number, d: number): Float64Array;
+/**
+ * Principal component analysis of a row-major `n×d` matrix, projected to `k`
+ * dims (default 2). Centers columns, forms the `d×d` covariance, then extracts
+ * the top-`k` eigenvectors by power iteration + deflation. Deterministic.
+ */
+declare function pca(data: ArrayLike<number>, n: number, d: number, k?: number): PcaResult;
+
+/**
+ * Convenience builders for ML / deep-learning charts. Each takes a {@link Plot}
+ * and composes existing layers (`addHeatmap`/`addLine`/`addScatter`/`addBar`/
+ * `addArea`) from the pure metrics in `ml/metrics.ts` and reducers in
+ * `ml/reduce.ts` — the same free-function style as the finance builders. No new
+ * WebGL layers. Import from `@photonviz/core`.
+ */
+
+/** tab10 categorical palette, cycled by class index. */
+declare const ML_PALETTE: readonly string[];
+interface ConfusionMatrixOptions {
+    yTrue: ArrayLike<number>;
+    yPred: ArrayLike<number>;
+    /** Number of classes; inferred from the labels when omitted. */
+    classes?: number;
+    colormap?: ColormapName;
+    /** Shade by row-normalized recall instead of raw counts. Default false. */
+    normalize?: boolean;
+    /** Draw the value inside each cell. Default true. */
+    annotate?: boolean;
+}
+interface ConfusionMatrixHandle {
+    heatmap: HeatmapLayer;
+    classes: number;
+}
+/**
+ * Confusion matrix as a heatmap with the true class 0 at the **top** (sklearn
+ * orientation) and per-cell value labels. Give the {@link Plot} `[0,classes]`
+ * axes; set categorical ticks for class names.
+ */
+declare function addConfusionMatrix(plot: Plot, opts: ConfusionMatrixOptions): ConfusionMatrixHandle;
+interface RocCurveOptions {
+    scores: ArrayLike<number>;
+    labels: ArrayLike<number>;
+    color?: string;
+    /** Shade the area under the curve. Default false. */
+    fill?: boolean;
+    /** Draw the y=x chance diagonal. Default true. */
+    showChance?: boolean;
+    name?: string;
+}
+interface RocCurveHandle {
+    line: LineLayer;
+    area?: AreaLayer;
+    auc: number;
+}
+/** ROC curve (FPR→TPR) with the chance diagonal and AUC in the series name. */
+declare function addRocCurve(plot: Plot, opts: RocCurveOptions): RocCurveHandle;
+interface PrCurveOptions {
+    scores: ArrayLike<number>;
+    labels: ArrayLike<number>;
+    color?: string;
+    fill?: boolean;
+    /** Draw the no-skill baseline at the positive base rate. Default true. */
+    showBaseline?: boolean;
+    name?: string;
+}
+interface PrCurveHandle {
+    line: LineLayer;
+    area?: AreaLayer;
+    ap: number;
+}
+/** Precision–recall curve with the no-skill baseline and AP in the series name. */
+declare function addPrCurve(plot: Plot, opts: PrCurveOptions): PrCurveHandle;
+interface CalibrationOptions {
+    scores: ArrayLike<number>;
+    labels: ArrayLike<number>;
+    bins?: number;
+    color?: string;
+    name?: string;
+}
+interface CalibrationHandle {
+    line: LineLayer;
+    points: ScatterLayer;
+    ece: number;
+}
+/** Reliability diagram: mean predicted probability vs. observed frequency + the perfect diagonal. */
+declare function addCalibration(plot: Plot, opts: CalibrationOptions): CalibrationHandle;
+interface EmbeddingOptions {
+    /** 2-D coordinates (t-SNE/UMAP/PCA output). */
+    x: ArrayLike<number>;
+    y: ArrayLike<number>;
+    /** Categorical class per point → one colored, legend-named series each. */
+    labels?: ArrayLike<number> | string[];
+    /** Names indexed by numeric label. */
+    classNames?: string[];
+    /** Continuous value per point → a single colormap series (ignored if `labels`). */
+    colorBy?: ArrayLike<number>;
+    colormap?: ColormapName;
+    palette?: readonly string[];
+    size?: number;
+    /** Per-point hover text (metadata). */
+    text?: ArrayLike<string>;
+    name?: string;
+    renderType?: RenderType;
+}
+interface EmbeddingHandle {
+    layers: ScatterLayer[];
+}
+/**
+ * Embedding scatter — one colored series per class when `labels` are given (a
+ * legend-ready projector), a single colormap series for a continuous `colorBy`,
+ * or a plain scatter otherwise. Use `pick: "xy"` on the {@link Plot} for hover.
+ */
+declare function addEmbedding(plot: Plot, opts: EmbeddingOptions): EmbeddingHandle;
+interface DecisionBoundaryOptions {
+    /** Row-major grid of predicted class / probability, row 0 at the bottom. */
+    values: ArrayLike<number>;
+    cols: number;
+    rows: number;
+    extent: {
+        x: Range;
+        y: Range;
+    };
+    colormap?: ColormapName;
+    domain?: Range;
+    /** Training points drawn over the field. */
+    points?: {
+        x: ArrayLike<number>;
+        y: ArrayLike<number>;
+        labels?: ArrayLike<number> | string[];
+        classNames?: string[];
+        palette?: readonly string[];
+        size?: number;
+    };
+}
+interface DecisionBoundaryHandle {
+    heatmap: HeatmapLayer;
+    points: ScatterLayer[];
+}
+/** A decision-boundary field (heatmap) with the training points scattered on top. */
+declare function addDecisionBoundary(plot: Plot, opts: DecisionBoundaryOptions): DecisionBoundaryHandle;
+interface FeatureImportanceOptions {
+    names: string[];
+    values: ArrayLike<number>;
+    color?: string;
+    /** Sort by descending magnitude. Default true. */
+    sort?: boolean;
+    /** Keep only the top-N features. */
+    top?: number;
+    /** Label each bar with its feature name (inside the plot). Default true. */
+    annotate?: boolean;
+    name?: string;
+    renderType?: RenderType;
+}
+interface FeatureImportanceHandle {
+    bars: BarLayer;
+    order: number[];
+}
+/** Feature importance as sorted horizontal bars (most important on top). */
+declare function addFeatureImportance(plot: Plot, opts: FeatureImportanceOptions): FeatureImportanceHandle;
+interface ShapBeeswarmOptions {
+    /** SHAP values per feature: `values[f]` is the row across all samples. */
+    values: number[][];
+    names: string[];
+    /** Feature values (same shape) → point color via a diverging colormap. */
+    featureValues?: number[][];
+    colormap?: ColormapName;
+    size?: number;
+    /** Vertical spread of each feature band, 0..1. Default 0.8. */
+    spread?: number;
+    name?: string;
+}
+interface ShapBeeswarmHandle {
+    scatter: ScatterLayer;
+    order: number[];
+}
+/**
+ * SHAP beeswarm — features stacked by mean |SHAP| (most important on top), each
+ * a horizontal swarm of per-sample points jittered by density and colored by the
+ * feature's value (low→high). A single scatter for one shared colorbar.
+ */
+declare function addShapBeeswarm(plot: Plot, opts: ShapBeeswarmOptions): ShapBeeswarmHandle;
+interface PartialDependenceOptions {
+    x: ArrayLike<number>;
+    /** Mean prediction over the grid. */
+    pd: ArrayLike<number>;
+    /** Optional per-instance ICE curves, each parallel to `x`. */
+    ice?: number[][];
+    color?: string;
+    iceColor?: string;
+    width?: number;
+    name?: string;
+    renderType?: RenderType;
+}
+interface PartialDependenceHandle {
+    pd: LineLayer;
+    ice: LineLayer[];
+}
+/** Partial-dependence line with faint ICE curves behind it. */
+declare function addPartialDependence(plot: Plot, opts: PartialDependenceOptions): PartialDependenceHandle;
+interface AttentionMapOptions {
+    /** Attention weights, query×key: a flat row-major array or a 2-D array. */
+    weights: ArrayLike<number> | number[][];
+    /** Required with a flat `weights`. */
+    queries?: number;
+    keys?: number;
+    colormap?: ColormapName;
+    /** Draw each weight in its cell (small maps only). Default false. */
+    annotate?: boolean;
+}
+interface AttentionMapHandle {
+    heatmap: HeatmapLayer;
+    queries: number;
+    keys: number;
+}
+/** Transformer attention as a heatmap with query 0 at the top, key 0 at the left. */
+declare function addAttentionMap(plot: Plot, opts: AttentionMapOptions): AttentionMapHandle;
+interface TrainingSeries {
+    name?: string;
+    x?: ArrayLike<number>;
+    y: ArrayLike<number>;
+    color?: string;
+}
+interface TrainingCurvesOptions {
+    series: TrainingSeries[];
+    /** EMA smoothing weight 0..1 (0 = raw). Default 0.6. */
+    smoothing?: number;
+    /** Draw the faint raw curve behind the smoothed one. Default true. */
+    showRaw?: boolean;
+    /** Mark the best epoch of each series. */
+    best?: "min" | "max";
+    width?: number;
+    palette?: readonly string[];
+    renderType?: RenderType;
+}
+interface TrainingCurvesHandle {
+    raw: LineLayer[];
+    smoothed: LineLayer[];
+}
+/**
+ * Training curves with TensorBoard-style EMA smoothing — a faint raw line under
+ * a bold smoothed one per series, each streamable via `setData`. Optionally
+ * marks the best epoch. Pair with `renderType: "dynamic"` for live updates.
+ */
+declare function addTrainingCurves(plot: Plot, opts: TrainingCurvesOptions): TrainingCurvesHandle;
+interface RidgeGroup {
+    label?: string;
+    values: ArrayLike<number>;
+}
+interface RidgelineOptions {
+    /** One distribution per group (e.g. a layer's weights per epoch). */
+    groups: RidgeGroup[];
+    /** KDE sample count. Default 96. */
+    points?: number;
+    /** Ridge overlap, 0 = touching, 1 = one full row of overlap. Default 1. */
+    overlap?: number;
+    palette?: readonly string[];
+    /** Fill each ridge. Default true. */
+    fill?: boolean;
+    /** Shared x-range; inferred from the data when omitted. */
+    range?: Range;
+}
+interface RidgelineHandle {
+    areas: AreaLayer[];
+    lines: LineLayer[];
+}
+/**
+ * Ridgeline / joyplot — one KDE per group, vertically offset (TensorBoard's
+ * "distributions over time"). Ridge `i` is baselined at `y=i`; `overlap` lets
+ * neighbours interleave. Feed per-epoch weight/activation samples.
+ */
+declare function addRidgeline(plot: Plot, opts: RidgelineOptions): RidgelineHandle;
+interface BeeswarmOptions {
+    bins?: number;
+    spread?: number;
+}
+/**
+ * Deterministic 1-D beeswarm: given point x-positions, return a symmetric
+ * vertical offset per point (in ±spread/2) so overlapping points fan out by
+ * local density. Pure — no RNG. Backs {@link addShapBeeswarm}.
+ */
+declare function beeswarmLayout(x: ArrayLike<number>, opts?: BeeswarmOptions): number[];
+
 /**
  * Squarified treemap — a pure layout plus a {@link Plot} builder that composes
  * the existing {@link PatchesLayer} (one rect patch per item) and a centered
@@ -3628,4 +4009,4 @@ 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 { type Adx, type Annotation, AreaLayer, type AreaOptions, type AreaSeries, Axis, type AxisConfig, type AxisFrame, type AxisScaleOptions, Bar3DLayer, type Bar3DOptions, BarLayer, type BarOptions, type BarSeries, type BollingerBands, type BollingerHandle, type BollingerOptions, type Bounds, type Bounds3, type BoxGroup, BoxLayer, type BoxOptions, type BoxStats, type Brick, CHORD_PALETTE, type CSVOptions, type Candle, type CandlestickData, CandlestickLayer, type CandlestickOptions, CategoricalScale, type Channel, type ChordGroupArc, type ChordLayoutOptions, type ChordLayoutResult, type ChordOptions, type ChordRibbon, type Color, type ColorInfo, type ColormapName, Contour3DLayer, type Contour3DOptions, ContourLayer, type ContourOptions, type Density, type DepthCurves, type DepthHandle, type DepthOptions, type Dim, type DrawState, type DrawTool, ErrorBarLayer, type ErrorBarOptions, type ExportOptions, FUNNEL_PALETTE, type FibLevel, type ForceLayoutOptions, type FunnelItem, type FunnelLayoutOptions, type FunnelOptions, type FunnelStage, type GaugeLayoutOptions, type GaugeOptions, type GaugeThreshold, type GraphInput, GraphLayer, type GraphOptions, type GroupedBarOptions, HeatmapLayer, type HeatmapOptions, type HeikinAshiOptions, HexbinLayer, type HexbinOptions, type Histogram, type HoverReadoutRow, type Ichimoku, ImageLayer, type ImageOptions, type ImageSource, type InteractionMode, IsosurfaceLayer, type IsosurfaceOptions, type Layer, type Layer3D, type Layout, type LegendOptions, Line3DLayer, type Line3DOptions, LineLayer, type LineOptions, LinearScale, LogScale, type Macd, type MarkerShape, type Ohlc, type OhlcArrays, type OhlcInput, OhlcLayer, type OhlcOptions, OrdinalTimeScale, PARALLEL_PALETTE, type ParallelAxis, type ParallelHandle, type ParallelLayoutResult, type ParallelLine, type ParallelOptions, type Patch, PatchesLayer, type PatchesOptions, type PfColumn, type PickMode, PieLayer, type PieOptions, Plot, Plot3D, type Plot3DOptions, type PlotOptions, type PlotTitleOptions, PointCloudLayer, type PointCloudOptions, type PolarLineOptions, type PolarOptions, PolarPlot, type PolarScatterOptions, type PolarSeries, Quiver3DLayer, type Quiver3DOptions, QuiverLayer, type QuiverOptions, type RGB, type Range, type RenderType, type RenkoOptions, type ResolvedAxisStyle, type Ring, type SankeyLayoutOptions, type SankeyLayoutResult, type SankeyLink, type SankeyNode, type SankeyNodeRect, type SankeyOptions, type SankeyRibbon, type Scale, type ScaleType, ScatterLayer, type ScatterOptions, type Spectrogram, type StackedAreaOptions, type StackedBarOptions, StemLayer, type StemOptions, type Stochastic, type SunburstArc, type SunburstLayoutOptions, type SunburstNode, type SunburstOptions, type SuperTrend, SurfaceLayer, type SurfaceOptions, TRANSFORM_GLSL, TRANSFORM_UNIFORMS, TREEMAP_PALETTE, type Table, type Theme, type Tick, type TicksSpec, TimeScale, type ToolbarHost, type ToolbarTheme, type TreemapCell, type TreemapExtent, type TreemapItem, type TreemapOptions, VolumeLayer, type VolumeOptions, type VolumeProfile, type VolumeProfileOptions, type YAxisOptions, addBollinger, addChord, addDepth, addFunnel, addGauge, addHeikinAshi, addParallelCoordinates, addRenko, addSankey, addSunburst, addTreemap, addVolumeProfile, adx, atr, autoTicks, bollinger, boxStats, bufferUsage, canvasToBlob, chordLayout, colormap, colormapLUT, copyCanvasToClipboard, createProgram, createToolbar, darkTheme, defaultFormat, depth, downloadCanvas, earcut, ema, fft, fibRetracements, firstFinite, forceLayout, funnelLayout, gaugeLayout, heikinAshi, histogram, ichimoku, kde, keltner, lightTheme, lineBreak, linkX, lttb, macd, makeScale, marchingCubes, obv, parallelLayout, parseCSV, parseColor, pointAndFigure, quantileSorted, renko, resolveAxisStyle, resolveTicks, rollingStd, rsi, sankeyLayout, setTransformUniforms, sma, spectrogram, stochastic, sunburstLayout, superTrend, toColorCss, treemapLayout, trueRange, uniformLocations, volumeProfile, vwap, withMinorTicks, wma };
+export { type Adx, type Annotation, AreaLayer, type AreaOptions, type AreaSeries, type AttentionMapHandle, type AttentionMapOptions, Axis, type AxisConfig, type AxisFrame, type AxisScaleOptions, Bar3DLayer, type Bar3DOptions, BarLayer, type BarOptions, type BarSeries, type BeeswarmOptions, type BollingerBands, type BollingerHandle, type BollingerOptions, type Bounds, type Bounds3, type BoxGroup, BoxLayer, type BoxOptions, type BoxStats, type Brick, CHORD_PALETTE, type CSVOptions, type CalibrationCurve, type CalibrationHandle, type CalibrationOptions, type Candle, type CandlestickData, CandlestickLayer, type CandlestickOptions, CategoricalScale, type Channel, type ChordGroupArc, type ChordLayoutOptions, type ChordLayoutResult, type ChordOptions, type ChordRibbon, type Color, type ColorInfo, type ColormapName, type ConfusionMatrix, type ConfusionMatrixHandle, type ConfusionMatrixOptions, Contour3DLayer, type Contour3DOptions, ContourLayer, type ContourOptions, type DecisionBoundaryHandle, type DecisionBoundaryOptions, type Density, type DepthCurves, type DepthHandle, type DepthOptions, type Dim, type DrawState, type DrawTool, type EmbeddingHandle, type EmbeddingOptions, ErrorBarLayer, type ErrorBarOptions, type ExportOptions, FUNNEL_PALETTE, type FeatureImportanceHandle, type FeatureImportanceOptions, type FibLevel, type ForceLayoutOptions, type FunnelItem, type FunnelLayoutOptions, type FunnelOptions, type FunnelStage, type GaugeLayoutOptions, type GaugeOptions, type GaugeThreshold, type GraphInput, GraphLayer, type GraphOptions, type GroupedBarOptions, HeatmapLayer, type HeatmapOptions, type HeikinAshiOptions, HexbinLayer, type HexbinOptions, type Histogram, type HoverReadoutRow, type Ichimoku, ImageLayer, type ImageOptions, type ImageSource, type InteractionMode, IsosurfaceLayer, type IsosurfaceOptions, type Layer, type Layer3D, type Layout, type LegendOptions, Line3DLayer, type Line3DOptions, LineLayer, type LineOptions, LinearScale, LogScale, ML_PALETTE, type Macd, type MarkerShape, type Ohlc, type OhlcArrays, type OhlcInput, OhlcLayer, type OhlcOptions, OrdinalTimeScale, PARALLEL_PALETTE, type ParallelAxis, type ParallelHandle, type ParallelLayoutResult, type ParallelLine, type ParallelOptions, type PartialDependenceHandle, type PartialDependenceOptions, type Patch, PatchesLayer, type PatchesOptions, type PcaResult, type PfColumn, type PickMode, PieLayer, type PieOptions, Plot, Plot3D, type Plot3DOptions, type PlotOptions, type PlotTitleOptions, PointCloudLayer, type PointCloudOptions, type PolarLineOptions, type PolarOptions, PolarPlot, type PolarScatterOptions, type PolarSeries, type PrCurve, type PrCurveHandle, type PrCurveOptions, Quiver3DLayer, type Quiver3DOptions, QuiverLayer, type QuiverOptions, type RGB, type Range, type RenderType, type RenkoOptions, type ResolvedAxisStyle, type RidgeGroup, type RidgelineHandle, type RidgelineOptions, type Ring, type RocCurve, type RocCurveHandle, type RocCurveOptions, type SankeyLayoutOptions, type SankeyLayoutResult, type SankeyLink, type SankeyNode, type SankeyNodeRect, type SankeyOptions, type SankeyRibbon, type Scale, type ScaleType, ScatterLayer, type ScatterOptions, type ShapBeeswarmHandle, type ShapBeeswarmOptions, type Spectrogram, type StackedAreaOptions, type StackedBarOptions, StemLayer, type StemOptions, type Stochastic, type SunburstArc, type SunburstLayoutOptions, type SunburstNode, type SunburstOptions, type SuperTrend, SurfaceLayer, type SurfaceOptions, TRANSFORM_GLSL, TRANSFORM_UNIFORMS, TREEMAP_PALETTE, type Table, type Theme, type Tick, type TicksSpec, TimeScale, type ToolbarHost, type ToolbarTheme, type TrainingCurvesHandle, type TrainingCurvesOptions, type TrainingSeries, type TreemapCell, type TreemapExtent, type TreemapItem, type TreemapOptions, VolumeLayer, type VolumeOptions, type VolumeProfile, type VolumeProfileOptions, type YAxisOptions, addAttentionMap, addBollinger, addCalibration, addChord, addConfusionMatrix, addDecisionBoundary, addDepth, addEmbedding, addFeatureImportance, addFunnel, addGauge, addHeikinAshi, addParallelCoordinates, addPartialDependence, addPrCurve, addRenko, addRidgeline, addRocCurve, addSankey, addShapBeeswarm, addSunburst, addTrainingCurves, addTreemap, addVolumeProfile, adx, atr, autoTicks, beeswarmLayout, bollinger, boxStats, bufferUsage, calibrationCurve, canvasToBlob, chordLayout, colormap, colormapLUT, confusionMatrix, copyCanvasToClipboard, createProgram, createToolbar, darkTheme, defaultFormat, depth, downloadCanvas, earcut, ema, emaSmooth, fft, fibRetracements, firstFinite, forceLayout, funnelLayout, gaugeLayout, heikinAshi, histogram, ichimoku, kde, keltner, lightTheme, lineBreak, linkX, lttb, macd, makeScale, marchingCubes, obv, parallelLayout, parseCSV, parseColor, pca, pointAndFigure, prCurve, quantileSorted, renko, resolveAxisStyle, resolveTicks, rocCurve, rollingStd, rsi, sankeyLayout, setTransformUniforms, sma, spectrogram, standardize, stochastic, sunburstLayout, superTrend, toColorCss, treemapLayout, trueRange, uniformLocations, volumeProfile, vwap, withMinorTicks, wma };