@chartts/core 0.1.0

package/dist/index.js

@@ -0,0 +1,1201 @@
+import { stepChartType } from './chunk-QAYX6XN3.js';
+export { stepChartType } from './chunk-QAYX6XN3.js';
+import { volumeChartType } from './chunk-SUNC3CPV.js';
+export { volumeChartType } from './chunk-SUNC3CPV.js';
+import { rangeChartType } from './chunk-NFD6VAVM.js';
+export { rangeChartType } from './chunk-NFD6VAVM.js';
+import { baselineChartType } from './chunk-SJS4ISBA.js';
+export { baselineChartType } from './chunk-SJS4ISBA.js';
+import { kagiChartType } from './chunk-TOS2RYHQ.js';
+export { kagiChartType } from './chunk-TOS2RYHQ.js';
+import { renkoChartType } from './chunk-N6IVODRJ.js';
+export { renkoChartType } from './chunk-N6IVODRJ.js';
+export { atr, bollingerBands, cumulativeReturns, drawdown, ema, logReturns, macd, maxDrawdown, obv, rsi, sharpeRatio, simpleReturns, sma, stochastic, toBollingerData, toMACDData, toOHLC, volatility, volumeDirections, vwap, wma } from './chunk-6YKFTEX4.js';
+import { themeRiverChartType } from './chunk-NMLDPXOL.js';
+export { themeRiverChartType } from './chunk-NMLDPXOL.js';
+import { pictorialBarChartType } from './chunk-4VG47RLS.js';
+export { pictorialBarChartType } from './chunk-4VG47RLS.js';
+import { chordChartType } from './chunk-O5KGKQSU.js';
+export { chordChartType } from './chunk-O5KGKQSU.js';
+import { geoChartType } from './chunk-JO6U4YR4.js';
+export { WORLD_REGIONS, WORLD_SIMPLE, geoChartType } from './chunk-JO6U4YR4.js';
+import { linesChartType } from './chunk-22LR6CFM.js';
+export { linesChartType } from './chunk-22LR6CFM.js';
+import { matrixChartType } from './chunk-7YV56WPE.js';
+export { matrixChartType } from './chunk-7YV56WPE.js';
+import { customChartType } from './chunk-D2SV6YT3.js';
+export { customChartType } from './chunk-D2SV6YT3.js';
+import { ohlcChartType } from './chunk-FUZFNUCJ.js';
+export { ohlcChartType } from './chunk-FUZFNUCJ.js';
+import { dumbbellChartType } from './chunk-SQJAKZ4W.js';
+export { dumbbellChartType } from './chunk-SQJAKZ4W.js';
+import { calendarChartType } from './chunk-BR3KTAGW.js';
+export { calendarChartType } from './chunk-BR3KTAGW.js';
+import { comboChartType } from './chunk-TW6KPQIS.js';
+export { comboChartType } from './chunk-TW6KPQIS.js';
+import { sankeyChartType } from './chunk-QIJZZOX7.js';
+export { sankeyChartType } from './chunk-QIJZZOX7.js';
+import { sunburstChartType } from './chunk-HOOOCSU4.js';
+export { sunburstChartType } from './chunk-HOOOCSU4.js';
+import { treeChartType } from './chunk-X2JNB5UN.js';
+export { treeChartType } from './chunk-X2JNB5UN.js';
+import { graphChartType } from './chunk-DNQ6N3VG.js';
+export { graphChartType } from './chunk-DNQ6N3VG.js';
+import { parallelChartType } from './chunk-KVI6DN3R.js';
+export { parallelChartType } from './chunk-KVI6DN3R.js';
+import { heatmapChartType } from './chunk-QZ4ZYTP6.js';
+export { heatmapChartType } from './chunk-QZ4ZYTP6.js';
+import { boxplotChartType } from './chunk-NQSC7CKN.js';
+export { boxplotChartType } from './chunk-NQSC7CKN.js';
+import { histogramChartType } from './chunk-6LKN3HRX.js';
+export { histogramChartType } from './chunk-6LKN3HRX.js';
+import { treemapChartType } from './chunk-LUTU4WW3.js';
+export { treemapChartType } from './chunk-LUTU4WW3.js';
+import { polarChartType } from './chunk-FKYNRMPX.js';
+export { polarChartType } from './chunk-FKYNRMPX.js';
+import { radialBarChartType } from './chunk-HDWWUEPD.js';
+export { radialBarChartType } from './chunk-HDWWUEPD.js';
+import { lollipopChartType } from './chunk-NYVFC2SF.js';
+export { lollipopChartType } from './chunk-NYVFC2SF.js';
+import { bulletChartType } from './chunk-66HSJRRH.js';
+export { bulletChartType } from './chunk-66HSJRRH.js';
+import { sparklineChartType } from './chunk-7SEHTEMR.js';
+export { sparklineChartType } from './chunk-7SEHTEMR.js';
+import { areaChartType } from './chunk-BRSHEDTZ.js';
+export { areaChartType } from './chunk-BRSHEDTZ.js';
+import { radarChartType } from './chunk-CMEXNS5V.js';
+export { radarChartType } from './chunk-CMEXNS5V.js';
+import { bubbleChartType } from './chunk-6N66T7VQ.js';
+export { bubbleChartType } from './chunk-6N66T7VQ.js';
+import { candlestickChartType } from './chunk-LB4MV5CG.js';
+export { candlestickChartType } from './chunk-LB4MV5CG.js';
+import { gaugeChartType } from './chunk-6KNBJ4CE.js';
+export { gaugeChartType } from './chunk-6KNBJ4CE.js';
+import { waterfallChartType } from './chunk-7CGXK7KT.js';
+export { waterfallChartType } from './chunk-7CGXK7KT.js';
+import { funnelChartType } from './chunk-SZVK6RRQ.js';
+export { funnelChartType } from './chunk-SZVK6RRQ.js';
+import { lineChartType } from './chunk-BC6KW2OG.js';
+export { lineChartType } from './chunk-BC6KW2OG.js';
+import { barChartType } from './chunk-MLX3EO2C.js';
+export { barChartType } from './chunk-MLX3EO2C.js';
+import { stackedBarChartType } from './chunk-E2S7RAT2.js';
+export { stackedBarChartType } from './chunk-E2S7RAT2.js';
+import { horizontalBarChartType } from './chunk-H2AE7JMU.js';
+export { horizontalBarChartType } from './chunk-H2AE7JMU.js';
+import './chunk-E6PR75X7.js';
+export { formatPercent, formatValue } from './chunk-OGSZO22B.js';
+import { pieChartType, donutChartType } from './chunk-SWYCVF46.js';
+export { donutChartType, pieChartType } from './chunk-SWYCVF46.js';
+import './chunk-3XVGEBR4.js';
+import { scatterChartType } from './chunk-ZL25X5WW.js';
+export { scatterChartType } from './chunk-ZL25X5WW.js';
+import { createChart, rect, PathBuilder, path, text, group, line, circle } from './chunk-3BRQGYDX.js';
+export { CORPORATE_THEME, CSS_PREFIX, DARK_THEME, EDITORIAL_THEME, LIGHT_THEME, OCEAN_THEME, PALETTE, SAAS_THEME, STARTUP_THEME, THEME_PRESETS, applyTheme, createBrush, createCanvasRenderer, createCategoricalScale, createChart, createDebugPanel, createEventBus, createLinearScale, createSVGRenderer, createWebGLRenderer, createZoomPan, decimateData, renderToString, resolveTheme } from './chunk-3BRQGYDX.js';
+
+// src/api/convenience.ts
+function Line(target, config) {
+  const { data, ...options } = config;
+  return createChart(target, lineChartType, data, options);
+}
+function Bar(target, config) {
+  const { data, ...options } = config;
+  return createChart(target, barChartType, data, options);
+}
+function StackedBar(target, config) {
+  const { data, ...options } = config;
+  return createChart(target, stackedBarChartType, data, options);
+}
+function HorizontalBar(target, config) {
+  const { data, ...options } = config;
+  return createChart(target, horizontalBarChartType, data, options);
+}
+function Pie(target, config) {
+  const { data, ...options } = config;
+  return createChart(target, pieChartType, data, options);
+}
+function Donut(target, config) {
+  const { data, ...options } = config;
+  return createChart(target, donutChartType, data, options);
+}
+function Scatter(target, config) {
+  const { data, ...options } = config;
+  return createChart(target, scatterChartType, data, options);
+}
+function Sparkline(target, config) {
+  const { data, ...options } = config;
+  return createChart(target, sparklineChartType, data, options);
+}
+function Area(target, config) {
+  const { data, ...options } = config;
+  return createChart(target, areaChartType, data, options);
+}
+function Radar(target, config) {
+  const { data, ...options } = config;
+  return createChart(target, radarChartType, data, options);
+}
+function Bubble(target, config) {
+  const { data, ...options } = config;
+  return createChart(target, bubbleChartType, data, options);
+}
+function Candlestick(target, config) {
+  const { data, ...options } = config;
+  return createChart(target, candlestickChartType, data, options);
+}
+function Gauge(target, config) {
+  const { data, ...options } = config;
+  return createChart(target, gaugeChartType, data, options);
+}
+function Waterfall(target, config) {
+  const { data, ...options } = config;
+  return createChart(target, waterfallChartType, data, options);
+}
+function Funnel(target, config) {
+  const { data, ...options } = config;
+  return createChart(target, funnelChartType, data, options);
+}
+function Heatmap(target, config) {
+  const { data, ...options } = config;
+  return createChart(target, heatmapChartType, data, options);
+}
+function Boxplot(target, config) {
+  const { data, ...options } = config;
+  return createChart(target, boxplotChartType, data, options);
+}
+function Histogram(target, config) {
+  const { data, ...options } = config;
+  return createChart(target, histogramChartType, data, options);
+}
+function Treemap(target, config) {
+  const { data, ...options } = config;
+  return createChart(target, treemapChartType, data, options);
+}
+function Polar(target, config) {
+  const { data, ...options } = config;
+  return createChart(target, polarChartType, data, options);
+}
+function RadialBar(target, config) {
+  const { data, ...options } = config;
+  return createChart(target, radialBarChartType, data, options);
+}
+function Lollipop(target, config) {
+  const { data, ...options } = config;
+  return createChart(target, lollipopChartType, data, options);
+}
+function Bullet(target, config) {
+  const { data, ...options } = config;
+  return createChart(target, bulletChartType, data, options);
+}
+function Dumbbell(target, config) {
+  const { data, ...options } = config;
+  return createChart(target, dumbbellChartType, data, options);
+}
+function Calendar(target, config) {
+  const { data, ...options } = config;
+  return createChart(target, calendarChartType, data, options);
+}
+function Combo(target, config) {
+  const { data, ...options } = config;
+  return createChart(target, comboChartType, data, options);
+}
+function Sankey(target, config) {
+  const { data, ...options } = config;
+  return createChart(target, sankeyChartType, data, options);
+}
+function Sunburst(target, config) {
+  const { data, ...options } = config;
+  return createChart(target, sunburstChartType, data, options);
+}
+function Tree(target, config) {
+  const { data, ...options } = config;
+  return createChart(target, treeChartType, data, options);
+}
+function Graph(target, config) {
+  const { data, ...options } = config;
+  return createChart(target, graphChartType, data, options);
+}
+function Parallel(target, config) {
+  const { data, ...options } = config;
+  return createChart(target, parallelChartType, data, options);
+}
+function ThemeRiver(target, config) {
+  const { data, ...options } = config;
+  return createChart(target, themeRiverChartType, data, options);
+}
+function PictorialBar(target, config) {
+  const { data, ...options } = config;
+  return createChart(target, pictorialBarChartType, data, options);
+}
+function Chord(target, config) {
+  const { data, ...options } = config;
+  return createChart(target, chordChartType, data, options);
+}
+function Geo(target, config) {
+  const { data, ...options } = config;
+  return createChart(target, geoChartType, data, options);
+}
+function Lines(target, config) {
+  const { data, ...options } = config;
+  return createChart(target, linesChartType, data, options);
+}
+function Matrix(target, config) {
+  const { data, ...options } = config;
+  return createChart(target, matrixChartType, data, options);
+}
+function Custom(target, config) {
+  const { data, ...options } = config;
+  return createChart(target, customChartType, data, options);
+}
+function OHLC(target, config) {
+  const { data, ...options } = config;
+  return createChart(target, ohlcChartType, data, options);
+}
+function Step(target, config) {
+  const { data, ...options } = config;
+  return createChart(target, stepChartType, data, options);
+}
+function Volume(target, config) {
+  const { data, ...options } = config;
+  return createChart(target, volumeChartType, data, options);
+}
+function Range(target, config) {
+  const { data, ...options } = config;
+  return createChart(target, rangeChartType, data, options);
+}
+function Baseline(target, config) {
+  const { data, ...options } = config;
+  return createChart(target, baselineChartType, data, options);
+}
+function Kagi(target, config) {
+  const { data, ...options } = config;
+  return createChart(target, kagiChartType, data, options);
+}
+function Renko(target, config) {
+  const { data, ...options } = config;
+  return createChart(target, renkoChartType, data, options);
+}
+
+// src/interaction/link.ts
+function linkCharts(...charts2) {
+  if (charts2.length < 2) return () => {
+  };
+  let broadcasting = false;
+  const unsubs = [];
+  for (const chart of charts2) {
+    const unsub = chart.on("crosshair:move", (payload) => {
+      if (broadcasting) return;
+      broadcasting = true;
+      const { x, label } = payload;
+      for (const other of charts2) {
+        if (other === chart) continue;
+        other._bus.emit("crosshair:move", { x, label });
+      }
+      broadcasting = false;
+    });
+    unsubs.push(unsub);
+    const unsubHide = chart.on("crosshair:hide", () => {
+      if (broadcasting) return;
+      broadcasting = true;
+      for (const other of charts2) {
+        if (other === chart) continue;
+        other._bus.emit("crosshair:hide", void 0);
+      }
+      broadcasting = false;
+    });
+    unsubs.push(unsubHide);
+  }
+  return () => {
+    for (const unsub of unsubs) unsub();
+    unsubs.length = 0;
+  };
+}
+
+// src/data/streaming.ts
+function createStreamingChart(chart, config = {}) {
+  const windowSize = config.windowSize ?? 100;
+  const seriesCount = config.seriesCount ?? 1;
+  const maxBuffer = config.maxBufferSize ?? windowSize * 10;
+  const throttleMs = config.throttleMs ?? 0;
+  const names = config.seriesNames ?? Array.from({ length: seriesCount }, (_, i) => `Series ${i + 1}`);
+  const colors = config.seriesColors ?? [];
+  const buffers = Array.from({ length: seriesCount }, () => []);
+  const labels = [];
+  let totalPushed = 0;
+  let paused = false;
+  let dirty = false;
+  let rafId = null;
+  let throttleTimer = null;
+  function scheduleUpdate() {
+    if (paused) {
+      dirty = true;
+      return;
+    }
+    if (throttleMs > 0) {
+      if (throttleTimer !== null) return;
+      throttleTimer = setTimeout(() => {
+        throttleTimer = null;
+        flush();
+      }, throttleMs);
+    } else {
+      if (rafId !== null) return;
+      rafId = requestAnimationFrame(() => {
+        rafId = null;
+        flush();
+      });
+    }
+  }
+  function flush() {
+    dirty = false;
+    const start = Math.max(0, labels.length - windowSize);
+    const windowLabels = labels.slice(start);
+    const series = buffers.map((buf, i) => ({
+      name: names[i] ?? `Series ${i + 1}`,
+      values: buf.slice(start),
+      ...colors[i] ? { color: colors[i] } : {}
+    }));
+    const data = {
+      labels: windowLabels,
+      series
+    };
+    chart.setData(data);
+  }
+  function trimBuffer() {
+    if (labels.length <= maxBuffer) return;
+    const excess = labels.length - maxBuffer;
+    labels.splice(0, excess);
+    for (const buf of buffers) {
+      buf.splice(0, excess);
+    }
+  }
+  return {
+    push(values, label) {
+      totalPushed++;
+      const lbl = label ?? totalPushed;
+      labels.push(lbl);
+      for (let i = 0; i < seriesCount; i++) {
+        buffers[i].push(values[i] ?? 0);
+      }
+      trimBuffer();
+      scheduleUpdate();
+    },
+    pushBatch(points) {
+      for (const pt of points) {
+        totalPushed++;
+        const lbl = pt.label ?? totalPushed;
+        labels.push(lbl);
+        for (let i = 0; i < seriesCount; i++) {
+          buffers[i].push(pt.values[i] ?? 0);
+        }
+      }
+      trimBuffer();
+      scheduleUpdate();
+    },
+    pause() {
+      paused = true;
+    },
+    resume() {
+      paused = false;
+      if (dirty) scheduleUpdate();
+    },
+    clear() {
+      labels.length = 0;
+      for (const buf of buffers) buf.length = 0;
+      totalPushed = 0;
+      dirty = false;
+    },
+    getBufferSize() {
+      return labels.length;
+    },
+    destroy() {
+      if (rafId !== null) cancelAnimationFrame(rafId);
+      if (throttleTimer !== null) clearTimeout(throttleTimer);
+      labels.length = 0;
+      for (const buf of buffers) buf.length = 0;
+    }
+  };
+}
+
+// src/features/dataset.ts
+function getLabels(data) {
+  return data.labels ?? [];
+}
+function filterData(data, predicate) {
+  const labels = getLabels(data);
+  const keepIndices = labels.map(
+    (_, i) => data.series.some((s, si) => predicate(s.values[i] ?? 0, i, si)) ? i : -1
+  ).filter((i) => i >= 0);
+  return {
+    ...data,
+    series: data.series.map((s, si) => ({
+      ...s,
+      values: s.values.filter((v, i) => predicate(v, i, si))
+    })),
+    labels: keepIndices.map((i) => labels[i])
+  };
+}
+function filterSeries(data, keep) {
+  return {
+    ...data,
+    series: data.series.filter(
+      (s, i) => keep.includes(s.name) || keep.includes(i)
+    )
+  };
+}
+function filterLabels(data, keep) {
+  const labels = getLabels(data);
+  const keepSet = new Set(keep.map(String));
+  const indices = labels.map((l, i) => keepSet.has(String(l)) ? i : -1).filter((i) => i >= 0);
+  return {
+    ...data,
+    labels: indices.map((i) => labels[i]),
+    series: data.series.map((s) => ({
+      ...s,
+      values: indices.map((i) => s.values[i] ?? 0)
+    }))
+  };
+}
+function sortData(data, by, direction = "asc") {
+  const labels = getLabels(data);
+  const indices = labels.map((_, i) => i);
+  const dir = direction === "asc" ? 1 : -1;
+  if (by === "label") {
+    indices.sort((a, b) => dir * String(labels[a]).localeCompare(String(labels[b])));
+  } else {
+    const series = data.series[by];
+    if (series) {
+      indices.sort((a, b) => dir * ((series.values[a] ?? 0) - (series.values[b] ?? 0)));
+    }
+  }
+  return {
+    ...data,
+    labels: indices.map((i) => labels[i]),
+    series: data.series.map((s) => ({
+      ...s,
+      values: indices.map((i) => s.values[i] ?? 0)
+    }))
+  };
+}
+function aggregateData(data, fn = "sum") {
+  const labels = getLabels(data);
+  const agg = getAggFn(fn);
+  const values = labels.map((_, i) => {
+    const vals = data.series.map((s) => s.values[i] ?? 0);
+    return agg(vals);
+  });
+  return {
+    ...data,
+    series: [{ name: fn, values }]
+  };
+}
+function getAggFn(fn) {
+  switch (fn) {
+    case "sum":
+      return (vals) => vals.reduce((a, b) => a + b, 0);
+    case "avg":
+      return (vals) => vals.length > 0 ? vals.reduce((a, b) => a + b, 0) / vals.length : 0;
+    case "min":
+      return (vals) => Math.min(...vals);
+    case "max":
+      return (vals) => Math.max(...vals);
+    case "count":
+      return (vals) => vals.filter((v) => v !== 0).length;
+  }
+}
+function transformData(data, ...transforms) {
+  return transforms.reduce((d, fn) => fn(d), data);
+}
+function pivotData(data) {
+  const labels = getLabels(data);
+  const newLabels = data.series.map((s) => s.name);
+  const newSeries = labels.map((label, i) => ({
+    name: String(label),
+    values: data.series.map((s) => s.values[i] ?? 0)
+  }));
+  return { labels: newLabels, series: newSeries };
+}
+function sliceData(data, start, end) {
+  const labels = getLabels(data);
+  return {
+    ...data,
+    labels: labels.slice(start, end),
+    series: data.series.map((s) => ({
+      ...s,
+      values: s.values.slice(start, end)
+    }))
+  };
+}
+
+// src/features/datazoom.ts
+function createDataZoomState(initial, onChange) {
+  const range = {
+    start: initial?.start ?? 0,
+    end: initial?.end ?? 1
+  };
+  function clamp() {
+    range.start = Math.max(0, Math.min(range.start, 1));
+    range.end = Math.max(range.start + 0.01, Math.min(range.end, 1));
+    onChange?.(range);
+  }
+  return {
+    range,
+    setRange(start, end) {
+      range.start = start;
+      range.end = end;
+      clamp();
+    },
+    reset() {
+      range.start = 0;
+      range.end = 1;
+      onChange?.(range);
+    },
+    zoomIn(factor = 0.1) {
+      const center = (range.start + range.end) / 2;
+      const halfSpan = (range.end - range.start) / 2 * (1 - factor);
+      range.start = center - halfSpan;
+      range.end = center + halfSpan;
+      clamp();
+    },
+    zoomOut(factor = 0.1) {
+      const center = (range.start + range.end) / 2;
+      const halfSpan = (range.end - range.start) / 2 * (1 + factor);
+      range.start = center - halfSpan;
+      range.end = center + halfSpan;
+      clamp();
+    },
+    panLeft(amount = 0.05) {
+      const span = range.end - range.start;
+      range.start = Math.max(0, range.start - amount);
+      range.end = range.start + span;
+      clamp();
+    },
+    panRight(amount = 0.05) {
+      const span = range.end - range.start;
+      range.end = Math.min(1, range.end + amount);
+      range.start = range.end - span;
+      clamp();
+    }
+  };
+}
+function applyDataZoom(data, range) {
+  const labels = data.labels ?? [];
+  const total = labels.length;
+  if (total === 0) return data;
+  const startIdx = Math.floor(range.start * total);
+  const endIdx = Math.ceil(range.end * total);
+  return {
+    ...data,
+    labels: labels.slice(startIdx, endIdx),
+    series: data.series.map((s) => ({
+      ...s,
+      values: s.values.slice(startIdx, endIdx)
+    }))
+  };
+}
+function renderDataZoomSlider(data, range, opts) {
+  const nodes = [];
+  const h = opts.height ?? 30;
+  const trackColor = opts.trackColor ?? "#e5e7eb";
+  const handleColor = opts.handleColor ?? "#6b7280";
+  const selectedColor = opts.selectedColor ?? "rgba(59,130,246,0.2)";
+  nodes.push(rect(opts.x, opts.y, opts.width, h, {
+    class: "chartts-datazoom-track",
+    fill: trackColor,
+    rx: 4,
+    ry: 4
+  }));
+  if (opts.showMinimap !== false && data.series[0]) {
+    const values = data.series[0].values;
+    const max = Math.max(...values.map(Math.abs), 1);
+    const pb = new PathBuilder();
+    for (let i = 0; i < values.length; i++) {
+      const x = opts.x + i / Math.max(values.length - 1, 1) * opts.width;
+      const y = opts.y + h - Math.abs(values[i]) / max * (h - 4) - 2;
+      if (i === 0) pb.moveTo(x, y);
+      else pb.lineTo(x, y);
+    }
+    nodes.push(path(pb.build(), {
+      class: "chartts-datazoom-minimap",
+      fill: "none",
+      stroke: handleColor,
+      strokeWidth: 1,
+      strokeOpacity: 0.4
+    }));
+  }
+  const selX = opts.x + range.start * opts.width;
+  const selW = (range.end - range.start) * opts.width;
+  nodes.push(rect(selX, opts.y, selW, h, {
+    class: "chartts-datazoom-selected",
+    fill: selectedColor,
+    rx: 2,
+    ry: 2
+  }));
+  nodes.push(rect(selX - 3, opts.y + 4, 6, h - 8, {
+    class: "chartts-datazoom-handle chartts-datazoom-handle-left",
+    fill: handleColor,
+    rx: 3,
+    ry: 3,
+    cursor: "ew-resize"
+  }));
+  nodes.push(rect(selX + selW - 3, opts.y + 4, 6, h - 8, {
+    class: "chartts-datazoom-handle chartts-datazoom-handle-right",
+    fill: handleColor,
+    rx: 3,
+    ry: 3,
+    cursor: "ew-resize"
+  }));
+  const dlabels = data.labels ?? [];
+  const total = dlabels.length;
+  const startIdx = Math.floor(range.start * total);
+  const endIdx = Math.min(Math.ceil(range.end * total) - 1, total - 1);
+  if (total > 0) {
+    nodes.push(text(selX, opts.y + h + 12, String(dlabels[startIdx] ?? ""), {
+      class: "chartts-datazoom-label",
+      fill: handleColor,
+      textAnchor: "start",
+      fontSize: 9
+    }));
+    nodes.push(text(selX + selW, opts.y + h + 12, String(dlabels[endIdx] ?? ""), {
+      class: "chartts-datazoom-label",
+      fill: handleColor,
+      textAnchor: "end",
+      fontSize: 9
+    }));
+  }
+  return nodes;
+}
+
+// src/features/datazoom-widget.ts
+function createDataZoomWidget(options) {
+  const h = options.height ?? 40;
+  const trackColor = options.trackColor ?? "#e5e7eb";
+  const handleColor = options.handleColor ?? "#6b7280";
+  const selectedColor = options.selectedColor ?? "rgba(59,130,246,0.25)";
+  const minimapColor = options.minimapColor ?? "#9ca3af";
+  let currentData = options.data;
+  const state = createDataZoomState(
+    options.initialRange,
+    (range) => {
+      updateLayout();
+      options.onChange?.(range);
+    }
+  );
+  const root = document.createElement("div");
+  root.className = "chartts-datazoom-widget";
+  root.style.cssText = `position:relative;height:${h}px;width:100%;user-select:none;touch-action:none;`;
+  const track = document.createElement("div");
+  track.className = "chartts-datazoom-track";
+  track.style.cssText = `position:absolute;inset:0;background:${trackColor};border-radius:4px;overflow:hidden;`;
+  root.appendChild(track);
+  const minimap = document.createElement("canvas");
+  minimap.className = "chartts-datazoom-minimap";
+  minimap.style.cssText = "position:absolute;inset:0;width:100%;height:100%;";
+  track.appendChild(minimap);
+  const maskLeft = document.createElement("div");
+  maskLeft.style.cssText = `position:absolute;top:0;left:0;height:100%;background:rgba(0,0,0,0.15);border-radius:4px 0 0 4px;pointer-events:none;`;
+  root.appendChild(maskLeft);
+  const maskRight = document.createElement("div");
+  maskRight.style.cssText = `position:absolute;top:0;right:0;height:100%;background:rgba(0,0,0,0.15);border-radius:0 4px 4px 0;pointer-events:none;`;
+  root.appendChild(maskRight);
+  const selected = document.createElement("div");
+  selected.className = "chartts-datazoom-selected";
+  selected.style.cssText = `position:absolute;top:0;height:100%;background:${selectedColor};cursor:grab;border-top:2px solid ${handleColor};border-bottom:2px solid ${handleColor};`;
+  root.appendChild(selected);
+  const handleLeft = document.createElement("div");
+  handleLeft.className = "chartts-datazoom-handle-left";
+  handleLeft.style.cssText = `position:absolute;top:2px;width:8px;height:${h - 4}px;background:${handleColor};border-radius:4px;cursor:ew-resize;z-index:2;transform:translateX(-50%);`;
+  root.appendChild(handleLeft);
+  const handleRight = document.createElement("div");
+  handleRight.className = "chartts-datazoom-handle-right";
+  handleRight.style.cssText = `position:absolute;top:2px;width:8px;height:${h - 4}px;background:${handleColor};border-radius:4px;cursor:ew-resize;z-index:2;transform:translateX(-50%);`;
+  root.appendChild(handleRight);
+  function updateLayout() {
+    const w = root.clientWidth || root.offsetWidth || 300;
+    const { start, end } = state.range;
+    const leftPx = start * w;
+    const rightPx = end * w;
+    const selWidth = rightPx - leftPx;
+    maskLeft.style.width = `${leftPx}px`;
+    maskRight.style.width = `${w - rightPx}px`;
+    selected.style.left = `${leftPx}px`;
+    selected.style.width = `${selWidth}px`;
+    handleLeft.style.left = `${leftPx}px`;
+    handleRight.style.left = `${rightPx}px`;
+  }
+  function drawMinimap() {
+    const w = root.clientWidth || root.offsetWidth || 300;
+    const dpr = window.devicePixelRatio || 1;
+    minimap.width = Math.round(w * dpr);
+    minimap.height = Math.round(h * dpr);
+    minimap.style.width = `${w}px`;
+    minimap.style.height = `${h}px`;
+    const ctx = minimap.getContext("2d");
+    if (!ctx) return;
+    ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
+    ctx.clearRect(0, 0, w, h);
+    const series = currentData.series[0];
+    if (!series || series.values.length === 0) return;
+    const values = series.values.filter((v) => !isNaN(v));
+    if (values.length === 0) return;
+    const max = Math.max(...values);
+    const min = Math.min(...values);
+    const range = max - min || 1;
+    const pad2 = 4;
+    ctx.beginPath();
+    ctx.strokeStyle = minimapColor;
+    ctx.lineWidth = 1;
+    ctx.globalAlpha = 0.5;
+    let started = false;
+    for (let i = 0; i < series.values.length; i++) {
+      const v = series.values[i];
+      if (isNaN(v)) continue;
+      const x = i / Math.max(series.values.length - 1, 1) * w;
+      const y = h - pad2 - (v - min) / range * (h - pad2 * 2);
+      if (!started) {
+        ctx.moveTo(x, y);
+        started = true;
+      } else ctx.lineTo(x, y);
+    }
+    ctx.stroke();
+    if (started) {
+      ctx.lineTo(w, h);
+      ctx.lineTo(0, h);
+      ctx.closePath();
+      ctx.fillStyle = minimapColor;
+      ctx.globalAlpha = 0.08;
+      ctx.fill();
+    }
+  }
+  let dragMode = null;
+  let dragStartX = 0;
+  let dragStartRange = { start: 0, end: 1 };
+  function toNormalized(clientX) {
+    const r = root.getBoundingClientRect();
+    return Math.max(0, Math.min(1, (clientX - r.left) / r.width));
+  }
+  function onPointerDown(e) {
+    const target = e.target;
+    if (target === handleLeft || target.closest(".chartts-datazoom-handle-left")) {
+      dragMode = "left";
+    } else if (target === handleRight || target.closest(".chartts-datazoom-handle-right")) {
+      dragMode = "right";
+    } else if (target === selected || target.closest(".chartts-datazoom-selected")) {
+      dragMode = "pan";
+      selected.style.cursor = "grabbing";
+    } else {
+      const pos = toNormalized(e.clientX);
+      const span = state.range.end - state.range.start;
+      state.setRange(pos - span / 2, pos + span / 2);
+      return;
+    }
+    dragStartX = e.clientX;
+    dragStartRange = { ...state.range };
+    root.setPointerCapture(e.pointerId);
+    e.preventDefault();
+  }
+  function onPointerMove(e) {
+    if (!dragMode) return;
+    const dx = e.clientX - dragStartX;
+    const w = root.clientWidth || root.offsetWidth || 300;
+    const delta = dx / w;
+    if (dragMode === "left") {
+      state.setRange(
+        Math.min(dragStartRange.start + delta, state.range.end - 0.02),
+        state.range.end
+      );
+    } else if (dragMode === "right") {
+      state.setRange(
+        state.range.start,
+        Math.max(dragStartRange.end + delta, state.range.start + 0.02)
+      );
+    } else if (dragMode === "pan") {
+      const span = dragStartRange.end - dragStartRange.start;
+      let newStart = dragStartRange.start + delta;
+      let newEnd = dragStartRange.end + delta;
+      if (newStart < 0) {
+        newStart = 0;
+        newEnd = span;
+      }
+      if (newEnd > 1) {
+        newEnd = 1;
+        newStart = 1 - span;
+      }
+      state.setRange(newStart, newEnd);
+    }
+  }
+  function onPointerUp(_e) {
+    dragMode = null;
+    selected.style.cursor = "grab";
+  }
+  function onDblClick() {
+    state.reset();
+  }
+  root.addEventListener("pointerdown", onPointerDown);
+  root.addEventListener("pointermove", onPointerMove);
+  root.addEventListener("pointerup", onPointerUp);
+  root.addEventListener("dblclick", onDblClick);
+  let resizeObserver = null;
+  if (typeof ResizeObserver !== "undefined") {
+    resizeObserver = new ResizeObserver(() => {
+      updateLayout();
+      drawMinimap();
+    });
+    resizeObserver.observe(root);
+  }
+  requestAnimationFrame(() => {
+    updateLayout();
+    drawMinimap();
+  });
+  return {
+    element: root,
+    state,
+    setData(data) {
+      currentData = data;
+      drawMinimap();
+    },
+    destroy() {
+      resizeObserver?.disconnect();
+      root.removeEventListener("pointerdown", onPointerDown);
+      root.removeEventListener("pointermove", onPointerMove);
+      root.removeEventListener("pointerup", onPointerUp);
+      root.removeEventListener("dblclick", onDblClick);
+      root.remove();
+    }
+  };
+}
+
+// src/features/graphic.ts
+function createGraphicElements(elements, area) {
+  return elements.map((el) => resolveElement(el, area)).filter(Boolean);
+}
+function resolveElement(el, area) {
+  const resolve = (v, dim) => {
+    if (v === void 0) return 0;
+    if (el.position === "relative" && area) {
+      return dim === "x" ? area.x + v * area.width : area.y + v * area.height;
+    }
+    return v;
+  };
+  const resolveSize = (v, dim) => {
+    if (v === void 0) return 0;
+    if (el.position === "relative" && area) {
+      return dim === "w" ? v * area.width : v * area.height;
+    }
+    return v;
+  };
+  const attrs = {
+    class: "chartts-graphic",
+    ...el.attrs
+  };
+  switch (el.type) {
+    case "rect":
+      return rect(
+        resolve(el.x, "x"),
+        resolve(el.y, "y"),
+        resolveSize(el.width, "w"),
+        resolveSize(el.height, "h"),
+        attrs
+      );
+    case "circle":
+      return circle(
+        resolve(el.x, "x"),
+        resolve(el.y, "y"),
+        el.r ?? 10,
+        attrs
+      );
+    case "path":
+      return el.d ? path(el.d, attrs) : null;
+    case "text":
+      return text(
+        resolve(el.x, "x"),
+        resolve(el.y, "y"),
+        el.content ?? "",
+        attrs
+      );
+    case "line":
+      return line(
+        resolve(el.x, "x"),
+        resolve(el.y, "y"),
+        resolve(el.x2, "x"),
+        resolve(el.y2, "y"),
+        attrs
+      );
+    case "group": {
+      const children = (el.children ?? []).map((c) => resolveElement(c, area)).filter(Boolean);
+      return group(children, attrs);
+    }
+    case "image":
+      return {
+        type: "image",
+        attrs: {
+          ...attrs,
+          href: el.src ?? "",
+          x: resolve(el.x, "x"),
+          y: resolve(el.y, "y"),
+          width: resolveSize(el.width, "w"),
+          height: resolveSize(el.height, "h")
+        }
+      };
+    default:
+      return null;
+  }
+}
+function horizontalLine(y, area, attrs) {
+  return line(area.x, y, area.x + area.width, y, {
+    class: "chartts-graphic-guideline",
+    stroke: "#6b7280",
+    strokeWidth: 1,
+    strokeDasharray: "4,3",
+    ...attrs
+  });
+}
+function verticalLine(x, area, attrs) {
+  return line(x, area.y, x, area.y + area.height, {
+    class: "chartts-graphic-guideline",
+    stroke: "#6b7280",
+    strokeWidth: 1,
+    strokeDasharray: "4,3",
+    ...attrs
+  });
+}
+function annotation(x, y, content, attrs) {
+  return text(x, y, content, {
+    class: "chartts-graphic-annotation",
+    fill: "#374151",
+    fontSize: 11,
+    textAnchor: "middle",
+    dominantBaseline: "auto",
+    ...attrs
+  });
+}
+
+// src/features/richtext.ts
+function parseRichText(input, options = {}) {
+  const spans = parse(input, options.defaults ?? {}, options.styles ?? {});
+  const tspans = spans.map((span) => ({
+    type: "tspan",
+    attrs: {
+      ...span.style.fontWeight ? { fontWeight: span.style.fontWeight } : {},
+      ...span.style.fontStyle ? { fontStyle: span.style.fontStyle } : {},
+      ...span.style.fill ? { fill: span.style.fill } : {},
+      ...span.style.fontSize ? { fontSize: span.style.fontSize } : {},
+      ...span.style.fontFamily ? { fontFamily: span.style.fontFamily } : {},
+      ...span.style.textDecoration ? { textDecoration: span.style.textDecoration } : {}
+    },
+    children: [],
+    text: span.text
+  }));
+  return {
+    type: "text",
+    x: options.x ?? 0,
+    y: options.y ?? 0,
+    text: "",
+    attrs: {
+      class: "chartts-richtext",
+      ...options.attrs
+    },
+    children: tspans
+  };
+}
+function richLabel(label, value, opts) {
+  const color = opts?.valueColor ?? "#3b82f6";
+  const weight = opts?.valueWeight ?? "";
+  const valueStr = typeof value === "number" ? formatNum(value) : value;
+  const weightTag = weight ? `{b}${valueStr}{/b}` : valueStr;
+  return `{b}${label}{/b}: {color:${color}}${weightTag}{/color}`;
+}
+function parse(input, defaults, namedStyles) {
+  const spans = [];
+  const styleStack = [{ ...defaults }];
+  const regex = /\{(b|\/b|i|\/i|color:([^}]+)|\/color|size:([^}]+)|\/size|style:([^}]+)|\/style)\}|\*\*(.+?)\*\*|\*(.+?)\*/g;
+  let lastIndex = 0;
+  let match;
+  while ((match = regex.exec(input)) !== null) {
+    if (match.index > lastIndex) {
+      spans.push({ text: input.slice(lastIndex, match.index), style: currentStyle(styleStack) });
+    }
+    const tag = match[1];
+    const boldShorthand = match[5];
+    const italicShorthand = match[6];
+    if (boldShorthand) {
+      spans.push({ text: boldShorthand, style: { ...currentStyle(styleStack), fontWeight: 700 } });
+    } else if (italicShorthand) {
+      spans.push({ text: italicShorthand, style: { ...currentStyle(styleStack), fontStyle: "italic" } });
+    } else if (tag === "b") {
+      styleStack.push({ ...currentStyle(styleStack), fontWeight: 700 });
+    } else if (tag === "/b") {
+      popStyle(styleStack);
+    } else if (tag === "i") {
+      styleStack.push({ ...currentStyle(styleStack), fontStyle: "italic" });
+    } else if (tag === "/i") {
+      popStyle(styleStack);
+    } else if (tag?.startsWith("color:")) {
+      styleStack.push({ ...currentStyle(styleStack), fill: match[2] });
+    } else if (tag === "/color") {
+      popStyle(styleStack);
+    } else if (tag?.startsWith("size:")) {
+      styleStack.push({ ...currentStyle(styleStack), fontSize: parseFloat(match[3]) || 12 });
+    } else if (tag === "/size") {
+      popStyle(styleStack);
+    } else if (tag?.startsWith("style:")) {
+      const named = namedStyles[match[4]];
+      if (named) {
+        styleStack.push({ ...currentStyle(styleStack), ...named });
+      }
+    } else if (tag === "/style") {
+      popStyle(styleStack);
+    }
+    lastIndex = match.index + match[0].length;
+  }
+  if (lastIndex < input.length) {
+    spans.push({ text: input.slice(lastIndex), style: currentStyle(styleStack) });
+  }
+  return spans;
+}
+function currentStyle(stack) {
+  return { ...stack[stack.length - 1] };
+}
+function popStyle(stack) {
+  if (stack.length > 1) stack.pop();
+}
+function formatNum(n) {
+  return n.toLocaleString();
+}
+
+// src/registry/registry.ts
+var charts = /* @__PURE__ */ new Map();
+var scales = /* @__PURE__ */ new Map();
+function registerChart(plugin) {
+  if (charts.has(plugin.type)) {
+    throw new Error(`[chartts] Chart type "${plugin.type}" already registered.`);
+  }
+  charts.set(plugin.type, plugin);
+}
+function getChart(type) {
+  const plugin = charts.get(type);
+  if (!plugin) {
+    const available = Array.from(charts.keys()).join(", ") || "none";
+    throw new Error(`[chartts] Unknown chart type "${type}". Registered: ${available}`);
+  }
+  return plugin;
+}
+function registerScale(type, factory) {
+  scales.set(type, factory);
+}
+function getScaleFactory(type) {
+  const factory = scales.get(type);
+  if (!factory) {
+    throw new Error(`[chartts] Unknown scale type "${type}".`);
+  }
+  return factory;
+}
+function clearRegistry() {
+  charts.clear();
+  scales.clear();
+}
+
+// src/scales/time.ts
+var S = 1e3;
+var M = 60 * S;
+var H = 60 * M;
+var D = 24 * H;
+var W = 7 * D;
+var MO = 30 * D;
+var Y = 365 * D;
+var INTERVALS = [
+  { ms: S, fmt: fmtTime },
+  { ms: 5 * S, fmt: fmtTime },
+  { ms: 15 * S, fmt: fmtTime },
+  { ms: 30 * S, fmt: fmtTime },
+  { ms: M, fmt: fmtTime },
+  { ms: 5 * M, fmt: fmtTime },
+  { ms: 15 * M, fmt: fmtTime },
+  { ms: H, fmt: fmtTime },
+  { ms: 3 * H, fmt: fmtTime },
+  { ms: 6 * H, fmt: fmtTime },
+  { ms: 12 * H, fmt: fmtTime },
+  { ms: D, fmt: fmtDate },
+  { ms: W, fmt: fmtDate },
+  { ms: MO, fmt: fmtMonthYear },
+  { ms: 3 * MO, fmt: fmtMonthYear },
+  { ms: 6 * MO, fmt: fmtMonthYear },
+  { ms: Y, fmt: fmtYear },
+  { ms: 5 * Y, fmt: fmtYear },
+  { ms: 10 * Y, fmt: fmtYear }
+];
+function createTimeScale(opts) {
+  let dMin = ts(opts?.domain?.[0] ?? 0);
+  let dMax = ts(opts?.domain?.[1] ?? Date.now());
+  let rMin = opts?.range?.[0] ?? 0;
+  let rMax = opts?.range?.[1] ?? 1;
+  const customFmt = opts?.format;
+  function map(value) {
+    const v = ts(value);
+    const span = dMax - dMin;
+    if (span === 0) return (rMin + rMax) / 2;
+    return rMin + (v - dMin) / span * (rMax - rMin);
+  }
+  function invert(px) {
+    const span = rMax - rMin;
+    if (span === 0) return (dMin + dMax) / 2;
+    return dMin + (px - rMin) / span * (dMax - dMin);
+  }
+  function ticks(count = 6) {
+    const span = dMax - dMin;
+    if (span <= 0) return [];
+    const target = span / count;
+    const interval = INTERVALS.find((i) => i.ms >= target) ?? INTERVALS[INTERVALS.length - 1];
+    const fmt = customFmt ?? interval.fmt;
+    const result = [];
+    const start = Math.ceil(dMin / interval.ms) * interval.ms;
+    for (let t = start; t <= dMax; t += interval.ms) {
+      const d = new Date(t);
+      result.push({ value: d, position: map(t), label: fmt(d) });
+    }
+    return result;
+  }
+  return {
+    map,
+    invert,
+    ticks,
+    setDomain(min, max) {
+      dMin = ts(min);
+      dMax = ts(max);
+    },
+    setRange(min, max) {
+      rMin = min;
+      rMax = max;
+    },
+    getDomain() {
+      return [new Date(dMin), new Date(dMax)];
+    },
+    getRange() {
+      return [rMin, rMax];
+    },
+    bandwidth() {
+      return 0;
+    }
+  };
+}
+function ts(v) {
+  return v instanceof Date ? v.getTime() : typeof v === "string" ? new Date(v).getTime() : v;
+}
+var MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+function pad(n) {
+  return n < 10 ? `0${n}` : String(n);
+}
+function fmtTime(d) {
+  return `${pad(d.getHours())}:${pad(d.getMinutes())}`;
+}
+function fmtDate(d) {
+  return `${MONTHS[d.getMonth()]} ${d.getDate()}`;
+}
+function fmtMonthYear(d) {
+  return `${MONTHS[d.getMonth()]} ${d.getFullYear()}`;
+}
+function fmtYear(d) {
+  return String(d.getFullYear());
+}
+
+export { Area, Bar, Baseline, Boxplot, Bubble, Bullet, Calendar, Candlestick, Chord, Combo, Custom, Donut, Dumbbell, Funnel, Gauge, Geo, Graph, Heatmap, Histogram, HorizontalBar, Kagi, Line, Lines, Lollipop, Matrix, OHLC, Parallel, PictorialBar, Pie, Polar, Radar, RadialBar, Range, Renko, Sankey, Scatter, Sparkline, StackedBar, Step, Sunburst, ThemeRiver, Tree, Treemap, Volume, Waterfall, aggregateData, annotation, applyDataZoom, clearRegistry, createDataZoomState, createDataZoomWidget, createGraphicElements, createStreamingChart, createTimeScale, filterData, filterLabels, filterSeries, getChart, getScaleFactory, horizontalLine, linkCharts, parseRichText, pivotData, registerChart, registerScale, renderDataZoomSlider, richLabel, sliceData, sortData, transformData, verticalLine };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map