@wick-charts/vue 0.4.1 → 0.5.0

package/dist/core/dist/components/crosshair.js

@@ -0,0 +1,9 @@
+function d(r, s, l, x) {
+  const { context: t, bitmapSize: e, horizontalPixelRatio: o, verticalPixelRatio: c } = r, a = Math.max(1, Math.round(c)), i = Math.max(1, Math.round(o));
+  t.strokeStyle = x.crosshair.color, t.lineWidth = Math.max(a, i), t.setLineDash([4 * o, 4 * o]);
+  const h = Math.round(s) + (i % 2 === 1 ? 0.5 : 0), n = Math.round(l) + (a % 2 === 1 ? 0.5 : 0);
+  t.beginPath(), t.moveTo(h, 0), t.lineTo(h, e.height), t.moveTo(0, n), t.lineTo(e.width, n), t.stroke(), t.setLineDash([]);
+}
+export {
+  d as renderCrosshair
+};

package/dist/core/dist/components/edge-indicator.js

@@ -0,0 +1,36 @@
+function v(i) {
+  const { state: e } = i;
+  if (e === "idle" || e === "has-more") return;
+  const o = i.timeScale.timeToX(i.boundaryTime);
+  if (Number.isFinite(o)) {
+    if (e === "loading") {
+      M(i, o);
+      return;
+    }
+    e === "no-data" && T(i, o);
+  }
+}
+function M({ scope: i, theme: e, chartMediaHeight: o, side: n, now: s }, t) {
+  const { context: a, horizontalPixelRatio: r, verticalPixelRatio: l } = i, c = 3 * r, f = 8 * r, h = 24 * r, d = t * r, u = n === "right" ? d + h : d - h, m = o / 2 * l, b = s % 900 / 900, p = Math.floor(b * 3), P = g(e.axis.textColor ?? "#787b86", 0.3), y = e.axis.textColor ?? "#787b86";
+  a.save();
+  for (let x = 0; x < 3; x++) {
+    const $ = (x - 1) * f, I = u + $;
+    a.beginPath(), a.arc(I, m, c, 0, Math.PI * 2), a.fillStyle = x === p ? y : P, a.fill();
+  }
+  a.restore();
+}
+function T({ scope: i, theme: e, chartMediaHeight: o, side: n }, s) {
+  const { context: t, horizontalPixelRatio: a, verticalPixelRatio: r } = i, l = Math.round(s * a) + 0.5;
+  t.save(), t.strokeStyle = g(e.axis.textColor ?? "#787b86", 0.6), t.lineWidth = 1, t.setLineDash([4 * a, 4 * a]), t.beginPath(), t.moveTo(l, 0), t.lineTo(l, o * r), t.stroke(), t.setLineDash([]);
+  const c = 10 * a, f = n === "right" ? l - c : l + c, h = 18 * r;
+  t.fillStyle = e.axis.textColor ?? "#787b86", t.font = `${11 * a}px ${e.typography.fontFamily}`, t.textAlign = n === "right" ? "right" : "left", t.textBaseline = "top", t.fillText("No more data", f, h), t.restore();
+}
+function g(i, e) {
+  const o = /^#([0-9a-f]{6})$/i.exec(i.trim());
+  if (!o) return i;
+  const n = parseInt(o[1].slice(0, 2), 16), s = parseInt(o[1].slice(2, 4), 16), t = parseInt(o[1].slice(4, 6), 16);
+  return `rgba(${n}, ${s}, ${t}, ${e})`;
+}
+export {
+  v as renderEdgeIndicator
+};

package/dist/core/dist/components/grid.js

