velo-plot 1.11.1 → 1.15.0

package/dist/types.d.ts

@@ -23,6 +23,8 @@ export interface AxisOptions {
     position?: "left" | "right" | "top" | "bottom";
     /** Scale type */
     scale?: ScaleType;
+    /** Tick display type — affects label formatting, not the mathematical scale */
+    type?: "linear" | "time";
     /** Axis label (e.g., 'E / V') */
     label?: string;
     /** Unit for formatting (e.g., 'V', 'A') */
@@ -65,8 +67,10 @@ export interface AxisOptions {
     labelFontSize?: number;
     /** Label rotation in degrees (useful for crowded X-axis) */
     labelRotation?: number;
+    /** Target number of tick divisions on this axis (default: 8 for X, 6 for Y) */
+    tickCount?: number;
 }
-export type SeriesType = "line" | "scatter" | "line+scatter" | "step" | "step+scatter" | "band" | "area" | "bar" | "heatmap" | "candlestick" | "polar" | "radar" | "boxplot" | "waterfall" | "gauge" | "sankey" | "ternary";
+export type SeriesType = "line" | "scatter" | "line+scatter" | "step" | "step+scatter" | "band" | "area" | "bar" | "heatmap" | "candlestick" | "polar" | "radar" | "boxplot" | "waterfall" | "gauge" | "sankey" | "ternary" | "indicator";
 /** Step mode defines where the step occurs */
 export type StepMode = "before" | "after" | "center";
 /** Error bar direction */
@@ -503,6 +507,8 @@ export interface TernaryOptions extends Omit<SeriesOptions, "data" | "style"> {
 export interface ChartOptions {
     /** Target container element */
     container: HTMLDivElement;
+    /** Stable chart id (used by sync groups; auto-generated if omitted) */
+    id?: string;
     /** Renderer backend selection (default: 'webgl') */
     renderer?: "webgl" | "webgpu";
     /** X-axis configuration */
@@ -589,6 +595,20 @@ export interface ZoomOptions {
     /** Animate the transition */
     animate?: boolean;
 }
+/** Options for {@link Chart.fit} — safe fit that skips empty series */
+export interface FitOptions {
+    /** Explicit X range (otherwise derived from visible series) */
+    x?: Range;
+    /** Explicit Y range for the primary Y axis (otherwise derived per axis) */
+    y?: Range;
+    /** Padding fraction applied to computed ranges (default: 0.02 for X, 0.05 for Y) */
+    padding?: number | {
+        x?: number;
+        y?: number;
+    };
+    /** Animate the transition */
+    animate?: boolean;
+}
 export interface CursorOptions {
     /** Enable cursor */
     enabled?: boolean;

package/dist/utils-BK5UUXxj.js

@@ -0,0 +1,172 @@
+const x = [
+  { symbol: "p", factor: 1e-12 },
+  { symbol: "n", factor: 1e-9 },
+  { symbol: "µ", factor: 1e-6 },
+  { symbol: "m", factor: 1e-3 },
+  { symbol: "", factor: 1 },
+  { symbol: "k", factor: 1e3 },
+  { symbol: "M", factor: 1e6 },
+  { symbol: "G", factor: 1e9 }
+];
+function g(t) {
+  const e = Math.abs(t);
+  if (e === 0)
+    return { symbol: "", factor: 1 };
+  for (let n = x.length - 1; n >= 0; n--) {
+    const r = x[n], o = e / r.factor;
+    if (o >= 1 && o < 1e3)
+      return r;
+  }
+  return { symbol: "", factor: 1 };
+}
+function F(t, e, n = 2) {
+  const r = g(t);
+  return `${(t / r.factor).toFixed(n)} ${r.symbol}${e}`;
+}
+function w(t, e = 3) {
+  return Math.abs(t) < 1e-3 || Math.abs(t) >= 1e6 ? t.toExponential(e) : t.toFixed(e);
+}
+function I(t, e = 2) {
+  return t.toExponential(e);
+}
+function v(t, e = 1e-3) {
+  const n = t instanceof Array ? new Float32Array(t) : t;
+  if (n.length < 3) return [];
+  const r = [];
+  let o = 0, i = 1, f = Math.sign(n[1] - n[0]), l = 0;
+  for (let a = 2; a < n.length; a++) {
+    const c = Math.sign(n[a] - n[a - 1]);
+    if (c !== 0 && c !== f) {
+      if (l++, l >= 2) {
+        const s = n[o], h = n[a];
+        Math.abs(h - s) < e && (r.push({
+          number: i,
+          startIndex: o,
+          endIndex: a,
+          direction: n[o + 1] > n[o] ? 1 : -1
+        }), i++, o = a, l = 0);
+      }
+      f = c;
+    }
+  }
+  return o < n.length - 1 && r.push({
+    number: i,
+    startIndex: o,
+    endIndex: n.length - 1,
+    direction: n[o + 1] > n[o] ? 1 : -1
+  }), r;
+}
+function D(t) {
+  const e = [], n = 360 / Math.max(t, 1);
+  for (let r = 0; r < t; r++) {
+    const o = r * n % 360;
+    e.push(`hsl(${o}, 70%, 55%)`);
+  }
+  return e;
+}
+function S(t, e, n = {}) {
+  const { minProminence: r = 0, type: o = "both" } = n, i = [], f = t instanceof Array ? new Float32Array(t) : t, l = e instanceof Array ? new Float32Array(e) : e;
+  for (let a = 1; a < l.length - 1; a++) {
+    const c = l[a - 1], s = l[a], h = l[a + 1];
+    if (s > c && s > h) {
+      const y = Math.min(s - c, s - h);
+      y >= r && (o === "both" || o === "max") && i.push({ index: a, x: f[a], y: s, type: "max", prominence: y });
+    }
+    if (s < c && s < h) {
+      const y = Math.min(c - s, h - s);
+      y >= r && (o === "both" || o === "min") && i.push({ index: a, x: f[a], y: s, type: "min", prominence: y });
+    }
+  }
+  return i;
+}
+function k(t) {
+  let e = 0, n = -1;
+  const r = t instanceof Array ? t : Array.from(t);
+  for (let o = 0; o < r.length; o++)
+    isFinite(r[o]) || (e++, n === -1 && (n = o));
+  return {
+    valid: e === 0,
+    invalidCount: e,
+    firstInvalidIndex: n
+  };
+}
+function C(t) {
+  const e = t instanceof Array ? t : Array.from(t), n = e.length;
+  if (n === 0)
+    return { min: 0, max: 0, mean: 0, stdDev: 0, count: 0 };
+  let r = e[0], o = e[0], i = 0;
+  for (let c = 0; c < n; c++) {
+    const s = e[c];
+    s < r && (r = s), s > o && (o = s), i += s;
+  }
+  const f = i / n;
+  let l = 0;
+  for (let c = 0; c < n; c++) {
+    const s = e[c] - f;
+    l += s * s;
+  }
+  const a = Math.sqrt(l / n);
+  return { min: r, max: o, mean: f, stdDev: a, count: n };
+}
+function E(t, e) {
+  const n = t instanceof Array ? new Float32Array(t) : t, r = new Float32Array(n.length), o = Math.floor(e / 2);
+  for (let i = 0; i < n.length; i++) {
+    let f = 0, l = 0;
+    for (let a = Math.max(0, i - o); a <= Math.min(n.length - 1, i + o); a++)
+      f += n[a], l++;
+    r[i] = f / l;
+  }
+  return r;
+}
+function B(t, e, n) {
+  const r = t.length;
+  if (n >= r || n < 3)
+    return { x: new Float32Array(t), y: new Float32Array(e) };
+  const o = new Float32Array(n), i = new Float32Array(n);
+  o[0] = t[0], i[0] = e[0];
+  const f = (r - 2) / (n - 2);
+  let l = 0, a = 1;
+  for (let c = 0; c < n - 2; c++) {
+    const s = Math.floor((c + 1) * f) + 1, h = Math.floor((c + 2) * f) + 1, y = Math.min(Math.floor((c + 3) * f) + 1, r);
+    let b = 0, u = 0, d = 0;
+    for (let m = h; m < y; m++)
+      b += t[m], u += e[m], d++;
+    d > 0 && (b /= d, u /= d);
+    let p = -1, A = s;
+    for (let m = s; m < h && m < r; m++) {
+      const M = Math.abs(
+        (t[l] - b) * (e[m] - e[l]) - (t[l] - t[m]) * (u - e[l])
+      );
+      M > p && (p = M, A = m);
+    }
+    o[a] = t[A], i[a] = e[A], a++, l = A;
+  }
+  return o[n - 1] = t[r - 1], i[n - 1] = e[r - 1], { x: o, y: i };
+}
+function V(t, e, n, r) {
+  const o = t.length, i = new Float32Array(o);
+  let f = 0, l = o - 1, a = 1 / 0, c = 1 / 0;
+  for (let u = 0; u < o; u++) {
+    const d = Math.abs(t[u] - n), p = Math.abs(t[u] - r);
+    d < a && (a = d, f = u), p < c && (c = p, l = u);
+  }
+  const s = e[f], y = (e[l] - s) / (t[l] - t[f]), b = s - y * t[f];
+  for (let u = 0; u < o; u++)
+    i[u] = e[u] - (y * t[u] + b);
+  return i;
+}
+export {
+  v as a,
+  S as b,
+  C as c,
+  B as d,
+  w as e,
+  F as f,
+  D as g,
+  I as h,
+  g as i,
+  E as m,
+  V as s,
+  k as v
+};
+//# sourceMappingURL=utils-BK5UUXxj.js.map

package/dist/utils-BK5UUXxj.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils-BK5UUXxj.js","sources":["../src/plugins/analysis/utils.ts"],"sourcesContent":["/**\n * Data Analysis Utilities\n *\n * General-purpose utilities for scientific data formatting,\n * cycle detection, peak detection, and data validation.\n */\n\n// ============================================\n// Unit Prefixes\n// ============================================\n\ntype SIPrefix = 'p' | 'n' | 'µ' | 'm' | '' | 'k' | 'M' | 'G';\n\nexport interface PrefixInfo {\n  symbol: SIPrefix;\n  factor: number;\n}\n\nconst SI_PREFIXES: PrefixInfo[] = [\n  { symbol: 'p', factor: 1e-12 },\n  { symbol: 'n', factor: 1e-9 },\n  { symbol: 'µ', factor: 1e-6 },\n  { symbol: 'm', factor: 1e-3 },\n  { symbol: '', factor: 1 },\n  { symbol: 'k', factor: 1e3 },\n  { symbol: 'M', factor: 1e6 },\n  { symbol: 'G', factor: 1e9 },\n];\n\n/**\n * Find the best SI prefix for a value\n */\nexport function getBestPrefix(value: number): PrefixInfo {\n  const absValue = Math.abs(value);\n\n  if (absValue === 0) {\n    return { symbol: '', factor: 1 };\n  }\n\n  // Find prefix where value becomes 1-999\n  for (let i = SI_PREFIXES.length - 1; i >= 0; i--) {\n    const prefix = SI_PREFIXES[i];\n    const scaled = absValue / prefix.factor;\n    if (scaled >= 1 && scaled < 1000) {\n      return prefix;\n    }\n  }\n\n  // Default to base unit\n  return { symbol: '', factor: 1 };\n}\n\n/**\n * Format a value with automatic SI prefix\n *\n * @example\n * formatWithPrefix(0.000001, 'A') // \"1.00 µA\"\n * formatWithPrefix(0.5, 'V')      // \"500 mV\"\n * formatWithPrefix(1500, 'm')     // \"1.50 km\"\n */\nexport function formatWithPrefix(\n  value: number,\n  unit: string,\n  decimals = 2\n): string {\n  const prefix = getBestPrefix(value);\n  const scaled = value / prefix.factor;\n  return `${scaled.toFixed(decimals)} ${prefix.symbol}${unit}`;\n}\n\n/**\n * Format a numeric value with specified decimals\n * Automatically switches to scientific notation for very large/small values\n */\nexport function formatValue(value: number, decimals = 3): string {\n  if (Math.abs(value) < 0.001 || Math.abs(value) >= 1e6) {\n    return value.toExponential(decimals);\n  }\n  return value.toFixed(decimals);\n}\n\n/**\n * Format value in scientific notation\n */\nexport function formatScientific(value: number, decimals = 2): string {\n  return value.toExponential(decimals);\n}\n\n// ============================================\n// Cycle Detection\n// ============================================\n\nexport interface CycleInfo {\n  /** Cycle number (1-indexed) */\n  number: number;\n  /** Start index in data array */\n  startIndex: number;\n  /** End index in data array */\n  endIndex: number;\n  /** Direction at start: 1 = forward, -1 = reverse */\n  direction: 1 | -1;\n}\n\n/**\n * Detect cycles in oscillating data\n *\n * A cycle is complete when the signal returns to its starting value\n * after going through both sweep directions. Useful for:\n * - Cyclic voltammetry data\n * - Periodic signals\n * - Oscillation analysis\n *\n * @param signal - The signal data (e.g., potential, position, etc.)\n * @param tolerance - How close to starting value to consider a cycle complete\n */\nexport function detectCycles(\n  signal: Float32Array | Float64Array | number[],\n  tolerance = 0.001\n): CycleInfo[] {\n  const data = signal instanceof Array ? new Float32Array(signal) : signal;\n  \n  if (data.length < 3) return [];\n\n  const cycles: CycleInfo[] = [];\n  let cycleStart = 0;\n  let cycleNumber = 1;\n\n  // Determine initial direction\n  let prevDirection = Math.sign(data[1] - data[0]);\n  let directionChanges = 0;\n\n  for (let i = 2; i < data.length; i++) {\n    const direction = Math.sign(data[i] - data[i - 1]);\n\n    // Skip if no movement\n    if (direction === 0) continue;\n\n    // Direction change detected\n    if (direction !== prevDirection) {\n      directionChanges++;\n\n      // After 2 direction changes, check if we're back at start\n      if (directionChanges >= 2) {\n        const startValue = data[cycleStart];\n        const currentValue = data[i];\n\n        if (Math.abs(currentValue - startValue) < tolerance) {\n          cycles.push({\n            number: cycleNumber,\n            startIndex: cycleStart,\n            endIndex: i,\n            direction: data[cycleStart + 1] > data[cycleStart] ? 1 : -1,\n          });\n\n          cycleNumber++;\n          cycleStart = i;\n          directionChanges = 0;\n        }\n      }\n\n      prevDirection = direction;\n    }\n  }\n\n  // Handle last incomplete cycle\n  if (cycleStart < data.length - 1) {\n    cycles.push({\n      number: cycleNumber,\n      startIndex: cycleStart,\n      endIndex: data.length - 1,\n      direction: data[cycleStart + 1] > data[cycleStart] ? 1 : -1,\n    });\n  }\n\n  return cycles;\n}\n\n/**\n * Generate distinct colors for cycles/series\n *\n * Uses HSL color space to generate evenly distributed hues\n */\nexport function generateCycleColors(count: number): string[] {\n  const colors: string[] = [];\n  const hueStep = 360 / Math.max(count, 1);\n\n  for (let i = 0; i < count; i++) {\n    const hue = (i * hueStep) % 360;\n    colors.push(`hsl(${hue}, 70%, 55%)`);\n  }\n\n  return colors;\n}\n\n// ============================================\n// Peak Detection\n// ============================================\n\nexport interface Peak {\n  /** Index in data array */\n  index: number;\n  /** X value at peak */\n  x: number;\n  /** Y value at peak */\n  y: number;\n  /** Peak type */\n  type: 'max' | 'min';\n  /** Prominence of the peak */\n  prominence: number;\n}\n\n/**\n * Detect peaks (local maxima and minima) in data\n *\n * Uses simple local extrema detection with optional prominence filtering.\n * Useful for:\n * - Signal peak detection\n * - Finding local maxima/minima\n * - Feature extraction\n *\n * @param x - X values (independent variable)\n * @param y - Y values (dependent variable)\n * @param options - Detection options\n */\nexport function detectPeaks(\n  x: Float32Array | Float64Array | number[],\n  y: Float32Array | Float64Array | number[],\n  options: {\n    /** Minimum prominence to be considered a peak */\n    minProminence?: number;\n    /** Only return 'max' or 'min' peaks */\n    type?: 'max' | 'min' | 'both';\n  } = {}\n): Peak[] {\n  const { minProminence = 0, type = 'both' } = options;\n  const peaks: Peak[] = [];\n\n  const xData = x instanceof Array ? new Float32Array(x) : x;\n  const yData = y instanceof Array ? new Float32Array(y) : y;\n\n  for (let i = 1; i < yData.length - 1; i++) {\n    const prev = yData[i - 1];\n    const curr = yData[i];\n    const next = yData[i + 1];\n\n    // Local maximum\n    if (curr > prev && curr > next) {\n      const prominence = Math.min(curr - prev, curr - next);\n      if (prominence >= minProminence && (type === 'both' || type === 'max')) {\n        peaks.push({ index: i, x: xData[i], y: curr, type: 'max', prominence });\n      }\n    }\n\n    // Local minimum\n    if (curr < prev && curr < next) {\n      const prominence = Math.min(prev - curr, next - curr);\n      if (prominence >= minProminence && (type === 'both' || type === 'min')) {\n        peaks.push({ index: i, x: xData[i], y: curr, type: 'min', prominence });\n      }\n    }\n  }\n\n  return peaks;\n}\n\n// ============================================\n// Data Validation\n// ============================================\n\nexport interface ValidationResult {\n  /** Whether all data is valid */\n  valid: boolean;\n  /** Number of invalid values (NaN, Infinity, etc.) */\n  invalidCount: number;\n  /** Index of first invalid value (-1 if all valid) */\n  firstInvalidIndex: number;\n}\n\n/**\n * Validate that data contains only finite numbers\n *\n * Checks for NaN, Infinity, and -Infinity values.\n * Useful for data quality checks before rendering.\n */\nexport function validateData(\n  data: Float32Array | Float64Array | number[]\n): ValidationResult {\n  let invalidCount = 0;\n  let firstInvalidIndex = -1;\n\n  const arr = data instanceof Array ? data : Array.from(data);\n\n  for (let i = 0; i < arr.length; i++) {\n    if (!isFinite(arr[i])) {\n      invalidCount++;\n      if (firstInvalidIndex === -1) {\n        firstInvalidIndex = i;\n      }\n    }\n  }\n\n  return {\n    valid: invalidCount === 0,\n    invalidCount,\n    firstInvalidIndex,\n  };\n}\n\n// ============================================\n// Data Statistics\n// ============================================\n\nexport interface DataStats {\n  min: number;\n  max: number;\n  mean: number;\n  stdDev: number;\n  count: number;\n}\n\n/**\n * Calculate basic statistics for a dataset\n */\nexport function calculateStats(\n  data: Float32Array | Float64Array | number[]\n): DataStats {\n  const arr = data instanceof Array ? data : Array.from(data);\n  const count = arr.length;\n\n  if (count === 0) {\n    return { min: 0, max: 0, mean: 0, stdDev: 0, count: 0 };\n  }\n\n  let min = arr[0];\n  let max = arr[0];\n  let sum = 0;\n\n  for (let i = 0; i < count; i++) {\n    const val = arr[i];\n    if (val < min) min = val;\n    if (val > max) max = val;\n    sum += val;\n  }\n\n  const mean = sum / count;\n\n  // Calculate standard deviation\n  let sumSquaredDiff = 0;\n  for (let i = 0; i < count; i++) {\n    const diff = arr[i] - mean;\n    sumSquaredDiff += diff * diff;\n  }\n  const stdDev = Math.sqrt(sumSquaredDiff / count);\n\n  return { min, max, mean, stdDev, count };\n}\n\n// ============================================\n// Data Smoothing\n// ============================================\n\n/**\n * Apply moving average smoothing to data\n *\n * @param data - Input data array\n * @param windowSize - Number of points to average (must be odd)\n */\nexport function movingAverage(\n  data: Float32Array | Float64Array | number[],\n  windowSize: number\n): Float32Array {\n  const arr = data instanceof Array ? new Float32Array(data) : data;\n  const result = new Float32Array(arr.length);\n  const halfWindow = Math.floor(windowSize / 2);\n\n  for (let i = 0; i < arr.length; i++) {\n    let sum = 0;\n    let count = 0;\n\n    for (let j = Math.max(0, i - halfWindow); j <= Math.min(arr.length - 1, i + halfWindow); j++) {\n      sum += arr[j];\n      count++;\n    }\n\n    result[i] = sum / count;\n  }\n\n  return result;\n}\n\n/**\n * Downsample data using LTTB (Largest Triangle Three Buckets) algorithm\n *\n * Preserves visual characteristics while reducing point count.\n * Ideal for rendering large datasets efficiently.\n *\n * @param x - X values\n * @param y - Y values\n * @param targetPoints - Desired number of output points\n */\nexport function downsampleLTTB(\n  x: Float32Array | Float64Array,\n  y: Float32Array | Float64Array,\n  targetPoints: number\n): { x: Float32Array; y: Float32Array } {\n  const dataLength = x.length;\n\n  if (targetPoints >= dataLength || targetPoints < 3) {\n    return { x: new Float32Array(x), y: new Float32Array(y) };\n  }\n\n  const sampledX = new Float32Array(targetPoints);\n  const sampledY = new Float32Array(targetPoints);\n\n  // Always include first point\n  sampledX[0] = x[0];\n  sampledY[0] = y[0];\n\n  const bucketSize = (dataLength - 2) / (targetPoints - 2);\n\n  let a = 0; // Previous selected point index\n  let sampledIndex = 1;\n\n  for (let i = 0; i < targetPoints - 2; i++) {\n    // Calculate bucket range\n    const bucketStart = Math.floor((i + 1) * bucketSize) + 1;\n    const bucketEnd = Math.floor((i + 2) * bucketSize) + 1;\n    const nextBucketEnd = Math.min(Math.floor((i + 3) * bucketSize) + 1, dataLength);\n\n    // Calculate average of next bucket for comparison\n    let avgX = 0;\n    let avgY = 0;\n    let avgCount = 0;\n\n    for (let j = bucketEnd; j < nextBucketEnd; j++) {\n      avgX += x[j];\n      avgY += y[j];\n      avgCount++;\n    }\n\n    if (avgCount > 0) {\n      avgX /= avgCount;\n      avgY /= avgCount;\n    }\n\n    // Find point in current bucket with largest triangle area\n    let maxArea = -1;\n    let maxAreaIndex = bucketStart;\n\n    for (let j = bucketStart; j < bucketEnd && j < dataLength; j++) {\n      // Triangle area calculation\n      const area = Math.abs(\n        (x[a] - avgX) * (y[j] - y[a]) - (x[a] - x[j]) * (avgY - y[a])\n      );\n\n      if (area > maxArea) {\n        maxArea = area;\n        maxAreaIndex = j;\n      }\n    }\n\n    sampledX[sampledIndex] = x[maxAreaIndex];\n    sampledY[sampledIndex] = y[maxAreaIndex];\n    sampledIndex++;\n    a = maxAreaIndex;\n  }\n\n  // Always include last point\n  sampledX[targetPoints - 1] = x[dataLength - 1];\n  sampledY[targetPoints - 1] = y[dataLength - 1];\n\n  return { x: sampledX, y: sampledY };\n}\n\n/**\n * Subtract a linear baseline from data\n * \n * @param x - X data\n * @param y - Y data\n * @param x1 - Start of baseline segment\n * @param x2 - End of baseline segment\n */\nexport function subtractBaseline(\n  x: Float32Array | number[],\n  y: Float32Array | number[],\n  x1: number,\n  x2: number\n): Float32Array {\n  const n = x.length;\n  const result = new Float32Array(n);\n\n  // Find points near x1 and x2 to determine baseline\n  let i1 = 0, i2 = n - 1;\n  let minDist1 = Infinity, minDist2 = Infinity;\n\n  for (let i = 0; i < n; i++) {\n    const d1 = Math.abs(x[i] - x1);\n    const d2 = Math.abs(x[i] - x2);\n    if (d1 < minDist1) { minDist1 = d1; i1 = i; }\n    if (d2 < minDist2) { minDist2 = d2; i2 = i; }\n  }\n\n  const y1 = y[i1];\n  const y2 = y[i2];\n  const slope = (y2 - y1) / (x[i2] - x[i1]);\n  const intercept = y1 - slope * x[i1];\n\n  for (let i = 0; i < n; i++) {\n    result[i] = y[i] - (slope * x[i] + intercept);\n  }\n\n  return result;\n}\n"],"names":["SI_PREFIXES","getBestPrefix","value","absValue","i","prefix","scaled","formatWithPrefix","unit","decimals","formatValue","formatScientific","detectCycles","signal","tolerance","data","cycles","cycleStart","cycleNumber","prevDirection","directionChanges","direction","startValue","currentValue","generateCycleColors","count","colors","hueStep","hue","detectPeaks","x","y","options","minProminence","type","peaks","xData","yData","prev","curr","next","prominence","validateData","invalidCount","firstInvalidIndex","arr","calculateStats","min","max","sum","val","mean","sumSquaredDiff","diff","stdDev","movingAverage","windowSize","result","halfWindow","j","downsampleLTTB","targetPoints","dataLength","sampledX","sampledY","bucketSize","a","sampledIndex","bucketStart","bucketEnd","nextBucketEnd","avgX","avgY","avgCount","maxArea","maxAreaIndex","area","subtractBaseline","x1","x2","n","i1","i2","minDist1","minDist2","d1","d2","y1","slope","intercept"],"mappings":"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"}