velo-plot 1.12.0 → 1.19.0

package/dist/plugins/lazy-load.js

@@ -0,0 +1,212 @@
+const D = {
+  name: "velo-plot-lazy-load",
+  version: "1.0.0",
+  description: "Lazy loading for large datasets with viewport-based chunking",
+  provides: ["lazy-load", "data-streaming"],
+  tags: ["performance", "data", "optimization"]
+}, T = {
+  enabled: !0,
+  chunkSize: 1e4,
+  viewportBuffer: 2,
+  autoLoad: !0,
+  autoUnload: !0,
+  unloadThreshold: 5,
+  preloadAdjacent: !0,
+  maxLoadedChunks: 100,
+  onLoadStart: () => {
+  },
+  onLoadProgress: () => {
+  },
+  onLoadComplete: () => {
+  },
+  onLoadError: () => {
+  },
+  debug: !1
+};
+function B(w = {}) {
+  const a = { ...T, ...w };
+  let l = null;
+  const h = /* @__PURE__ */ new Map();
+  function L(t) {
+    return Math.floor(t / a.chunkSize);
+  }
+  function m() {
+    if (!l) return null;
+    const t = l.data.getViewBounds();
+    return t ? { xMin: t.xMin, xMax: t.xMax } : null;
+  }
+  async function M(t, n) {
+    if (!(t.chunks.has(n) || t.loading.has(n))) {
+      t.loading.add(n);
+      try {
+        const o = n * a.chunkSize, r = Math.min(
+          o + a.chunkSize,
+          t.totalPoints
+        );
+        a.debug && console.log(`[LazyLoad] Loading chunk ${n} for ${t.id} (${o}-${r})`);
+        const e = await t.provider.loadChunk(o, r);
+        t.chunks.set(n, e), t.loading.delete(n), await z(t);
+        const s = Array.from(t.chunks.values()).reduce(
+          (c, f) => c + (f.endIndex - f.startIndex),
+          0
+        ), i = Math.ceil(t.totalPoints / a.chunkSize), u = {
+          seriesId: t.id,
+          loadedPoints: s,
+          totalPoints: t.totalPoints,
+          progress: s / t.totalPoints,
+          currentChunk: n,
+          totalChunks: i
+        };
+        s === t.totalPoints ? a.onLoadComplete(u) : a.onLoadProgress(u);
+      } catch (o) {
+        t.loading.delete(n), a.onLoadError(o, t.id), a.debug && console.error(`[LazyLoad] Error loading chunk ${n}:`, o);
+      }
+    }
+  }
+  async function z(t) {
+    var i, u;
+    if (!l) return;
+    const n = Array.from(t.chunks.entries()).sort((c, f) => c[0] - f[0]);
+    if (n.length === 0) return;
+    let o = 0;
+    for (const [, c] of n)
+      o += c.x.length;
+    const r = new Float32Array(o), e = new Float32Array(o);
+    let s = 0;
+    for (const [, c] of n)
+      r.set(c.x, s), e.set(c.y, s), s += c.x.length;
+    (u = (i = l.chart).updateSeries) == null || u.call(i, t.id, { x: r, y: e });
+  }
+  async function g() {
+    if (!a.enabled || !l) return;
+    const t = m();
+    if (!t) return;
+    const n = a.viewportBuffer, o = t.xMax - t.xMin, r = {
+      xMin: t.xMin - o * n,
+      xMax: t.xMax + o * n
+    };
+    for (const [, e] of h) {
+      const s = [], i = Math.ceil(e.totalPoints / a.chunkSize), u = Math.max(0, Math.floor(r.xMin / a.chunkSize)), c = Math.min(i - 1, Math.floor(r.xMax / a.chunkSize));
+      for (let d = u; d <= c; d++)
+        !e.chunks.has(d) && !e.loading.has(d) && s.push(d);
+      const f = Math.min(s.length, 10);
+      for (let d = 0; d < f; d++)
+        await M(e, s[d]);
+      if (a.preloadAdjacent && c + 1 < i) {
+        const d = c + 1;
+        !e.chunks.has(d) && !e.loading.has(d) && M(e, d);
+      }
+    }
+  }
+  function b(t, n) {
+    const o = a.viewportBuffer, r = n.xMax - n.xMin, e = {
+      xMin: n.xMin - r * o,
+      xMax: n.xMax + r * o
+    }, s = Math.ceil(t.totalPoints / a.chunkSize), i = Math.max(0, Math.floor(e.xMin / a.chunkSize)), u = Math.min(s - 1, Math.floor(e.xMax / a.chunkSize));
+    return { startChunk: i, endChunk: u };
+  }
+  function x() {
+    if (!a.autoUnload || !l) return 0;
+    const t = m();
+    if (!t) return 0;
+    let n = 0;
+    for (const [, o] of h) {
+      let r = 0;
+      const { startChunk: e, endChunk: s } = b(o, t), i = Math.max(1, s - e + 1), u = Math.ceil(a.unloadThreshold * i), c = Math.max(0, e - u), f = s + u;
+      for (const d of Array.from(o.chunks.keys()))
+        (d < c || d > f) && (o.chunks.delete(d), r++);
+      if (o.chunks.size > a.maxLoadedChunks) {
+        const d = Array.from(o.chunks.entries()).sort(
+          (k, $) => k[1].loadedAt - $[1].loadedAt
+        ), U = o.chunks.size - a.maxLoadedChunks;
+        for (let k = 0; k < U; k++)
+          o.chunks.delete(d[k][0]), r++;
+      }
+      r > 0 && (z(o), n += r);
+    }
+    return a.debug && n > 0 && console.log(`[LazyLoad] Unloaded ${n} chunks`), n;
+  }
+  function P(t, n) {
+    const o = n.getTotalCount();
+    h.set(t, {
+      id: t,
+      provider: n,
+      chunks: /* @__PURE__ */ new Map(),
+      loading: /* @__PURE__ */ new Set(),
+      totalPoints: o
+    }), a.debug && console.log(`[LazyLoad] Registered series ${t} with ${o} points`), a.onLoadStart({
+      seriesId: t,
+      loadedPoints: 0,
+      totalPoints: o,
+      progress: 0,
+      currentChunk: 0,
+      totalChunks: Math.ceil(o / a.chunkSize)
+    }), a.autoLoad && g();
+  }
+  function v(t) {
+    h.delete(t), a.debug && console.log(`[LazyLoad] Unregistered series ${t}`);
+  }
+  async function C(t, n, o) {
+    const r = h.get(t);
+    if (!r) return;
+    const e = L(n), s = L(o);
+    for (let i = e; i <= s; i++)
+      await M(r, i);
+  }
+  function A(t) {
+    const n = h.get(t);
+    return n ? {
+      loadedPoints: Array.from(n.chunks.values()).reduce(
+        (r, e) => r + (e.endIndex - e.startIndex),
+        0
+      ),
+      totalPoints: n.totalPoints,
+      loadedChunks: n.chunks.size,
+      totalChunks: Math.ceil(n.totalPoints / a.chunkSize)
+    } : null;
+  }
+  function y() {
+    for (const [, t] of h)
+      t.chunks.clear(), t.loading.clear();
+  }
+  async function p(t) {
+    if (!l || !a.enabled) return;
+    const n = t.buffer ?? a.viewportBuffer, o = t.to - t.from, r = Math.max(0, Math.floor(t.from - o * n)), e = Math.ceil(t.to + o * n), s = t.seriesId ? [[t.seriesId, h.get(t.seriesId)]] : Array.from(h.entries()).map(([i, u]) => [i, u]);
+    for (const [i, u] of s)
+      u && await C(i, r, e);
+    a.autoUnload && x();
+  }
+  const S = {
+    registerSeries: P,
+    unregisterSeries: v,
+    loadRange: C,
+    loadVisible: g,
+    unloadDistant: x,
+    setDataWindow: p,
+    getLoadingStatus: A,
+    clear: y,
+    updateConfig(t) {
+      Object.assign(a, t);
+    }
+  };
+  return {
+    manifest: D,
+    onInit(t) {
+      var n, o, r, e;
+      l = t, l.chart.lazyLoad = S, l.chart.setDataWindow = (s) => p(s), a.autoLoad && ((o = (n = l.chart).on) == null || o.call(n, "zoom", () => {
+        g(), a.autoUnload && x();
+      }), (e = (r = l.chart).on) == null || e.call(r, "pan", () => {
+        g(), a.autoUnload && x();
+      }));
+    },
+    onDestroy(t) {
+      y(), delete t.chart.lazyLoad, delete t.chart.setDataWindow, l = null;
+    },
+    api: S
+  };
+}
+export {
+  B as PluginLazyLoad,
+  B as default
+};
+//# sourceMappingURL=lazy-load.js.map