@@ -0,0 +1,22 @@
+function T({ scope: c, timeScale: h, yScale: d, theme: a, yTicks: m, timeTicks: p }) {
+  const { context: t, bitmapSize: s, horizontalPixelRatio: e, verticalPixelRatio: u } = c;
+  t.save(), t.strokeStyle = a.grid.color, a.grid.style === "dashed" ? t.setLineDash([4 * e, 4 * e]) : a.grid.style === "dotted" && t.setLineDash([1 * e, 3 * e]);
+  const l = Math.max(1, Math.round(u)), g = l % 2 === 1 ? 0.5 : 0;
+  t.lineWidth = l;
+  for (const { value: n, opacity: o } of m.entries) {
+    if (o <= 0.01) continue;
+    const i = Math.round(d.valueToBitmapY(n)) + g;
+    t.globalAlpha = o, t.beginPath(), t.moveTo(0, i), t.lineTo(s.width, i), t.stroke();
+  }
+  const r = Math.max(1, Math.round(e)), y = r % 2 === 1 ? 0.5 : 0;
+  t.lineWidth = r;
+  for (const { value: n, opacity: o } of p.entries) {
+    if (o <= 0.01) continue;
+    const i = Math.round(h.timeToBitmapX(n)) + y;
+    t.globalAlpha = o, t.beginPath(), t.moveTo(i, 0), t.lineTo(i, s.height), t.stroke();
+  }
+  t.restore();
+}
+export {
+  T as renderGrid
+};

package/dist/core/dist/components/marker.js

@@ -0,0 +1,41 @@
+import { fillRoundedRect as d } from "../series/painters/canvas-path.js";
+import { hexToRgba as P } from "../utils/color.js";
+const f = 4, x = 5, g = 9, v = 6, M = 6, S = 3;
+function B(t) {
+  const { scope: i, timeScale: o, yScale: c, theme: l, marker: e, phase: s } = t, { context: r, horizontalPixelRatio: a, verticalPixelRatio: h } = i, n = o.timeToBitmapX(e.time), p = c.valueToBitmapY(e.value);
+  if (!Number.isFinite(n) || !Number.isFinite(p)) return;
+  const b = f * a;
+  r.save(), e.pulse && T({ context: r, bx: n, by: p, color: e.color, radius: b, hpr: a, phase: s }), w({ context: r, bx: n, by: p, color: e.color, radius: b, hpr: a, vpr: h, shape: e.shape }), e.label && R({ context: r, bx: n, by: p, color: e.color, theme: l, hpr: a, vpr: h, label: e.label, shape: e.shape }), r.restore();
+}
+function T({ context: t, bx: i, by: o, color: c, radius: l, hpr: e, phase: s }) {
+  const r = 0.4 + 0.6 * Math.abs(Math.sin(s * 2 * Math.PI)), a = l + 4 * e * r;
+  t.beginPath(), t.arc(i, o, a, 0, Math.PI * 2), t.fillStyle = P(c, r * 0.3), t.fill();
+}
+function w({ context: t, bx: i, by: o, color: c, radius: l, hpr: e, vpr: s, shape: r }) {
+  if (r === "dot") {
+    t.beginPath(), t.arc(i, o, l, 0, Math.PI * 2), t.fillStyle = c, t.fill();
+    return;
+  }
+  if (r === "circle") {
+    t.beginPath(), t.arc(i, o, l, 0, Math.PI * 2), t.strokeStyle = c, t.lineWidth = Math.max(1, Math.round(1.5 * e)), t.stroke();
+    return;
+  }
+  const a = x * e, h = g * s, n = r === "arrow-down" ? -1 : 1;
+  t.beginPath(), t.moveTo(i, o), t.lineTo(i - a, o + n * h), t.lineTo(i + a, o + n * h), t.closePath(), t.fillStyle = c, t.fill();
+}
+function R({ context: t, bx: i, by: o, color: c, theme: l, hpr: e, vpr: s, label: r, shape: a }) {
+  const h = l.yLabel.fontSize * e;
+  t.font = `${h}px ${l.typography.fontFamily}`, t.textAlign = "left", t.textBaseline = "middle";
+  const n = M * e, p = S * s, b = v * e, m = a === "arrow-down" || a === "arrow-up" ? x * e : f * e, y = t.measureText(r).width, u = i + m + b + n;
+  t.fillStyle = c, d(t, {
+    x: u - n,
+    y: o - h / 2 - p,
+    width: y + n * 2,
+    height: h + p * 2,
+    radius: 3 * e,
+    corners: { tl: !0, tr: !0, br: !0, bl: !0 }
+  }), t.fillStyle = l.yLabel.textColor, t.fillText(r, u, o);
+}
+export {
+  B as renderMarker
+};

