velo-plot 1.11.1

package/dist/plugins/PluginContext.d.ts

@@ -0,0 +1,53 @@
+import { Chart } from '../core/chart/types';
+import { Bounds } from '../types';
+import { ChartTheme } from '../theme';
+import { PluginContext, PluginStorage, PickResult, ChartPlugin } from './types';
+
+declare class PluginStorageImpl implements PluginStorage {
+    private data;
+    constructor(_pluginName: string);
+    get<T>(key: string): T | undefined;
+    set<T>(key: string, value: T): void;
+    remove(key: string): void;
+    clear(): void;
+    keys(): string[];
+    _serialize(): Record<string, unknown>;
+    _deserialize(data: Record<string, unknown>): void;
+}
+export interface ContextDependencies {
+    chart: Chart;
+    container: HTMLDivElement;
+    theme: ChartTheme;
+    getGL?: () => WebGLRenderingContext | WebGL2RenderingContext | undefined;
+    get2DContext?: () => CanvasRenderingContext2D | undefined;
+    getPixelRatio: () => number;
+    getCanvasSize: () => {
+        width: number;
+        height: number;
+    };
+    getPlotArea: () => {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    getViewBounds: () => Bounds;
+    getYAxisBounds: (yAxisId?: string) => {
+        yMin: number;
+        yMax: number;
+    };
+    dataToPixelX: (x: number) => number;
+    dataToPixelY: (y: number, yAxisId?: string) => number;
+    pixelToDataX: (px: number) => number;
+    pixelToDataY: (py: number, yAxisId?: string) => number;
+    findNearestPoint?: (px: number, py: number, radius?: number) => PickResult | null;
+    getPlugin: (name: string) => ChartPlugin | undefined;
+}
+/**
+ * Create a complete plugin context from chart dependencies
+ */
+export declare function createPluginContext(pluginName: string, deps: ContextDependencies): PluginContext & {
+    _cleanup: () => void;
+    _getStorage: () => PluginStorageImpl;
+};
+export {};

package/dist/plugins/PluginManager.d.ts

@@ -0,0 +1,129 @@
+import { ChartTheme } from '../theme';
+import { ChartPlugin, PluginFactory, PluginManager, PluginManifest, BeforeRenderEvent, AfterRenderEvent, ViewChangeEvent, SeriesChangeEvent, DataUpdateEvent, InteractionEvent } from './types';
+import { ContextDependencies } from './PluginContext';
+
+export declare class PluginManagerImpl implements PluginManager {
+    private plugins;
+    private deps;
+    private destroyed;
+    private hooksBeforeRender;
+    private hooksAfterRender;
+    private hooksRenderWebGL;
+    private hooksRenderOverlay;
+    private hooksInteraction;
+    private hooksViewChange;
+    private hooksDataUpdate;
+    private hooksSeriesAdd;
+    private hooksSeriesRemove;
+    private hooksSeriesChange;
+    private hooksResize;
+    private hooksThemeChange;
+    private hooksSelectionChange;
+    private hooksSerialize;
+    constructor(dependencies: ContextDependencies);
+    /**
+     * Register and initialize a plugin
+     */
+    use<TConfig>(pluginOrFactory: ChartPlugin<TConfig> | PluginFactory<TConfig>, config?: TConfig): Promise<void>;
+    /**
+     * Remove a plugin
+     */
+    remove(name: string): Promise<boolean>;
+    /**
+     * Get a plugin instance
+     */
+    get<T extends ChartPlugin = ChartPlugin>(name: string): T | undefined;
+    /**
+     * Check if a plugin is loaded
+     */
+    has(name: string): boolean;
+    /**
+     * Get all loaded plugin names
+     */
+    getNames(): string[];
+    /**
+     * Get all loaded plugin manifests
+     */
+    getManifests(): PluginManifest[];
+    /**
+     * Update plugin configuration
+     */
+    configure<TConfig>(name: string, config: TConfig): void;
+    /**
+     * Notify all plugins of a hook event
+     */
+    notify(hook: string, ...args: unknown[]): void;
+    /**
+     * Notify beforeRender hooks
+     * Returns false if any plugin wants to skip rendering
+     */
+    notifyBeforeRender(event: BeforeRenderEvent): boolean;
+    /**
+     * Notify afterRender hooks
+     */
+    notifyAfterRender(event: AfterRenderEvent): void;
+    /**
+     * Notify WebGL render hooks
+     */
+    notifyRenderWebGL(event: AfterRenderEvent): void;
+    /**
+     * Notify overlay render hooks
+     */
+    notifyRenderOverlay(event: AfterRenderEvent): void;
+    /**
+     * Notify interaction hooks
+     * Returns false if any plugin prevents default
+     */
+    notifyInteraction(event: InteractionEvent): boolean;
+    /**
+     * Notify view change hooks
+     */
+    notifyViewChange(event: ViewChangeEvent): void;
+    /**
+     * Notify data update hooks
+     */
+    notifyDataUpdate(event: DataUpdateEvent): void;
+    /**
+     * Notify series add hooks
+     */
+    notifySeriesAdd(event: SeriesChangeEvent): void;
+    /**
+     * Notify series remove hooks
+     */
+    notifySeriesRemove(event: SeriesChangeEvent): void;
+    /**
+     * Notify series change hooks
+     */
+    notifySeriesChange(event: SeriesChangeEvent): void;
+    /**
+     * Notify resize hooks
+     */
+    notifyResize(size: {
+        width: number;
+        height: number;
+    }): void;
+    /**
+     * Notify theme change hooks
+     */
+    notifyThemeChange(theme: ChartTheme): void;
+    /**
+     * Notify selection change hooks
+     */
+    notifySelectionChange(points: readonly import('../core/selection').SelectedPoint[]): void;
+    /**
+     * Collect serialization data from plugins
+     */
+    collectSerializationData(): Record<string, unknown>;
+    /**
+     * Restore plugin data from serialization
+     */
+    restoreSerializationData(data: Record<string, unknown>): void;
+    /**
+     * Destroy all plugins and cleanup
+     */
+    destroy(): void;
+    private checkDependencies;
+    private findDependents;
+    private rebuildHookCaches;
+    private clearHookCaches;
+}

package/dist/plugins/PluginRegistry.d.ts

@@ -0,0 +1,38 @@
+import { PluginFactory, PluginManifest, PluginCapability, PluginRegistry, PluginRegistryEntry } from './types';
+
+/**
+ * Get the global plugin registry singleton
+ */
+export declare function getPluginRegistry(): PluginRegistry;
+/**
+ * Register a plugin in the global registry
+ * Shorthand for getPluginRegistry().register()
+ */
+export declare function registerPlugin(entry: PluginRegistryEntry): void;
+/**
+ * Create a plugin factory with manifest validation
+ */
+export declare function definePlugin<TConfig = unknown>(manifest: PluginManifest, factory: (config?: TConfig) => Omit<import('./types').ChartPlugin<TConfig>, "manifest">): PluginFactory<TConfig>;
+/**
+ * Register a plugin from definition
+ */
+export declare function defineAndRegister<TConfig = unknown>(manifest: PluginManifest, factory: (config?: TConfig) => Omit<import('./types').ChartPlugin<TConfig>, "manifest">): PluginFactory<TConfig>;
+/**
+ * Load a plugin from the registry by name
+ */
+export declare function loadPlugin<TConfig = unknown>(name: string, config?: TConfig): Promise<import('./types').ChartPlugin<TConfig> | undefined>;
+/**
+ * List available plugins by category
+ */
+export declare function listPluginsByCategory(): Record<PluginCapability, PluginManifest[]>;
+/**
+ * Validate a plugin manifest
+ */
+export declare function validateManifest(manifest: PluginManifest): string[];
+/**
+ * Validate a plugin for compatibility
+ */
+export declare function checkPluginCompatibility(manifest: PluginManifest, engineVersion: string): {
+    compatible: boolean;
+    warnings: string[];
+};

package/dist/plugins/analysis/SeriesFit.d.ts

@@ -0,0 +1,3 @@
+import { FitType, FitOptions } from './index';
+
+export declare function addFitLine(ctx: any, seriesId: string, type: FitType, options?: FitOptions): string;

package/dist/plugins/analysis/contours.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Contour Plot Generation (Marching Squares)
+ */
+export interface ContourPoint {
+    x: number;
+    y: number;
+}
+export interface ContourLine {
+    level: number;
+    points: ContourPoint[];
+}
+export interface ContourOptions {
+    levels?: number[];
+    numLevels?: number;
+}
+/**
+ * Generate contour lines from a 2D grid of values
+ * Values are assumed to be in row-major order: z = values[y * width + x]
+ */
+export declare function generateContours(z: Float32Array | number[], xValues: Float32Array | number[], yValues: Float32Array | number[], options?: ContourOptions): ContourLine[];

package/dist/plugins/analysis/fft.d.ts

@@ -0,0 +1,138 @@
+/**
+ * Fast Fourier Transform (FFT) Implementation
+ *
+ * Provides:
+ * - FFT for spectral analysis
+ * - Inverse FFT
+ * - Power spectrum
+ * - Frequency bins calculation
+ */
+/** Complex number representation */
+export interface Complex {
+    re: number;
+    im: number;
+}
+/** FFT Result */
+export interface FFTResult {
+    /** Frequency bins in Hz (if sample rate provided) or normalized */
+    frequency: Float32Array;
+    /** Magnitude spectrum */
+    magnitude: Float32Array;
+    /** Phase spectrum in radians */
+    phase: Float32Array;
+    /** Full complex spectrum as Complex[] array */
+    complex: Complex[];
+    /** Real part of full spectrum as Float32Array */
+    real: Float32Array;
+    /** Imaginary part of full spectrum as Float32Array */
+    imag: Float32Array;
+}
+/** Complex FFT Result - full spectrum with separate real/imag arrays */
+export interface ComplexFFTResult {
+    /** Real part of spectrum */
+    real: Float32Array;
+    /** Imaginary part of spectrum */
+    imag: Float32Array;
+    /** Frequency bins in Hz (if sample rate provided) */
+    frequency: Float32Array;
+    /** Magnitude spectrum (sqrt(real² + imag²)) */
+    magnitude: Float32Array;
+    /** Phase spectrum in radians (atan2(imag, real)) */
+    phase: Float32Array;
+    /** Original spectrum length (power of 2) */
+    length: number;
+    /** Nyquist index (length / 2) */
+    nyquist: number;
+}
+/** Power spectrum result */
+export interface PowerSpectrumResult {
+    /** Frequency bins */
+    frequency: Float32Array;
+    /** Power values (magnitude squared) */
+    power: Float32Array;
+    /** Power in dB */
+    powerDb: Float32Array;
+}
+/**
+ * Compute FFT using Cooley-Tukey algorithm
+ * Input length must be a power of 2
+ */
+export declare function fft(input: Float32Array | Float64Array | number[]): Complex[];
+/**
+ * Compute inverse FFT
+ */
+export declare function ifft(spectrum: Complex[]): Float32Array;
+/**
+ * Find next power of 2
+ */
+export declare function nextPowerOf2(n: number): number;
+/**
+ * Compute full FFT analysis with frequencies and magnitudes
+ */
+export declare function analyzeSpectrum(data: Float32Array | Float64Array | number[], sampleRate?: number): FFTResult;
+/**
+ * Compute power spectrum
+ */
+export declare function powerSpectrum(data: Float32Array | Float64Array | number[], sampleRate?: number): PowerSpectrumResult;
+/**
+ * Find dominant frequency in signal
+ */
+export declare function dominantFrequency(data: Float32Array | Float64Array | number[], sampleRate?: number, minFrequency?: number): {
+    frequency: number;
+    magnitude: number;
+};
+/**
+ * Apply Hanning window to data
+ */
+export declare function hanningWindow(data: Float32Array | Float64Array): Float32Array;
+/**
+ * Apply Hamming window to data
+ */
+export declare function hammingWindow(data: Float32Array | Float64Array): Float32Array;
+/**
+ * Apply Blackman window to data
+ */
+export declare function blackmanWindow(data: Float32Array | Float64Array): Float32Array;
+/**
+ * Compute full complex FFT analysis with separate real and imaginary arrays
+ * This is useful when you need direct access to real/imag components
+ */
+export declare function analyzeComplexSpectrum(data: Float32Array | Float64Array | number[], sampleRate?: number): ComplexFFTResult;
+/**
+ * Compute FFT from complex input (real + imaginary arrays)
+ * Useful for processing complex signals or chaining FFT operations
+ */
+export declare function fftFromComplexInput(real: Float32Array | Float64Array | number[], imag: Float32Array | Float64Array | number[]): ComplexFFTResult;
+/**
+ * Convert Complex[] array to separate real and imaginary Float32Arrays
+ */
+export declare function complexToArrays(complex: Complex[]): {
+    real: Float32Array;
+    imag: Float32Array;
+};
+/**
+ * Convert separate real and imaginary arrays to Complex[] array
+ */
+export declare function arraysToComplex(real: Float32Array | Float64Array | number[], imag: Float32Array | Float64Array | number[]): Complex[];
+/**
+ * Compute inverse FFT from separate real and imaginary arrays
+ * Returns the real part of the inverse transform
+ */
+export declare function ifftFromArrays(real: Float32Array | Float64Array | number[], imag: Float32Array | Float64Array | number[]): Float32Array;
+/**
+ * Compute inverse FFT returning complex result (both real and imaginary parts)
+ */
+export declare function ifftComplex(spectrum: Complex[]): {
+    real: Float32Array;
+    imag: Float32Array;
+};
+/**
+ * Get only positive frequencies (up to Nyquist) from complex spectrum
+ */
+export declare function getPositiveFrequencies(result: ComplexFFTResult): {
+    real: Float32Array;
+    imag: Float32Array;
+    frequency: Float32Array;
+    magnitude: Float32Array;
+    phase: Float32Array;
+};

package/dist/plugins/analysis/filters.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Digital Filters Implementation
+ *
+ * Provides:
+ * - Low-pass filter
+ * - High-pass filter
+ * - Band-pass filter
+ * - Band-stop (notch) filter
+ * - Butterworth filter
+ * - Moving average (for smoothing)
+ * - Savitzky-Golay filter
+ */
+export type FilterType = 'lowpass' | 'highpass' | 'bandpass' | 'bandstop';
+export interface FilterOptions {
+    /** Cutoff frequency in Hz (or normalized 0-1) */
+    cutoff: number;
+    /** Second cutoff for bandpass/bandstop filters */
+    cutoffHigh?: number;
+    /** Sample rate in Hz (default: 1.0 for normalized) */
+    sampleRate?: number;
+    /** Filter order (default: 2) */
+    order?: number;
+}
+export interface ButterworthOptions extends FilterOptions {
+    /** Filter type */
+    type: FilterType;
+}
+export interface SingleFrequencyFilterOptions {
+    /** Frequency to remove in Hz */
+    frequency: number;
+    /** Sampling rate in Hz */
+    sampleRate: number;
+    /** Bandwidth of the notch in Hz (default: 1.0) */
+    bandwidth?: number;
+}
+/**
+ * Apply a simple low-pass FIR filter
+ */
+export declare function lowPassFilter(data: Float32Array | Float64Array, cutoffHz: number, sampleRate: number, order?: number): Float32Array;
+/**
+ * Apply a simple high-pass FIR filter
+ */
+export declare function highPassFilter(data: Float32Array | Float64Array, cutoffHz: number, sampleRate: number, order?: number): Float32Array;
+/**
+ * Apply a band-pass FIR filter
+ */
+export declare function bandPassFilter(data: Float32Array | Float64Array, lowCutoffHz: number, highCutoffHz: number, sampleRate: number, order?: number): Float32Array;
+/**
+ * Apply a band-stop (notch) FIR filter
+ */
+export declare function bandStopFilter(data: Float32Array | Float64Array, lowCutoffHz: number, highCutoffHz: number, sampleRate: number, order?: number): Float32Array;
+/**
+ * Apply Butterworth filter (IIR)
+ */
+export declare function butterworth(data: Float32Array | Float64Array, options: ButterworthOptions): Float32Array;
+/**
+ * Apply a single frequency notch filter to remove periodic noise.
+ * Implementing a 2nd order IIR notch filter.
+ */
+export declare function singleFrequencyFilter(data: Float32Array | Float64Array, options: SingleFrequencyFilterOptions): Float32Array;
+/**
+ * Exponential moving average filter
+ */
+export declare function exponentialMovingAverage(data: Float32Array | Float64Array, alpha?: number): Float32Array;
+/**
+ * Gaussian smoothing filter
+ */
+export declare function gaussianSmooth(data: Float32Array | Float64Array, sigma?: number): Float32Array;
+/**
+ * Savitzky-Golay smoothing filter
+ */
+export declare function savitzkyGolay(data: Float32Array | Float64Array, windowSize?: number, polynomialOrder?: number): Float32Array;
+/**
+ * Median filter (good for spike removal)
+ */
+export declare function medianFilter(data: Float32Array | Float64Array, windowSize?: number): Float32Array;

package/dist/plugins/analysis/fitting.d.ts

@@ -0,0 +1,24 @@
+export type FitType = 'linear' | 'polynomial' | 'exponential' | 'logarithmic' | 'power';
+export interface FitOptions {
+    /** Degree for polynomial fit (default: 2) */
+    degree?: number;
+    /** Custom label for the equation */
+    label?: string;
+    /** Number of decimals in equation string */
+    precision?: number;
+}
+export interface FitResult {
+    type: FitType;
+    /** Coefficients (a, b, c...) */
+    coefficients: number[];
+    /** Formatted equation string */
+    equation: string;
+    /** Coefficient of determination */
+    rSquared: number;
+    /** Function to calculate value at X */
+    predict: (x: number) => number;
+}
+/**
+ * Perform regression on a dataset
+ */
+export declare function fitData(x: number[] | Float32Array, y: number[] | Float32Array, type: FitType, options?: FitOptions): FitResult;

package/dist/plugins/analysis/index.d.ts

@@ -0,0 +1,29 @@
+import { ChartPlugin } from '../types';
+
+export { formatWithPrefix, formatValue, formatScientific, getBestPrefix, detectCycles, generateCycleColors, detectPeaks, validateData, calculateStats, movingAverage, downsampleLTTB, subtractBaseline, } from './utils';
+export { solveLinearSystem, calculateR2, integrate, derivative, cumulativeIntegral, } from './math';
+export { fitData, } from './fitting';
+export type { CycleInfo, Peak, PrefixInfo, ValidationResult, DataStats, } from './utils';
+export type { FitType, FitOptions, FitResult, } from './fitting';
+export * from './contours';
+export { fft, ifft, analyzeSpectrum, powerSpectrum, dominantFrequency, hanningWindow, hammingWindow, blackmanWindow, nextPowerOf2, analyzeComplexSpectrum, fftFromComplexInput, complexToArrays, arraysToComplex, ifftFromArrays, ifftComplex, getPositiveFrequencies, } from './fft';
+export type { Complex, FFTResult, ComplexFFTResult, PowerSpectrumResult, } from './fft';
+export { lowPassFilter, highPassFilter, bandPassFilter, bandStopFilter, butterworth, exponentialMovingAverage, gaussianSmooth, savitzkyGolay, medianFilter, singleFrequencyFilter, } from './filters';
+export type { FilterType, FilterOptions, ButterworthOptions, SingleFrequencyFilterOptions, } from './filters';
+export { crossCorrelation, autoCorrelation, detectAnomalies, trapezoidalIntegration, simpsonsIntegration, cumulativeIntegration as cumulativeIntegral2, tTest, } from './statistics';
+export type { CorrelationResult, AnomalyResult, AnomalyOptions, TTestResult, } from './statistics';
+export { sma, ema, wma, dema, tema, rsi, macd, stochastic, roc, momentum, bollingerBands, atr, standardDeviation, vwap, obv, adx, aroon, percentChange, cumsum, normalize, } from './indicators';
+export type { IndicatorResult, OHLCData, } from './indicators';
+export interface PluginAnalysisConfig {
+    /** Enable worker-based off-main-thread processing */
+    useWorkers?: boolean;
+    /** Precision for statistical calculations */
+    precision?: number;
+}
+/**
+ * SciPlot Analysis Plugin
+ *
+ * Adds comprehensive data analysis capabilities to the chart.
+ */
+export declare function PluginAnalysis(_config?: PluginAnalysisConfig): ChartPlugin<PluginAnalysisConfig>;
+export default PluginAnalysis;

package/dist/plugins/analysis/indicators.d.ts

@@ -0,0 +1,148 @@
+/**
+ * Sci Plot - Financial/Technical Indicators Module
+ *
+ * Provides common financial and technical analysis indicators:
+ * - Moving Averages (SMA, EMA, WMA)
+ * - Momentum Indicators (RSI, MACD, Stochastic)
+ * - Volatility (Bollinger Bands, ATR)
+ * - Volume (VWAP, OBV)
+ * - Trend (ADX, Aroon)
+ *
+ * @module indicators
+ */
+export interface IndicatorResult {
+    /** Indicator values (NaN for insufficient data) */
+    values: Float32Array;
+    /** Additional line (e.g., signal line for MACD) */
+    signal?: Float32Array;
+    /** Upper band (e.g., Bollinger upper) */
+    upper?: Float32Array;
+    /** Lower band (e.g., Bollinger lower) */
+    lower?: Float32Array;
+    /** Histogram (e.g., MACD histogram) */
+    histogram?: Float32Array;
+}
+export interface OHLCData {
+    open: Float32Array | Float64Array;
+    high: Float32Array | Float64Array;
+    low: Float32Array | Float64Array;
+    close: Float32Array | Float64Array;
+    volume?: Float32Array | Float64Array;
+}
+/**
+ * Simple Moving Average (SMA)
+ * @param data Input data array
+ * @param period Number of periods
+ */
+export declare function sma(data: Float32Array | Float64Array | number[], period: number): Float32Array;
+/**
+ * Exponential Moving Average (EMA)
+ * @param data Input data array
+ * @param period Number of periods
+ */
+export declare function ema(data: Float32Array | Float64Array | number[], period: number): Float32Array;
+/**
+ * Weighted Moving Average (WMA)
+ * @param data Input data array
+ * @param period Number of periods
+ */
+export declare function wma(data: Float32Array | Float64Array | number[], period: number): Float32Array;
+/**
+ * Double Exponential Moving Average (DEMA)
+ * @param data Input data array
+ * @param period Number of periods
+ */
+export declare function dema(data: Float32Array | Float64Array | number[], period: number): Float32Array;
+/**
+ * Triple Exponential Moving Average (TEMA)
+ * @param data Input data array
+ * @param period Number of periods
+ */
+export declare function tema(data: Float32Array | Float64Array | number[], period: number): Float32Array;
+/**
+ * Relative Strength Index (RSI)
+ * @param data Close prices
+ * @param period RSI period (default: 14)
+ */
+export declare function rsi(data: Float32Array | Float64Array | number[], period?: number): Float32Array;
+/**
+ * Moving Average Convergence Divergence (MACD)
+ * @param data Close prices
+ * @param fastPeriod Fast EMA period (default: 12)
+ * @param slowPeriod Slow EMA period (default: 26)
+ * @param signalPeriod Signal line period (default: 9)
+ */
+export declare function macd(data: Float32Array | Float64Array | number[], fastPeriod?: number, slowPeriod?: number, signalPeriod?: number): IndicatorResult;
+/**
+ * Stochastic Oscillator
+ * @param ohlc OHLC data
+ * @param kPeriod %K period (default: 14)
+ * @param dPeriod %D smoothing period (default: 3)
+ */
+export declare function stochastic(ohlc: OHLCData, kPeriod?: number, dPeriod?: number): IndicatorResult;
+/**
+ * Rate of Change (ROC)
+ * @param data Close prices
+ * @param period ROC period (default: 10)
+ */
+export declare function roc(data: Float32Array | Float64Array | number[], period?: number): Float32Array;
+/**
+ * Momentum
+ * @param data Close prices
+ * @param period Momentum period (default: 10)
+ */
+export declare function momentum(data: Float32Array | Float64Array | number[], period?: number): Float32Array;
+/**
+ * Bollinger Bands
+ * @param data Close prices
+ * @param period SMA period (default: 20)
+ * @param stdDev Standard deviation multiplier (default: 2)
+ */
+export declare function bollingerBands(data: Float32Array | Float64Array | number[], period?: number, stdDev?: number): IndicatorResult;
+/**
+ * Average True Range (ATR)
+ * @param ohlc OHLC data
+ * @param period ATR period (default: 14)
+ */
+export declare function atr(ohlc: OHLCData, period?: number): Float32Array;
+/**
+ * Standard Deviation
+ * @param data Input data
+ * @param period Period for calculation (default: 20)
+ */
+export declare function standardDeviation(data: Float32Array | Float64Array | number[], period?: number): Float32Array;
+/**
+ * Volume Weighted Average Price (VWAP)
+ * @param ohlc OHLC data with volume
+ */
+export declare function vwap(ohlc: OHLCData): Float32Array;
+/**
+ * On-Balance Volume (OBV)
+ * @param close Close prices
+ * @param volume Volume data
+ */
+export declare function obv(close: Float32Array | Float64Array | number[], volume: Float32Array | Float64Array | number[]): Float32Array;
+/**
+ * Average Directional Index (ADX)
+ * @param ohlc OHLC data
+ * @param period ADX period (default: 14)
+ */
+export declare function adx(ohlc: OHLCData, period?: number): IndicatorResult;
+/**
+ * Aroon Indicator
+ * @param ohlc OHLC data
+ * @param period Aroon period (default: 25)
+ */
+export declare function aroon(ohlc: OHLCData, period?: number): IndicatorResult;
+/**
+ * Calculate percentage change
+ */
+export declare function percentChange(data: Float32Array | Float64Array | number[], period?: number): Float32Array;
+/**
+ * Calculate cumulative sum
+ */
+export declare function cumsum(data: Float32Array | Float64Array | number[]): Float32Array;
+/**
+ * Normalize data to 0-100 range
+ */
+export declare function normalize(data: Float32Array | Float64Array | number[]): Float32Array;