@wick-charts/vue 0.6.1 → 0.6.3

package/dist/core/dist/series/line.js

@@ -1,74 +1,94 @@
-import { DEFAULT_HISTORY_REVEAL as tt, DEFAULT_LINE_INTRO as et, DEFAULT_LINE_PULSE as it, DEFAULT_LINE_SMOOTH as ot, DEFAULT_LINE_ENTRY as st } from "../animation/config.js";
-import { easeOutCubic as _ } from "../animation/easing.js";
-import { decimateLineData as j } from "../data/decimation.js";
-import { hexToRgba as C } from "../utils/color.js";
-import { lerp as Y } from "../utils/math.js";
-import { BaseMultiLayerSeries as rt } from "./base-multi-layer.js";
-import { unfoldIntro as lt, backfillSweepIntro as at } from "./line-intro.js";
-import { buildCurveSegments as q } from "./painters/canvas-path.js";
-import { resolveLinePainter as ht } from "./painters/resolve.js";
-const ct = {
+import { DEFAULT_HISTORY_REVEAL as nt, DEFAULT_LINE_INTRO as lt, DEFAULT_LINE_PULSE as at, DEFAULT_LINE_SMOOTH as rt, DEFAULT_LINE_ENTRY as ht } from "../animation/config.js";
+import { easeOutCubic as U } from "../animation/easing.js";
+import { decimateLineData as q } from "../data/decimation.js";
+import { hexToRgba as X } from "../utils/color.js";
+import { lerp as N } from "../utils/math.js";
+import { BaseMultiLayerSeries as ut } from "./base-multi-layer.js";
+import { unfoldIntro as ft, backfillSweepIntro as pt } from "./line-intro.js";
+import { buildCurveSegments as tt } from "./painters/canvas-path.js";
+import { resolveLinePainter as mt } from "./painters/resolve.js";
+import { ScaleStack as et } from "./scale-stack.js";
+const gt = {
   colors: ["#2962FF"],
   strokeWidth: 1,
   area: { visible: !0 },
   pulse: !0,
   stacking: "off",
   curve: "straight",
-  entryMs: st,
-  smoothMs: ot,
-  pulseMs: it,
-  introMs: et,
-  historyRevealMs: tt
+  entryMs: ht,
+  smoothMs: rt,
+  pulseMs: at,
+  introMs: lt,
+  historyRevealMs: nt
 };
-function Q(v) {
-  const t = v.areaFill, e = t !== void 0 && v.area === void 0 ? { visible: !!t } : v.area;
+function it(x) {
+  const t = x.areaFill, e = t !== void 0 && x.area === void 0 ? { visible: !!t } : x.area;
   return {
-    ...v,
+    ...x,
     area: e,
-    entryMs: v.entryMs === !1 ? 0 : v.entryMs ?? st,
-    smoothMs: v.smoothMs === !1 ? 0 : v.smoothMs ?? ot,
-    pulseMs: v.pulseMs === !1 ? 0 : v.pulseMs ?? it,
-    introMs: v.introMs === !1 ? 0 : v.introMs ?? et,
-    historyRevealMs: v.historyRevealMs === !1 ? 0 : v.historyRevealMs ?? tt
+    entryMs: x.entryMs === !1 ? 0 : x.entryMs ?? ht,
+    smoothMs: x.smoothMs === !1 ? 0 : x.smoothMs ?? rt,
+    pulseMs: x.pulseMs === !1 ? 0 : x.pulseMs ?? at,
+    introMs: x.introMs === !1 ? 0 : x.introMs ?? lt,
+    historyRevealMs: x.historyRevealMs === !1 ? 0 : x.historyRevealMs ?? nt
   };
 }
-function Z(v) {
-  return v.map(([t, e]) => ({ x: t, y: e }));
+function ot(x) {
+  return x.map(([t, e]) => ({ x: t, y: e }));
 }
-const $ = 0.15, ut = at();
-function U(v, t, e) {
-  if (v.length === 0) return null;
-  if (t <= v[0].time) return Number.isFinite(v[0].value) ? e(v[0]) : null;
-  const i = v[v.length - 1];
-  if (t >= i.time) return Number.isFinite(i.value) ? e(i) : null;
-  let s = 0, o = v.length - 1;
-  for (; o - s > 1; ) {
-    const a = s + o >> 1;
-    v[a].time <= t ? s = a : o = a;
-  }
-  const n = v[s], r = v[o];
-  if (!Number.isFinite(n.value) || !Number.isFinite(r.value)) return null;
-  const l = r.time - n.time;
-  return l <= 0 ? e(n) : Y(e(n), e(r), (t - n.time) / l);
+const J = 0.15, dt = pt();
+function j(x, t, e) {
+  const { resolve: i, lerp: o = N } = e;
+  if (x.length === 0) return null;
+  if (t <= x[0].time) return Number.isFinite(x[0].value) ? i(x[0]) : null;
+  const s = x[x.length - 1];
+  if (t >= s.time) return Number.isFinite(s.value) ? i(s) : null;
+  let l = 0, a = x.length - 1;
+  for (; a - l > 1; ) {
+    const p = l + a >> 1;
+    x[p].time <= t ? l = p : a = p;
+  }
+  const f = x[l], r = x[a];
+  if (!Number.isFinite(f.value) || !Number.isFinite(r.value)) return null;
+  const m = r.time - f.time;
+  return m <= 0 ? i(f) : o(i(f), i(r), (t - f.time) / m);
 }
-function K(v, t) {
+function xt(x, t) {
+  const e = t.getTransform();
+  let i = 0, o = 0;
+  for (const l of x)
+    t.isPlottable(l.value) && (i += e === null ? l.value : e.forward(l.value), o++);
+  if (o === 0) return null;
+  const s = i / o;
+  return e === null ? s : e.inverse(s);
+}
+function vt(x, t) {
+  let e = 0, i = x.length - 1;
+  for (; e <= i; ) {
+    const o = e + i >> 1;
+    if (x[o] === t) return o;
+    x[o] < t ? e = o + 1 : i = o - 1;
+  }
+  return -1;
+}
+function st(x, t) {
   for (const e of t)
-    e.kind === "line" ? v.lineTo(e.x, e.y) : v.bezierCurveTo(e.cp1x, e.cp1y, e.cp2x, e.cp2y, e.x, e.y);
+    e.kind === "line" ? x.lineTo(e.x, e.y) : x.bezierCurveTo(e.cp1x, e.cp1y, e.cp2x, e.cp2y, e.x, e.y);
 }
-function ft(v, t, e) {
+function yt(x, t, e) {
   for (let i = e.length - 1; i >= 0; i--) {
-    const s = e[i], o = i > 0 ? e[i - 1] : t[0];
-    s.kind === "line" ? v.lineTo(o.x, o.y) : v.bezierCurveTo(s.cp2x, s.cp2y, s.cp1x, s.cp1y, o.x, o.y);
+    const o = e[i], s = i > 0 ? e[i - 1] : t[0];
+    o.kind === "line" ? x.lineTo(s.x, s.y) : x.bezierCurveTo(o.cp2x, o.cp2y, o.cp1x, o.cp1y, s.x, s.y);
   }
 }
-class mt extends rt {
+class bt extends ut {
   kind = "line";
   areaGradientCache = /* @__PURE__ */ new Map();
   constructor(t, e) {
-    super(t), this.options = Q({ ...ct, ...e });
+    super(t), this.options = it({ ...gt, ...e });
   }
   updateOptions(t) {
-    this.options = Q({ ...this.options, ...t });
+    this.options = it({ ...this.options, ...t });
   }
   getStacking() {
     return this.options.stacking;
@@ -89,24 +109,24 @@ class mt extends rt {
   hasOverlayContentInRange(t, e) {
     for (let i = 0; i < this.stores.length; i++) {
       if (this.getLayerAlpha(i) <= 0) continue;
-      const s = this.stores[i].last();
-      if (s && s.time >= t) return !0;
+      const o = this.stores[i].last();
+      if (o && o.time >= t) return !0;
     }
     return !1;
   }
   render(t) {
-    this.tickAnimations(performance.now());
+    this.tickAnimations(performance.now()), this.lastYScale = t.yScale;
     const { context: e } = t.scope;
     this.historyDirectives = null;
     const i = this.historyRange;
     if (this.historyWave.active && i !== null) {
-      const r = this.options.historyReveal ?? ut;
-      r !== "none" && (this.historyDirectives = r(this.buildHistoryFrame(t, i)));
+      const a = this.options.historyReveal ?? dt;
+      a !== "none" && (this.historyDirectives = a(this.buildHistoryFrame(t, i)));
     }
-    const s = this.historyDirectives, o = s?.ghostAlpha ?? 0;
-    o > 0 && (e.save(), e.globalAlpha *= o, this.introGhostPass = !0, this.renderBody(t), this.introGhostPass = !1, e.restore());
-    const n = this.applyHistoryClip(t, s, i);
-    this.introWave.active ? this.renderWithIntro(t) : (this.introDirectives = null, this.renderBody(t)), n && e.restore(), s?.heads !== void 0 && s.heads.length > 0 && this.drawIntroHeads(t, s.heads, this.historyWave.linear());
+    const o = this.historyDirectives, s = o?.ghostAlpha ?? 0;
+    s > 0 && (e.save(), e.globalAlpha *= s, this.introGhostPass = !0, this.renderBody(t), this.introGhostPass = !1, e.restore());
+    const l = this.applyHistoryClip(t, o, i);
+    this.introWave.active ? this.renderWithIntro(t) : (this.introDirectives = null, this.renderBody(t)), l && e.restore(), o?.heads !== void 0 && o.heads.length > 0 && this.drawIntroHeads(t, o.heads, this.historyWave.linear());
   }
   /**
    * Initial-load intro pass: the resolved LineIntroFn describes this frame
@@ -116,14 +136,14 @@ class mt extends rt {
   renderWithIntro(t) {
     const e = this.resolveIntro()(this.buildIntroFrame(t));
     this.introDirectives = e;
-    const { context: i } = t.scope, { width: s, height: o } = t.scope.bitmapSize, n = e.ghostAlpha ?? 0;
-    n > 0 && (i.save(), i.globalAlpha *= n, this.introGhostPass = !0, this.renderBody(t), this.introGhostPass = !1, i.restore());
-    const r = e.clip, l = r !== void 0 && (r.fromX !== void 0 || r.toX !== void 0);
-    if (l) {
-      const a = r.fromX ?? 0, p = r.toX ?? s;
-      i.save(), i.beginPath(), i.rect(a, 0, Math.max(0, p - a), o), i.clip();
+    const { context: i } = t.scope, { width: o, height: s } = t.scope.bitmapSize, l = e.ghostAlpha ?? 0;
+    l > 0 && (i.save(), i.globalAlpha *= l, this.introGhostPass = !0, this.renderBody(t), this.introGhostPass = !1, i.restore());
+    const a = e.clip, f = a !== void 0 && (a.fromX !== void 0 || a.toX !== void 0);
+    if (f) {
+      const r = a.fromX ?? 0, m = a.toX ?? o;
+      i.save(), i.beginPath(), i.rect(r, 0, Math.max(0, m - r), s), i.clip();
     }
-    this.renderBody(t), l && i.restore(), e.heads !== void 0 && e.heads.length > 0 && this.drawIntroHeads(t, e.heads, this.introWave.linear());
+    this.renderBody(t), f && i.restore(), e.heads !== void 0 && e.heads.length > 0 && this.drawIntroHeads(t, e.heads, this.introWave.linear());
   }
   /**
    * Apply the history reveal's clip directive, mapped from reveal space
@@ -132,14 +152,22 @@ class mt extends rt {
    * small pad keeps the stroke cap at the reveal front from being shaved.
    */
   applyHistoryClip(t, e, i) {
-    const s = e?.clip;
-    if (s === void 0 || i === null || s.fromX === void 0 && s.toX === void 0) return !1;
-    const { context: o } = t.scope, { width: n, height: r } = t.scope.bitmapSize, l = t.timeScale.timeToBitmapX(i.to), a = Math.abs(l - t.timeScale.timeToBitmapX(i.from)), p = Math.max(2, (this.options.strokeWidth ?? 1) * t.scope.horizontalPixelRatio), f = s.fromX ?? 0, y = s.toX ?? a;
-    return o.save(), o.beginPath(), o.rect(l - y - p, 0, Math.max(0, y - f + p), r), o.rect(l, 0, Math.max(0, n - l), r), o.clip(), !0;
+    const o = e?.clip;
+    if (o === void 0 || i === null || o.fromX === void 0 && o.toX === void 0) return !1;
+    const { context: s } = t.scope, { width: l, height: a } = t.scope.bitmapSize, f = t.timeScale.timeToBitmapXExact(i.to), r = Math.abs(f - t.timeScale.timeToBitmapXExact(i.from)), m = Math.max(2, (this.options.strokeWidth ?? 1) * t.scope.horizontalPixelRatio), p = o.fromX ?? 0, v = o.toX ?? r;
+    return s.save(), s.beginPath(), s.rect(f - v - m, 0, Math.max(0, v - p + m), a), s.rect(f, 0, Math.max(0, l - f), a), s.clip(), !0;
   }
   renderBody(t) {
-    this.options.stacking === "off" ? this.renderOff(t) : this.renderStacked(t, this.options.stacking === "percent");
+    this.options.stacking === "off" ? (this.stackedEdges = null, this.renderOff(t)) : this.renderStacked(t, this.options.stacking === "percent");
   }
+  /**
+   * What the stacked pass drew this frame, in data space — shared columns,
+   * their eased cumulative per layer, and the per-column grow chain. Lets the
+   * overlay's dots reproduce the painted geometry against its own scales
+   * instead of re-deriving the entrance from a different chain.
+   * `null` when the stacked path didn't run.
+   */
+  stackedEdges = null;
   /** True while a ghost pre-pass is drawing — skips the area fill so the
    *  translucent pass shows only the stroke skeleton. */
   introGhostPass = !1;
@@ -151,11 +179,13 @@ class mt extends rt {
   introDirectives = null;
   /** Per-frame history-reveal directives; `null` when no reveal is in flight. */
   historyDirectives = null;
+  /** Y scale of the last render — value queries run without a render context. */
+  lastYScale = null;
   /** Default intro, built lazily — one instance per renderer. */
   defaultIntro = null;
   resolveIntro() {
     const t = this.options.introAnimation;
-    return t !== void 0 ? t : (this.defaultIntro === null && (this.defaultIntro = lt()), this.defaultIntro);
+    return t !== void 0 ? t : (this.defaultIntro === null && (this.defaultIntro = ft()), this.defaultIntro);
   }
   /**
    * Frame context handed to the intro fn — progress plus memoized data
@@ -181,54 +211,51 @@ class mt extends rt {
     return this.buildFrame(t, {
       progress: this.historyWave.linear(),
       range: e,
-      width: Math.abs(t.timeScale.timeToBitmapX(e.to) - t.timeScale.timeToBitmapX(e.from))
+      width: Math.abs(
+        t.timeScale.timeToBitmapXExact(e.to) - t.timeScale.timeToBitmapXExact(e.from)
+      )
     });
   }
   buildFrame(t, e) {
-    const { timeScale: i, yScale: s, scope: o } = t, { progress: n, range: r, width: l } = e, a = new Array(this.stores.length), p = new Array(this.stores.length);
-    let f;
-    const y = (h) => {
-      let m = a[h];
-      return m === void 0 && (m = this.stores[h]?.getVisibleData(r.from, r.to) ?? [], a[h] = m), m;
+    const { timeScale: i, yScale: o, scope: s } = t, { progress: l, range: a, width: f } = e, r = new Array(this.stores.length), m = new Array(this.stores.length);
+    let p;
+    const v = (n) => {
+      let u = r[n];
+      return u === void 0 && (u = this.stores[n]?.getVisibleData(a.from, a.to) ?? [], r[n] = u), u;
     };
     return {
-      progress: n,
-      range: r,
-      width: l,
-      height: s.getMediaHeight() * o.verticalPixelRatio,
+      progress: l,
+      range: a,
+      width: f,
+      height: o.getMediaHeight() * s.verticalPixelRatio,
       stacking: this.options.stacking,
-      timeToX: (h) => i.timeToBitmapX(h),
-      xToTime: (h) => i.xToTime(h / o.horizontalPixelRatio),
-      valueToY: (h) => s.valueToBitmapY(h),
+      timeToX: (n) => i.timeToBitmapXExact(n),
+      xToTime: (n) => i.xToTime(n / s.horizontalPixelRatio),
+      valueToY: (n) => o.valueToBitmapYExact(n),
+      lerpValue: (n, u, c) => o.lerpValue(n, u, c),
       layerCount: this.stores.length,
-      layerData: y,
-      layerMean: (h) => {
-        let m = p[h];
-        if (m === void 0) {
-          let u = 0, A = 0;
-          for (const R of y(h))
-            Number.isFinite(R.value) && (u += R.value, A++);
-          m = A > 0 ? u / A : null, p[h] = m;
-        }
-        return m;
+      layerData: v,
+      layerMean: (n) => {
+        let u = m[n];
+        return u === void 0 && (u = xt(v(n), o), m[n] = u), u;
       },
       primaryPath: () => {
-        if (f === void 0) {
-          f = null;
-          for (let h = 0; h < this.stores.length; h++) {
-            if (this.getLayerAlpha(h) <= 0 || !this.stores[h].isVisible()) continue;
-            const m = y(h).filter((u) => Number.isFinite(u.value));
-            if (!(m.length < 2)) {
-              f = m.map((u) => ({
-                x: i.timeToBitmapX(u.time),
-                y: s.valueToBitmapY(u.value),
-                time: u.time
+        if (p === void 0) {
+          p = null;
+          for (let n = 0; n < this.stores.length; n++) {
+            if (this.getLayerAlpha(n) <= 0 || !this.stores[n].isVisible()) continue;
+            const u = v(n).filter((c) => o.isPlottable(c.value));
+            if (!(u.length < 2)) {
+              p = u.map((c) => ({
+                x: i.timeToBitmapXExact(c.time),
+                y: o.valueToBitmapYExact(c.value),
+                time: c.time
               }));
               break;
             }
           }
         }
-        return f;
+        return p;
       }
     };
   }
@@ -238,47 +265,55 @@ class mt extends rt {
    * overlay pulse) already flows through `effectiveValue`, so one override
    * animates the whole geometry.
    */
-  effectiveValue(t, e, i, s) {
-    const o = super.effectiveValue(t, e, i, s), n = this.historyWave.active ? this.historyDirectives?.value : void 0, r = this.historyRange;
-    if (n !== void 0 && r !== null && i < r.to) {
-      const y = r.to - r.from, h = y > 0 ? Math.min(1, Math.max(0, (r.to - i) / y)) : 0;
-      return n({ layerIndex: e, time: i, value: o, position: h });
+  effectiveValue(t, e, i, o) {
+    const s = super.effectiveValue(t, e, i, o), l = this.historyWave.active ? this.historyDirectives?.value : void 0, a = this.historyRange;
+    if (l !== void 0 && a !== null && i < a.to) {
+      const v = a.to - a.from, n = v > 0 ? Math.min(1, Math.max(0, (a.to - i) / v)) : 0;
+      return l({ layerIndex: e, time: i, value: s, position: n });
     }
-    const l = this.introWave.active ? this.introDirectives?.value : void 0;
-    if (l === void 0) return o;
-    const a = t.timeScale.getRange(), p = a.to - a.from, f = p > 0 ? Math.min(1, Math.max(0, (i - a.from) / p)) : 0;
-    return l({ layerIndex: e, time: i, value: o, position: f });
+    const f = this.introWave.active ? this.introDirectives?.value : void 0;
+    if (f === void 0) return s;
+    const r = t.timeScale.getRange(), m = r.to - r.from, p = m > 0 ? Math.min(1, Math.max(0, (i - r.from) / m)) : 0;
+    return f({ layerIndex: e, time: i, value: s, position: p });
   }
   /**
    * Extends the base last-value query with the 'grow' entrance's value-space
-   * equivalent of {@link chainedTailPositions}'s eased position lerp — the Y
-   * scale is affine, so lerping the *value* by the same eased progress and
-   * mapping it through `yScale` afterward lands on the identical pixel the
-   * renderer paints. Without this, a tooltip/YLabel query would report a
-   * freshly-appended point's raw value the instant it lands, `entryMs`
-   * before the marker visually arrives there.
+   * equivalent of {@link chainedTailPositions}'s eased position lerp — the
+   * value lerps along the Y axis by the same eased progress, so mapping it
+   * through `yScale` lands on the identical pixel the renderer paints. Without
+   * this, a tooltip/YLabel query would report a freshly-appended point's raw
+   * value the instant it lands, `entryMs` before the marker visually arrives there.
    */
   snapshotValue(t, e, i) {
-    const s = super.snapshotValue(t, e, i);
-    return (this.options.entryAnimation ?? "grow") !== "grow" ? s : this.chainedTailValues(t)?.get(e) ?? s;
-  }
-  /** Value-space counterpart of {@link chainedTailPositions} — see {@link snapshotValue}. */
-  chainedTailValues(t) {
-    const e = this.unsettledTail(t);
-    if (e.length === 0) return null;
-    const i = this.stores[t].getAll(), s = i.length - 1 - e.length;
+    const o = super.snapshotValue(t, e, i);
+    return (this.options.entryAnimation ?? "grow") !== "grow" ? o : this.chainedTailValues(t)?.get(e) ?? o;
+  }
+  /**
+   * Value-space counterpart of {@link chainedTailPositions} — see {@link snapshotValue}.
+   * `resolve` lets the stacked renderer feed its ctx-aware `effectiveValue`
+   * in; query paths, which have no render context, keep the `liveValue` default.
+   */
+  chainedTailValues(t, e = (i, o) => this.liveValue(t, i, o)) {
+    const i = this.unsettledTail(t);
+    if (i.length === 0) return null;
+    const o = this.stores[t].getAll(), s = o.length - 1 - i.length;
     if (s < 0) return null;
-    const o = i[s];
-    if (!Number.isFinite(o.value)) return null;
-    let n = this.liveValue(t, o.time, o.value);
-    const r = /* @__PURE__ */ new Map();
-    for (let l = 0; l < e.length; l++) {
-      const a = i[s + 1 + l];
-      if (!Number.isFinite(a.value)) return null;
-      const p = _(e[l].progress), f = this.liveValue(t, a.time, a.value), y = Y(n, f, p);
-      r.set(a.time, y), n = y;
+    const l = o[s];
+    if (!Number.isFinite(l.value)) return null;
+    let a = e(l.time, l.value);
+    const f = /* @__PURE__ */ new Map();
+    for (let r = 0; r < i.length; r++) {
+      const m = o[s + 1 + r];
+      if (!Number.isFinite(m.value)) return null;
+      const p = U(i[r].progress), v = e(m.time, m.value), n = this.axisLerp(a, v, p);
+      f.set(m.time, n), a = n;
     }
-    return r;
+    return f;
+  }
+  /** `lerp` along the last rendered Y axis — plain before the first render. */
+  axisLerp(t, e, i) {
+    const o = this.lastYScale;
+    return o === null ? N(t, e, i) : o.lerpValue(t, e, i);
   }
   /**
    * Glowing pulse dots riding the intro's head anchors — the line reads as
@@ -288,22 +323,22 @@ class mt extends rt {
    */
   drawIntroHeads(t, e, i) {
     if (this.options.stacking !== "off") return;
-    const s = Math.min(1, i / $), o = Math.min(1, (1 - i) / $), n = Math.max(0, Math.min(s, o));
-    if (n <= 0) return;
-    const { scope: r } = t;
-    for (const l of e)
-      for (let a = 0; a < this.stores.length; a++) {
-        const p = this.getLayerAlpha(a);
-        if (p <= 0 || !this.stores[a].isVisible()) continue;
-        const f = this.introHeadAnchor(t, a, l);
-        f !== null && this.drawPulse({
-          ctx: r.context,
-          x: f.x,
-          y: f.y,
-          color: this.resolveLayerColor(a, f.value),
-          pixelRatio: r.horizontalPixelRatio,
+    const o = Math.min(1, i / J), s = Math.min(1, (1 - i) / J), l = Math.max(0, Math.min(o, s));
+    if (l <= 0) return;
+    const { scope: a } = t;
+    for (const f of e)
+      for (let r = 0; r < this.stores.length; r++) {
+        const m = this.getLayerAlpha(r);
+        if (m <= 0 || !this.stores[r].isVisible()) continue;
+        const p = this.introHeadAnchor(t, r, f);
+        p !== null && this.drawPulse({
+          ctx: a.context,
+          x: p.x,
+          y: p.y,
+          color: this.resolveLayerColor(r, p.value),
+          pixelRatio: a.horizontalPixelRatio,
           phase: i * 2,
-          alpha: n * p
+          alpha: l * m
         });
       }
   }
@@ -319,22 +354,30 @@ class mt extends rt {
    * visible range, not the data span) and jumps back on settle.
    */
   introHeadAnchor(t, e, i) {
-    const { timeScale: s, yScale: o } = t, n = s.getRange(), r = this.stores[e].getVisibleData(n.from, n.to);
-    if (r.length === 0) return null;
-    const l = this.stores[e].last();
-    if (l !== void 0 && i.time >= l.time) {
-      if (!Number.isFinite(l.value)) return null;
-      const f = this.trailingEndpoint(t, e);
-      return f === null ? null : { x: f.x, y: f.y, value: l.value };
+    const { timeScale: o, yScale: s } = t, l = o.getRange(), a = this.stores[e].getVisibleData(l.from, l.to);
+    if (a.length === 0) return null;
+    const f = this.stores[e].last();
+    if (f !== void 0 && i.time >= f.time) {
+      if (!s.isPlottable(f.value)) return null;
+      const p = this.trailingEndpoint(t, e);
+      return p === null ? null : { x: p.x, y: p.y, value: f.value };
     }
-    const a = r[0];
-    if (i.time <= a.time) {
-      if (!Number.isFinite(a.value)) return null;
-      const f = this.effectiveValue(t, e, a.time, a.value);
-      return { x: s.timeToBitmapX(a.time), y: o.valueToBitmapY(f), value: a.value };
+    const r = a[0];
+    if (i.time <= r.time) {
+      if (!s.isPlottable(r.value)) return null;
+      const p = this.effectiveValue(t, e, r.time, r.value);
+      return {
+        x: o.timeToBitmapXExact(r.time),
+        y: s.valueToBitmapYExact(p),
+        value: r.value
+      };
     }
-    const p = U(r, i.time, (f) => this.effectiveValue(t, e, f.time, f.value));
-    return p === null ? null : { x: i.x, y: o.valueToBitmapY(p), value: p };
+    const m = j(a, i.time, {
+      resolve: (p) => this.effectiveValue(t, e, p.time, p.value),
+      // Along the axis, so the dot stays on the straight segment the stroke draws.
+      lerp: (p, v, n) => !s.isPlottable(p) || !s.isPlottable(v) ? Number.NaN : s.lerpValue(p, v, n)
+    });
+    return m === null || !s.isPlottable(m) ? null : { x: i.x, y: s.valueToBitmapYExact(m), value: m };
   }
   /**
    * Rendered positions of the layer's still-unsettled trailing points, keyed
@@ -359,61 +402,95 @@ class mt extends rt {
    * it (see `renderStacked`'s `valueMaps` comment for the full rationale).
    */
   stackedValueAt(t, e, i) {
-    const s = this.options.stacking === "percent", o = (l) => {
-      const a = this.getLayerAlpha(l);
-      if (a <= 0) return 0;
-      const p = this.stores[l].getAll();
-      if (p.length === 0 || i < p[0].time) return 0;
-      const f = U(p, i, (y) => this.effectiveValue(t, l, y.time, y.value));
-      return f === null ? 0 : f * a;
+    const o = this.options.stacking === "percent", s = (this.options.entryAnimation ?? "grow") === "grow", l = new Array(this.stores.length), a = (n) => {
+      if (!s) return null;
+      const u = l[n];
+      if (u !== void 0) return u;
+      const c = this.chainedTailValues(n, (y, k) => this.effectiveValue(t, n, y, k));
+      return l[n] = c, c;
+    }, f = (n) => {
+      const u = this.stores[n].getAll();
+      if (u.length === 0 || i < u[0].time) return null;
+      const c = a(n);
+      return j(u, i, {
+        resolve: (y) => c?.get(y.time) ?? this.effectiveValue(t, n, y.time, y.value)
+      });
+    }, { yScale: r } = t;
+    if (r.getTransform() !== null && !o) {
+      const n = new et(r);
+      for (let u = 0; u <= e; u++) {
+        const c = this.getLayerAlpha(u), y = c > 0 ? f(u) : null;
+        y !== null && r.isPlottable(y) && n.push(y, c);
+      }
+      return n.edge;
+    }
+    const m = (n) => {
+      const u = this.getLayerAlpha(n);
+      if (u <= 0) return 0;
+      const c = f(n);
+      return c === null ? 0 : c * u;
     };
-    let n = 0;
-    if (s)
-      for (let l = 0; l < this.stores.length; l++) n += o(l);
-    let r = 0;
-    for (let l = 0; l <= e; l++) {
-      const a = o(l);
-      r += s && n > 0 ? a / n * 100 : a;
+    let p = 0;
+    if (o)
+      for (let n = 0; n < this.stores.length; n++) p += m(n);
+    let v = 0;
+    for (let n = 0; n <= e; n++) {
+      const u = m(n);
+      v += o && p > 0 ? u / p * 100 : u;
     }
-    return r;
+    return v;
   }
   /**
-   * Bitmap position for layer `li`'s stacked boundary at time `t`, chain-
-   * lerped through that layer's own still-unsettled trailing entries when
-   * `t` is its current live tip — a single dot has no shared edge to tear,
-   * so (unlike `renderStacked`'s polygon boundaries) gating off the layer's
-   * own entrance state is enough. Falls back to the raw settled position
-   * for historical points or when the 'grow' entrance is disabled.
+   * Bitmap position for layer `li`'s stacked boundary at time `t`.
+   *
+   * Reads back the vertex {@link renderStacked} actually painted this frame
+   * whenever `t` is one of its columns. The stacked entrance is driven by a
+   * *shared* per-column chain (columns are common to every layer), which this
+   * layer's own entrance state cannot reconstruct — deriving it here is what
+   * left the pulse dots hanging a column ahead of the stroke on a ragged
+   * feed. Falls back to the raw settled position off-column (decimated
+   * history, or before the first stacked frame).
    */
   stackedPositionAt(t, e, i) {
-    const { timeScale: s, yScale: o } = t, n = s.timeToBitmapX(i), r = o.valueToBitmapY(this.stackedValueAt(t, e, i)), l = this.stores[e].last()?.time;
-    if ((this.options.entryAnimation ?? "grow") !== "grow" || i !== l) return { x: n, y: r };
-    const a = this.unsettledTail(e), p = this.stores[e].getAll(), f = p.length - 1 - a.length;
-    if (a.length === 0 || f < 0) return { x: n, y: r };
-    const y = p[f];
-    let h = s.timeToBitmapX(y.time), m = o.valueToBitmapY(this.stackedValueAt(t, e, y.time));
-    for (let u = 0; u < a.length; u++) {
-      const A = p[f + 1 + u], R = _(a[u].progress), M = s.timeToBitmapX(A.time), I = o.valueToBitmapY(this.stackedValueAt(t, e, A.time));
-      h = Y(h, M, R), m = Y(m, I, R);
-    }
-    return { x: h, y: m };
+    const o = this.paintedStackVertex(t, e, i);
+    if (o !== null) return o;
+    const { timeScale: s, yScale: l } = t, a = l.valueToBitmapYExact(this.stackedValueAt(t, e, i)), f = s.timeToBitmapXExact(i), r = this.unsettledTail(e), m = this.stores[e].getAll(), p = m.length - 1 - r.length;
+    if ((this.options.entryAnimation ?? "grow") !== "grow" || i !== m[m.length - 1]?.time || r.length === 0 || p < 0) return { x: f, y: a };
+    let v = s.timeToBitmapXExact(m[p].time);
+    for (let n = 0; n < r.length; n++)
+      v = N(v, s.timeToBitmapXExact(m[p + 1 + n].time), U(r[n].progress));
+    return { x: v, y: a };
+  }
+  /** Upper-edge vertex of layer `li` at column `t`, replayed from the last
+   *  stacked frame's data-space record against `ctx`'s scales. */
+  paintedStackVertex(t, e, i) {
+    const o = this.stackedEdges, s = o?.cumulative[e];
+    if (o === null || s === void 0) return null;
+    const { times: l, growChain: a, collapse: f } = o, r = vt(l, i);
+    if (r < 0) return null;
+    const { timeScale: m, yScale: p } = t, v = t.scope.bitmapSize.height, n = f[e] ?? 1, u = p.valueToBitmapYExact(s[r]), c = n >= 1 ? u : v + (u - v) * n, y = l.length - a.length;
+    if (r < y) return { x: m.timeToBitmapXExact(i), y: c };
+    let k = m.timeToBitmapXExact(l[y - 1]);
+    for (let w = 0; w <= r - y; w++)
+      k = N(k, m.timeToBitmapXExact(l[y + w]), a[w]);
+    return { x: k, y: c };
   }
   chainedTailPositions(t, e) {
     const i = this.unsettledTail(e);
     if (i.length === 0) return null;
-    const s = this.stores[e].getAll(), o = s.length - 1 - i.length;
-    if (o < 0) return null;
-    const { timeScale: n, yScale: r } = t, l = s[o];
-    if (!Number.isFinite(l.value)) return null;
-    let a = n.timeToBitmapX(l.time), p = r.valueToBitmapY(this.effectiveValue(t, e, l.time, l.value));
-    const f = /* @__PURE__ */ new Map();
-    for (let y = 0; y < i.length; y++) {
-      const h = s[o + 1 + y];
-      if (!Number.isFinite(h.value)) return null;
-      const m = _(i[y].progress), u = n.timeToBitmapX(h.time), A = r.valueToBitmapY(this.effectiveValue(t, e, h.time, h.value)), R = Y(a, u, m), M = Y(p, A, m);
-      f.set(h.time, { x: R, y: M }), a = R, p = M;
+    const o = this.stores[e].getAll(), s = o.length - 1 - i.length;
+    if (s < 0) return null;
+    const { timeScale: l, yScale: a } = t, f = o[s];
+    if (!a.isPlottable(f.value)) return null;
+    let r = l.timeToBitmapXExact(f.time), m = a.valueToBitmapYExact(this.effectiveValue(t, e, f.time, f.value));
+    const p = /* @__PURE__ */ new Map();
+    for (let v = 0; v < i.length; v++) {
+      const n = o[s + 1 + v];
+      if (!a.isPlottable(n.value)) return null;
+      const u = U(i[v].progress), c = l.timeToBitmapXExact(n.time), y = a.valueToBitmapYExact(this.effectiveValue(t, e, n.time, n.value)), k = N(r, c, u), w = N(m, y, u);
+      p.set(n.time, { x: k, y: w }), r = k, m = w;
     }
-    return f;
+    return p;
   }
   /**
    * Bitmap coordinates for the trailing endpoint of a layer — i.e. where the
@@ -428,8 +505,8 @@ class mt extends rt {
   trailingEndpoint(t, e) {
     const i = this.stores[e].last();
     if (!i) return null;
-    const { timeScale: s, yScale: o } = t, n = s.timeToBitmapX(i.time), r = o.valueToBitmapY(this.effectiveValue(t, e, i.time, i.value));
-    return (this.options.entryAnimation ?? "grow") !== "grow" ? { x: n, y: r } : this.chainedTailPositions(t, e)?.get(i.time) ?? { x: n, y: r };
+    const { timeScale: o, yScale: s } = t, l = o.timeToBitmapXExact(i.time), a = s.valueToBitmapYExact(this.effectiveValue(t, e, i.time, i.value));
+    return (this.options.entryAnimation ?? "grow") !== "grow" ? { x: l, y: a } : this.chainedTailPositions(t, e)?.get(i.time) ?? { x: l, y: a };
   }
   /**
    * Vertical stroke + area gradients for `options.threshold`, pinned to the
@@ -443,10 +520,10 @@ class mt extends rt {
   buildThresholdPaint(t, e) {
     const i = this.options.threshold;
     if (!i) return null;
-    const { scope: s, yScale: o } = t, { context: n } = s, r = s.bitmapSize.height, l = i.above, a = i.below ?? e, p = Math.min(1, Math.max(0, o.valueToBitmapY(i.value) / r)), f = Math.min(6 * s.verticalPixelRatio, r * 0.02) / r, y = Math.max(0, p - f), h = Math.min(1, p + f), m = n.createLinearGradient(0, 0, 0, r);
-    m.addColorStop(0, l), m.addColorStop(y, l), m.addColorStop(h, a), m.addColorStop(1, a);
-    const u = n.createLinearGradient(0, 0, 0, r);
-    return u.addColorStop(0, C(l, 0.26)), u.addColorStop(y, C(l, 0.14)), u.addColorStop(h, C(a, 0.1)), u.addColorStop(1, C(a, 0.01)), { stroke: m, area: u };
+    const { scope: o, yScale: s } = t, { context: l } = o, a = o.bitmapSize.height, f = i.above, r = i.below ?? e, m = Math.min(1, Math.max(0, s.valueToBitmapYExact(i.value) / a)), p = Math.min(6 * o.verticalPixelRatio, a * 0.02) / a, v = Math.max(0, m - p), n = Math.min(1, m + p), u = l.createLinearGradient(0, 0, 0, a);
+    u.addColorStop(0, f), u.addColorStop(v, f), u.addColorStop(n, r), u.addColorStop(1, r);
+    const c = l.createLinearGradient(0, 0, 0, a);
+    return c.addColorStop(0, X(f, 0.26)), c.addColorStop(v, X(f, 0.14)), c.addColorStop(n, X(r, 0.1)), c.addColorStop(1, X(r, 0.01)), { stroke: u, area: c };
   }
   /**
    * Dot markers at each data point (`options.points`). Callers pass the same
@@ -459,215 +536,235 @@ class mt extends rt {
   drawPointMarkers(t) {
     const e = this.options.points;
     if (!e?.visible) return;
-    const { context: i, points: s, pixelRatio: o, color: n } = t;
-    if (s.length === 0) return;
-    const r = Math.max(1, (e.radius ?? 3) * o);
-    if (!(s.length > 1 && (s[s.length - 1].x - s[0].x) / (s.length - 1) < r * 3)) {
+    const { context: i, points: o, pixelRatio: s, color: l } = t;
+    if (o.length === 0) return;
+    const a = Math.max(1, (e.radius ?? 3) * s);
+    if (!(o.length > 1 && (o[o.length - 1].x - o[0].x) / (o.length - 1) < a * 3)) {
       i.beginPath();
-      for (const l of s)
-        i.moveTo(l.x + r, l.y), i.arc(l.x, l.y, r, 0, Math.PI * 2);
-      i.fillStyle = e.color ?? n, i.fill();
+      for (const f of o)
+        i.moveTo(f.x + a, f.y), i.arc(f.x, f.y, a, 0, Math.PI * 2);
+      i.fillStyle = e.color ?? l, i.fill();
     }
   }
   /** Each layer drawn independently */
   renderOff(t) {
-    const { scope: e, timeScale: i, yScale: s } = t, { context: o } = e, n = i.getRange(), { verticalPixelRatio: r } = e, l = this.options.strokeWidth > 0, a = Math.max(1, Math.round(this.options.strokeWidth * r)), p = this.options.entryAnimation ?? "grow", f = ht(this.options.linePainter ?? this.options.curve ?? "straight"), y = {
-      ctx: o,
+    const { scope: e, timeScale: i, yScale: o } = t, { context: s } = e, l = i.getRange(), { verticalPixelRatio: a } = e, f = this.options.strokeWidth > 0, r = Math.max(1, Math.round(this.options.strokeWidth * a)), m = this.options.entryAnimation ?? "grow", p = mt(this.options.linePainter ?? this.options.curve ?? "straight"), v = {
+      ctx: s,
       theme: t.theme,
       horizontalPixelRatio: e.horizontalPixelRatio,
-      verticalPixelRatio: r
+      verticalPixelRatio: a
     };
-    for (let h = 0; h < this.stores.length; h++) {
-      const m = this.getLayerAlpha(h);
-      if (m <= 0) continue;
-      let u = this.stores[h].getVisibleData(n.from, n.to);
-      const A = e.mediaSize.width;
-      if (u.length > A * 2 && (u = j(u, Math.round(A * 1.5))), u.length < 2) continue;
-      const R = this.stores[h].last()?.value ?? u[u.length - 1].value, M = this.resolveLayerColor(h, R), I = this.buildThresholdPaint(t, M), F = u[u.length - 1], z = this.stores[h].last(), D = z !== void 0 && F.time === z.time, N = D ? this.entranceProgress(h, F.time) : 1, W = D && p === "fade" && N < 1, E = (D ? this.trailingEndpoint(t, h) : null) ?? {
-        x: i.timeToBitmapX(F.time),
-        y: s.valueToBitmapY(this.effectiveValue(t, h, F.time, F.value))
-      }, G = E.x, c = E.y, x = D && p === "grow" ? this.chainedTailPositions(t, h) : null, b = m < 1;
-      (b || W) && (o.save(), b && (o.globalAlpha *= m), W && (o.globalAlpha *= N));
-      const S = u.length - 1, d = [];
-      let T = null;
-      for (let P = 0; P < S; P++) {
-        const B = u[P].value;
-        if (!Number.isFinite(B)) {
-          T = null;
+    for (let n = 0; n < this.stores.length; n++) {
+      const u = this.getLayerAlpha(n);
+      if (u <= 0) continue;
+      let c = this.stores[n].getVisibleData(l.from, l.to);
+      const y = e.mediaSize.width;
+      if (c.length > y * 2 && (c = q(c, Math.round(y * 1.5))), c.length < 2) continue;
+      const k = this.stores[n].last()?.value ?? c[c.length - 1].value, w = this.resolveLayerColor(n, k), B = this.buildThresholdPaint(t, w), L = c[c.length - 1], z = this.stores[n].last(), D = z !== void 0 && L.time === z.time, F = D ? this.entranceProgress(n, L.time) : 1, C = D && m === "fade" && F < 1, O = (D ? this.trailingEndpoint(t, n) : null) ?? {
+        x: i.timeToBitmapXExact(L.time),
+        y: o.valueToBitmapYExact(this.effectiveValue(t, n, L.time, L.value))
+      }, W = O.x, I = O.y, $ = D && m === "grow" ? this.chainedTailPositions(t, n) : null, G = u < 1;
+      (G || C) && (s.save(), G && (s.globalAlpha *= u), C && (s.globalAlpha *= F));
+      const _ = c.length - 1, h = [];
+      let d = null;
+      for (let g = 0; g < _; g++) {
+        const S = c[g].value;
+        if (!o.isPlottable(S)) {
+          d = null;
           continue;
         }
-        T || (T = [], d.push(T));
-        const g = x?.get(u[P].time);
-        if (g)
-          T.push({ x: g.x, y: g.y });
+        d || (d = [], h.push(d));
+        const M = $?.get(c[g].time);
+        if (M)
+          d.push({ x: M.x, y: M.y });
         else {
-          const L = s.valueToBitmapY(this.effectiveValue(t, h, u[P].time, B));
-          T.push({ x: i.timeToBitmapX(u[P].time), y: L });
+          const Y = o.valueToBitmapYExact(this.effectiveValue(t, n, c[g].time, S));
+          d.push({ x: i.timeToBitmapXExact(c[g].time), y: Y });
         }
       }
-      const k = u[S]?.value, V = Number.isFinite(G) && Number.isFinite(c) && Number.isFinite(k), X = p === "grow" && N < 1;
-      let H = null;
-      if (V && (T ? (T.push({ x: G, y: c }), H = T) : d.push([{ x: G, y: c }])), l && d.some((P) => P.length >= 2)) {
-        o.beginPath();
-        for (const P of d)
-          P.length < 2 || f(y, { points: P, color: M, lineWidth: a, closing: !1, grew: X && P === H });
-        o.strokeStyle = I ? I.stroke : M, o.lineWidth = a, o.lineJoin = "round", o.lineCap = "round", o.stroke();
+      const b = c[_]?.value, A = Number.isFinite(W) && Number.isFinite(I) && o.isPlottable(b), P = m === "grow" && F < 1;
+      let T = null;
+      if (A && (d ? (d.push({ x: W, y: I }), T = d) : h.push([{ x: W, y: I }])), f && h.some((g) => g.length >= 2)) {
+        s.beginPath();
+        for (const g of h)
+          g.length < 2 || p(v, { points: g, color: w, lineWidth: r, closing: !1, grew: P && g === T });
+        s.strokeStyle = B ? B.stroke : w, s.lineWidth = r, s.lineJoin = "round", s.lineCap = "round", s.stroke();
       }
-      if (l) {
-        const P = Math.max(1, a / 2);
-        let B = !1;
-        for (const g of d)
-          g.length === 1 && (B || (o.beginPath(), B = !0), o.moveTo(g[0].x + P, g[0].y), o.arc(g[0].x, g[0].y, P, 0, Math.PI * 2));
-        B && (o.fillStyle = M, o.fill());
+      if (f) {
+        const g = Math.max(1, r / 2);
+        let S = !1;
+        for (const M of h)
+          M.length === 1 && (S || (s.beginPath(), S = !0), s.moveTo(M[0].x + g, M[0].y), s.arc(M[0].x, M[0].y, g, 0, Math.PI * 2));
+        S && (s.fillStyle = w, s.fill());
       }
       if (this.options.area.visible && !this.introGhostPass) {
-        const P = e.bitmapSize.height;
-        let B;
-        if (I)
-          B = I.area;
+        const g = e.bitmapSize.height;
+        let S;
+        if (B)
+          S = B.area;
         else {
-          const g = String(h), L = this.areaGradientCache.get(g);
-          L && L.bottomY === P && L.color === M ? B = L.gradient : (B = o.createLinearGradient(0, 0, 0, P), B.addColorStop(0, C(M, 0.12)), B.addColorStop(1, C(M, 0.01)), this.areaGradientCache.set(g, { gradient: B, bottomY: P, color: M }));
+          const M = String(n), Y = this.areaGradientCache.get(M);
+          Y && Y.bottomY === g && Y.color === w ? S = Y.gradient : (S = s.createLinearGradient(0, 0, 0, g), S.addColorStop(0, X(w, 0.12)), S.addColorStop(1, X(w, 0.01)), this.areaGradientCache.set(M, { gradient: S, bottomY: g, color: w }));
         }
-        o.fillStyle = B;
-        for (const g of d)
-          g.length < 2 || (o.beginPath(), f(y, { points: g, color: M, lineWidth: a, closing: !0, grew: X && g === H }), o.lineTo(g[g.length - 1].x, P), o.lineTo(g[0].x, P), o.closePath(), o.fill());
+        s.fillStyle = S;
+        for (const M of h)
+          M.length < 2 || (s.beginPath(), p(v, { points: M, color: w, lineWidth: r, closing: !0, grew: P && M === T }), s.lineTo(M[M.length - 1].x, g), s.lineTo(M[0].x, g), s.closePath(), s.fill());
       }
       if (this.options.points?.visible) {
-        const P = [];
-        for (const B of d)
-          for (const g of B) P.push(g);
-        this.drawPointMarkers({ context: o, points: P, pixelRatio: e.horizontalPixelRatio, color: M });
+        const g = [];
+        for (const S of h)
+          for (const M of S) g.push(M);
+        this.drawPointMarkers({ context: s, points: g, pixelRatio: e.horizontalPixelRatio, color: w });
       }
-      (W || b) && o.restore();
+      (C || G) && s.restore();
     }
   }
   /** Stacked area rendering */
   renderStacked(t, e) {
-    const { scope: i, timeScale: s, yScale: o } = t, { context: n } = i, r = s.getRange(), { verticalPixelRatio: l } = i, a = this.options.strokeWidth > 0, p = Math.max(1, Math.round(this.options.strokeWidth * l)), f = this.options.curve ?? "straight", y = i.mediaSize.width, h = this.stores.map((c, x) => {
-      if (this.getLayerAlpha(x) <= 0) return [];
-      let b = c.getVisibleData(r.from, r.to);
-      return b.length > y * 2 && (b = j(b, Math.round(y * 1.5))), b;
-    }), m = /* @__PURE__ */ new Set();
-    for (const c of h)
-      for (const x of c) m.add(x.time);
-    const u = Array.from(m).sort((c, x) => c - x);
-    if (u.length < 2) return;
-    const A = h.map((c, x) => {
+    const { scope: i, timeScale: o, yScale: s } = t, { context: l } = i, a = o.getRange(), { verticalPixelRatio: f } = i, r = this.options.strokeWidth > 0, m = Math.max(1, Math.round(this.options.strokeWidth * f)), p = this.options.curve ?? "straight", v = i.mediaSize.width, n = this.stores.map((h, d) => {
+      if (this.getLayerAlpha(d) <= 0) return [];
+      let b = h.getVisibleData(a.from, a.to);
+      return b.length > v * 2 && (b = q(b, Math.round(v * 1.5))), b;
+    }), u = /* @__PURE__ */ new Set();
+    for (const h of n)
+      for (const d of h) u.add(d.time);
+    const c = Array.from(u).sort((h, d) => h - d);
+    if (c.length < 2) {
+      this.stackedEdges = null;
+      return;
+    }
+    const y = this.options.entryAnimation ?? "grow", k = n.map((h, d) => {
       const b = /* @__PURE__ */ new Map();
-      if (c.length === 0) return b;
-      const S = this.getLayerAlpha(x), d = c[0].time;
-      for (const T of u) {
-        if (T < d) continue;
-        const k = U(c, T, (V) => this.effectiveValue(t, x, V.time, V.value));
-        k !== null && b.set(T, k * S);
+      if (h.length === 0) return b;
+      const A = h[0].time, P = y === "grow" ? this.chainedTailValues(d, (g, S) => this.effectiveValue(t, d, g, S)) : null, T = (g) => P?.get(g.time) ?? this.effectiveValue(t, d, g.time, g.value);
+      for (const g of c) {
+        if (g < A) continue;
+        const S = j(h, g, { resolve: T });
+        S !== null && b.set(g, S);
       }
       return b;
-    }), R = Array.from({ length: this.stores.length }, () => new Array(u.length).fill(0));
-    for (let c = 0; c < u.length; c++) {
-      const x = u[c];
+    }), w = this.stores.map((h, d) => this.getLayerAlpha(d)), B = (h, d) => {
+      const b = k[h].get(d);
+      return b === void 0 ? void 0 : b * w[h];
+    }, L = s.getTransform() !== null && !e, z = Array.from({ length: this.stores.length }, () => new Array(c.length).fill(0));
+    for (let h = 0; h < c.length; h++) {
+      const d = c[h];
+      if (L) {
+        const P = new et(s);
+        for (let T = 0; T < this.stores.length; T++) {
+          const g = k[T].get(d);
+          g !== void 0 && s.isPlottable(g) && P.push(g, w[T]), z[T][h] = P.edge;
+        }
+        continue;
+      }
       let b = 0;
       if (e)
-        for (let d = 0; d < this.stores.length; d++) {
-          const T = A[d].get(x);
-          Number.isFinite(T) && (b += T);
+        for (let P = 0; P < this.stores.length; P++) {
+          const T = B(P, d);
+          T !== void 0 && s.isPlottable(T) && (b += T);
         }
-      let S = 0;
-      for (let d = 0; d < this.stores.length; d++) {
-        const T = A[d].get(x), k = Number.isFinite(T) ? T : 0;
-        S += e && b > 0 ? k / b * 100 : k, R[d][c] = S;
+      let A = 0;
+      for (let P = 0; P < this.stores.length; P++) {
+        const T = B(P, d), g = T !== void 0 && s.isPlottable(T) ? T : 0;
+        A += e && b > 0 ? g / b * 100 : g, z[P][h] = A;
       }
     }
-    const M = this.options.entryAnimation ?? "grow", I = /* @__PURE__ */ new Map();
-    for (let c = 0; c < u.length; c++) I.set(u[c], c);
+    const D = /* @__PURE__ */ new Map();
+    for (let h = 0; h < c.length; h++) D.set(c[h], h);
     const F = new Array(this.stores.length).fill(1);
-    for (let c = 0; c < this.stores.length; c++) {
-      if (this.getLayerAlpha(c) <= 0) continue;
-      const x = this.unsettledTail(c), b = x.length;
+    for (let h = 0; h < this.stores.length; h++) {
+      if (this.getLayerAlpha(h) <= 0) continue;
+      const d = this.unsettledTail(h), b = d.length;
       if (b === 0) continue;
-      let S = !0;
-      for (let d = 0; d < b; d++)
-        if (I.get(x[d].time) !== u.length - b + d) {
-          S = !1;
+      let A = !0;
+      for (let P = 0; P < b; P++)
+        if (D.get(d[P].time) !== c.length - b + P) {
+          A = !1;
           break;
         }
-      S && (F[c] = x[b - 1].progress);
+      A && (F[h] = d[b - 1].progress);
     }
-    const z = [];
-    if (M === "grow")
-      for (let c = u.length - 1; c >= 0; c--) {
-        const x = u[c];
-        let b = 1, S = !1;
-        for (let d = 0; d < this.stores.length; d++) {
-          if (this.getLayerAlpha(d) <= 0 || this.entries[d]?.get(x) === void 0) continue;
-          const T = this.entranceProgress(d, x);
-          T >= 1 || (S = !0, T < b && (b = T));
+    const C = [];
+    if (y === "grow") {
+      const h = n.map((d) => d.length - 1);
+      for (let d = c.length - 1; d >= 1; d--) {
+        const b = c[d];
+        let A = 1, P = !1;
+        for (let T = 0; T < n.length; T++) {
+          if (this.getLayerAlpha(T) <= 0) continue;
+          const g = n[T];
+          for (; h[T] >= 0 && g[h[T]].time > b; ) h[T]--;
+          if (h[T] < 0 || g[h[T]].time !== b) continue;
+          const S = this.entranceProgress(T, b);
+          (!P || S > A) && (A = S), P = !0;
         }
-        if (!S) break;
-        z.unshift(_(b));
+        if (!P || A >= 1) break;
+        C.unshift(U(A));
       }
-    const D = (c, x) => {
-      const b = x.length;
-      if (!(b === 0 || c.length < b + 1))
-        for (let S = 0; S < b; S++) {
-          const d = c.length - b + S, T = c[d - 1], k = c[d];
-          c[d] = [Y(T[0], k[0], x[S]), Y(T[1], k[1], x[S])];
+    }
+    const O = (h, d) => {
+      const b = d.length;
+      if (!(b === 0 || h.length < b + 1))
+        for (let A = 0; A < b; A++) {
+          const P = h.length - b + A;
+          h[P][0] = N(h[P - 1][0], h[P][0], d[A]);
         }
-    }, N = i.bitmapSize.height;
-    let W = -1, E = -1;
-    for (let c = 0; c < this.stores.length; c++)
-      if (!(this.getLayerAlpha(c) <= 0))
-        if (W < 0)
-          W = c;
+    }, W = i.bitmapSize.height;
+    let I = -1, $ = -1;
+    for (let h = 0; h < this.stores.length; h++)
+      if (!(this.getLayerAlpha(h) <= 0))
+        if (I < 0)
+          I = h;
         else {
-          E = c;
+          $ = h;
           break;
         }
-    const G = W >= 0 ? this.getLayerAlpha(W) : 1;
-    for (let c = this.stores.length - 1; c >= 0; c--) {
-      const x = this.getLayerAlpha(c);
-      if (x <= 0) continue;
-      const b = this.stores[c].last()?.value ?? 0, S = this.resolveLayerColor(c, b), d = c === W, T = E >= 0 && c === E && G < 1, k = [];
-      for (let g = 0; g < u.length; g++) {
-        const L = c > 0 ? o.valueToBitmapY(R[c - 1][g]) : N;
-        let O = L;
-        d ? O = N : T && (O = L + (N - L) * (1 - G)), k.push([s.timeToBitmapX(u[g]), O]);
+    const G = I >= 0 ? this.getLayerAlpha(I) : 1, _ = n.map((h, d) => d === I ? Math.min(1, this.getLayerAlpha(d)) : 1);
+    for (let h = this.stores.length - 1; h >= 0; h--) {
+      const d = this.getLayerAlpha(h);
+      if (d <= 0) continue;
+      const b = this.stores[h].last()?.value ?? 0, A = this.resolveLayerColor(h, b), P = h === I, T = $ >= 0 && h === $ && G < 1, g = [];
+      for (let R = 0; R < c.length; R++) {
+        const V = h > 0 ? s.valueToBitmapYExact(z[h - 1][R]) : W;
+        let H = V;
+        P ? H = W : T && (H = V + (W - V) * (1 - G)), g.push([o.timeToBitmapXExact(c[R]), H]);
       }
-      M === "grow" && !d && D(k, z);
-      const V = [];
-      for (let g = 0; g < u.length; g++) {
-        let L = o.valueToBitmapY(R[c][g]);
-        d && x < 1 && (L = N + (L - N) * x), V.push([s.timeToBitmapX(u[g]), L]);
+      y === "grow" && O(g, C);
+      const S = [];
+      for (let R = 0; R < c.length; R++) {
+        let V = s.valueToBitmapYExact(z[h][R]);
+        P && d < 1 && (V = W + (V - W) * d), S.push([o.timeToBitmapXExact(c[R]), V]);
       }
-      M === "grow" && D(V, z);
-      const X = Z(V), H = q(X, f, M === "grow" && z.length > 0), P = M === "fade" && F[c] < 1;
-      if (P && (n.save(), n.globalAlpha *= F[c]), this.options.area.visible && !this.introGhostPass) {
-        let g = V[0][1], L = k[0][1];
-        for (let w = 1; w < V.length; w++)
-          V[w][1] < g && (g = V[w][1]);
-        for (let w = 1; w < k.length; w++)
-          k[w][1] > L && (L = k[w][1]);
-        let O = C(S, 0.25);
-        if (L > g + 0.5) {
-          const w = n.createLinearGradient(0, g, 0, L);
-          w.addColorStop(0, C(S, 0.25)), w.addColorStop(1, C(S, 0.05)), O = w;
+      y === "grow" && O(S, C);
+      const M = ot(S), Y = tt(M, p, y === "grow" && C.length > 0), K = y === "fade" && F[h] < 1;
+      if (K && (l.save(), l.globalAlpha *= F[h]), this.options.area.visible && !this.introGhostPass) {
+        let R = S[0][1], V = g[0][1];
+        for (let E = 1; E < S.length; E++)
+          S[E][1] < R && (R = S[E][1]);
+        for (let E = 1; E < g.length; E++)
+          g[E][1] > V && (V = g[E][1]);
+        let H = X(A, 0.25);
+        if (V > R + 0.5) {
+          const E = l.createLinearGradient(0, R, 0, V);
+          E.addColorStop(0, X(A, 0.25)), E.addColorStop(1, X(A, 0.05)), H = E;
         }
-        if (n.beginPath(), n.moveTo(X[0].x, X[0].y), K(n, H), d)
-          for (let w = k.length - 1; w >= 0; w--)
-            n.lineTo(k[w][0], k[w][1]);
+        if (l.beginPath(), l.moveTo(M[0].x, M[0].y), st(l, Y), P)
+          for (let E = g.length - 1; E >= 0; E--)
+            l.lineTo(g[E][0], g[E][1]);
         else {
-          const w = Z(k), nt = q(w, f, M === "grow" && z.length > 0), J = w[w.length - 1];
-          n.lineTo(J.x, J.y), ft(n, w, nt);
+          const E = ot(g), ct = tt(E, p, y === "grow" && C.length > 0), Z = E[E.length - 1];
+          l.lineTo(Z.x, Z.y), yt(l, E, ct);
         }
-        n.closePath(), n.fillStyle = O, n.fill();
+        l.closePath(), l.fillStyle = H, l.fill();
       }
-      const B = a && x < 1;
-      if (B && (n.save(), n.globalAlpha *= x), a && (n.beginPath(), n.moveTo(X[0].x, X[0].y), K(n, H), n.strokeStyle = S, n.lineWidth = p, n.lineJoin = "round", n.lineCap = "round", n.stroke()), B && n.restore(), this.options.points?.visible) {
-        const g = x < 1;
-        g && (n.save(), n.globalAlpha *= x), this.drawPointMarkers({ context: n, points: X, pixelRatio: i.horizontalPixelRatio, color: S }), g && n.restore();
+      const Q = r && d < 1;
+      if (Q && (l.save(), l.globalAlpha *= d), r && (l.beginPath(), l.moveTo(M[0].x, M[0].y), st(l, Y), l.strokeStyle = A, l.lineWidth = m, l.lineJoin = "round", l.lineCap = "round", l.stroke()), Q && l.restore(), this.options.points?.visible) {
+        const R = d < 1;
+        R && (l.save(), l.globalAlpha *= d), this.drawPointMarkers({ context: l, points: M, pixelRatio: i.horizontalPixelRatio, color: A }), R && l.restore();
       }
-      P && n.restore();
+      K && l.restore();
     }
+    this.stackedEdges = { times: c, cumulative: z, growChain: C, collapse: _ };
   }
   /**
    * Overlay hook: draws crosshair nearest-point dots and last-point pulse dots.
@@ -675,54 +772,55 @@ class mt extends rt {
    */
   drawOverlay(t) {
     this.tickAnimations(performance.now());
-    const { scope: e, timeScale: i, yScale: s, crosshair: o, dataInterval: n } = t, r = e, l = this.options.pulseMs, a = l > 0 ? performance.now() / (l * 2 * Math.PI) % 1 : 0;
-    if (o) {
-      const y = this.options.stacking, h = 4 * r.horizontalPixelRatio;
-      for (let m = 0; m < this.stores.length; m++) {
-        const u = this.getLayerAlpha(m);
-        if (u <= 0) continue;
-        const A = this.stores[m].findNearest(o.time, n);
-        if (!A) continue;
-        const R = this.resolveLayerColor(m, A.value), { x: M, y: I } = y === "off" ? {
-          x: i.timeToBitmapX(A.time),
-          y: s.valueToBitmapY(this.effectiveValue(t, m, A.time, A.value))
-        } : this.stackedPositionAt(t, m, A.time), F = u < 1;
-        F && (e.context.save(), e.context.globalAlpha *= u), e.context.save(), e.context.globalAlpha *= 0.25, e.context.beginPath(), e.context.arc(M, I, h + 3 * r.horizontalPixelRatio, 0, Math.PI * 2), e.context.fillStyle = R, e.context.fill(), e.context.restore(), e.context.beginPath(), e.context.arc(M, I, h, 0, Math.PI * 2), e.context.fillStyle = R, e.context.fill(), F && e.context.restore();
+    const { scope: e, timeScale: i, yScale: o, crosshair: s, dataInterval: l } = t, a = e, f = this.options.pulseMs, r = f > 0 ? performance.now() / (f * 2 * Math.PI) % 1 : 0;
+    if (s) {
+      const v = this.options.stacking, n = 4 * a.horizontalPixelRatio;
+      for (let u = 0; u < this.stores.length; u++) {
+        const c = this.getLayerAlpha(u);
+        if (c <= 0) continue;
+        const y = this.stores[u].findNearest(s.time, l);
+        if (!y || v === "off" && !o.isPlottable(y.value)) continue;
+        const k = this.resolveLayerColor(u, y.value), { x: w, y: B } = v === "off" ? {
+          x: i.timeToBitmapXExact(y.time),
+          y: o.valueToBitmapYExact(this.effectiveValue(t, u, y.time, y.value))
+        } : this.stackedPositionAt(t, u, y.time), L = c < 1;
+        L && (e.context.save(), e.context.globalAlpha *= c), e.context.save(), e.context.globalAlpha *= 0.25, e.context.beginPath(), e.context.arc(w, B, n + 3 * a.horizontalPixelRatio, 0, Math.PI * 2), e.context.fillStyle = k, e.context.fill(), e.context.restore(), e.context.beginPath(), e.context.arc(w, B, n, 0, Math.PI * 2), e.context.fillStyle = k, e.context.fill(), L && e.context.restore();
       }
     }
-    const p = this.introWave.active && this.introDirectives?.clip !== void 0;
-    let f = 1;
-    if (p && (f = Math.max(0, (this.introWave.linear() - (1 - $)) / $)), this.hasPulse && l > 0 && f > 0) {
-      const y = this.options.stacking;
-      for (let h = 0; h < this.stores.length; h++) {
-        const m = this.getLayerAlpha(h);
-        if (m <= 0) continue;
-        const u = this.stores[h].last()?.value ?? 0, A = this.resolveLayerColor(h, u);
-        if (y === "off") {
-          const F = this.trailingEndpoint(t, h);
-          if (!F) continue;
+    const m = this.introWave.active && this.introDirectives?.clip !== void 0;
+    let p = 1;
+    if (m && (p = Math.max(0, (this.introWave.linear() - (1 - J)) / J)), this.hasPulse && f > 0 && p > 0) {
+      const v = this.options.stacking;
+      for (let n = 0; n < this.stores.length; n++) {
+        const u = this.getLayerAlpha(n);
+        if (u <= 0) continue;
+        const c = this.stores[n].last()?.value ?? 0, y = this.resolveLayerColor(n, c);
+        if (v === "off") {
+          if (!o.isPlottable(c)) continue;
+          const L = this.trailingEndpoint(t, n);
+          if (!L) continue;
           this.drawPulse({
             ctx: e.context,
-            x: F.x,
-            y: F.y,
-            color: A,
-            pixelRatio: r.horizontalPixelRatio,
-            phase: a,
-            alpha: m * f
+            x: L.x,
+            y: L.y,
+            color: y,
+            pixelRatio: a.horizontalPixelRatio,
+            phase: r,
+            alpha: u * p
           });
           continue;
         }
-        const R = this.stores[h].last();
-        if (!R) continue;
-        const { x: M, y: I } = this.stackedPositionAt(t, h, R.time);
+        const k = this.stores[n].last();
+        if (!k) continue;
+        const { x: w, y: B } = this.stackedPositionAt(t, n, k.time);
         this.drawPulse({
           ctx: e.context,
-          x: M,
-          y: I,
-          color: A,
-          pixelRatio: r.horizontalPixelRatio,
-          phase: a,
-          alpha: m * f
+          x: w,
+          y: B,
+          color: y,
+          pixelRatio: a.horizontalPixelRatio,
+          phase: r,
+          alpha: u * p
         });
       }
     }
@@ -731,24 +829,24 @@ class mt extends rt {
     ctx: t,
     x: e,
     y: i,
-    color: s,
-    pixelRatio: o,
-    phase: n,
-    alpha: r = 1
+    color: o,
+    pixelRatio: s,
+    phase: l,
+    alpha: a = 1
   }) {
-    const l = 3 * o, a = 0.4 + 0.6 * Math.abs(Math.sin(n * 2 * Math.PI)), p = l + 4 * o * a, f = r < 1;
-    f && (t.save(), t.globalAlpha *= r), t.beginPath(), t.arc(e, i, p, 0, Math.PI * 2), t.fillStyle = C(s, a * 0.3), t.fill(), t.beginPath(), t.arc(e, i, l, 0, Math.PI * 2), t.fillStyle = s, t.fill(), f && t.restore();
+    const f = 3 * s, r = 0.4 + 0.6 * Math.abs(Math.sin(l * 2 * Math.PI)), m = f + 4 * s * r, p = a < 1;
+    p && (t.save(), t.globalAlpha *= a), t.beginPath(), t.arc(e, i, m, 0, Math.PI * 2), t.fillStyle = X(o, r * 0.3), t.fill(), t.beginPath(), t.arc(e, i, f, 0, Math.PI * 2), t.fillStyle = o, t.fill(), p && t.restore();
   }
 }
-const Pt = {
+const Bt = {
   type: "line",
-  create: ({ theme: v, layerCount: t }, e) => new mt(t, {
-    colors: t === 1 ? [v.line.color] : v.seriesColors.slice(0, t),
-    strokeWidth: v.line.width,
+  create: ({ theme: x, layerCount: t }, e) => new bt(t, {
+    colors: t === 1 ? [x.line.color] : x.seriesColors.slice(0, t),
+    strokeWidth: x.line.width,
     ...e
   })
 };
 export {
-  mt as LineRenderer,
-  Pt as LineSeriesDef
+  bt as LineRenderer,
+  Bt as LineSeriesDef
 };