package/dist/core/dist/components/reference-line.js

@@ -0,0 +1,48 @@
+import { fillRoundedRect as S } from "../series/painters/canvas-path.js";
+const b = 4, T = 6, M = 6, g = 3;
+function R(i) {
+  const { scope: h, timeScale: l, yScale: m, theme: f, line: e, plotWidth: r, plotHeight: c } = i, { context: t, horizontalPixelRatio: a, verticalPixelRatio: d } = h;
+  if (t.save(), t.strokeStyle = e.color, e.style === "dashed" && t.setLineDash([b * a, b * a]), e.orientation === "horizontal") {
+    const o = m.valueToBitmapY(e.coord);
+    if (!Number.isFinite(o) || o < 0 || o > c) {
+      t.restore();
+      return;
+    }
+    const n = Math.max(1, Math.round(e.width * d)), s = Math.round(o) + (n % 2 === 1 ? 0.5 : 0);
+    t.lineWidth = n, t.beginPath(), t.moveTo(0, s), t.lineTo(r, s), t.stroke();
+  } else {
+    const o = l.timeToBitmapX(e.coord);
+    if (!Number.isFinite(o) || o < 0 || o > r) {
+      t.restore();
+      return;
+    }
+    const n = Math.max(1, Math.round(e.width * a)), s = Math.round(o) + (n % 2 === 1 ? 0.5 : 0);
+    t.lineWidth = n, t.beginPath(), t.moveTo(s, 0), t.lineTo(s, c), t.stroke();
+  }
+  t.setLineDash([]), e.label !== void 0 && L({ context: t, theme: f, line: e, timeScale: l, yScale: m, plotWidth: r, hpr: a, vpr: d }), t.restore();
+}
+function L({ context: i, theme: h, line: l, timeScale: m, yScale: f, plotWidth: e, hpr: r, vpr: c }) {
+  const t = l.label;
+  if (t === void 0) return;
+  const a = h.yLabel.fontSize * r;
+  i.font = `${a}px ${h.typography.fontFamily}`, i.textAlign = "left", i.textBaseline = "middle";
+  const d = M * r, o = g * c, n = T * r, s = T * c, y = i.measureText(t).width + d * 2, x = a + o * 2;
+  let u, p;
+  if (l.orientation === "horizontal")
+    u = n, p = f.valueToBitmapY(l.coord) - x / 2;
+  else {
+    const v = m.timeToBitmapX(l.coord);
+    u = Math.min(v + n, e - y - n), p = s;
+  }
+  i.fillStyle = l.color, S(i, {
+    x: u,
+    y: p,
+    width: y,
+    height: x,
+    radius: 3 * r,
+    corners: { tl: !0, tr: !0, br: !0, bl: !0 }
+  }), i.fillStyle = h.yLabel.textColor, i.fillText(t, u + d, p + x / 2);
+}
+export {
+  R as renderReferenceLine
+};

package/dist/core/dist/components/time-region.js