package/dist/plugins/lazy-load.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazy-load.js","sources":["../../src/plugins/lazy-load/index.ts"],"sourcesContent":["/**\n * @fileoverview Lazy loading plugin for large datasets\n * @module plugins/lazy-load\n */\n\nimport type {\n  PluginLazyLoadConfig,\n  LazyLoadAPI,\n  DataProvider,\n  LazyLoadedSeries,\n  LoadProgressEvent,\n} from './types';\nimport type {\n  ChartPlugin,\n  PluginContext,\n  PluginManifest,\n} from '../types';\n\nconst manifest: PluginManifest = {\n  name: 'velo-plot-lazy-load',\n  version: '1.0.0',\n  description: 'Lazy loading for large datasets with viewport-based chunking',\n  provides: ['lazy-load', 'data-streaming'],\n  tags: ['performance', 'data', 'optimization'],\n};\n\nconst DEFAULT_CONFIG: Required<PluginLazyLoadConfig> = {\n  enabled: true,\n  chunkSize: 10000,\n  viewportBuffer: 2,\n  autoLoad: true,\n  autoUnload: true,\n  unloadThreshold: 5,\n  preloadAdjacent: true,\n  maxLoadedChunks: 100,\n  onLoadStart: () => {},\n  onLoadProgress: () => {},\n  onLoadComplete: () => {},\n  onLoadError: () => {},\n  debug: false,\n};\n\nexport function PluginLazyLoad(\n  userConfig: Partial<PluginLazyLoadConfig> = {}\n): ChartPlugin<PluginLazyLoadConfig> {\n  const config = { ...DEFAULT_CONFIG, ...userConfig };\n  let ctx: PluginContext | null = null;\n\n  // Registered series\n  const series = new Map<string, LazyLoadedSeries>();\n\n  /**\n   * Calculate chunk index from point index\n   */\n  function getChunkIndex(pointIndex: number): number {\n    return Math.floor(pointIndex / config.chunkSize);\n  }\n\n  /**\n   * Get visible range from chart\n   */\n  function getVisibleRange(): { xMin: number; xMax: number } | null {\n    if (!ctx) return null;\n    \n    // Get current view bounds from data context\n    const bounds = ctx.data.getViewBounds();\n    if (bounds) {\n      return { xMin: bounds.xMin, xMax: bounds.xMax };\n    }\n    \n    return null;\n  }\n\n  /**\n   * Load a specific chunk\n   */\n  async function loadChunk(\n    seriesInfo: LazyLoadedSeries,\n    chunkIndex: number\n  ): Promise<void> {\n    // Already loaded or loading\n    if (seriesInfo.chunks.has(chunkIndex) || seriesInfo.loading.has(chunkIndex)) {\n      return;\n    }\n\n    seriesInfo.loading.add(chunkIndex);\n\n    try {\n      const startIndex = chunkIndex * config.chunkSize;\n      const endIndex = Math.min(\n        startIndex + config.chunkSize,\n        seriesInfo.totalPoints\n      );\n\n      if (config.debug) {\n        console.log(`[LazyLoad] Loading chunk ${chunkIndex} for ${seriesInfo.id} (${startIndex}-${endIndex})`);\n      }\n\n      const chunk = await seriesInfo.provider.loadChunk(startIndex, endIndex);\n      \n      seriesInfo.chunks.set(chunkIndex, chunk);\n      seriesInfo.loading.delete(chunkIndex);\n\n      // Update chart data\n      await updateSeriesData(seriesInfo);\n\n      // Fire progress event\n      const loadedPoints = Array.from(seriesInfo.chunks.values()).reduce(\n        (sum, c) => sum + (c.endIndex - c.startIndex),\n        0\n      );\n\n      const totalChunks = Math.ceil(seriesInfo.totalPoints / config.chunkSize);\n      \n      const event: LoadProgressEvent = {\n        seriesId: seriesInfo.id,\n        loadedPoints,\n        totalPoints: seriesInfo.totalPoints,\n        progress: loadedPoints / seriesInfo.totalPoints,\n        currentChunk: chunkIndex,\n        totalChunks,\n      };\n\n      if (loadedPoints === seriesInfo.totalPoints) {\n        config.onLoadComplete(event);\n      } else {\n        config.onLoadProgress(event);\n      }\n\n    } catch (error) {\n      seriesInfo.loading.delete(chunkIndex);\n      config.onLoadError(error as Error, seriesInfo.id);\n      \n      if (config.debug) {\n        console.error(`[LazyLoad] Error loading chunk ${chunkIndex}:`, error);\n      }\n    }\n  }\n\n  /**\n   * Update series data from loaded chunks\n   */\n  async function updateSeriesData(seriesInfo: LazyLoadedSeries): Promise<void> {\n    if (!ctx) return;\n\n    // Merge all loaded chunks\n    const sortedChunks = Array.from(seriesInfo.chunks.entries()).sort((a, b) => a[0] - b[0]);\n    \n    if (sortedChunks.length === 0) return;\n\n    // Calculate total size\n    let totalSize = 0;\n    for (const [, chunk] of sortedChunks) {\n      totalSize += chunk.x.length;\n    }\n\n    // Allocate arrays\n    const x = new Float32Array(totalSize);\n    const y = new Float32Array(totalSize);\n\n    // Copy data\n    let offset = 0;\n    for (const [, chunk] of sortedChunks) {\n      x.set(chunk.x, offset);\n      y.set(chunk.y, offset);\n      offset += chunk.x.length;\n    }\n\n    // Update series\n    (ctx.chart as any).updateSeries?.(seriesInfo.id, { x, y });\n  }\n\n  /**\n   * Load visible data\n   */\n  async function loadVisible(): Promise<void> {\n    if (!config.enabled || !ctx) return;\n\n    const visibleRange = getVisibleRange();\n    if (!visibleRange) return;\n\n    const buffer = config.viewportBuffer;\n    const rangeWidth = visibleRange.xMax - visibleRange.xMin;\n    const buffered = {\n      xMin: visibleRange.xMin - rangeWidth * buffer,\n      xMax: visibleRange.xMax + rangeWidth * buffer,\n    };\n\n    for (const [, seriesInfo] of series) {\n      const chunksToLoad: number[] = [];\n      const totalChunks = Math.ceil(seriesInfo.totalPoints / config.chunkSize);\n\n      // Identify chunks within the buffered viewport\n      const startIdx = Math.max(0, Math.floor(buffered.xMin / config.chunkSize));\n      const endIdx = Math.min(totalChunks - 1, Math.floor(buffered.xMax / config.chunkSize));\n\n      for (let i = startIdx; i <= endIdx; i++) {\n        if (!seriesInfo.chunks.has(i) && !seriesInfo.loading.has(i)) {\n          chunksToLoad.push(i);\n        }\n      }\n\n      // Load chunks sequentially (limit to avoid flood)\n      const maxToLoad = Math.min(chunksToLoad.length, 10);\n      for (let i = 0; i < maxToLoad; i++) {\n        await loadChunk(seriesInfo, chunksToLoad[i]);\n      }\n\n      // Preload next adjacent chunk if enabled\n      if (config.preloadAdjacent && endIdx + 1 < totalChunks) {\n        const nextChunk = endIdx + 1;\n        if (!seriesInfo.chunks.has(nextChunk) && !seriesInfo.loading.has(nextChunk)) {\n          loadChunk(seriesInfo, nextChunk); // Fire and forget\n        }\n      }\n    }\n  }\n\n  /**\n   * Chunk index range that should stay loaded for the current viewport.\n   */\n  function getKeepChunkRange(\n    seriesInfo: LazyLoadedSeries,\n    visibleRange: { xMin: number; xMax: number },\n  ): { startChunk: number; endChunk: number } {\n    const buffer = config.viewportBuffer;\n    const rangeWidth = visibleRange.xMax - visibleRange.xMin;\n    const buffered = {\n      xMin: visibleRange.xMin - rangeWidth * buffer,\n      xMax: visibleRange.xMax + rangeWidth * buffer,\n    };\n    const totalChunks = Math.ceil(seriesInfo.totalPoints / config.chunkSize);\n    const startChunk = Math.max(0, Math.floor(buffered.xMin / config.chunkSize));\n    const endChunk = Math.min(totalChunks - 1, Math.floor(buffered.xMax / config.chunkSize));\n    return { startChunk, endChunk };\n  }\n\n  /**\n   * Unload distant chunks\n   */\n  function unloadDistant(): number {\n    if (!config.autoUnload || !ctx) return 0;\n\n    const visibleRange = getVisibleRange();\n    if (!visibleRange) return 0;\n\n    let unloadedCount = 0;\n\n    for (const [, seriesInfo] of series) {\n      let seriesUnloaded = 0;\n      const { startChunk, endChunk } = getKeepChunkRange(seriesInfo, visibleRange);\n      const visibleSpan = Math.max(1, endChunk - startChunk + 1);\n      const thresholdChunks = Math.ceil(config.unloadThreshold * visibleSpan);\n      const keepStart = Math.max(0, startChunk - thresholdChunks);\n      const keepEnd = endChunk + thresholdChunks;\n\n      for (const chunkIndex of Array.from(seriesInfo.chunks.keys())) {\n        if (chunkIndex < keepStart || chunkIndex > keepEnd) {\n          seriesInfo.chunks.delete(chunkIndex);\n          seriesUnloaded++;\n        }\n      }\n\n      // Enforce max chunks limit (LRU eviction)\n      if (seriesInfo.chunks.size > config.maxLoadedChunks) {\n        const sortedChunks = Array.from(seriesInfo.chunks.entries()).sort(\n          (a, b) => a[1].loadedAt - b[1].loadedAt,\n        );\n\n        const toRemove = seriesInfo.chunks.size - config.maxLoadedChunks;\n        for (let i = 0; i < toRemove; i++) {\n          seriesInfo.chunks.delete(sortedChunks[i][0]);\n          seriesUnloaded++;\n        }\n      }\n\n      if (seriesUnloaded > 0) {\n        void updateSeriesData(seriesInfo);\n        unloadedCount += seriesUnloaded;\n      }\n    }\n\n    if (config.debug && unloadedCount > 0) {\n      console.log(`[LazyLoad] Unloaded ${unloadedCount} chunks`);\n    }\n\n    return unloadedCount;\n  }\n\n  /**\n   * Register a series\n   */\n  function registerSeries(seriesId: string, provider: DataProvider): void {\n    const totalPoints = provider.getTotalCount();\n    \n    series.set(seriesId, {\n      id: seriesId,\n      provider,\n      chunks: new Map(),\n      loading: new Set(),\n      totalPoints,\n    });\n\n    if (config.debug) {\n      console.log(`[LazyLoad] Registered series ${seriesId} with ${totalPoints} points`);\n    }\n\n    // Fire load start event\n    config.onLoadStart({\n      seriesId,\n      loadedPoints: 0,\n      totalPoints,\n      progress: 0,\n      currentChunk: 0,\n      totalChunks: Math.ceil(totalPoints / config.chunkSize),\n    });\n\n    // Auto-load if enabled\n    if (config.autoLoad) {\n      loadVisible();\n    }\n  }\n\n  /**\n   * Unregister a series\n   */\n  function unregisterSeries(seriesId: string): void {\n    series.delete(seriesId);\n    \n    if (config.debug) {\n      console.log(`[LazyLoad] Unregistered series ${seriesId}`);\n    }\n  }\n\n  /**\n   * Load specific range\n   */\n  async function loadRange(\n    seriesId: string,\n    startIndex: number,\n    endIndex: number\n  ): Promise<void> {\n    const seriesInfo = series.get(seriesId);\n    if (!seriesInfo) return;\n\n    const startChunk = getChunkIndex(startIndex);\n    const endChunk = getChunkIndex(endIndex);\n\n    for (let i = startChunk; i <= endChunk; i++) {\n      await loadChunk(seriesInfo, i);\n    }\n  }\n\n  /**\n   * Get loading status\n   */\n  function getLoadingStatus(seriesId: string) {\n    const seriesInfo = series.get(seriesId);\n    if (!seriesInfo) return null;\n\n    const loadedPoints = Array.from(seriesInfo.chunks.values()).reduce(\n      (sum, c) => sum + (c.endIndex - c.startIndex),\n      0\n    );\n\n    return {\n      loadedPoints,\n      totalPoints: seriesInfo.totalPoints,\n      loadedChunks: seriesInfo.chunks.size,\n      totalChunks: Math.ceil(seriesInfo.totalPoints / config.chunkSize),\n    };\n  }\n\n  /**\n   * Clear all data\n   */\n  function clear(): void {\n    for (const [, seriesInfo] of series) {\n      seriesInfo.chunks.clear();\n      seriesInfo.loading.clear();\n    }\n  }\n\n  /**\n   * Load a data window with optional buffer (viewport-aware windowing API).\n   */\n  async function setDataWindow(opts: {\n    from: number;\n    to: number;\n    buffer?: number;\n    seriesId?: string;\n  }): Promise<void> {\n    if (!ctx || !config.enabled) return;\n\n    const buffer = opts.buffer ?? config.viewportBuffer;\n    const span = opts.to - opts.from;\n    const startIndex = Math.max(0, Math.floor(opts.from - span * buffer));\n    const endIndex = Math.ceil(opts.to + span * buffer);\n\n    const targets = opts.seriesId\n      ? [[opts.seriesId, series.get(opts.seriesId)] as const]\n      : Array.from(series.entries()).map(([id, info]) => [id, info] as const);\n\n    for (const [seriesId, seriesInfo] of targets) {\n      if (!seriesInfo) continue;\n      await loadRange(seriesId, startIndex, endIndex);\n    }\n\n    if (config.autoUnload) {\n      unloadDistant();\n    }\n  }\n\n  // API implementation\n  const api: LazyLoadAPI & Record<string, unknown> = {\n    registerSeries,\n    unregisterSeries,\n    loadRange,\n    loadVisible,\n    unloadDistant,\n    setDataWindow,\n    getLoadingStatus,\n    clear,\n    updateConfig(newConfig: Partial<PluginLazyLoadConfig>) {\n      Object.assign(config, newConfig);\n    },\n  };\n\n  return {\n    manifest,\n\n    onInit(pluginCtx: PluginContext) {\n      ctx = pluginCtx;\n\n      // Attach to chart API\n      (ctx.chart as any).lazyLoad = api;\n      (ctx.chart as any).setDataWindow = (opts: {\n        from: number;\n        to: number;\n        buffer?: number;\n        seriesId?: string;\n      }) => setDataWindow(opts);\n\n      // Listen for zoom/pan if auto-load enabled\n      if (config.autoLoad) {\n        ctx.chart.on?.('zoom', () => {\n          loadVisible();\n          if (config.autoUnload) {\n            unloadDistant();\n          }\n        });\n\n        ctx.chart.on?.('pan', () => {\n          loadVisible();\n          if (config.autoUnload) {\n            unloadDistant();\n          }\n        });\n      }\n    },\n\n    onDestroy(pluginCtx: PluginContext) {\n      // Clear all data\n      clear();\n\n      // Remove from chart API\n      delete (pluginCtx.chart as any).lazyLoad;\n      delete (pluginCtx.chart as any).setDataWindow;\n\n      ctx = null;\n    },\n\n    api,\n  };\n}\n\nexport default PluginLazyLoad;\n\n// Type exports\nexport type {\n  PluginLazyLoadConfig,\n  LazyLoadAPI,\n  DataProvider,\n  DataChunk,\n  LoadProgressEvent,\n} from './types';\n"],"names":["manifest","DEFAULT_CONFIG","PluginLazyLoad","userConfig","config","ctx","series","getChunkIndex","pointIndex","getVisibleRange","bounds","loadChunk","seriesInfo","chunkIndex","startIndex","endIndex","chunk","updateSeriesData","loadedPoints","sum","c","totalChunks","event","error","_a","_b","sortedChunks","a","b","totalSize","x","y","offset","loadVisible","visibleRange","buffer","rangeWidth","buffered","chunksToLoad","startIdx","endIdx","i","maxToLoad","nextChunk","getKeepChunkRange","startChunk","endChunk","unloadDistant","unloadedCount","seriesUnloaded","visibleSpan","thresholdChunks","keepStart","keepEnd","toRemove","registerSeries","seriesId","provider","totalPoints","unregisterSeries","loadRange","getLoadingStatus","clear","setDataWindow","opts","span","targets","id","info","api","newConfig","pluginCtx","_c","_d"],"mappings":"AAkBA,MAAMA,IAA2B;AAAA,EAC/B,MAAM;AAAA,EACN,SAAS;AAAA,EACT,aAAa;AAAA,EACb,UAAU,CAAC,aAAa,gBAAgB;AAAA,EACxC,MAAM,CAAC,eAAe,QAAQ,cAAc;AAC9C,GAEMC,IAAiD;AAAA,EACrD,SAAS;AAAA,EACT,WAAW;AAAA,EACX,gBAAgB;AAAA,EAChB,UAAU;AAAA,EACV,YAAY;AAAA,EACZ,iBAAiB;AAAA,EACjB,iBAAiB;AAAA,EACjB,iBAAiB;AAAA,EACjB,aAAa,MAAM;AAAA,EAAC;AAAA,EACpB,gBAAgB,MAAM;AAAA,EAAC;AAAA,EACvB,gBAAgB,MAAM;AAAA,EAAC;AAAA,EACvB,aAAa,MAAM;AAAA,EAAC;AAAA,EACpB,OAAO;AACT;AAEO,SAASC,EACdC,IAA4C,IACT;AACnC,QAAMC,IAAS,EAAE,GAAGH,GAAgB,GAAGE,EAAA;AACvC,MAAIE,IAA4B;AAGhC,QAAMC,wBAAa,IAAA;AAKnB,WAASC,EAAcC,GAA4B;AACjD,WAAO,KAAK,MAAMA,IAAaJ,EAAO,SAAS;AAAA,EACjD;AAKA,WAASK,IAAyD;AAChE,QAAI,CAACJ,EAAK,QAAO;AAGjB,UAAMK,IAASL,EAAI,KAAK,cAAA;AACxB,WAAIK,IACK,EAAE,MAAMA,EAAO,MAAM,MAAMA,EAAO,KAAA,IAGpC;AAAA,EACT;AAKA,iBAAeC,EACbC,GACAC,GACe;AAEf,QAAI,EAAAD,EAAW,OAAO,IAAIC,CAAU,KAAKD,EAAW,QAAQ,IAAIC,CAAU,IAI1E;AAAA,MAAAD,EAAW,QAAQ,IAAIC,CAAU;AAEjC,UAAI;AACF,cAAMC,IAAaD,IAAaT,EAAO,WACjCW,IAAW,KAAK;AAAA,UACpBD,IAAaV,EAAO;AAAA,UACpBQ,EAAW;AAAA,QAAA;AAGb,QAAIR,EAAO,SACT,QAAQ,IAAI,4BAA4BS,CAAU,QAAQD,EAAW,EAAE,KAAKE,CAAU,IAAIC,CAAQ,GAAG;AAGvG,cAAMC,IAAQ,MAAMJ,EAAW,SAAS,UAAUE,GAAYC,CAAQ;AAEtE,QAAAH,EAAW,OAAO,IAAIC,GAAYG,CAAK,GACvCJ,EAAW,QAAQ,OAAOC,CAAU,GAGpC,MAAMI,EAAiBL,CAAU;AAGjC,cAAMM,IAAe,MAAM,KAAKN,EAAW,OAAO,OAAA,CAAQ,EAAE;AAAA,UAC1D,CAACO,GAAKC,MAAMD,KAAOC,EAAE,WAAWA,EAAE;AAAA,UAClC;AAAA,QAAA,GAGIC,IAAc,KAAK,KAAKT,EAAW,cAAcR,EAAO,SAAS,GAEjEkB,IAA2B;AAAA,UAC/B,UAAUV,EAAW;AAAA,UACrB,cAAAM;AAAA,UACA,aAAaN,EAAW;AAAA,UACxB,UAAUM,IAAeN,EAAW;AAAA,UACpC,cAAcC;AAAA,UACd,aAAAQ;AAAA,QAAA;AAGF,QAAIH,MAAiBN,EAAW,cAC9BR,EAAO,eAAekB,CAAK,IAE3BlB,EAAO,eAAekB,CAAK;AAAA,MAG/B,SAASC,GAAO;AACd,QAAAX,EAAW,QAAQ,OAAOC,CAAU,GACpCT,EAAO,YAAYmB,GAAgBX,EAAW,EAAE,GAE5CR,EAAO,SACT,QAAQ,MAAM,kCAAkCS,CAAU,KAAKU,CAAK;AAAA,MAExE;AAAA;AAAA,EACF;AAKA,iBAAeN,EAAiBL,GAA6C;AA5H/E,QAAAY,GAAAC;AA6HI,QAAI,CAACpB,EAAK;AAGV,UAAMqB,IAAe,MAAM,KAAKd,EAAW,OAAO,SAAS,EAAE,KAAK,CAACe,GAAGC,MAAMD,EAAE,CAAC,IAAIC,EAAE,CAAC,CAAC;AAEvF,QAAIF,EAAa,WAAW,EAAG;AAG/B,QAAIG,IAAY;AAChB,eAAW,CAAA,EAAGb,CAAK,KAAKU;AACtB,MAAAG,KAAab,EAAM,EAAE;AAIvB,UAAMc,IAAI,IAAI,aAAaD,CAAS,GAC9BE,IAAI,IAAI,aAAaF,CAAS;AAGpC,QAAIG,IAAS;AACb,eAAW,CAAA,EAAGhB,CAAK,KAAKU;AACtB,MAAAI,EAAE,IAAId,EAAM,GAAGgB,CAAM,GACrBD,EAAE,IAAIf,EAAM,GAAGgB,CAAM,GACrBA,KAAUhB,EAAM,EAAE;AAInB,KAAAS,KAAAD,IAAAnB,EAAI,OAAc,iBAAlB,QAAAoB,EAAA,KAAAD,GAAiCZ,EAAW,IAAI,EAAE,GAAAkB,GAAG,GAAAC;EACxD;AAKA,iBAAeE,IAA6B;AAC1C,QAAI,CAAC7B,EAAO,WAAW,CAACC,EAAK;AAE7B,UAAM6B,IAAezB,EAAA;AACrB,QAAI,CAACyB,EAAc;AAEnB,UAAMC,IAAS/B,EAAO,gBAChBgC,IAAaF,EAAa,OAAOA,EAAa,MAC9CG,IAAW;AAAA,MACf,MAAMH,EAAa,OAAOE,IAAaD;AAAA,MACvC,MAAMD,EAAa,OAAOE,IAAaD;AAAA,IAAA;AAGzC,eAAW,CAAA,EAAGvB,CAAU,KAAKN,GAAQ;AACnC,YAAMgC,IAAyB,CAAA,GACzBjB,IAAc,KAAK,KAAKT,EAAW,cAAcR,EAAO,SAAS,GAGjEmC,IAAW,KAAK,IAAI,GAAG,KAAK,MAAMF,EAAS,OAAOjC,EAAO,SAAS,CAAC,GACnEoC,IAAS,KAAK,IAAInB,IAAc,GAAG,KAAK,MAAMgB,EAAS,OAAOjC,EAAO,SAAS,CAAC;AAErF,eAASqC,IAAIF,GAAUE,KAAKD,GAAQC;AAClC,QAAI,CAAC7B,EAAW,OAAO,IAAI6B,CAAC,KAAK,CAAC7B,EAAW,QAAQ,IAAI6B,CAAC,KACxDH,EAAa,KAAKG,CAAC;AAKvB,YAAMC,IAAY,KAAK,IAAIJ,EAAa,QAAQ,EAAE;AAClD,eAASG,IAAI,GAAGA,IAAIC,GAAWD;AAC7B,cAAM9B,EAAUC,GAAY0B,EAAaG,CAAC,CAAC;AAI7C,UAAIrC,EAAO,mBAAmBoC,IAAS,IAAInB,GAAa;AACtD,cAAMsB,IAAYH,IAAS;AAC3B,QAAI,CAAC5B,EAAW,OAAO,IAAI+B,CAAS,KAAK,CAAC/B,EAAW,QAAQ,IAAI+B,CAAS,KACxEhC,EAAUC,GAAY+B,CAAS;AAAA,MAEnC;AAAA,IACF;AAAA,EACF;AAKA,WAASC,EACPhC,GACAsB,GAC0C;AAC1C,UAAMC,IAAS/B,EAAO,gBAChBgC,IAAaF,EAAa,OAAOA,EAAa,MAC9CG,IAAW;AAAA,MACf,MAAMH,EAAa,OAAOE,IAAaD;AAAA,MACvC,MAAMD,EAAa,OAAOE,IAAaD;AAAA,IAAA,GAEnCd,IAAc,KAAK,KAAKT,EAAW,cAAcR,EAAO,SAAS,GACjEyC,IAAa,KAAK,IAAI,GAAG,KAAK,MAAMR,EAAS,OAAOjC,EAAO,SAAS,CAAC,GACrE0C,IAAW,KAAK,IAAIzB,IAAc,GAAG,KAAK,MAAMgB,EAAS,OAAOjC,EAAO,SAAS,CAAC;AACvF,WAAO,EAAE,YAAAyC,GAAY,UAAAC,EAAA;AAAA,EACvB;AAKA,WAASC,IAAwB;AAC/B,QAAI,CAAC3C,EAAO,cAAc,CAACC,EAAK,QAAO;AAEvC,UAAM6B,IAAezB,EAAA;AACrB,QAAI,CAACyB,EAAc,QAAO;AAE1B,QAAIc,IAAgB;AAEpB,eAAW,CAAA,EAAGpC,CAAU,KAAKN,GAAQ;AACnC,UAAI2C,IAAiB;AACrB,YAAM,EAAE,YAAAJ,GAAY,UAAAC,EAAA,IAAaF,EAAkBhC,GAAYsB,CAAY,GACrEgB,IAAc,KAAK,IAAI,GAAGJ,IAAWD,IAAa,CAAC,GACnDM,IAAkB,KAAK,KAAK/C,EAAO,kBAAkB8C,CAAW,GAChEE,IAAY,KAAK,IAAI,GAAGP,IAAaM,CAAe,GACpDE,IAAUP,IAAWK;AAE3B,iBAAWtC,KAAc,MAAM,KAAKD,EAAW,OAAO,KAAA,CAAM;AAC1D,SAAIC,IAAauC,KAAavC,IAAawC,OACzCzC,EAAW,OAAO,OAAOC,CAAU,GACnCoC;AAKJ,UAAIrC,EAAW,OAAO,OAAOR,EAAO,iBAAiB;AACnD,cAAMsB,IAAe,MAAM,KAAKd,EAAW,OAAO,QAAA,CAAS,EAAE;AAAA,UAC3D,CAACe,GAAGC,MAAMD,EAAE,CAAC,EAAE,WAAWC,EAAE,CAAC,EAAE;AAAA,QAAA,GAG3B0B,IAAW1C,EAAW,OAAO,OAAOR,EAAO;AACjD,iBAASqC,IAAI,GAAGA,IAAIa,GAAUb;AAC5B,UAAA7B,EAAW,OAAO,OAAOc,EAAae,CAAC,EAAE,CAAC,CAAC,GAC3CQ;AAAA,MAEJ;AAEA,MAAIA,IAAiB,MACdhC,EAAiBL,CAAU,GAChCoC,KAAiBC;AAAA,IAErB;AAEA,WAAI7C,EAAO,SAAS4C,IAAgB,KAClC,QAAQ,IAAI,uBAAuBA,CAAa,SAAS,GAGpDA;AAAA,EACT;AAKA,WAASO,EAAeC,GAAkBC,GAA8B;AACtE,UAAMC,IAAcD,EAAS,cAAA;AAE7B,IAAAnD,EAAO,IAAIkD,GAAU;AAAA,MACnB,IAAIA;AAAA,MACJ,UAAAC;AAAA,MACA,4BAAY,IAAA;AAAA,MACZ,6BAAa,IAAA;AAAA,MACb,aAAAC;AAAA,IAAA,CACD,GAEGtD,EAAO,SACT,QAAQ,IAAI,gCAAgCoD,CAAQ,SAASE,CAAW,SAAS,GAInFtD,EAAO,YAAY;AAAA,MACjB,UAAAoD;AAAA,MACA,cAAc;AAAA,MACd,aAAAE;AAAA,MACA,UAAU;AAAA,MACV,cAAc;AAAA,MACd,aAAa,KAAK,KAAKA,IAActD,EAAO,SAAS;AAAA,IAAA,CACtD,GAGGA,EAAO,YACT6B,EAAA;AAAA,EAEJ;AAKA,WAAS0B,EAAiBH,GAAwB;AAChD,IAAAlD,EAAO,OAAOkD,CAAQ,GAElBpD,EAAO,SACT,QAAQ,IAAI,kCAAkCoD,CAAQ,EAAE;AAAA,EAE5D;AAKA,iBAAeI,EACbJ,GACA1C,GACAC,GACe;AACf,UAAMH,IAAaN,EAAO,IAAIkD,CAAQ;AACtC,QAAI,CAAC5C,EAAY;AAEjB,UAAMiC,IAAatC,EAAcO,CAAU,GACrCgC,IAAWvC,EAAcQ,CAAQ;AAEvC,aAAS,IAAI8B,GAAY,KAAKC,GAAU;AACtC,YAAMnC,EAAUC,GAAY,CAAC;AAAA,EAEjC;AAKA,WAASiD,EAAiBL,GAAkB;AAC1C,UAAM5C,IAAaN,EAAO,IAAIkD,CAAQ;AACtC,WAAK5C,IAOE;AAAA,MACL,cANmB,MAAM,KAAKA,EAAW,OAAO,OAAA,CAAQ,EAAE;AAAA,QAC1D,CAACO,GAAKC,MAAMD,KAAOC,EAAE,WAAWA,EAAE;AAAA,QAClC;AAAA,MAAA;AAAA,MAKA,aAAaR,EAAW;AAAA,MACxB,cAAcA,EAAW,OAAO;AAAA,MAChC,aAAa,KAAK,KAAKA,EAAW,cAAcR,EAAO,SAAS;AAAA,IAAA,IAX1C;AAAA,EAa1B;AAKA,WAAS0D,IAAc;AACrB,eAAW,CAAA,EAAGlD,CAAU,KAAKN;AAC3B,MAAAM,EAAW,OAAO,MAAA,GAClBA,EAAW,QAAQ,MAAA;AAAA,EAEvB;AAKA,iBAAemD,EAAcC,GAKX;AAChB,QAAI,CAAC3D,KAAO,CAACD,EAAO,QAAS;AAE7B,UAAM+B,IAAS6B,EAAK,UAAU5D,EAAO,gBAC/B6D,IAAOD,EAAK,KAAKA,EAAK,MACtBlD,IAAa,KAAK,IAAI,GAAG,KAAK,MAAMkD,EAAK,OAAOC,IAAO9B,CAAM,CAAC,GAC9DpB,IAAW,KAAK,KAAKiD,EAAK,KAAKC,IAAO9B,CAAM,GAE5C+B,IAAUF,EAAK,WACjB,CAAC,CAACA,EAAK,UAAU1D,EAAO,IAAI0D,EAAK,QAAQ,CAAC,CAAU,IACpD,MAAM,KAAK1D,EAAO,QAAA,CAAS,EAAE,IAAI,CAAC,CAAC6D,GAAIC,CAAI,MAAM,CAACD,GAAIC,CAAI,CAAU;AAExE,eAAW,CAACZ,GAAU5C,CAAU,KAAKsD;AACnC,MAAKtD,KACL,MAAMgD,EAAUJ,GAAU1C,GAAYC,CAAQ;AAGhD,IAAIX,EAAO,cACT2C,EAAA;AAAA,EAEJ;AAGA,QAAMsB,IAA6C;AAAA,IACjD,gBAAAd;AAAA,IACA,kBAAAI;AAAA,IACA,WAAAC;AAAA,IACA,aAAA3B;AAAA,IACA,eAAAc;AAAA,IACA,eAAAgB;AAAA,IACA,kBAAAF;AAAA,IACA,OAAAC;AAAA,IACA,aAAaQ,GAA0C;AACrD,aAAO,OAAOlE,GAAQkE,CAAS;AAAA,IACjC;AAAA,EAAA;AAGF,SAAO;AAAA,IACL,UAAAtE;AAAA,IAEA,OAAOuE,GAA0B;AA7ZrC,UAAA/C,GAAAC,GAAA+C,GAAAC;AA8ZM,MAAApE,IAAMkE,GAGLlE,EAAI,MAAc,WAAWgE,GAC7BhE,EAAI,MAAc,gBAAgB,CAAC2D,MAK9BD,EAAcC,CAAI,GAGpB5D,EAAO,cACTqB,KAAAD,IAAAnB,EAAI,OAAM,OAAV,QAAAoB,EAAA,KAAAD,GAAe,QAAQ,MAAM;AAC3B,QAAAS,EAAA,GACI7B,EAAO,cACT2C,EAAA;AAAA,MAEJ,KAEA0B,KAAAD,IAAAnE,EAAI,OAAM,OAAV,QAAAoE,EAAA,KAAAD,GAAe,OAAO,MAAM;AAC1B,QAAAvC,EAAA,GACI7B,EAAO,cACT2C,EAAA;AAAA,MAEJ;AAAA,IAEJ;AAAA,IAEA,UAAUwB,GAA0B;AAElC,MAAAT,EAAA,GAGA,OAAQS,EAAU,MAAc,UAChC,OAAQA,EAAU,MAAc,eAEhClE,IAAM;AAAA,IACR;AAAA,IAEA,KAAAgE;AAAA,EAAA;AAEJ;"}

package/dist/plugins/ml-integration.d.ts

@@ -0,0 +1,3 @@
+export * from './ml-integration/index'
+import SciPlot from './ml-integration/index'
+export default SciPlot

package/dist/plugins/ml-integration.js

@@ -0,0 +1,355 @@
+var A = Object.defineProperty;
+var X = (i, t, n) => t in i ? A(i, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : i[t] = n;
+var h = (i, t, n) => X(i, typeof t != "symbol" ? t + "" : t, n);
+class b {
+  constructor(t) {
+    h(this, "network");
+    h(this, "config");
+    h(this, "ready", !1);
+    this.config = t, this.network = {
+      layers: [],
+      learningRate: 0.01,
+      epochs: 100
+    };
+  }
+  get id() {
+    return this.config.id;
+  }
+  get name() {
+    return this.config.name;
+  }
+  get type() {
+    return this.config.type;
+  }
+  async predict(t) {
+    const n = performance.now(), e = Array.from(t.data), r = this.forwardPass(e), o = performance.now() - n;
+    return {
+      modelId: this.config.id,
+      output: new Float32Array(r),
+      outputShape: [r.length],
+      timestamp: Date.now(),
+      processingTime: o
+    };
+  }
+  forwardPass(t) {
+    let n = t;
+    for (const e of this.network.layers)
+      e.type === "dense" && (n = this.denseLayer(n, e.weights, e.biases)), e.activation && (n = this.applyActivation(n, e.activation));
+    return n;
+  }
+  denseLayer(t, n, e) {
+    const r = [];
+    for (let o = 0; o < n.length; o++) {
+      let s = e[o];
+      for (let l = 0; l < t.length; l++)
+        s += t[l] * n[o][l];
+      r.push(s);
+    }
+    return r;
+  }
+  applyActivation(t, n) {
+    switch (n) {
+      case "relu":
+        return t.map((e) => Math.max(0, e));
+      case "sigmoid":
+        return t.map((e) => 1 / (1 + Math.exp(-e)));
+      case "tanh":
+        return t.map((e) => Math.tanh(e));
+      default:
+        return t;
+    }
+  }
+  getInfo() {
+    return { ...this.config };
+  }
+  isReady() {
+    return this.ready;
+  }
+  async warmup() {
+    const t = new Array(10).fill(0.1);
+    await this.predict({ data: t }), this.ready = !0;
+  }
+  dispose() {
+    this.ready = !1;
+  }
+}
+class R {
+  constructor(t) {
+    h(this, "config");
+    h(this, "coefficients", []);
+    h(this, "intercept", 0);
+    h(this, "ready", !1);
+    this.config = t;
+  }
+  get id() {
+    return this.config.id;
+  }
+  get name() {
+    return this.config.name;
+  }
+  get type() {
+    return this.config.type;
+  }
+  async predict(t) {
+    const n = performance.now(), r = Array.from(t.data).map((s) => {
+      let l = this.intercept;
+      for (let a = 0; a < this.coefficients.length && a < s; a++)
+        l += this.coefficients[a] * s;
+      return l;
+    }), o = performance.now() - n;
+    return {
+      modelId: this.config.id,
+      output: new Float32Array(r),
+      outputShape: [r.length],
+      timestamp: Date.now(),
+      processingTime: o
+    };
+  }
+  train(t) {
+    const n = t.x.length, e = [];
+    for (let a = 0; a < n; a++)
+      e.push([1, ...t.x[a]]);
+    const r = this.matrixMultiply(this.transpose(e), e), o = this.matrixMultiply(this.transpose(e), t.y.map((a) => [a])), s = this.matrixInverse(r), l = this.matrixMultiply(s, o);
+    this.intercept = l[0][0], this.coefficients = l.slice(1).map((a) => a[0]), this.ready = !0;
+  }
+  transpose(t) {
+    return t[0].map((n, e) => t.map((r) => r[e]));
+  }
+  matrixMultiply(t, n) {
+    const e = [];
+    for (let r = 0; r < t.length; r++) {
+      e[r] = [];
+      for (let o = 0; o < n[0].length; o++) {
+        let s = 0;
+        for (let l = 0; l < n.length; l++)
+          s += t[r][l] * n[l][o];
+        e[r][o] = s;
+      }
+    }
+    return e;
+  }
+  matrixInverse(t) {
+    if (t.length === 2 && t[0].length === 2) {
+      const n = t[0][0] * t[1][1] - t[0][1] * t[1][0];
+      if (Math.abs(n) < 1e-10)
+        return [[1, 0], [0, 1]];
+      const e = 1 / n;
+      return [
+        [e * t[1][1], -e * t[0][1]],
+        [-e * t[1][0], e * t[0][0]]
+      ];
+    }
+    return t.map((n, e) => n.map((r, o) => e === o ? 1 : 0));
+  }
+  getInfo() {
+    return { ...this.config };
+  }
+  isReady() {
+    return this.ready;
+  }
+  async warmup() {
+    this.coefficients = [1], this.intercept = 0, this.ready = !0;
+  }
+  dispose() {
+    this.ready = !1;
+  }
+}
+class k {
+  constructor(t) {
+    h(this, "config");
+    h(this, "filterType");
+    h(this, "cutoffFrequency");
+    h(this, "sampleRate");
+    h(this, "ready", !1);
+    var n, e, r;
+    this.config = t, this.filterType = ((n = t.metadata) == null ? void 0 : n.filterType) || "lowpass", this.cutoffFrequency = ((e = t.metadata) == null ? void 0 : e.cutoffFrequency) || 1e3, this.sampleRate = ((r = t.metadata) == null ? void 0 : r.sampleRate) || 44100;
+  }
+  get id() {
+    return this.config.id;
+  }
+  get name() {
+    return this.config.name;
+  }
+  get type() {
+    return this.config.type;
+  }
+  async predict(t) {
+    const n = performance.now(), e = Array.from(t.data), r = this.applyFilter(e), o = performance.now() - n;
+    return {
+      modelId: this.config.id,
+      output: new Float32Array(r),
+      outputShape: [r.length],
+      timestamp: Date.now(),
+      processingTime: o
+    };
+  }
+  applyFilter(t) {
+    switch (this.filterType) {
+      case "lowpass":
+        return this.lowpassFilter(t);
+      case "highpass":
+        return this.highpassFilter(t);
+      case "bandpass":
+        return this.bandpassFilter(t);
+      default:
+        return t;
+    }
+  }
+  lowpassFilter(t) {
+    const n = 2 * Math.PI * this.cutoffFrequency / this.sampleRate, e = n / (1 + n), r = [t[0]];
+    for (let o = 1; o < t.length; o++)
+      r.push(e * t[o] + (1 - e) * r[o - 1]);
+    return r;
+  }
+  highpassFilter(t) {
+    const n = [];
+    for (let e = 1; e < t.length; e++)
+      n.push(t[e] - t[e - 1]);
+    return n;
+  }
+  bandpassFilter(t) {
+    const n = this.lowpassFilter(t);
+    return this.highpassFilter(n);
+  }
+  getInfo() {
+    return { ...this.config };
+  }
+  isReady() {
+    return this.ready;
+  }
+  async warmup() {
+    this.ready = !0;
+  }
+  dispose() {
+    this.ready = !1;
+  }
+}
+function q(i) {
+  switch (i.type) {
+    case "neural-network":
+      return new b(i);
+    case "linear-regression":
+      return new R(i);
+    case "signal-processor":
+      return new k(i);
+    default:
+      return new R(i);
+  }
+}
+function L(i) {
+  const t = i.length, n = new Array(t), e = new Array(t);
+  for (let r = 0; r < t; r++) {
+    let o = 0, s = 0;
+    for (let l = 0; l < t; l++) {
+      const a = -2 * Math.PI * r * l / t;
+      o += i[l] * Math.cos(a), s += i[l] * Math.sin(a);
+    }
+    n[r] = o, e[r] = s;
+  }
+  return { real: n, imag: e };
+}
+function F(i) {
+  return i.reduce((t, n) => t + n, 0) / i.length;
+}
+function Y(i) {
+  const t = F(i), n = i.reduce((e, r) => e + Math.pow(r - t, 2), 0) / i.length;
+  return Math.sqrt(n);
+}
+function z(i, t) {
+  const n = i.length, e = F(i), r = F(t);
+  let o = 0, s = 0, l = 0;
+  for (let a = 0; a < n; a++) {
+    const c = i[a] - e, f = t[a] - r;
+    o += c * f, s += c * c, l += f * f;
+  }
+  return o / Math.sqrt(s * l);
+}
+const N = {
+  name: "velo-plot-ml-integration",
+  version: "1.0.0",
+  description: "Machine Learning Integration Bridge for Sci Plot",
+  provides: ["ml", "prediction", "inference"],
+  tags: ["ml", "ai", "analysis"]
+};
+function $(i = {}) {
+  let t = null;
+  const n = /* @__PURE__ */ new Map(), e = /* @__PURE__ */ new Map();
+  i.models && i.models.forEach((s) => n.set(s.id, q(s)));
+  const r = {
+    registerModel(s) {
+      if (!s.id) {
+        t == null || t.log.error("Cannot register model without id");
+        return;
+      }
+      n.set(s.id, s), t == null || t.log.info(`Model registered: ${s.name || "Unnamed"} (${s.id})`);
+    },
+    async runInference(s, l) {
+      const a = n.get(s);
+      if (!a) throw new Error(`Model not found: ${s}`);
+      const c = t == null ? void 0 : t.data.getSeriesData(l);
+      if (!c) throw new Error(`Series not found: ${l}`);
+      const f = new Float32Array(c.y), m = await a.predict({ data: f });
+      return m.xValues = c.x, m;
+    },
+    visualizeResults(s, l = {}) {
+      const a = `ml-viz-${Math.random().toString(36).substr(2, 9)}`;
+      return e.set(a, {
+        result: s,
+        config: { ...i.defaultVisualization, ...l }
+      }), t == null || t.requestRender(), a;
+    },
+    clearResults(s) {
+      s ? e.delete(s) : e.clear(), t == null || t.requestRender();
+    },
+    stats: {
+      fft: L,
+      mean: F,
+      standardDeviation: Y,
+      correlation: z
+    }
+  };
+  function o(s) {
+    const { render: l, coords: a } = s, { ctx2d: c } = l;
+    c && e.forEach((f) => {
+      var S, I, P, D;
+      const { result: m, config: p } = f, { output: w, xValues: y, confidence: v } = m;
+      if (!y) return;
+      const M = Math.min(y.length, w.length);
+      if (c.save(), p.showConfidenceInterval && v && v.length === M) {
+        c.beginPath();
+        const d = p.intervalOpacity ?? 0.2;
+        c.fillStyle = (((S = p.lineStyle) == null ? void 0 : S.color) || "#3b82f6") + Math.floor(d * 255).toString(16).padStart(2, "0");
+        for (let u = 0; u < M; u++) {
+          const g = a.dataToPixelX(y[u]), T = a.dataToPixelY(w[u] + v[u]);
+          u === 0 ? c.moveTo(g, T) : c.lineTo(g, T);
+        }
+        for (let u = M - 1; u >= 0; u--) {
+          const g = a.dataToPixelX(y[u]), T = a.dataToPixelY(w[u] - v[u]);
+          c.lineTo(g, T);
+        }
+        c.closePath(), c.fill();
+      }
+      c.beginPath(), c.strokeStyle = ((I = p.lineStyle) == null ? void 0 : I.color) || "#3b82f6", c.lineWidth = ((P = p.lineStyle) == null ? void 0 : P.width) || 2, (D = p.lineStyle) != null && D.dash && c.setLineDash(p.lineStyle.dash);
+      for (let d = 0; d < M; d++) {
+        const u = a.dataToPixelX(y[d]), g = a.dataToPixelY(w[d]);
+        d === 0 ? c.moveTo(u, g) : c.lineTo(u, g);
+      }
+      c.stroke(), c.restore();
+    });
+  }
+  return {
+    manifest: N,
+    onInit(s) {
+      t = s;
+    },
+    onRenderOverlay(s, l) {
+      o(s);
+    },
+    api: r
+  };
+}
+export {
+  $ as PluginMLIntegration,
+  $ as default
+};
+//# sourceMappingURL=ml-integration.js.map