@wick-charts/vue 0.8.0 → 0.8.1

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

@@ -1,10 +1,10 @@
 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 $ } from "../animation/easing.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 { hexToRgba as C } from "../utils/color.js";
+import { lerp as z } from "../utils/math.js";
 import { BaseMultiLayerSeries as ut } from "./base-multi-layer.js";
-import { unfoldIntro as ft, scaleMean as mt, backfillSweepIntro as pt } from "./line-intro.js";
+import { unfoldIntro as mt, scaleMean as pt, backfillSweepIntro as ft } from "./line-intro.js";
 import { buildCurveSegments as tt, replaySegmentsForward as et, replaySegmentsReversed as gt } from "./painters/canvas-path.js";
 import { resolveLinePainter as dt } from "./painters/resolve.js";
 import { ScaleStack as it } from "./scale-stack.js";
@@ -36,22 +36,24 @@ function ot(y) {
 function st(y) {
   return y.map(([t, i]) => ({ x: t, y: i }));
 }
-const J = 0.15, xt = pt();
+const J = 0.15, xt = ft();
 function j(y, t, i) {
-  const { resolve: e, lerp: o = N } = i;
+  const { resolve: e, lerp: o = z } = i;
   if (y.length === 0) return null;
   if (t <= y[0].time) return Number.isFinite(y[0].value) ? e(y[0]) : null;
   const s = y[y.length - 1];
   if (t >= s.time) return Number.isFinite(s.value) ? e(s) : null;
-  let l = 0, r = y.length - 1;
-  for (; r - l > 1; ) {
-    const c = l + r >> 1;
-    y[c].time <= t ? l = c : r = c;
-  }
-  const f = y[l], h = y[r];
-  if (!Number.isFinite(f.value) || !Number.isFinite(h.value)) return null;
-  const m = h.time - f.time;
-  return m <= 0 ? e(f) : o(e(f), e(h), (t - f.time) / m);
+  let a = 0, r = y.length - 1;
+  for (; r - a > 1; ) {
+    const c = a + r >> 1;
+    y[c].time <= t ? a = c : r = c;
+  }
+  const m = y[a];
+  if (m.time === t) return Number.isFinite(m.value) ? e(m) : null;
+  const h = y[r];
+  if (!Number.isFinite(m.value) || !Number.isFinite(h.value)) return null;
+  const p = h.time - m.time;
+  return p <= 0 ? e(m) : o(e(m), e(h), (t - m.time) / p);
 }
 function yt(y, t) {
   let i = 0, e = y.length - 1;
@@ -106,8 +108,8 @@ class Pt extends ut {
     }
     const o = this.historyDirectives, s = o?.ghostAlpha ?? 0;
     s > 0 && (i.save(), i.globalAlpha *= s, this.introGhostPass = !0, this.renderBody(t), this.introGhostPass = !1, i.restore());
-    const l = this.applyHistoryClip(t, o, e);
-    this.introWave.active ? this.renderWithIntro(t) : (this.introDirectives = null, this.renderBody(t)), l && i.restore(), o?.heads !== void 0 && o.heads.length > 0 && this.drawIntroHeads(t, o.heads, this.historyWave.linear());
+    const a = this.applyHistoryClip(t, o, e);
+    this.introWave.active ? this.renderWithIntro(t) : (this.introDirectives = null, this.renderBody(t)), a && i.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
@@ -117,14 +119,14 @@ class Pt extends ut {
   renderWithIntro(t) {
     const i = this.resolveIntro()(this.buildIntroFrame(t));
     this.introDirectives = i;
-    const { context: e } = t.scope, { width: o, height: s } = t.scope.bitmapSize, l = i.ghostAlpha ?? 0;
-    l > 0 && (e.save(), e.globalAlpha *= l, this.introGhostPass = !0, this.renderBody(t), this.introGhostPass = !1, e.restore());
-    const r = i.clip, f = r !== void 0 && (r.fromX !== void 0 || r.toX !== void 0);
-    if (f) {
-      const h = r.fromX ?? 0, m = r.toX ?? o;
-      e.save(), e.beginPath(), e.rect(h, 0, Math.max(0, m - h), s), e.clip();
+    const { context: e } = t.scope, { width: o, height: s } = t.scope.bitmapSize, a = i.ghostAlpha ?? 0;
+    a > 0 && (e.save(), e.globalAlpha *= a, this.introGhostPass = !0, this.renderBody(t), this.introGhostPass = !1, e.restore());
+    const r = i.clip, m = r !== void 0 && (r.fromX !== void 0 || r.toX !== void 0);
+    if (m) {
+      const h = r.fromX ?? 0, p = r.toX ?? o;
+      e.save(), e.beginPath(), e.rect(h, 0, Math.max(0, p - h), s), e.clip();
     }
-    this.renderBody(t), f && e.restore(), i.heads !== void 0 && i.heads.length > 0 && this.drawIntroHeads(t, i.heads, this.introWave.linear());
+    this.renderBody(t), m && e.restore(), i.heads !== void 0 && i.heads.length > 0 && this.drawIntroHeads(t, i.heads, this.introWave.linear());
   }
   /**
    * Apply the history reveal's clip directive, mapped from reveal space
@@ -135,8 +137,8 @@ class Pt extends ut {
   applyHistoryClip(t, i, e) {
     const o = i?.clip;
     if (o === void 0 || e === null || o.fromX === void 0 && o.toX === void 0) return !1;
-    const { context: s } = t.scope, { width: l, height: r } = t.scope.bitmapSize, f = t.timeScale.timeToBitmapXExact(e.to), h = Math.abs(f - t.timeScale.timeToBitmapXExact(e.from)), m = Math.max(2, (this.options.strokeWidth ?? 1) * t.scope.horizontalPixelRatio), c = o.fromX ?? 0, x = o.toX ?? h;
-    return s.save(), s.beginPath(), s.rect(f - x - m, 0, Math.max(0, x - c + m), r), s.rect(f, 0, Math.max(0, l - f), r), s.clip(), !0;
+    const { context: s } = t.scope, { width: a, height: r } = t.scope.bitmapSize, m = t.timeScale.timeToBitmapXExact(e.to), h = Math.abs(m - t.timeScale.timeToBitmapXExact(e.from)), p = Math.max(2, (this.options.strokeWidth ?? 1) * t.scope.horizontalPixelRatio), c = o.fromX ?? 0, x = o.toX ?? h;
+    return s.save(), s.beginPath(), s.rect(m - x - p, 0, Math.max(0, x - c + p), r), s.rect(m, 0, Math.max(0, a - m), r), s.clip(), !0;
   }
   renderBody(t) {
     this.options.stacking === "off" ? (this.stackedEdges = null, this.renderOff(t)) : this.renderStacked(t, this.options.stacking === "percent");
@@ -166,7 +168,7 @@ class Pt extends ut {
   defaultIntro = null;
   resolveIntro() {
     const t = this.options.introAnimation;
-    return t !== void 0 ? t : (this.defaultIntro === null && (this.defaultIntro = ft()), this.defaultIntro);
+    return t !== void 0 ? t : (this.defaultIntro === null && (this.defaultIntro = mt()), this.defaultIntro);
   }
   /**
    * Frame context handed to the intro fn — progress plus memoized data
@@ -198,39 +200,39 @@ class Pt extends ut {
     });
   }
   buildFrame(t, i) {
-    const { timeScale: e, yScale: o, scope: s } = t, { progress: l, range: r, width: f } = i, h = this.options.stacking === "percent", m = new Array(this.stores.length), c = new Array(this.stores.length);
+    const { timeScale: e, yScale: o, scope: s } = t, { progress: a, range: r, width: m } = i, h = this.options.stacking === "percent", p = new Array(this.stores.length), c = new Array(this.stores.length);
     let x, n;
-    const p = (a) => {
-      let g = m[a];
-      return g === void 0 && (g = this.stores[a]?.getVisibleData(r.from, r.to) ?? [], m[a] = g), g;
+    const f = (l) => {
+      let g = p[l];
+      return g === void 0 && (g = this.stores[l]?.getVisibleData(r.from, r.to) ?? [], p[l] = g), g;
     };
     return {
-      progress: l,
+      progress: a,
       range: r,
-      width: f,
+      width: m,
       height: o.getMediaHeight() * s.verticalPixelRatio,
       stacking: this.options.stacking,
-      timeToX: (a) => e.timeToBitmapXExact(a),
-      xToTime: (a) => e.xToTime(a / s.horizontalPixelRatio),
-      valueToY: (a) => o.valueToBitmapYExact(a),
-      lerpValue: (a, g, A) => o.lerpValue(a, g, A),
+      timeToX: (l) => e.timeToBitmapXExact(l),
+      xToTime: (l) => e.xToTime(l / s.horizontalPixelRatio),
+      valueToY: (l) => o.valueToBitmapYExact(l),
+      lerpValue: (l, g, b) => o.lerpValue(l, g, b),
       layerCount: this.stores.length,
-      layerData: p,
-      layerMean: (a) => {
-        let g = c[a];
-        return g === void 0 && (h ? (x ??= this.meanShares(p, o), g = x[a]) : g = mt(p(a), o), c[a] = g), g;
+      layerData: f,
+      layerMean: (l) => {
+        let g = c[l];
+        return g === void 0 && (h ? (x ??= this.meanShares(f, o), g = x[l]) : g = pt(f(l), o), c[l] = g), g;
       },
       primaryPath: () => {
         if (n === void 0) {
           n = null;
-          for (let a = 0; a < this.stores.length; a++) {
-            if (this.getLayerAlpha(a) <= 0 || !this.stores[a].isVisible()) continue;
-            const g = p(a).filter((A) => o.isPlottable(A.value));
+          for (let l = 0; l < this.stores.length; l++) {
+            if (this.getLayerAlpha(l) <= 0 || !this.stores[l].isVisible()) continue;
+            const g = f(l).filter((b) => o.isPlottable(b.value));
             if (!(g.length < 2)) {
-              n = g.map((A) => ({
-                x: e.timeToBitmapXExact(A.time),
-                y: o.valueToBitmapYExact(A.value),
-                time: A.time
+              n = g.map((b) => ({
+                x: e.timeToBitmapXExact(b.time),
+                y: o.valueToBitmapYExact(b.value),
+                time: b.time
               }));
               break;
             }
@@ -252,9 +254,9 @@ class Pt extends ut {
   }
   /** Layer's share of its column in percent, passed through the intro value transform. */
   introShare(t, i) {
-    const { layerIndex: e, time: o, value: s, total: l } = i;
-    if (l <= 0) return s;
-    const r = s / l * 100;
+    const { layerIndex: e, time: o, value: s, total: a } = i;
+    if (a <= 0) return s;
+    const r = s / a * 100;
     return Math.max(0, this.introValue(t, { layerIndex: e, time: o, value: r }));
   }
   /**
@@ -265,40 +267,40 @@ class Pt extends ut {
   meanShares(t, i) {
     const e = this.stores.length, o = /* @__PURE__ */ new Set();
     for (let h = 0; h < e; h++)
-      for (const m of t(h))
-        o.add(m.time);
-    const s = new Array(e).fill(0), l = new Array(e).fill(!1), r = new Array(e);
-    let f = 0;
+      for (const p of t(h))
+        o.add(p.time);
+    const s = new Array(e).fill(0), a = new Array(e).fill(!1), r = new Array(e);
+    let m = 0;
     for (const h of o) {
-      let m = 0;
+      let p = 0;
       for (let c = 0; c < e; c++) {
         r[c] = null;
         const x = this.getLayerAlpha(c), n = t(c);
         if (x <= 0 || n.length === 0 || h < n[0].time) continue;
-        const p = j(n, h, { resolve: (a) => a.value });
-        p === null || !i.isPlottable(p) || (r[c] = p * x, m += p * x);
+        const f = j(n, h, { resolve: (l) => l.value });
+        f === null || !i.isPlottable(f) || (r[c] = f * x, p += f * x);
       }
-      if (!(m <= 0)) {
-        f++;
+      if (!(p <= 0)) {
+        m++;
         for (let c = 0; c < e; c++) {
           const x = r[c];
-          x !== null && (s[c] += x / m * 100, l[c] = !0);
+          x !== null && (s[c] += x / p * 100, a[c] = !0);
         }
       }
     }
-    return s.map((h, m) => l[m] ? h / f : null);
+    return s.map((h, p) => a[p] ? h / m : null);
   }
   /** The active history-reveal or intro value transform applied to one value. */
   introValue(t, i) {
-    const { layerIndex: e, time: o, value: s } = i, l = this.historyWave.active ? this.historyDirectives?.value : void 0, r = this.historyRange;
-    if (l !== void 0 && r !== null && o < r.to) {
+    const { layerIndex: e, time: o, value: s } = i, a = this.historyWave.active ? this.historyDirectives?.value : void 0, r = this.historyRange;
+    if (a !== void 0 && r !== null && o < r.to) {
       const x = r.to - r.from, n = x > 0 ? Math.min(1, Math.max(0, (r.to - o) / x)) : 0;
-      return l({ layerIndex: e, time: o, value: s, position: n });
+      return a({ layerIndex: e, time: o, value: s, position: n });
     }
-    const f = this.introWave.active ? this.introDirectives?.value : void 0;
-    if (f === void 0) return s;
-    const h = t.timeScale.getRange(), m = h.to - h.from, c = m > 0 ? Math.min(1, Math.max(0, (o - h.from) / m)) : 0;
-    return f({ layerIndex: e, time: o, value: s, position: c });
+    const m = this.introWave.active ? this.introDirectives?.value : void 0;
+    if (m === void 0) return s;
+    const h = t.timeScale.getRange(), p = h.to - h.from, c = p > 0 ? Math.min(1, Math.max(0, (o - h.from) / p)) : 0;
+    return m({ layerIndex: e, time: o, value: s, position: c });
   }
   /**
    * Extends the base last-value query with the 'grow' entrance's value-space
@@ -322,22 +324,22 @@ class Pt extends ut {
     if (e.length === 0) return null;
     const o = this.stores[t].getAll(), s = o.length - 1 - e.length;
     if (s < 0) return null;
-    const l = o[s];
-    if (!Number.isFinite(l.value)) return null;
-    let r = i(l.time, l.value);
-    const f = /* @__PURE__ */ new Map();
+    const a = o[s];
+    if (!Number.isFinite(a.value)) return null;
+    let r = i(a.time, a.value);
+    const m = /* @__PURE__ */ new Map();
     for (let h = 0; h < e.length; h++) {
-      const m = o[s + 1 + h];
-      if (!Number.isFinite(m.value)) return null;
-      const c = $(e[h].progress), x = i(m.time, m.value), n = this.axisLerp(r, x, c);
-      f.set(m.time, n), r = n;
+      const p = o[s + 1 + h];
+      if (!Number.isFinite(p.value)) return null;
+      const c = U(e[h].progress), x = i(p.time, p.value), n = this.axisLerp(r, x, c);
+      m.set(p.time, n), r = n;
     }
-    return f;
+    return m;
   }
   /** `lerp` along the last rendered Y axis — plain before the first render. */
   axisLerp(t, i, e) {
     const o = this.lastYScale;
-    return o === null ? N(t, i, e) : o.lerpValue(t, i, e);
+    return o === null ? z(t, i, e) : o.lerpValue(t, i, e);
   }
   /**
    * Glowing pulse dots riding the intro's head anchors — the line reads as
@@ -347,14 +349,14 @@ class Pt extends ut {
    */
   drawIntroHeads(t, i, e) {
     if (this.options.stacking !== "off") return;
-    const o = Math.min(1, e / J), s = Math.min(1, (1 - e) / J), l = Math.max(0, Math.min(o, s));
-    if (l <= 0) return;
+    const o = Math.min(1, e / J), s = Math.min(1, (1 - e) / J), a = Math.max(0, Math.min(o, s));
+    if (a <= 0) return;
     const { scope: r } = t;
-    for (const f of i)
+    for (const m of i)
       for (let h = 0; h < this.stores.length; h++) {
-        const m = this.getLayerAlpha(h);
-        if (m <= 0 || !this.stores[h].isVisible()) continue;
-        const c = this.introHeadAnchor(t, h, f);
+        const p = this.getLayerAlpha(h);
+        if (p <= 0 || !this.stores[h].isVisible()) continue;
+        const c = this.introHeadAnchor(t, h, m);
         c !== null && this.drawPulse({
           ctx: r.context,
           x: c.x,
@@ -362,7 +364,7 @@ class Pt extends ut {
           color: this.resolveLayerColor(h, c.value),
           pixelRatio: r.horizontalPixelRatio,
           phase: e * 2,
-          alpha: l * m
+          alpha: a * p
         });
       }
   }
@@ -378,13 +380,13 @@ class Pt extends ut {
    * visible range, not the data span) and jumps back on settle.
    */
   introHeadAnchor(t, i, e) {
-    const { timeScale: o, yScale: s } = t, l = o.getRange(), r = this.stores[i].getVisibleData(l.from, l.to);
+    const { timeScale: o, yScale: s } = t, a = o.getRange(), r = this.stores[i].getVisibleData(a.from, a.to);
     if (r.length === 0) return null;
-    const f = this.stores[i].last();
-    if (f !== void 0 && e.time >= f.time) {
-      if (!s.isPlottable(f.value)) return null;
+    const m = this.stores[i].last();
+    if (m !== void 0 && e.time >= m.time) {
+      if (!s.isPlottable(m.value)) return null;
       const c = this.trailingEndpoint(t, i);
-      return c === null ? null : { x: c.x, y: c.y, value: f.value };
+      return c === null ? null : { x: c.x, y: c.y, value: m.value };
     }
     const h = r[0];
     if (e.time <= h.time) {
@@ -396,12 +398,12 @@ class Pt extends ut {
         value: h.value
       };
     }
-    const m = j(r, e.time, {
+    const p = j(r, e.time, {
       resolve: (c) => this.effectiveValue(t, i, c.time, c.value),
       // Along the axis, so the dot stays on the straight segment the stroke draws.
       lerp: (c, x, n) => !s.isPlottable(c) || !s.isPlottable(x) ? Number.NaN : s.lerpValue(c, x, n)
     });
-    return m === null || !s.isPlottable(m) ? null : { x: e.x, y: s.valueToBitmapYExact(m), value: m };
+    return p === null || !s.isPlottable(p) ? null : { x: e.x, y: s.valueToBitmapYExact(p), value: p };
   }
   /**
    * Rendered positions of the layer's still-unsettled trailing points, keyed
@@ -426,49 +428,49 @@ class Pt extends ut {
    * it (see `renderStacked`'s `valueMaps` comment for the full rationale).
    */
   stackedValueAt(t, i, e) {
-    const o = this.options.stacking === "percent", s = (this.options.entryAnimation ?? "grow") === "grow", l = new Array(this.stores.length), r = (n) => {
+    const o = this.options.stacking === "percent", s = (this.options.entryAnimation ?? "grow") === "grow", a = new Array(this.stores.length), r = (n) => {
       if (!s) return null;
-      const p = l[n];
-      if (p !== void 0) return p;
-      const a = this.chainedTailValues(n, (g, A) => this.effectiveValue(t, n, g, A));
-      return l[n] = a, a;
-    }, f = (n) => {
-      const p = this.stores[n].getAll();
-      if (p.length === 0 || e < p[0].time) return null;
-      const a = r(n);
-      return j(p, e, {
-        resolve: (g) => a?.get(g.time) ?? this.effectiveValue(t, n, g.time, g.value)
+      const f = a[n];
+      if (f !== void 0) return f;
+      const l = this.chainedTailValues(n, (g, b) => this.effectiveValue(t, n, g, b));
+      return a[n] = l, l;
+    }, m = (n) => {
+      const f = this.stores[n].getAll();
+      if (f.length === 0 || e < f[0].time) return null;
+      const l = r(n);
+      return j(f, e, {
+        resolve: (g) => l?.get(g.time) ?? this.effectiveValue(t, n, g.time, g.value)
       });
     }, { yScale: h } = t;
     if (h.getTransform() !== null && !o) {
       const n = new it(h);
-      for (let p = 0; p <= i; p++) {
-        const a = this.getLayerAlpha(p), g = a > 0 ? f(p) : null;
-        g !== null && h.isPlottable(g) && n.push(g, a);
+      for (let f = 0; f <= i; f++) {
+        const l = this.getLayerAlpha(f), g = l > 0 ? m(f) : null;
+        g !== null && h.isPlottable(g) && n.push(g, l);
       }
       return n.edge;
     }
-    const m = (n) => {
-      const p = this.getLayerAlpha(n);
-      if (p <= 0) return null;
-      const a = this.stores[n].getAll();
-      if (o && a.length > 0 && e < a[0].time) return 0;
-      const g = f(n);
-      return g === null ? null : g * p;
+    const p = (n) => {
+      const f = this.getLayerAlpha(n);
+      if (f <= 0) return null;
+      const l = this.stores[n].getAll();
+      if (o && l.length > 0 && e < l[0].time) return 0;
+      const g = m(n);
+      return g === null ? null : g * f;
     };
     let c = 0;
     if (o)
       for (let n = 0; n < this.stores.length; n++)
-        c += m(n) ?? 0;
+        c += p(n) ?? 0;
     let x = 0;
     for (let n = 0; n <= i; n++) {
-      const p = m(n);
-      if (p !== null)
+      const f = p(n);
+      if (f !== null)
         if (o) {
-          const a = this.introShare(t, { layerIndex: n, time: e, value: p, total: c });
-          x = Math.min(100, x + a);
+          const l = this.introShare(t, { layerIndex: n, time: e, value: f, total: c });
+          x = Math.min(100, x + l);
         } else
-          x += p;
+          x += f;
     }
     return x;
   }
@@ -486,11 +488,11 @@ class Pt extends ut {
   stackedPositionAt(t, i, e) {
     const o = this.paintedStackVertex(t, i, e);
     if (o !== null) return o;
-    const { timeScale: s, yScale: l } = t, r = l.valueToBitmapYExact(this.stackedValueAt(t, i, e)), f = s.timeToBitmapXExact(e), h = this.unsettledTail(i), m = this.stores[i].getAll(), c = m.length - 1 - h.length;
-    if ((this.options.entryAnimation ?? "grow") !== "grow" || e !== m[m.length - 1]?.time || h.length === 0 || c < 0) return { x: f, y: r };
-    let x = s.timeToBitmapXExact(m[c].time);
+    const { timeScale: s, yScale: a } = t, r = a.valueToBitmapYExact(this.stackedValueAt(t, i, e)), m = s.timeToBitmapXExact(e), h = this.unsettledTail(i), p = this.stores[i].getAll(), c = p.length - 1 - h.length;
+    if ((this.options.entryAnimation ?? "grow") !== "grow" || e !== p[p.length - 1]?.time || h.length === 0 || c < 0) return { x: m, y: r };
+    let x = s.timeToBitmapXExact(p[c].time);
     for (let n = 0; n < h.length; n++)
-      x = N(x, s.timeToBitmapXExact(m[c + 1 + n].time), $(h[n].progress));
+      x = z(x, s.timeToBitmapXExact(p[c + 1 + n].time), U(h[n].progress));
     return { x, y: r };
   }
   /** Upper-edge vertex of layer `li` at column `t`, replayed from the last
@@ -498,29 +500,29 @@ class Pt extends ut {
   paintedStackVertex(t, i, e) {
     const o = this.stackedEdges, s = o?.cumulative[i];
     if (o === null || s === void 0) return null;
-    const { times: l, growChain: r, collapse: f } = o, h = yt(l, e);
+    const { times: a, growChain: r, collapse: m } = o, h = yt(a, e);
     if (h < 0) return null;
-    const { timeScale: m, yScale: c } = t, x = t.scope.bitmapSize.height, n = f[i] ?? 1, p = c.valueToBitmapYExact(s[h]), a = n >= 1 ? p : x + (p - x) * n, g = l.length - r.length;
-    if (h < g) return { x: m.timeToBitmapXExact(e), y: a };
-    let A = m.timeToBitmapXExact(l[g - 1]);
+    const { timeScale: p, yScale: c } = t, x = t.scope.bitmapSize.height, n = m[i] ?? 1, f = c.valueToBitmapYExact(s[h]), l = n >= 1 ? f : x + (f - x) * n, g = a.length - r.length;
+    if (h < g) return { x: p.timeToBitmapXExact(e), y: l };
+    let b = p.timeToBitmapXExact(a[g - 1]);
     for (let E = 0; E <= h - g; E++)
-      A = N(A, m.timeToBitmapXExact(l[g + E]), r[E]);
-    return { x: A, y: a };
+      b = z(b, p.timeToBitmapXExact(a[g + E]), r[E]);
+    return { x: b, y: l };
   }
   chainedTailPositions(t, i) {
     const e = this.unsettledTail(i);
     if (e.length === 0) return null;
     const o = this.stores[i].getAll(), s = o.length - 1 - e.length;
     if (s < 0) return null;
-    const { timeScale: l, yScale: r } = t, f = o[s];
-    if (!r.isPlottable(f.value)) return null;
-    let h = l.timeToBitmapXExact(f.time), m = r.valueToBitmapYExact(this.effectiveValue(t, i, f.time, f.value));
+    const { timeScale: a, yScale: r } = t, m = o[s];
+    if (!r.isPlottable(m.value)) return null;
+    let h = a.timeToBitmapXExact(m.time), p = r.valueToBitmapYExact(this.effectiveValue(t, i, m.time, m.value));
     const c = /* @__PURE__ */ new Map();
     for (let x = 0; x < e.length; x++) {
       const n = o[s + 1 + x];
       if (!r.isPlottable(n.value)) return null;
-      const p = $(e[x].progress), a = l.timeToBitmapXExact(n.time), g = r.valueToBitmapYExact(this.effectiveValue(t, i, n.time, n.value)), A = N(h, a, p), E = N(m, g, p);
-      c.set(n.time, { x: A, y: E }), h = A, m = E;
+      const f = U(e[x].progress), l = a.timeToBitmapXExact(n.time), g = r.valueToBitmapYExact(this.effectiveValue(t, i, n.time, n.value)), b = z(h, l, f), E = z(p, g, f);
+      c.set(n.time, { x: b, y: E }), h = b, p = E;
     }
     return c;
   }
@@ -537,8 +539,8 @@ class Pt extends ut {
   trailingEndpoint(t, i) {
     const e = this.stores[i].last();
     if (!e) return null;
-    const { timeScale: o, yScale: s } = t, l = o.timeToBitmapXExact(e.time), r = s.valueToBitmapYExact(this.effectiveValue(t, i, e.time, e.value));
-    return (this.options.entryAnimation ?? "grow") !== "grow" ? { x: l, y: r } : this.chainedTailPositions(t, i)?.get(e.time) ?? { x: l, y: r };
+    const { timeScale: o, yScale: s } = t, a = o.timeToBitmapXExact(e.time), r = s.valueToBitmapYExact(this.effectiveValue(t, i, e.time, e.value));
+    return (this.options.entryAnimation ?? "grow") !== "grow" ? { x: a, y: r } : this.chainedTailPositions(t, i)?.get(e.time) ?? { x: a, y: r };
   }
   /**
    * Vertical stroke + area gradients for `options.threshold`, pinned to the
@@ -552,10 +554,10 @@ class Pt extends ut {
   buildThresholdPaint(t, i) {
     const e = this.options.threshold;
     if (!e) return null;
-    const { scope: o, yScale: s } = t, { context: l } = o, r = o.bitmapSize.height, f = e.above, h = e.below ?? i, m = Math.min(1, Math.max(0, s.valueToBitmapYExact(e.value) / r)), c = Math.min(6 * o.verticalPixelRatio, r * 0.02) / r, x = Math.max(0, m - c), n = Math.min(1, m + c), p = l.createLinearGradient(0, 0, 0, r);
-    p.addColorStop(0, f), p.addColorStop(x, f), p.addColorStop(n, h), p.addColorStop(1, h);
-    const a = l.createLinearGradient(0, 0, 0, r);
-    return a.addColorStop(0, X(f, 0.26)), a.addColorStop(x, X(f, 0.14)), a.addColorStop(n, X(h, 0.1)), a.addColorStop(1, X(h, 0.01)), { stroke: p, area: a };
+    const { scope: o, yScale: s } = t, { context: a } = o, r = o.bitmapSize.height, m = e.above, h = e.below ?? i, p = Math.min(1, Math.max(0, s.valueToBitmapYExact(e.value) / r)), c = Math.min(6 * o.verticalPixelRatio, r * 0.02) / r, x = Math.max(0, p - c), n = Math.min(1, p + c), f = a.createLinearGradient(0, 0, 0, r);
+    f.addColorStop(0, m), f.addColorStop(x, m), f.addColorStop(n, h), f.addColorStop(1, h);
+    const l = a.createLinearGradient(0, 0, 0, r);
+    return l.addColorStop(0, C(m, 0.26)), l.addColorStop(x, C(m, 0.14)), l.addColorStop(n, C(h, 0.1)), l.addColorStop(1, C(h, 0.01)), { stroke: f, area: l };
   }
   /**
    * Dot markers at each data point (`options.points`). Callers pass the same
@@ -568,61 +570,61 @@ class Pt extends ut {
   drawPointMarkers(t) {
     const i = this.options.points;
     if (!i?.visible) return;
-    const { context: e, points: o, pixelRatio: s, color: l } = t;
+    const { context: e, points: o, pixelRatio: s, color: a } = t;
     if (o.length === 0) return;
     const r = Math.max(1, (i.radius ?? 3) * s);
     if (!(o.length > 1 && (o[o.length - 1].x - o[0].x) / (o.length - 1) < r * 3)) {
       e.beginPath();
-      for (const f of o)
-        e.moveTo(f.x + r, f.y), e.arc(f.x, f.y, r, 0, Math.PI * 2);
-      e.fillStyle = i.color ?? l, e.fill();
+      for (const m of o)
+        e.moveTo(m.x + r, m.y), e.arc(m.x, m.y, r, 0, Math.PI * 2);
+      e.fillStyle = i.color ?? a, e.fill();
     }
   }
   /** Each layer drawn independently */
   renderOff(t) {
-    const { scope: i, timeScale: e, yScale: o } = t, { context: s } = i, l = e.getRange(), { verticalPixelRatio: r } = i, f = this.options.strokeWidth > 0, h = Math.max(1, Math.round(this.options.strokeWidth * r)), m = this.options.entryAnimation ?? "grow", c = dt(this.options.linePainter ?? this.options.curve ?? "straight"), x = {
+    const { scope: i, timeScale: e, yScale: o } = t, { context: s } = i, a = e.getRange(), { verticalPixelRatio: r } = i, m = this.options.strokeWidth > 0, h = Math.max(1, Math.round(this.options.strokeWidth * r)), p = this.options.entryAnimation ?? "grow", c = dt(this.options.linePainter ?? this.options.curve ?? "straight"), x = {
       ctx: s,
       theme: t.theme,
       horizontalPixelRatio: i.horizontalPixelRatio,
       verticalPixelRatio: r
     };
     for (let n = 0; n < this.stores.length; n++) {
-      const p = this.getLayerAlpha(n);
-      if (p <= 0) continue;
-      let a = this.stores[n].getVisibleData(l.from, l.to);
+      const f = this.getLayerAlpha(n);
+      if (f <= 0) continue;
+      let l = this.stores[n].getVisibleData(a.from, a.to);
       const g = i.mediaSize.width;
-      if (a.length > g * 2 && (a = q(a, Math.round(g * 1.5))), a.length < 2) continue;
-      const A = this.stores[n].last()?.value ?? a[a.length - 1].value, E = this.resolveLayerColor(n, A), B = this.buildThresholdPaint(t, E), L = a[a.length - 1], D = this.stores[n].last(), Y = D !== void 0 && L.time === D.time, z = Y ? this.entranceProgress(n, L.time) : 1, I = Y && m === "fade" && z < 1, H = (Y ? this.trailingEndpoint(t, n) : null) ?? {
-        x: e.timeToBitmapXExact(L.time),
-        y: o.valueToBitmapYExact(this.effectiveValue(t, n, L.time, L.value))
-      }, W = H.x, C = H.y, _ = Y && m === "grow" ? this.chainedTailPositions(t, n) : null, G = p < 1;
-      (G || I) && (s.save(), G && (s.globalAlpha *= p), I && (s.globalAlpha *= z));
-      const U = a.length - 1, u = [];
+      if (l.length > g * 2 && (l = q(l, Math.round(g * 1.5))), l.length < 2) continue;
+      const b = this.lastFinitePoint(n)?.value ?? l[l.length - 1].value, E = this.resolveLayerColor(n, b), B = this.buildThresholdPaint(t, E), V = l[l.length - 1], Y = this.stores[n].last(), D = Y !== void 0 && V.time === Y.time, N = D ? this.entranceProgress(n, V.time) : 1, I = D && p === "fade" && N < 1, H = (D ? this.trailingEndpoint(t, n) : null) ?? {
+        x: e.timeToBitmapXExact(V.time),
+        y: o.valueToBitmapYExact(this.effectiveValue(t, n, V.time, V.value))
+      }, F = H.x, X = H.y, $ = D && p === "grow" ? this.chainedTailPositions(t, n) : null, G = f < 1;
+      (G || I) && (s.save(), G && (s.globalAlpha *= f), I && (s.globalAlpha *= N));
+      const _ = l.length - 1, u = [];
       let v = null;
-      for (let d = 0; d < U; d++) {
-        const S = a[d].value;
+      for (let d = 0; d < _; d++) {
+        const S = l[d].value;
         if (!o.isPlottable(S)) {
           v = null;
           continue;
         }
         v || (v = [], u.push(v));
-        const w = _?.get(a[d].time);
+        const w = $?.get(l[d].time);
         if (w)
           v.push({ x: w.x, y: w.y });
         else {
-          const F = o.valueToBitmapYExact(this.effectiveValue(t, n, a[d].time, S));
-          v.push({ x: e.timeToBitmapXExact(a[d].time), y: F });
+          const W = o.valueToBitmapYExact(this.effectiveValue(t, n, l[d].time, S));
+          v.push({ x: e.timeToBitmapXExact(l[d].time), y: W });
         }
       }
-      const M = a[U]?.value, b = Number.isFinite(W) && Number.isFinite(C) && o.isPlottable(M), P = m === "grow" && z < 1;
-      let T = null;
-      if (b && (v ? (v.push({ x: W, y: C }), T = v) : u.push([{ x: W, y: C }])), f && u.some((d) => d.length >= 2)) {
+      const T = l[_]?.value, A = Number.isFinite(F) && Number.isFinite(X) && o.isPlottable(T), P = p === "grow" && N < 1;
+      let M = null;
+      if (A && (v ? (v.push({ x: F, y: X }), M = v) : u.push([{ x: F, y: X }])), m && u.some((d) => d.length >= 2)) {
         s.beginPath();
         for (const d of u)
-          d.length < 2 || c(x, { points: d, color: E, lineWidth: h, closing: !1, grew: P && d === T });
+          d.length < 2 || c(x, { points: d, color: E, lineWidth: h, closing: !1, grew: P && d === M });
         s.strokeStyle = B ? B.stroke : E, s.lineWidth = h, s.lineJoin = "round", s.lineCap = "round", s.stroke();
       }
-      if (f) {
+      if (m) {
         const d = Math.max(1, h / 2);
         let S = !1;
         for (const w of u)
@@ -635,12 +637,12 @@ class Pt extends ut {
         if (B)
           S = B.area;
         else {
-          const w = String(n), F = this.areaGradientCache.get(w);
-          F && F.bottomY === d && F.color === E ? S = F.gradient : (S = s.createLinearGradient(0, 0, 0, d), S.addColorStop(0, X(E, 0.12)), S.addColorStop(1, X(E, 0.01)), this.areaGradientCache.set(w, { gradient: S, bottomY: d, color: E }));
+          const w = String(n), W = this.areaGradientCache.get(w);
+          W && W.bottomY === d && W.color === E ? S = W.gradient : (S = s.createLinearGradient(0, 0, 0, d), S.addColorStop(0, C(E, 0.12)), S.addColorStop(1, C(E, 0.01)), this.areaGradientCache.set(w, { gradient: S, bottomY: d, color: E }));
         }
         s.fillStyle = S;
         for (const w of u)
-          w.length < 2 || (s.beginPath(), c(x, { points: w, color: E, lineWidth: h, closing: !0, grew: P && w === T }), s.lineTo(w[w.length - 1].x, d), s.lineTo(w[0].x, d), s.closePath(), s.fill());
+          w.length < 2 || (s.beginPath(), c(x, { points: w, color: E, lineWidth: h, closing: !0, grew: P && w === M }), s.lineTo(w[w.length - 1].x, d), s.lineTo(w[0].x, d), s.closePath(), s.fill());
       }
       if (this.options.points?.visible) {
         const d = [];
@@ -653,158 +655,158 @@ class Pt extends ut {
   }
   /** Stacked area rendering */
   renderStacked(t, i) {
-    const { scope: e, timeScale: o, yScale: s } = t, { context: l } = e, r = o.getRange(), { verticalPixelRatio: f } = e, h = this.options.strokeWidth > 0, m = Math.max(1, Math.round(this.options.strokeWidth * f)), c = this.options.curve ?? "straight", x = e.mediaSize.width, n = this.stores.map((u, v) => {
+    const { scope: e, timeScale: o, yScale: s } = t, { context: a } = e, r = o.getRange(), { verticalPixelRatio: m } = e, h = this.options.strokeWidth > 0, p = Math.max(1, Math.round(this.options.strokeWidth * m)), c = this.options.curve ?? "straight", x = e.mediaSize.width, n = this.stores.map((u, v) => {
       if (this.getLayerAlpha(v) <= 0) return [];
-      let M = u.getVisibleData(r.from, r.to);
-      return M.length > x * 2 && (M = q(M, Math.round(x * 1.5))), M;
-    }), p = /* @__PURE__ */ new Set();
+      let T = u.getVisibleData(r.from, r.to);
+      return T.length > x * 2 && (T = q(T, Math.round(x * 1.5))), T;
+    }), f = /* @__PURE__ */ new Set();
     for (const u of n)
-      for (const v of u) p.add(v.time);
-    const a = Array.from(p).sort((u, v) => u - v);
-    if (a.length < 2) {
+      for (const v of u) f.add(v.time);
+    const l = Array.from(f).sort((u, v) => u - v);
+    if (l.length < 2) {
       this.stackedEdges = null;
       return;
     }
-    const g = this.options.entryAnimation ?? "grow", A = n.map((u, v) => {
-      const M = /* @__PURE__ */ new Map();
-      if (u.length === 0) return M;
-      const b = u[0].time, P = g === "grow" ? this.chainedTailValues(v, (d, S) => this.effectiveValue(t, v, d, S)) : null, T = (d) => P?.get(d.time) ?? this.effectiveValue(t, v, d.time, d.value);
-      for (const d of a) {
-        if (d < b) continue;
-        const S = j(u, d, { resolve: T });
-        S !== null && M.set(d, S);
+    const g = this.options.entryAnimation ?? "grow", b = n.map((u, v) => {
+      const T = /* @__PURE__ */ new Map();
+      if (u.length === 0) return T;
+      const A = u[0].time, P = g === "grow" ? this.chainedTailValues(v, (d, S) => this.effectiveValue(t, v, d, S)) : null, M = (d) => P?.get(d.time) ?? this.effectiveValue(t, v, d.time, d.value);
+      for (const d of l) {
+        if (d < A) continue;
+        const S = j(u, d, { resolve: M });
+        S !== null && T.set(d, S);
       }
-      return M;
+      return T;
     }), E = this.stores.map((u, v) => this.getLayerAlpha(v)), B = (u, v) => {
-      const M = A[u].get(v);
-      return M === void 0 ? void 0 : M * E[u];
-    }, L = s.getTransform() !== null && !i, D = Array.from({ length: this.stores.length }, () => new Array(a.length).fill(0));
-    for (let u = 0; u < a.length; u++) {
-      const v = a[u];
-      if (L) {
+      const T = b[u].get(v);
+      return T === void 0 ? void 0 : T * E[u];
+    }, V = s.getTransform() !== null && !i, Y = Array.from({ length: this.stores.length }, () => new Array(l.length).fill(0));
+    for (let u = 0; u < l.length; u++) {
+      const v = l[u];
+      if (V) {
         const P = new it(s);
-        for (let T = 0; T < this.stores.length; T++) {
-          const d = A[T].get(v);
-          d !== void 0 && s.isPlottable(d) && P.push(d, E[T]), D[T][u] = P.edge;
+        for (let M = 0; M < this.stores.length; M++) {
+          const d = b[M].get(v);
+          d !== void 0 && s.isPlottable(d) && P.push(d, E[M]), Y[M][u] = P.edge;
         }
         continue;
       }
-      let M = 0;
+      let T = 0;
       if (i)
         for (let P = 0; P < this.stores.length; P++) {
-          const T = B(P, v);
-          T !== void 0 && s.isPlottable(T) && (M += T);
+          const M = B(P, v);
+          M !== void 0 && s.isPlottable(M) && (T += M);
         }
-      let b = 0;
+      let A = 0;
       for (let P = 0; P < this.stores.length; P++) {
-        const T = B(P, v);
-        let d = T !== void 0 && s.isPlottable(T) ? T : null;
+        const M = B(P, v);
+        let d = M !== void 0 && s.isPlottable(M) ? M : null;
         const S = n[P];
         if (i && S.length > 0 && v < S[0].time && (d = 0), d !== null)
           if (i) {
-            const w = this.introShare(t, { layerIndex: P, time: v, value: d, total: M });
-            b = Math.min(100, b + w);
+            const w = this.introShare(t, { layerIndex: P, time: v, value: d, total: T });
+            A = Math.min(100, A + w);
           } else
-            b += d;
-        D[P][u] = b;
+            A += d;
+        Y[P][u] = A;
       }
     }
-    const Y = /* @__PURE__ */ new Map();
-    for (let u = 0; u < a.length; u++) Y.set(a[u], u);
-    const z = new Array(this.stores.length).fill(1);
+    const D = /* @__PURE__ */ new Map();
+    for (let u = 0; u < l.length; u++) D.set(l[u], u);
+    const N = new Array(this.stores.length).fill(1);
     for (let u = 0; u < this.stores.length; u++) {
       if (this.getLayerAlpha(u) <= 0) continue;
-      const v = this.unsettledTail(u), M = v.length;
-      if (M === 0) continue;
-      let b = !0;
-      for (let P = 0; P < M; P++)
-        if (Y.get(v[P].time) !== a.length - M + P) {
-          b = !1;
+      const v = this.unsettledTail(u), T = v.length;
+      if (T === 0) continue;
+      let A = !0;
+      for (let P = 0; P < T; P++)
+        if (D.get(v[P].time) !== l.length - T + P) {
+          A = !1;
           break;
         }
-      b && (z[u] = v[M - 1].progress);
+      A && (N[u] = v[T - 1].progress);
     }
     const I = [];
     if (g === "grow") {
       const u = n.map((v) => v.length - 1);
-      for (let v = a.length - 1; v >= 1; v--) {
-        const M = a[v];
-        let b = 1, P = !1;
-        for (let T = 0; T < n.length; T++) {
-          if (this.getLayerAlpha(T) <= 0) continue;
-          const d = n[T];
-          for (; u[T] >= 0 && d[u[T]].time > M; ) u[T]--;
-          if (u[T] < 0 || d[u[T]].time !== M) continue;
-          const S = this.entranceProgress(T, M);
-          (!P || S > b) && (b = S), P = !0;
+      for (let v = l.length - 1; v >= 1; v--) {
+        const T = l[v];
+        let A = 1, P = !1;
+        for (let M = 0; M < n.length; M++) {
+          if (this.getLayerAlpha(M) <= 0) continue;
+          const d = n[M];
+          for (; u[M] >= 0 && d[u[M]].time > T; ) u[M]--;
+          if (u[M] < 0 || d[u[M]].time !== T) continue;
+          const S = this.entranceProgress(M, T);
+          (!P || S > A) && (A = S), P = !0;
         }
-        if (!P || b >= 1) break;
-        I.unshift($(b));
+        if (!P || A >= 1) break;
+        I.unshift(U(A));
       }
     }
     const H = (u, v) => {
-      const M = v.length;
-      if (!(M === 0 || u.length < M + 1))
-        for (let b = 0; b < M; b++) {
-          const P = u.length - M + b;
-          u[P][0] = N(u[P - 1][0], u[P][0], v[b]);
+      const T = v.length;
+      if (!(T === 0 || u.length < T + 1))
+        for (let A = 0; A < T; A++) {
+          const P = u.length - T + A;
+          u[P][0] = z(u[P - 1][0], u[P][0], v[A]);
         }
-    }, W = e.bitmapSize.height;
-    let C = -1, _ = -1;
+    }, F = e.bitmapSize.height;
+    let X = -1, $ = -1;
     for (let u = 0; u < this.stores.length; u++)
       if (!(this.getLayerAlpha(u) <= 0))
-        if (C < 0)
-          C = u;
+        if (X < 0)
+          X = u;
         else {
-          _ = u;
+          $ = u;
           break;
         }
-    const G = C >= 0 ? this.getLayerAlpha(C) : 1, U = n.map((u, v) => v === C ? Math.min(1, this.getLayerAlpha(v)) : 1);
+    const G = X >= 0 ? this.getLayerAlpha(X) : 1, _ = n.map((u, v) => v === X ? Math.min(1, this.getLayerAlpha(v)) : 1);
     for (let u = this.stores.length - 1; u >= 0; u--) {
       const v = this.getLayerAlpha(u);
       if (v <= 0) continue;
-      const M = this.stores[u].last()?.value ?? 0, b = this.resolveLayerColor(u, M), P = u === C, T = _ >= 0 && u === _ && G < 1, d = [];
-      for (let R = 0; R < a.length; R++) {
-        const V = u > 0 ? s.valueToBitmapYExact(D[u - 1][R]) : W;
-        let O = V;
-        P ? O = W : T && (O = V + (W - V) * (1 - G)), d.push([o.timeToBitmapXExact(a[R]), O]);
+      const T = this.lastFinitePoint(u)?.value ?? 0, A = this.resolveLayerColor(u, T), P = u === X, M = $ >= 0 && u === $ && G < 1, d = [];
+      for (let R = 0; R < l.length; R++) {
+        const L = u > 0 ? s.valueToBitmapYExact(Y[u - 1][R]) : F;
+        let O = L;
+        P ? O = F : M && (O = L + (F - L) * (1 - G)), d.push([o.timeToBitmapXExact(l[R]), O]);
       }
       g === "grow" && H(d, I);
       const S = [];
-      for (let R = 0; R < a.length; R++) {
-        let V = s.valueToBitmapYExact(D[u][R]);
-        P && v < 1 && (V = W + (V - W) * v), S.push([o.timeToBitmapXExact(a[R]), V]);
+      for (let R = 0; R < l.length; R++) {
+        let L = s.valueToBitmapYExact(Y[u][R]);
+        P && v < 1 && (L = F + (L - F) * v), S.push([o.timeToBitmapXExact(l[R]), L]);
       }
       g === "grow" && H(S, I);
-      const w = st(S), F = tt(w, c, g === "grow" && I.length > 0), K = g === "fade" && z[u] < 1;
-      if (K && (l.save(), l.globalAlpha *= z[u]), this.options.area.visible && !this.introGhostPass) {
-        let R = S[0][1], V = d[0][1];
+      const w = st(S), W = tt(w, c, g === "grow" && I.length > 0), K = g === "fade" && N[u] < 1;
+      if (K && (a.save(), a.globalAlpha *= N[u]), this.options.area.visible && !this.introGhostPass) {
+        let R = S[0][1], L = d[0][1];
         for (let k = 1; k < S.length; k++)
           S[k][1] < R && (R = S[k][1]);
         for (let k = 1; k < d.length; k++)
-          d[k][1] > V && (V = d[k][1]);
-        let O = X(b, 0.25);
-        if (V > R + 0.5) {
-          const k = l.createLinearGradient(0, R, 0, V);
-          k.addColorStop(0, X(b, 0.25)), k.addColorStop(1, X(b, 0.05)), O = k;
+          d[k][1] > L && (L = d[k][1]);
+        let O = C(A, 0.25);
+        if (L > R + 0.5) {
+          const k = a.createLinearGradient(0, R, 0, L);
+          k.addColorStop(0, C(A, 0.25)), k.addColorStop(1, C(A, 0.05)), O = k;
         }
-        if (l.beginPath(), l.moveTo(w[0].x, w[0].y), et(l, F), P)
+        if (a.beginPath(), a.moveTo(w[0].x, w[0].y), et(a, W), P)
           for (let k = d.length - 1; k >= 0; k--)
-            l.lineTo(d[k][0], d[k][1]);
+            a.lineTo(d[k][0], d[k][1]);
         else {
           const k = st(d), ct = tt(k, c, g === "grow" && I.length > 0), Z = k[k.length - 1];
-          l.lineTo(Z.x, Z.y), gt(l, k, ct);
+          a.lineTo(Z.x, Z.y), gt(a, k, ct);
         }
-        l.closePath(), l.fillStyle = O, l.fill();
+        a.closePath(), a.fillStyle = O, a.fill();
       }
       const Q = h && v < 1;
-      if (Q && (l.save(), l.globalAlpha *= v), h && (l.beginPath(), l.moveTo(w[0].x, w[0].y), et(l, F), l.strokeStyle = b, l.lineWidth = m, l.lineJoin = "round", l.lineCap = "round", l.stroke()), Q && l.restore(), this.options.points?.visible) {
+      if (Q && (a.save(), a.globalAlpha *= v), h && (a.beginPath(), a.moveTo(w[0].x, w[0].y), et(a, W), a.strokeStyle = A, a.lineWidth = p, a.lineJoin = "round", a.lineCap = "round", a.stroke()), Q && a.restore(), this.options.points?.visible) {
         const R = v < 1;
-        R && (l.save(), l.globalAlpha *= v), this.drawPointMarkers({ context: l, points: w, pixelRatio: e.horizontalPixelRatio, color: b }), R && l.restore();
+        R && (a.save(), a.globalAlpha *= v), this.drawPointMarkers({ context: a, points: w, pixelRatio: e.horizontalPixelRatio, color: A }), R && a.restore();
       }
-      K && l.restore();
+      K && a.restore();
     }
-    this.stackedEdges = { times: a, cumulative: D, growChain: I, collapse: U };
+    this.stackedEdges = { times: l, cumulative: Y, growChain: I, collapse: _ };
   }
   /**
    * Overlay hook: draws crosshair nearest-point dots and last-point pulse dots.
@@ -812,55 +814,58 @@ class Pt extends ut {
    */
   drawOverlay(t) {
     this.tickAnimations(performance.now());
-    const { scope: i, timeScale: e, yScale: o, crosshair: s, dataInterval: l } = t, r = i, f = this.options.pulseMs, h = f > 0 ? performance.now() / (f * 2 * Math.PI) % 1 : 0;
+    const { scope: i, timeScale: e, yScale: o, crosshair: s, dataInterval: a } = t, r = i, m = this.options.pulseMs, h = m > 0 ? performance.now() / (m * 2 * Math.PI) % 1 : 0;
     if (s) {
       const x = this.options.stacking, n = 4 * r.horizontalPixelRatio;
-      for (let p = 0; p < this.stores.length; p++) {
-        const a = this.getLayerAlpha(p);
-        if (a <= 0) continue;
-        const g = this.stores[p].findNearest(s.time, l);
+      for (let f = 0; f < this.stores.length; f++) {
+        const l = this.getLayerAlpha(f);
+        if (l <= 0) continue;
+        const g = this.stores[f].findNearest(s.time, a);
         if (!g || x === "off" && !o.isPlottable(g.value)) continue;
-        const A = this.resolveLayerColor(p, g.value), { x: E, y: B } = x === "off" ? {
+        const b = this.resolveLayerColor(f, g.value), { x: E, y: B } = x === "off" ? {
           x: e.timeToBitmapXExact(g.time),
-          y: o.valueToBitmapYExact(this.effectiveValue(t, p, g.time, g.value))
-        } : this.stackedPositionAt(t, p, g.time), L = a < 1;
-        L && (i.context.save(), i.context.globalAlpha *= a), i.context.save(), i.context.globalAlpha *= 0.25, i.context.beginPath(), i.context.arc(E, B, n + 3 * r.horizontalPixelRatio, 0, Math.PI * 2), i.context.fillStyle = A, i.context.fill(), i.context.restore(), i.context.beginPath(), i.context.arc(E, B, n, 0, Math.PI * 2), i.context.fillStyle = A, i.context.fill(), L && i.context.restore();
+          y: o.valueToBitmapYExact(this.effectiveValue(t, f, g.time, g.value))
+        } : this.stackedPositionAt(t, f, g.time), V = l < 1;
+        V && (i.context.save(), i.context.globalAlpha *= l), i.context.save(), i.context.globalAlpha *= 0.25, i.context.beginPath(), i.context.arc(E, B, n + 3 * r.horizontalPixelRatio, 0, Math.PI * 2), i.context.fillStyle = b, i.context.fill(), i.context.restore(), i.context.beginPath(), i.context.arc(E, B, n, 0, Math.PI * 2), i.context.fillStyle = b, i.context.fill(), V && i.context.restore();
       }
     }
-    const m = this.introWave.active && this.introDirectives?.clip !== void 0;
+    const p = this.introWave.active && this.introDirectives?.clip !== void 0;
     let c = 1;
-    if (m && (c = Math.max(0, (this.introWave.linear() - (1 - J)) / J)), this.hasPulse && f > 0 && c > 0) {
+    if (p && (c = Math.max(0, (this.introWave.linear() - (1 - J)) / J)), this.hasPulse && m > 0 && c > 0) {
       const x = this.options.stacking;
       for (let n = 0; n < this.stores.length; n++) {
-        const p = this.getLayerAlpha(n);
-        if (p <= 0) continue;
-        const a = this.stores[n].last()?.value ?? 0, g = this.resolveLayerColor(n, a);
+        const f = this.getLayerAlpha(n);
+        if (f <= 0) continue;
+        const l = this.lastFinitePoint(n);
+        if (!l) continue;
+        const g = this.resolveLayerColor(n, l.value);
         if (x === "off") {
-          if (!o.isPlottable(a)) continue;
-          const L = this.trailingEndpoint(t, n);
-          if (!L) continue;
+          if (!o.isPlottable(l.value)) continue;
+          const B = l === this.stores[n].last() ? this.trailingEndpoint(t, n) : {
+            x: e.timeToBitmapXExact(l.time),
+            y: o.valueToBitmapYExact(this.effectiveValue(t, n, l.time, l.value))
+          };
+          if (!B) continue;
           this.drawPulse({
             ctx: i.context,
-            x: L.x,
-            y: L.y,
+            x: B.x,
+            y: B.y,
             color: g,
             pixelRatio: r.horizontalPixelRatio,
             phase: h,
-            alpha: p * c
+            alpha: f * c
           });
           continue;
         }
-        const A = this.stores[n].last();
-        if (!A) continue;
-        const { x: E, y: B } = this.stackedPositionAt(t, n, A.time);
+        const { x: b, y: E } = this.stackedPositionAt(t, n, l.time);
         this.drawPulse({
           ctx: i.context,
-          x: E,
-          y: B,
+          x: b,
+          y: E,
           color: g,
           pixelRatio: r.horizontalPixelRatio,
           phase: h,
-          alpha: p * c
+          alpha: f * c
         });
       }
     }
@@ -871,14 +876,14 @@ class Pt extends ut {
     y: e,
     color: o,
     pixelRatio: s,
-    phase: l,
+    phase: a,
     alpha: r = 1
   }) {
-    const f = 3 * s, h = 0.4 + 0.6 * Math.abs(Math.sin(l * 2 * Math.PI)), m = f + 4 * s * h, c = r < 1;
-    c && (t.save(), t.globalAlpha *= r), t.beginPath(), t.arc(i, e, m, 0, Math.PI * 2), t.fillStyle = X(o, h * 0.3), t.fill(), t.beginPath(), t.arc(i, e, f, 0, Math.PI * 2), t.fillStyle = o, t.fill(), c && t.restore();
+    const m = 3 * s, h = 0.4 + 0.6 * Math.abs(Math.sin(a * 2 * Math.PI)), p = m + 4 * s * h, c = r < 1;
+    c && (t.save(), t.globalAlpha *= r), t.beginPath(), t.arc(i, e, p, 0, Math.PI * 2), t.fillStyle = C(o, h * 0.3), t.fill(), t.beginPath(), t.arc(i, e, m, 0, Math.PI * 2), t.fillStyle = o, t.fill(), c && t.restore();
   }
 }
-const Bt = {
+const Lt = {
   type: "line",
   xTypes: ["time", "numeric", "category"],
   create: ({ theme: y, layerCount: t }, i) => new Pt(t, {
@@ -889,5 +894,5 @@ const Bt = {
 };
 export {
   Pt as LineRenderer,
-  Bt as LineSeriesDef
+  Lt as LineSeriesDef
 };