@@ -0,0 +1,35 @@
+import { fillRoundedRect as d } from "../series/painters/canvas-path.js";
+import { hexToRgba as g } from "../utils/color.js";
+const y = 0.5, p = 6, T = 6, R = 3;
+function $(e) {
+  const { scope: l, timeScale: i, theme: a, region: o, plotWidth: r, plotHeight: m } = e, { context: t, horizontalPixelRatio: h, verticalPixelRatio: u } = l, s = i.timeToBitmapX(o.from), c = o.to === null ? r : i.timeToBitmapX(o.to);
+  if (!Number.isFinite(s) || !Number.isFinite(c)) return;
+  const n = Math.max(0, Math.min(s, c)), f = Math.min(r, Math.max(s, c));
+  f <= 0 || n >= r || f <= n || (t.save(), t.fillStyle = o.fill, t.fillRect(n, 0, f - n, m), t.globalAlpha = y, t.strokeStyle = o.color, t.lineWidth = Math.max(1, Math.round(h)), b(t, s, r, m), o.to !== null && b(t, c, r, m), t.globalAlpha = 1, o.label && v({ context: t, theme: a, region: o, left: n, hpr: h, vpr: u }), t.restore());
+}
+function b(e, l, i, a) {
+  l < 0 || l > i || (e.beginPath(), e.moveTo(l, 0), e.lineTo(l, a), e.stroke());
+}
+function v({ context: e, theme: l, region: i, left: a, hpr: o, vpr: r }) {
+  const m = i.label;
+  if (m === void 0) return;
+  const t = l.yLabel.fontSize * o;
+  e.font = `${t}px ${l.typography.fontFamily}`, e.textAlign = "left", e.textBaseline = "middle";
+  const h = T * o, u = R * r, s = p * o, c = e.measureText(m).width, n = a + s, f = p * r, x = t + u * 2;
+  e.fillStyle = i.color, d(e, {
+    x: n,
+    y: f,
+    width: c + h * 2,
+    height: x,
+    radius: 3 * o,
+    corners: { tl: !0, tr: !0, br: !0, bl: !0 }
+  }), e.fillStyle = l.yLabel.textColor, e.fillText(m, n + h, f + x / 2);
+}
+function A(e, l) {
+  const i = e.color ?? l.axis.textColor, a = e.fill ?? g(i, 0.08);
+  return { color: i, fill: a };
+}
+export {
+  $ as renderTimeRegion,
+  A as resolveTimeRegionColors
+};

package/dist/core/dist/data/decimation.js

@@ -0,0 +1,54 @@
+function D(t, o) {
+  return t.length <= o ? t : x(
+    t,
+    o,
+    (l) => l.time,
+    (l) => l.value
+  );
+}
+function L(t, o) {
+  if (t.length <= o) return t;
+  const l = Math.ceil(t.length / o), c = [];
+  for (let h = 0; h < t.length; h += l) {
+    const s = Math.min(h + l, t.length);
+    let r = -1 / 0, a = 1 / 0, f = 0;
+    for (let n = h; n < s; n++)
+      t[n].high > r && (r = t[n].high), t[n].low < a && (a = t[n].low), f += t[n].volume ?? 0;
+    c.push({
+      time: t[h].time,
+      open: t[h].open,
+      high: r,
+      low: a,
+      close: t[s - 1].close,
+      volume: f
+    });
+  }
+  return c;
+}
+function x(t, o, l, c) {
+  if (o >= t.length || o < 3) return t;
+  const h = [t[0]], s = (t.length - 2) / (o - 2);
+  let r = 0;
+  for (let a = 0; a < o - 2; a++) {
+    const f = Math.floor((a + 1) * s) + 1, n = Math.min(Math.floor((a + 2) * s) + 1, t.length - 1);
+    let u = 0, g = 0;
+    const M = n, p = Math.min(Math.floor((a + 3) * s) + 1, t.length), e = p - M;
+    if (e > 0) {
+      for (let i = M; i < p; i++)
+        u += l(t[i]), g += c(t[i]);
+      u /= e, g /= e;
+    }
+    let v = -1, m = f;
+    const w = l(t[r]), b = c(t[r]);
+    for (let i = f; i < n; i++) {
+      const d = Math.abs((w - u) * (c(t[i]) - b) - (w - l(t[i])) * (g - b));
+      d > v && (v = d, m = i);
+    }
+    h.push(t[m]), r = m;
+  }
+  return h.push(t[t.length - 1]), h;
+}
+export {
+  D as decimateLineData,
+  L as decimateOHLCData
+};

package/dist/core/dist/data/store.js

@@ -0,0 +1,76 @@
+import { EventEmitter as l } from "../events.js";
+import { binarySearch as n } from "../utils/math.js";
+class g extends l {
+  data = [];
+  _visible = !0;
+  cachedRange = null;
+  cachedResult = [];
+  setVisible(t) {
+    this._visible = t;
+  }
+  isVisible() {
+    return this._visible;
+  }
+  setData(t) {
+    let e = !0;
+    for (let a = 1; a < t.length; a++)
+      if (t[a].time < t[a - 1].time) {
+        e = !1;
+        break;
+      }
+    this.data = e ? t.slice() : [...t].sort((a, i) => a.time - i.time), this.cachedRange = null, this.emit("update");
+  }
+  append(t) {
+    if (this.data.length > 0 && t.time <= this.data[this.data.length - 1].time) {
+      this.updateLast(t);
+      return;
+    }
+    this.data.push(t), this.cachedRange = null, this.emit("update");
+  }
+  updateLast(t) {
+    this.data.length !== 0 && (this.data[this.data.length - 1] = t, this.cachedRange = null, this.emit("update"));
+  }
+  trimStart(t) {
+    if (!(t <= 0 || this.data.length === 0)) {
+      if (t >= this.data.length) {
+        this.data = [], this.cachedRange = null, this.emit("update");
+        return;
+      }
+      this.data = this.data.slice(t), this.cachedRange = null, this.emit("update");
+    }
+  }
+  getAll() {
+    return this.data;
+  }
+  getVisibleData(t, e) {
+    if (this.data.length === 0) return [];
+    if (this.cachedRange && this.cachedRange.from === t && this.cachedRange.to === e) return this.cachedResult;
+    const a = Math.max(0, n(this.data, t, (h) => h.time) - 1), i = Math.min(this.data.length, n(this.data, e, (h) => h.time) + 1);
+    return this.cachedResult = this.data.slice(a, i), this.cachedRange = { from: t, to: e }, this.cachedResult;
+  }
+  first() {
+    return this.data[0];
+  }
+  last() {
+    return this.data[this.data.length - 1];
+  }
+  get length() {
+    return this.data.length;
+  }
+  isEmpty() {
+    return this.data.length === 0;
+  }
+  findNearest(t, e) {
+    if (this.data.length === 0) return null;
+    const a = n(this.data, t, (s) => s.time);
+    let i = null, h = e;
+    for (let s = Math.max(0, a - 1); s <= Math.min(this.data.length - 1, a + 1); s++) {
+      const d = Math.abs(this.data[s].time - t);
+      d <= h && (h = d, i = this.data[s]);
+    }
+    return i;
+  }
+}
+export {
+  g as TimeSeriesStore
+};

package/dist/core/dist/data/sync.js

@@ -0,0 +1,47 @@
+import { normalizeTime as h } from "../utils/time.js";
+const y = { len: 0, firstTime: null, lastTime: null }, d = 20;
+function f(a) {
+  return typeof a == "object" && a !== null && !Array.isArray(a) && Array.isArray(a.data);
+}
+function p(a) {
+  if (!Array.isArray(a)) return [a];
+  if (a.length === 0) return [{ data: [] }];
+  const r = a[0];
+  return Array.isArray(r) || f(r) ? a.map((t) => Array.isArray(t) ? { data: t } : t) : [{ data: a }];
+}
+function A(a) {
+  const { chart: r, id: t } = a, e = p(a.data), l = e.length > 1 ? e.map((n, i) => n.label ?? `Series ${i + 1}`) : [e[0].label];
+  r.setSeriesLabels(t, l), r.setLayerColors(
+    t,
+    e.map((n) => n.color)
+  );
+  const s = [];
+  return r.batch(() => {
+    for (let n = 0; n < e.length; n++)
+      s[n] = T({
+        chart: r,
+        id: t,
+        data: e[n].data,
+        prev: a.prev[n] ?? y,
+        layerIndex: n
+      });
+  }), s;
+}
+function T(a) {
+  const { chart: r, id: t, data: e, prev: l, layerIndex: s } = a;
+  if (e.length === 0)
+    return r.setSeriesData(t, [], s), { len: 0, firstTime: null, lastTime: null };
+  const n = h(e[0].time), i = h(e[e.length - 1].time), c = l.firstTime !== null && l.firstTime !== n, u = e.length - l.len, m = l.lastTime !== null && l.lastTime !== i;
+  return c && u === 0 && m ? r.batch(() => {
+    r.appendData(t, e[e.length - 1], s), r.keepLast(t, e.length, s);
+  }) : l.len === 0 || e.length < l.len || u > d || c ? r.setSeriesData(t, e, s) : e.length === l.len ? r.updateData(t, e[e.length - 1], s) : r.batch(() => {
+    for (let o = l.len; o < e.length; o++)
+      r.appendData(t, e[o], s);
+  }), { len: e.length, firstTime: n, lastTime: i };
+}
+export {
+  y as EMPTY_SYNC_STATE,
+  A as syncLayers,
+  T as syncSeriesLayer,
+  p as toLayers
+};

package/dist/core/dist/events.js

@@ -0,0 +1,19 @@
+class l {
+  listeners = /* @__PURE__ */ new Map();
+  on(e, s) {
+    let t = this.listeners.get(e);
+    t || (t = /* @__PURE__ */ new Set(), this.listeners.set(e, t)), t.add(s);
+  }
+  off(e, s) {
+    this.listeners.get(e)?.delete(s);
+  }
+  emit(e, ...s) {
+    this.listeners.get(e)?.forEach((t) => t(...s));
+  }
+  removeAllListeners() {
+    this.listeners.clear();
+  }
+}
+export {
+  l as EventEmitter
+};

package/dist/core/dist/interactions/handler.js

@@ -0,0 +1,84 @@
+import { EventEmitter as c } from "../events.js";
+import { clamp as u } from "../utils/math.js";
+import { PanHandler as l } from "./pan.js";
+import { ZoomHandler as r } from "./zoom.js";
+function i(n, t) {
+  const e = n.clientX - t.clientX, s = n.clientY - t.clientY;
+  return Math.hypot(e, s);
+}
+class M extends c {
+  zoom;
+  pan;
+  canvas;
+  timeScale;
+  yScale;
+  target;
+  constructor(t, e, s, o) {
+    super(), this.canvas = t, this.target = e, this.timeScale = s, this.yScale = o, this.zoom = new r(e, s), this.pan = new l(e, s, t), t.style.cursor = "crosshair", t.style.touchAction = "none", t.addEventListener("wheel", this.onWheel, { passive: !1 }), t.addEventListener("mousedown", this.onMouseDown), t.addEventListener("mousemove", this.onMouseMove), t.addEventListener("mouseup", this.onMouseUp), t.addEventListener("mouseleave", this.onMouseLeave), t.addEventListener("dblclick", this.onDblClick), t.addEventListener("touchstart", this.onTouchStart, { passive: !1 }), t.addEventListener("touchmove", this.onTouchMove, { passive: !1 }), t.addEventListener("touchend", this.onTouchEnd), t.addEventListener("touchcancel", this.onTouchCancel);
+  }
+  onWheel = (t) => {
+    this.zoom.handleWheel(t);
+  };
+  onMouseDown = (t) => {
+    this.zoom.cancelPendingRebound(), this.pan.handleMouseDown(t);
+  };
+  onMouseMove = (t) => {
+    this.pan.isDragging() && this.pan.handleMouseMove(t), this.emitCrosshair(t.offsetX, t.offsetY);
+  };
+  onMouseUp = () => {
+    this.pan.handleMouseUp();
+  };
+  onMouseLeave = () => {
+    this.pan.handleMouseUp(), this.emit("crosshairMove", null);
+  };
+  onDblClick = () => {
+  };
+  // Touch handling
+  lastTouchDist = 0;
+  touchCount = 0;
+  onTouchStart = (t) => {
+    t.preventDefault(), this.zoom.cancelPendingRebound(), this.touchCount = t.touches.length, t.touches.length === 1 ? this.pan.handleMouseDown({
+      button: 0,
+      clientX: t.touches[0].clientX
+    }) : t.touches.length === 2 && (this.lastTouchDist = i(t.touches[0], t.touches[1]));
+  };
+  onTouchMove = (t) => {
+    if (t.preventDefault(), t.touches.length === 1 && this.touchCount === 1)
+      this.pan.handleMouseMove({
+        clientX: t.touches[0].clientX
+      });
+    else if (t.touches.length === 2) {
+      const e = i(t.touches[0], t.touches[1]), s = (t.touches[0].clientX + t.touches[1].clientX) / 2, o = this.canvas.getBoundingClientRect();
+      if (e > 0 && this.lastTouchDist > 0) {
+        const h = u(this.lastTouchDist / e, 0.1, 10), a = this.timeScale.xToTime(s - o.left);
+        this.target.zoomAt(a, h, this.timeScale.getMediaWidth());
+      }
+      this.lastTouchDist = e;
+    }
+  };
+  onTouchEnd = (t) => {
+    if (t.touches.length === 0) {
+      this.pan.handleMouseUp(), this.touchCount = 0, this.lastTouchDist = 0, this.emit("crosshairMove", null);
+      return;
+    }
+    t.touches.length === 1 && (this.touchCount = 1, this.lastTouchDist = 0, this.pan.handleMouseDown({ button: 0, clientX: t.touches[0].clientX }));
+  };
+  onTouchCancel = () => {
+    this.pan.handleMouseUp(), this.touchCount = 0, this.lastTouchDist = 0, this.emit("crosshairMove", null);
+  };
+  emitCrosshair(t, e) {
+    const s = this.timeScale.xToTime(t), o = this.yScale.yToValue(e);
+    this.emit("crosshairMove", {
+      mediaX: t,
+      mediaY: e,
+      time: s,
+      y: o
+    });
+  }
+  destroy() {
+    this.zoom.cancelPendingRebound(), this.canvas.removeEventListener("wheel", this.onWheel), this.canvas.removeEventListener("mousedown", this.onMouseDown), this.canvas.removeEventListener("mousemove", this.onMouseMove), this.canvas.removeEventListener("mouseup", this.onMouseUp), this.canvas.removeEventListener("mouseleave", this.onMouseLeave), this.canvas.removeEventListener("dblclick", this.onDblClick), this.canvas.removeEventListener("touchstart", this.onTouchStart), this.canvas.removeEventListener("touchmove", this.onTouchMove), this.canvas.removeEventListener("touchend", this.onTouchEnd), this.canvas.removeEventListener("touchcancel", this.onTouchCancel), this.removeAllListeners();
+  }
+}
+export {
+  M as InteractionHandler
+};

package/dist/core/dist/interactions/pan.js

@@ -0,0 +1,26 @@
+class e {
+  constructor(t, s, i) {
+    this.target = t, this.timeScale = s, this.canvas = i;
+  }
+  dragging = !1;
+  lastX = 0;
+  handleMouseDown(t) {
+    t.button === 0 && (this.dragging = !0, this.lastX = t.clientX, this.canvas.style.cursor = "grabbing");
+  }
+  handleMouseMove(t) {
+    if (!this.dragging) return;
+    const s = t.clientX - this.lastX;
+    this.lastX = t.clientX;
+    const i = this.timeScale.pixelDeltaToTimeDelta(-s);
+    this.target.pan(i, this.timeScale.getMediaWidth());
+  }
+  handleMouseUp() {
+    this.dragging && (this.dragging = !1, this.canvas.style.cursor = "crosshair");
+  }
+  isDragging() {
+    return this.dragging;
+  }
+}
+export {
+  e as PanHandler
+};

package/dist/core/dist/interactions/zoom.js

@@ -0,0 +1,21 @@
+class s {
+  constructor(e, a) {
+    this.target = e, this.timeScale = a;
+  }
+  handleWheel(e) {
+    e.preventDefault();
+    const a = l(e.deltaY, e.deltaMode), i = Math.exp(a * 5e-3), n = this.timeScale.getMediaWidth(), o = Math.min(e.offsetX, n), h = this.timeScale.xToTime(o);
+    this.target.zoomAt(h, i, n);
+  }
+  /** Kept for API parity with InteractionHandler.destroy. Phase 2 step 2
+   *  removed the wheel-idle rebound timer alongside the rest of the
+   *  rebound feature; this is now a no-op. */
+  cancelPendingRebound() {
+  }
+}
+function l(t, e) {
+  return e === WheelEvent.DOM_DELTA_LINE ? t * 8 : e === WheelEvent.DOM_DELTA_PAGE ? t * 24 : t;
+}
+export {
+  s as ZoomHandler
+};