@wick-charts/vue 0.8.0 → 0.8.2

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

@@ -1,81 +1,85 @@
-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 { 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, scaleMean as mt, backfillSweepIntro as pt } 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";
-const vt = {
+import { DEFAULT_HISTORY_REVEAL as it, DEFAULT_LINE_INTRO as ot, DEFAULT_LINE_PULSE as st, DEFAULT_LINE_SMOOTH as nt, DEFAULT_LINE_ENTRY as lt } from "../animation/config.js";
+import { easeOutCubic as J } from "../animation/easing.js";
+import { decimateLineData as Z } from "../data/decimation.js";
+import { hexToRgba as B } from "../utils/color.js";
+import { lerp as G } from "../utils/math.js";
+import { BaseMultiLayerSeries as ht } from "./base-multi-layer.js";
+import { unfoldIntro as ct, scaleMean as ut, backfillSweepIntro as ft } from "./line-intro.js";
+import { buildCurveSegments as j, replaySegmentsForward as q, replaySegmentsReversed as mt } from "./painters/canvas-path.js";
+import { resolveLinePainter as pt } from "./painters/resolve.js";
+import { ScaleStack as tt } from "./scale-stack.js";
+const gt = {
   colors: ["#2962FF"],
   strokeWidth: 1,
   area: { visible: !0 },
   pulse: !0,
   stacking: "off",
   curve: "straight",
-  entryMs: ht,
-  smoothMs: rt,
-  pulseMs: at,
-  introMs: lt,
-  historyRevealMs: nt
+  entryMs: lt,
+  smoothMs: nt,
+  pulseMs: st,
+  introMs: ot,
+  historyRevealMs: it
 };
-function ot(y) {
-  const t = y.areaFill, i = t !== void 0 && y.area === void 0 ? { visible: !!t } : y.area;
+function et(S) {
+  const t = S.areaFill, i = t !== void 0 && S.area === void 0 ? { visible: !!t } : S.area;
   return {
-    ...y,
+    ...S,
     area: i,
-    entryMs: y.entryMs === !1 ? 0 : y.entryMs ?? ht,
-    smoothMs: y.smoothMs === !1 ? 0 : y.smoothMs ?? rt,
-    pulseMs: y.pulseMs === !1 ? 0 : y.pulseMs ?? at,
-    introMs: y.introMs === !1 ? 0 : y.introMs ?? lt,
-    historyRevealMs: y.historyRevealMs === !1 ? 0 : y.historyRevealMs ?? nt
+    entryMs: S.entryMs === !1 ? 0 : S.entryMs ?? lt,
+    smoothMs: S.smoothMs === !1 ? 0 : S.smoothMs ?? nt,
+    pulseMs: S.pulseMs === !1 ? 0 : S.pulseMs ?? st,
+    introMs: S.introMs === !1 ? 0 : S.introMs ?? ot,
+    historyRevealMs: S.historyRevealMs === !1 ? 0 : S.historyRevealMs ?? it
   };
 }
-function st(y) {
-  return y.map(([t, i]) => ({ x: t, y: i }));
+function Q(S) {
+  return S.map(([t, i]) => ({ x: t, y: i }));
 }
-const J = 0.15, xt = pt();
-function j(y, t, i) {
-  const { resolve: e, lerp: o = N } = 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];
+const K = 0.15, dt = ft();
+function _(S, t, i) {
+  const { resolve: e, lerp: o = G } = i;
+  if (S.length === 0) return null;
+  if (t <= S[0].time) return Number.isFinite(S[0].value) ? e(S[0]) : null;
+  const s = S[S.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 h = 0, l = S.length - 1;
+  for (; l - h > 1; ) {
+    const c = h + l >> 1;
+    S[c].time <= t ? h = c : l = c;
+  }
+  const u = S[h];
+  if (u.time === t) return Number.isFinite(u.value) ? e(u) : null;
+  const r = S[l];
+  if (!Number.isFinite(u.value) || !Number.isFinite(r.value)) return null;
+  const f = r.time - u.time;
+  return f <= 0 ? e(u) : o(e(u), e(r), (t - u.time) / f);
 }
-function yt(y, t) {
-  let i = 0, e = y.length - 1;
+function vt(S, t) {
+  let i = 0, e = S.length - 1;
   for (; i <= e; ) {
     const o = i + e >> 1;
-    if (y[o] === t) return o;
-    y[o] < t ? i = o + 1 : e = o - 1;
+    if (S[o] === t) return o;
+    S[o] < t ? i = o + 1 : e = o - 1;
   }
   return -1;
 }
-class Pt extends ut {
+class xt extends ht {
   kind = "line";
   areaGradientCache = /* @__PURE__ */ new Map();
-  constructor(t, i) {
-    super(t), this.options = ot({ ...vt, ...i });
+  /** First palette slot of the theme default colours — see `SeriesCreateEnv.paletteIndex`. */
+  #t;
+  constructor(t, i, e = 0) {
+    super(t), this.options = et({ ...gt, ...i }), this.#t = e;
   }
   updateOptions(t) {
-    this.options = ot({ ...this.options, ...t });
+    this.options = et({ ...this.options, ...t });
   }
   getStacking() {
     return this.options.stacking;
   }
   applyTheme(t, i) {
-    const e = this.stores.length === 1 ? [t.line.color] : t.seriesColors.slice(0, this.stores.length);
+    const e = at({ theme: t, layerCount: this.stores.length, paletteIndex: this.#t });
     this.updateOptions({ colors: e }), this.options.strokeWidth === i.line.width && this.updateOptions({ strokeWidth: t.line.width });
   }
   isEntryEnabled() {
@@ -96,18 +100,18 @@ class Pt extends ut {
     return !1;
   }
   render(t) {
-    this.tickAnimations(performance.now()), this.lastYScale = t.yScale;
+    this.tickAnimations(performance.now()), this.lastYScale = t.yScale, this.lastTimeScale = t.timeScale;
     const { context: i } = t.scope;
     this.historyDirectives = null;
     const e = this.historyRange;
     if (this.historyWave.active && e !== null) {
-      const r = this.options.historyReveal ?? xt;
-      r !== "none" && (this.historyDirectives = r(this.buildHistoryFrame(t, e)));
+      const l = this.options.historyReveal ?? dt;
+      l !== "none" && (this.historyDirectives = l(this.buildHistoryFrame(t, e)));
     }
     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 h = this.applyHistoryClip(t, o, e);
+    this.introWave.active ? this.renderWithIntro(t) : (this.introDirectives = null, this.renderBody(t)), h && 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 +121,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, h = i.ghostAlpha ?? 0;
+    h > 0 && (e.save(), e.globalAlpha *= h, this.introGhostPass = !0, this.renderBody(t), this.introGhostPass = !1, e.restore());
+    const l = i.clip, u = l !== void 0 && (l.fromX !== void 0 || l.toX !== void 0);
+    if (u) {
+      const r = l.fromX ?? 0, f = l.toX ?? o;
+      e.save(), e.beginPath(), e.rect(r, 0, Math.max(0, f - r), 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), u && 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 +139,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: h, height: l } = t.scope.bitmapSize, u = t.timeScale.timeToBitmapXExact(e.to), r = Math.abs(u - t.timeScale.timeToBitmapXExact(e.from)), f = Math.max(2, (this.options.strokeWidth ?? 1) * t.scope.horizontalPixelRatio), c = o.fromX ?? 0, v = o.toX ?? r;
+    return s.save(), s.beginPath(), s.rect(u - v - f, 0, Math.max(0, v - c + f), l), s.rect(u, 0, Math.max(0, h - u), l), s.clip(), !0;
   }
   renderBody(t) {
     this.options.stacking === "off" ? (this.stackedEdges = null, this.renderOff(t)) : this.renderStacked(t, this.options.stacking === "percent");
@@ -162,11 +166,13 @@ class Pt extends ut {
   historyDirectives = null;
   /** Y scale of the last render — value queries run without a render context. */
   lastYScale = null;
+  /** Time scale of the last render — places a share query's column in the intro wave. */
+  lastTimeScale = 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 = ft()), this.defaultIntro);
+    return t !== void 0 ? t : (this.defaultIntro === null && (this.defaultIntro = ct()), this.defaultIntro);
   }
   /**
    * Frame context handed to the intro fn — progress plus memoized data
@@ -198,45 +204,45 @@ 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);
-    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 { timeScale: e, yScale: o, scope: s } = t, { progress: h, range: l, width: u } = i, r = this.options.stacking === "percent", f = new Array(this.stores.length), c = new Array(this.stores.length);
+    let v, a;
+    const g = (n) => {
+      let d = f[n];
+      return d === void 0 && (d = this.stores[n]?.getVisibleData(l.from, l.to) ?? [], f[n] = d), d;
     };
     return {
-      progress: l,
-      range: r,
-      width: f,
+      progress: h,
+      range: l,
+      width: u,
       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: (n) => e.timeToBitmapXExact(n),
+      xToTime: (n) => e.xToTime(n / s.horizontalPixelRatio),
+      valueToY: (n) => o.valueToBitmapYExact(n),
+      lerpValue: (n, d, M) => o.lerpValue(n, d, M),
       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: g,
+      layerMean: (n) => {
+        let d = c[n];
+        return d === void 0 && (r ? (v ??= this.meanShares(g, o), d = v[n]) : d = ut(g(n), o), c[n] = d), d;
       },
       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));
-            if (!(g.length < 2)) {
-              n = g.map((A) => ({
-                x: e.timeToBitmapXExact(A.time),
-                y: o.valueToBitmapYExact(A.value),
-                time: A.time
+        if (a === void 0) {
+          a = null;
+          for (let n = 0; n < this.stores.length; n++) {
+            if (this.getLayerAlpha(n) <= 0 || !this.stores[n].isVisible()) continue;
+            const d = g(n).filter((M) => o.isPlottable(M.value));
+            if (!(d.length < 2)) {
+              a = d.map((M) => ({
+                x: e.timeToBitmapXExact(M.time),
+                y: o.valueToBitmapYExact(M.value),
+                time: M.time
               }));
               break;
             }
           }
         }
-        return n;
+        return a;
       }
     };
   }
@@ -250,12 +256,36 @@ class Pt extends ut {
     const s = super.effectiveValue(t, i, e, o);
     return this.options.stacking === "percent" ? s : this.introValue(t, { layerIndex: i, time: e, value: s });
   }
+  /**
+   * The line stack's reading of a percent column (see `renderStacked`): each
+   * layer's current value at `time` times its alpha, 0 for a layer yet to
+   * start, over one signed total, then through the intro's share transform and
+   * the 100% cap; a total at or below 0 is a gap.
+   */
+  percentShares(t) {
+    const i = /* @__PURE__ */ new Map();
+    let e = 0;
+    for (let l = 0; l < this.stores.length; l++) {
+      const u = this.getLayerAlpha(l);
+      if (u <= 0) continue;
+      const r = this.stores[l].getAll(), f = r.length > 0 && t < r[0].time ? 0 : _(r, t, { resolve: (c) => this.snapshotValue(l, c.time, c.value) });
+      f !== null && (i.set(l, f * u), e += f * u);
+    }
+    if (e <= 0) return null;
+    const o = this.lastTimeScale, s = /* @__PURE__ */ new Map();
+    let h = 0;
+    for (const [l, u] of i) {
+      const r = { layerIndex: l, time: t, value: u, total: e }, f = o === null ? Math.max(0, u / e * 100) : this.introShare({ timeScale: o }, r), c = Math.min(100, h + f);
+      s.set(l, c - h), h = c;
+    }
+    return s;
+  }
   /** 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;
-    return Math.max(0, this.introValue(t, { layerIndex: e, time: o, value: r }));
+    const { layerIndex: e, time: o, value: s, total: h } = i;
+    if (h <= 0) return s;
+    const l = s / h * 100;
+    return Math.max(0, this.introValue(t, { layerIndex: e, time: o, value: l }));
   }
   /**
    * What `layerMean` reports on a percent stack: each layer's mean share over
@@ -264,41 +294,41 @@ 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 h of o) {
-      let m = 0;
+    for (let r = 0; r < e; r++)
+      for (const f of t(r))
+        o.add(f.time);
+    const s = new Array(e).fill(0), h = new Array(e).fill(!1), l = new Array(e);
+    let u = 0;
+    for (const r of o) {
+      let f = 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);
+        l[c] = null;
+        const v = this.getLayerAlpha(c), a = t(c);
+        if (v <= 0 || a.length === 0 || r < a[0].time) continue;
+        const g = _(a, r, { resolve: (n) => n.value });
+        g === null || !i.isPlottable(g) || (l[c] = g * v, f += g * v);
       }
-      if (!(m <= 0)) {
-        f++;
+      if (!(f <= 0)) {
+        u++;
         for (let c = 0; c < e; c++) {
-          const x = r[c];
-          x !== null && (s[c] += x / m * 100, l[c] = !0);
+          const v = l[c];
+          v !== null && (s[c] += v / f * 100, h[c] = !0);
         }
       }
     }
-    return s.map((h, m) => l[m] ? h / f : null);
+    return s.map((r, f) => h[f] ? r / u : 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 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 });
+    const { layerIndex: e, time: o, value: s } = i, h = this.historyWave.active ? this.historyDirectives?.value : void 0, l = this.historyRange;
+    if (h !== void 0 && l !== null && o < l.to) {
+      const v = l.to - l.from, a = v > 0 ? Math.min(1, Math.max(0, (l.to - o) / v)) : 0;
+      return h({ layerIndex: e, time: o, value: s, position: a });
     }
-    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 u = this.introWave.active ? this.introDirectives?.value : void 0;
+    if (u === void 0) return s;
+    const r = t.timeScale.getRange(), f = r.to - r.from, c = f > 0 ? Math.min(1, Math.max(0, (o - r.from) / f)) : 0;
+    return u({ layerIndex: e, time: o, value: s, position: c });
   }
   /**
    * Extends the base last-value query with the 'grow' entrance's value-space
@@ -322,22 +352,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();
-    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 h = o[s];
+    if (!Number.isFinite(h.value)) return null;
+    let l = i(h.time, h.value);
+    const u = /* @__PURE__ */ new Map();
+    for (let r = 0; r < e.length; r++) {
+      const f = o[s + 1 + r];
+      if (!Number.isFinite(f.value)) return null;
+      const c = J(e[r].progress), v = i(f.time, f.value), a = this.axisLerp(l, v, c);
+      u.set(f.time, a), l = a;
     }
-    return f;
+    return u;
   }
   /** `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 ? G(t, i, e) : o.lerpValue(t, i, e);
   }
   /**
    * Glowing pulse dots riding the intro's head anchors — the line reads as
@@ -347,22 +377,22 @@ 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 { scope: r } = t;
-    for (const f 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 o = Math.min(1, e / K), s = Math.min(1, (1 - e) / K), h = Math.max(0, Math.min(o, s));
+    if (h <= 0) return;
+    const { scope: l } = t;
+    for (const u of i)
+      for (let r = 0; r < this.stores.length; r++) {
+        const f = this.getLayerAlpha(r);
+        if (f <= 0 || !this.stores[r].isVisible()) continue;
+        const c = this.introHeadAnchor(t, r, u);
         c !== null && this.drawPulse({
-          ctx: r.context,
+          ctx: l.context,
           x: c.x,
           y: c.y,
-          color: this.resolveLayerColor(h, c.value),
-          pixelRatio: r.horizontalPixelRatio,
+          color: this.resolveLayerColor(r, c.value),
+          pixelRatio: l.horizontalPixelRatio,
           phase: e * 2,
-          alpha: l * m
+          alpha: h * f
         });
       }
   }
@@ -378,30 +408,30 @@ 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);
-    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 { timeScale: o, yScale: s } = t, h = o.getRange(), l = this.stores[i].getVisibleData(h.from, h.to);
+    if (l.length === 0) return null;
+    const u = this.stores[i].last();
+    if (u !== void 0 && e.time >= u.time) {
+      if (!s.isPlottable(u.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: u.value };
     }
-    const h = r[0];
-    if (e.time <= h.time) {
-      if (!s.isPlottable(h.value)) return null;
-      const c = this.effectiveValue(t, i, h.time, h.value);
+    const r = l[0];
+    if (e.time <= r.time) {
+      if (!s.isPlottable(r.value)) return null;
+      const c = this.effectiveValue(t, i, r.time, r.value);
       return {
-        x: o.timeToBitmapXExact(h.time),
+        x: o.timeToBitmapXExact(r.time),
         y: s.valueToBitmapYExact(c),
-        value: h.value
+        value: r.value
       };
     }
-    const m = j(r, e.time, {
+    const f = _(l, 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)
+      lerp: (c, v, a) => !s.isPlottable(c) || !s.isPlottable(v) ? Number.NaN : s.lerpValue(c, v, a)
     });
-    return m === null || !s.isPlottable(m) ? null : { x: e.x, y: s.valueToBitmapYExact(m), value: m };
+    return f === null || !s.isPlottable(f) ? null : { x: e.x, y: s.valueToBitmapYExact(f), value: f };
   }
   /**
    * Rendered positions of the layer's still-unsettled trailing points, keyed
@@ -426,51 +456,53 @@ 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", h = new Array(this.stores.length), l = (a) => {
       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 g = h[a];
+      if (g !== void 0) return g;
+      const n = this.chainedTailValues(a, (d, M) => this.effectiveValue(t, a, d, M));
+      return h[a] = n, n;
+    }, u = (a) => {
+      const g = this.stores[a].getAll();
+      if (g.length === 0 || e < g[0].time) return null;
+      const n = l(a);
+      return _(g, e, {
+        resolve: (d) => n?.get(d.time) ?? this.effectiveValue(t, a, d.time, d.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);
+    }, { yScale: r } = t;
+    if (r.getTransform() !== null && !o) {
+      const a = new tt(r);
+      for (let g = 0; g <= i; g++) {
+        const n = this.getLayerAlpha(g), d = n > 0 ? u(g) : null;
+        d !== null && r.isPlottable(d) && a.push(d, n);
       }
-      return n.edge;
+      return a.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 f = (a) => {
+      const g = this.getLayerAlpha(a);
+      if (g <= 0) return null;
+      const n = this.stores[a].getAll();
+      if (o && n.length > 0 && e < n[0].time) return 0;
+      const d = u(a);
+      return d === null ? null : d * g;
     };
     let c = 0;
-    if (o)
-      for (let n = 0; n < this.stores.length; n++)
-        c += m(n) ?? 0;
-    let x = 0;
-    for (let n = 0; n <= i; n++) {
-      const p = m(n);
-      if (p !== null)
+    if (o) {
+      for (let a = 0; a < this.stores.length; a++)
+        c += f(a) ?? 0;
+      if (c <= 0) return Number.NaN;
+    }
+    let v = 0;
+    for (let a = 0; a <= i; a++) {
+      const g = f(a);
+      if (g !== null)
         if (o) {
-          const a = this.introShare(t, { layerIndex: n, time: e, value: p, total: c });
-          x = Math.min(100, x + a);
+          const n = this.introShare(t, { layerIndex: a, time: e, value: g, total: c });
+          v = Math.min(100, v + n);
         } else
-          x += p;
+          v += g;
     }
-    return x;
+    return v;
   }
   /**
    * Bitmap position for layer `li`'s stacked boundary at time `t`.
@@ -486,41 +518,41 @@ 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);
-    for (let n = 0; n < h.length; n++)
-      x = N(x, s.timeToBitmapXExact(m[c + 1 + n].time), $(h[n].progress));
-    return { x, y: r };
+    const { timeScale: s, yScale: h } = t, l = h.valueToBitmapYExact(this.stackedValueAt(t, i, e)), u = s.timeToBitmapXExact(e), r = this.unsettledTail(i), f = this.stores[i].getAll(), c = f.length - 1 - r.length;
+    if ((this.options.entryAnimation ?? "grow") !== "grow" || e !== f[f.length - 1]?.time || r.length === 0 || c < 0) return { x: u, y: l };
+    let v = s.timeToBitmapXExact(f[c].time);
+    for (let a = 0; a < r.length; a++)
+      v = G(v, s.timeToBitmapXExact(f[c + 1 + a].time), J(r[a].progress));
+    return { x: v, y: l };
   }
   /** 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, 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);
-    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]);
-    for (let E = 0; E <= h - g; E++)
-      A = N(A, m.timeToBitmapXExact(l[g + E]), r[E]);
-    return { x: A, y: a };
+    const { times: h, growChain: l, collapse: u } = o, r = vt(h, e);
+    if (r < 0) return null;
+    const { timeScale: f, yScale: c } = t, v = t.scope.bitmapSize.height, a = u[i] ?? 1, g = c.valueToBitmapYExact(s[r]), n = a >= 1 ? g : v + (g - v) * a, d = h.length - l.length;
+    if (r < d) return { x: f.timeToBitmapXExact(e), y: n };
+    let M = f.timeToBitmapXExact(h[d - 1]);
+    for (let x = 0; x <= r - d; x++)
+      M = G(M, f.timeToBitmapXExact(h[d + x]), l[x]);
+    return { x: M, y: n };
   }
   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: h, yScale: l } = t, u = o[s];
+    if (!l.isPlottable(u.value)) return null;
+    let r = h.timeToBitmapXExact(u.time), f = l.valueToBitmapYExact(this.effectiveValue(t, i, u.time, u.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;
+    for (let v = 0; v < e.length; v++) {
+      const a = o[s + 1 + v];
+      if (!l.isPlottable(a.value)) return null;
+      const g = J(e[v].progress), n = h.timeToBitmapXExact(a.time), d = l.valueToBitmapYExact(this.effectiveValue(t, i, a.time, a.value)), M = G(r, n, g), x = G(f, d, g);
+      c.set(a.time, { x: M, y: x }), r = M, f = x;
     }
     return c;
   }
@@ -537,8 +569,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, h = o.timeToBitmapXExact(e.time), l = s.valueToBitmapYExact(this.effectiveValue(t, i, e.time, e.value));
+    return (this.options.entryAnimation ?? "grow") !== "grow" ? { x: h, y: l } : this.chainedTailPositions(t, i)?.get(e.time) ?? { x: h, y: l };
   }
   /**
    * Vertical stroke + area gradients for `options.threshold`, pinned to the
@@ -552,10 +584,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: h } = o, l = o.bitmapSize.height, u = e.above, r = e.below ?? i, f = Math.min(1, Math.max(0, s.valueToBitmapYExact(e.value) / l)), c = Math.min(6 * o.verticalPixelRatio, l * 0.02) / l, v = Math.max(0, f - c), a = Math.min(1, f + c), g = h.createLinearGradient(0, 0, 0, l);
+    g.addColorStop(0, u), g.addColorStop(v, u), g.addColorStop(a, r), g.addColorStop(1, r);
+    const n = h.createLinearGradient(0, 0, 0, l);
+    return n.addColorStop(0, B(u, 0.26)), n.addColorStop(v, B(u, 0.14)), n.addColorStop(a, B(r, 0.1)), n.addColorStop(1, B(r, 0.01)), { stroke: g, area: n };
   }
   /**
    * Dot markers at each data point (`options.points`). Callers pass the same
@@ -568,243 +600,281 @@ 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: h } = 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)) {
+    const l = Math.max(1, (i.radius ?? 3) * s);
+    if (!(o.length > 1 && (o[o.length - 1].x - o[0].x) / (o.length - 1) < l * 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 u of o)
+        e.moveTo(u.x + l, u.y), e.arc(u.x, u.y, l, 0, Math.PI * 2);
+      e.fillStyle = i.color ?? h, 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, h = e.getRange(), { verticalPixelRatio: l } = i, u = this.options.strokeWidth > 0, r = Math.max(1, Math.round(this.options.strokeWidth * l)), f = this.options.entryAnimation ?? "grow", c = pt(this.options.linePainter ?? this.options.curve ?? "straight"), v = {
       ctx: s,
       theme: t.theme,
       horizontalPixelRatio: i.horizontalPixelRatio,
-      verticalPixelRatio: r
+      verticalPixelRatio: l
     };
-    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 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 = [];
-      let v = null;
-      for (let d = 0; d < U; d++) {
-        const S = a[d].value;
-        if (!o.isPlottable(S)) {
-          v = null;
+    for (let a = 0; a < this.stores.length; a++) {
+      const g = this.getLayerAlpha(a);
+      if (g <= 0) continue;
+      let n = this.stores[a].getVisibleData(h.from, h.to);
+      const d = i.mediaSize.width;
+      if (n.length > d * 2 && (n = Z(n, Math.round(d * 1.5))), n.length < 2) continue;
+      const M = this.lastFinitePoint(a)?.value ?? n[n.length - 1].value, x = this.resolveLayerColor(a, M), w = this.buildThresholdPaint(t, x), R = n[n.length - 1], C = this.stores[a].last(), W = C !== void 0 && R.time === C.time, H = W ? this.entranceProgress(a, R.time) : 1, D = W && f === "fade" && H < 1, N = (W ? this.trailingEndpoint(t, a) : null) ?? {
+        x: e.timeToBitmapXExact(R.time),
+        y: o.valueToBitmapYExact(this.effectiveValue(t, a, R.time, R.value))
+      }, O = N.x, X = N.y, Y = W && f === "grow" ? this.chainedTailPositions(t, a) : null, z = g < 1;
+      (z || D) && (s.save(), z && (s.globalAlpha *= g), D && (s.globalAlpha *= H));
+      const $ = n.length - 1, F = [];
+      let V = null;
+      for (let p = 0; p < $; p++) {
+        const y = n[p].value;
+        if (!o.isPlottable(y)) {
+          V = null;
           continue;
         }
-        v || (v = [], u.push(v));
-        const w = _?.get(a[d].time);
-        if (w)
-          v.push({ x: w.x, y: w.y });
+        V || (V = [], F.push(V));
+        const P = Y?.get(n[p].time);
+        if (P)
+          V.push({ x: P.x, y: P.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 E = o.valueToBitmapYExact(this.effectiveValue(t, a, n[p].time, y));
+          V.push({ x: e.timeToBitmapXExact(n[p].time), y: E });
         }
       }
-      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 m = n[$]?.value, b = Number.isFinite(O) && Number.isFinite(X) && o.isPlottable(m), T = f === "grow" && H < 1;
+      let k = null;
+      if (b && (V ? (V.push({ x: O, y: X }), k = V) : F.push([{ x: O, y: X }])), u && F.some((p) => p.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 });
-        s.strokeStyle = B ? B.stroke : E, s.lineWidth = h, s.lineJoin = "round", s.lineCap = "round", s.stroke();
+        for (const p of F)
+          p.length < 2 || c(v, { points: p, color: x, lineWidth: r, closing: !1, grew: T && p === k });
+        s.strokeStyle = w ? w.stroke : x, s.lineWidth = r, s.lineJoin = "round", s.lineCap = "round", s.stroke();
       }
-      if (f) {
-        const d = Math.max(1, h / 2);
-        let S = !1;
-        for (const w of u)
-          w.length === 1 && (S || (s.beginPath(), S = !0), s.moveTo(w[0].x + d, w[0].y), s.arc(w[0].x, w[0].y, d, 0, Math.PI * 2));
-        S && (s.fillStyle = E, s.fill());
+      if (u) {
+        const p = Math.max(1, r / 2);
+        let y = !1;
+        for (const P of F)
+          P.length === 1 && (y || (s.beginPath(), y = !0), s.moveTo(P[0].x + p, P[0].y), s.arc(P[0].x, P[0].y, p, 0, Math.PI * 2));
+        y && (s.fillStyle = x, s.fill());
       }
       if (this.options.area.visible && !this.introGhostPass) {
-        const d = i.bitmapSize.height;
-        let S;
-        if (B)
-          S = B.area;
+        const p = i.bitmapSize.height;
+        let y;
+        if (w)
+          y = w.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 I = String(a), A = this.areaGradientCache.get(I);
+          A && A.bottomY === p && A.color === x ? y = A.gradient : (y = s.createLinearGradient(0, 0, 0, p), y.addColorStop(0, B(x, 0.12)), y.addColorStop(1, B(x, 0.01)), this.areaGradientCache.set(I, { gradient: y, bottomY: p, color: x }));
+        }
+        s.fillStyle = y, s.beginPath();
+        const P = r + i.horizontalPixelRatio;
+        let E = null;
+        for (const I of F) {
+          if (I.length < 2) continue;
+          const A = I[0], L = I[I.length - 1];
+          E !== null && A.x - E.x <= P && (s.moveTo(E.x, E.y), s.lineTo(A.x, A.y), s.lineTo(A.x, p), s.lineTo(E.x, p), s.closePath()), c(v, { points: I, color: x, lineWidth: r, closing: !0, grew: T && I === k }), s.lineTo(L.x, p), s.lineTo(A.x, p), s.closePath(), E = L;
         }
-        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());
+        s.fill();
       }
       if (this.options.points?.visible) {
-        const d = [];
-        for (const S of u)
-          for (const w of S) d.push(w);
-        this.drawPointMarkers({ context: s, points: d, pixelRatio: i.horizontalPixelRatio, color: E });
+        const p = [];
+        for (const y of F)
+          for (const P of y) p.push(P);
+        this.drawPointMarkers({ context: s, points: p, pixelRatio: i.horizontalPixelRatio, color: x });
       }
-      (I || G) && s.restore();
+      (D || z) && s.restore();
     }
   }
   /** 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) => {
-      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();
-    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) {
+    const { scope: e, timeScale: o, yScale: s } = t, { context: h } = e, l = o.getRange(), { verticalPixelRatio: u } = e, r = this.options.strokeWidth > 0, f = Math.max(1, Math.round(this.options.strokeWidth * u)), c = this.options.curve ?? "straight", v = e.mediaSize.width, a = this.stores.map((m, b) => {
+      if (this.getLayerAlpha(b) <= 0) return [];
+      let T = m.getVisibleData(l.from, l.to);
+      return T.length > v * 2 && (T = Z(T, Math.round(v * 1.5))), T;
+    }), g = /* @__PURE__ */ new Set();
+    for (const m of a)
+      for (const b of m) g.add(b.time);
+    const n = Array.from(g).sort((m, b) => m - b);
+    if (n.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 d = this.options.entryAnimation ?? "grow", M = a.map((m, b) => {
+      const T = /* @__PURE__ */ new Map();
+      if (m.length === 0) return T;
+      const k = m[0].time, p = d === "grow" ? this.chainedTailValues(b, (P, E) => this.effectiveValue(t, b, P, E)) : null, y = (P) => p?.get(P.time) ?? this.effectiveValue(t, b, P.time, P.value);
+      for (const P of n) {
+        if (P < k) continue;
+        const E = _(m, P, { resolve: y });
+        E !== null && T.set(P, E);
       }
-      return M;
-    }), 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 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;
+      return T;
+    }), x = this.stores.map((m, b) => this.getLayerAlpha(b)), w = (m, b) => {
+      const T = M[m].get(b);
+      return T === void 0 ? void 0 : T * x[m];
+    }, R = s.getTransform() !== null && !i, C = Array.from({ length: this.stores.length }, () => new Array(n.length).fill(0)), W = new Array(n.length).fill(!1);
+    for (let m = 0; m < n.length; m++) {
+      const b = n[m];
+      if (R) {
+        const p = new tt(s);
+        for (let y = 0; y < this.stores.length; y++) {
+          const P = M[y].get(b);
+          P !== void 0 && s.isPlottable(P) && p.push(P, x[y]), C[y][m] = 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);
+        for (let p = 0; p < this.stores.length; p++) {
+          const y = w(p, b);
+          y !== void 0 && s.isPlottable(y) && (T += y);
         }
-      let b = 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 S = n[P];
-        if (i && S.length > 0 && v < S[0].time && (d = 0), d !== null)
+      if (i && T <= 0) {
+        W[m] = !0;
+        for (let p = 0; p < this.stores.length; p++)
+          C[p][m] = Number.NaN;
+        continue;
+      }
+      let k = 0;
+      for (let p = 0; p < this.stores.length; p++) {
+        const y = w(p, b);
+        let P = y !== void 0 && s.isPlottable(y) ? y : null;
+        const E = a[p];
+        if (i && E.length > 0 && b < E[0].time && (P = 0), P !== null)
           if (i) {
-            const w = this.introShare(t, { layerIndex: P, time: v, value: d, total: M });
-            b = Math.min(100, b + w);
+            const I = this.introShare(t, { layerIndex: p, time: b, value: P, total: T });
+            k = Math.min(100, k + I);
           } else
-            b += d;
-        D[P][u] = b;
+            k += P;
+        C[p][m] = k;
       }
     }
-    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);
-    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 H = /* @__PURE__ */ new Map();
+    for (let m = 0; m < n.length; m++) H.set(n[m], m);
+    const D = new Array(this.stores.length).fill(1);
+    for (let m = 0; m < this.stores.length; m++) {
+      if (this.getLayerAlpha(m) <= 0) continue;
+      const b = this.unsettledTail(m), T = b.length;
+      if (T === 0) continue;
+      let k = !0;
+      for (let p = 0; p < T; p++)
+        if (H.get(b[p].time) !== n.length - T + p) {
+          k = !1;
           break;
         }
-      b && (z[u] = v[M - 1].progress);
+      k && (D[m] = b[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;
+    const N = [];
+    if (d === "grow") {
+      const m = a.map((b) => b.length - 1);
+      for (let b = n.length - 1; b >= 1; b--) {
+        const T = n[b];
+        let k = 1, p = !1;
+        for (let y = 0; y < a.length; y++) {
+          if (this.getLayerAlpha(y) <= 0) continue;
+          const P = a[y];
+          for (; m[y] >= 0 && P[m[y]].time > T; ) m[y]--;
+          if (m[y] < 0 || P[m[y]].time !== T) continue;
+          const E = this.entranceProgress(y, T);
+          (!p || E > k) && (k = E), p = !0;
         }
-        if (!P || b >= 1) break;
-        I.unshift($(b));
+        if (!p || k >= 1) break;
+        N.unshift(J(k));
       }
     }
-    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 O = (m, b) => {
+      const T = b.length;
+      if (!(T === 0 || m.length < T + 1))
+        for (let k = 0; k < T; k++) {
+          const p = m.length - T + k;
+          m[p][0] = G(m[p - 1][0], m[p][0], b[k]);
         }
-    }, W = e.bitmapSize.height;
-    let C = -1, _ = -1;
-    for (let u = 0; u < this.stores.length; u++)
-      if (!(this.getLayerAlpha(u) <= 0))
-        if (C < 0)
-          C = u;
+    }, X = e.bitmapSize.height;
+    let Y = -1, z = -1;
+    for (let m = 0; m < this.stores.length; m++)
+      if (!(this.getLayerAlpha(m) <= 0))
+        if (Y < 0)
+          Y = m;
         else {
-          _ = u;
+          z = m;
           break;
         }
-    const G = C >= 0 ? this.getLayerAlpha(C) : 1, U = n.map((u, v) => v === C ? 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 $ = Y >= 0 ? this.getLayerAlpha(Y) : 1, F = a.map((m, b) => b === Y ? Math.min(1, this.getLayerAlpha(b)) : 1), V = yt(W);
+    for (let m = this.stores.length - 1; m >= 0; m--) {
+      const b = this.getLayerAlpha(m);
+      if (b <= 0) continue;
+      const T = this.lastFinitePoint(m)?.value ?? 0, k = this.resolveLayerColor(m, T), p = m === Y, y = z >= 0 && m === z && $ < 1, P = [];
+      for (let A = 0; A < n.length; A++) {
+        const L = m > 0 ? s.valueToBitmapYExact(C[m - 1][A]) : X;
+        let U = L;
+        p ? U = X : y && (U = L + (X - L) * (1 - $)), P.push([o.timeToBitmapXExact(n[A]), U]);
       }
-      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]);
+      d === "grow" && O(P, N);
+      const E = [];
+      for (let A = 0; A < n.length; A++) {
+        let L = s.valueToBitmapYExact(C[m][A]);
+        p && b < 1 && (L = X + (L - X) * b), E.push([o.timeToBitmapXExact(n[A]), 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];
-        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;
-        }
-        if (l.beginPath(), l.moveTo(w[0].x, w[0].y), et(l, F), P)
-          for (let k = d.length - 1; k >= 0; k--)
-            l.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);
-        }
-        l.closePath(), l.fillStyle = O, l.fill();
+      d === "grow" && O(E, N);
+      const I = d === "fade" && D[m] < 1;
+      I && (h.save(), h.globalAlpha *= D[m]);
+      for (const A of V) {
+        const L = d === "grow" && N.length > 0 && A.to === n.length;
+        this.drawStackSlice({
+          ctx: t,
+          lowerXY: P.slice(A.from, A.to),
+          upperXY: E.slice(A.from, A.to),
+          layer: { color: k, alpha: b, isBottomVisible: p },
+          curve: { kind: c, growing: L, hasStroke: r, lineWidth: f }
+        });
       }
-      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) {
-        const R = v < 1;
-        R && (l.save(), l.globalAlpha *= v), this.drawPointMarkers({ context: l, points: w, pixelRatio: e.horizontalPixelRatio, color: b }), R && l.restore();
+      if (this.options.points?.visible) {
+        const A = Q(E).filter((U, rt) => !W[rt]), L = b < 1;
+        L && (h.save(), h.globalAlpha *= b), this.drawPointMarkers({ context: h, points: A, pixelRatio: e.horizontalPixelRatio, color: k }), L && h.restore();
       }
-      K && l.restore();
+      I && h.restore();
     }
-    this.stackedEdges = { times: a, cumulative: D, growChain: I, collapse: U };
+    this.stackedEdges = { times: n, cumulative: C, growChain: N, collapse: F };
+  }
+  /** Fill and stroke of one layer's slice over one run of stacked columns. */
+  drawStackSlice(t) {
+    const { lowerXY: i, upperXY: e } = t, { context: o } = t.ctx.scope, { color: s, alpha: h, isBottomVisible: l } = t.layer, { kind: u, growing: r, hasStroke: f, lineWidth: c } = t.curve, v = Q(e);
+    if (v.length === 1) {
+      f && this.drawStackDot({ context: o, point: v[0], color: s, lineWidth: c, alpha: h });
+      return;
+    }
+    const a = j(v, u, r);
+    if (this.options.area.visible && !this.introGhostPass) {
+      let n = e[0][1], d = i[0][1];
+      for (let x = 1; x < e.length; x++)
+        e[x][1] < n && (n = e[x][1]);
+      for (let x = 1; x < i.length; x++)
+        i[x][1] > d && (d = i[x][1]);
+      let M = B(s, 0.25);
+      if (d > n + 0.5) {
+        const x = o.createLinearGradient(0, n, 0, d);
+        x.addColorStop(0, B(s, 0.25)), x.addColorStop(1, B(s, 0.05)), M = x;
+      }
+      if (o.beginPath(), o.moveTo(v[0].x, v[0].y), q(o, a), l)
+        for (let x = i.length - 1; x >= 0; x--)
+          o.lineTo(i[x][0], i[x][1]);
+      else {
+        const x = Q(i), w = j(x, u, r), R = x[x.length - 1];
+        o.lineTo(R.x, R.y), mt(o, x, w);
+      }
+      o.closePath(), o.fillStyle = M, o.fill();
+    }
+    const g = f && h < 1;
+    g && (o.save(), o.globalAlpha *= h), f && (o.beginPath(), o.moveTo(v[0].x, v[0].y), q(o, a), o.strokeStyle = s, o.lineWidth = c, o.lineJoin = "round", o.lineCap = "round", o.stroke()), g && o.restore();
+  }
+  /** A stroke-wide dot for a lone stacked column, faded with its layer like the stroke. */
+  drawStackDot(t) {
+    const { context: i, point: e, color: o, lineWidth: s, alpha: h } = t, l = Math.max(1, s / 2);
+    i.save(), i.globalAlpha *= h, i.beginPath(), i.moveTo(e.x + l, e.y), i.arc(e.x, e.y, l, 0, Math.PI * 2), i.fillStyle = o, i.fill(), i.restore();
   }
   /**
    * Overlay hook: draws crosshair nearest-point dots and last-point pulse dots.
@@ -812,55 +882,60 @@ 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: h } = t, l = i, u = this.options.pulseMs, r = u > 0 ? performance.now() / (u * 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);
-        if (!g || x === "off" && !o.isPlottable(g.value)) continue;
-        const A = this.resolveLayerColor(p, 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();
+      const v = this.options.stacking, a = 4 * l.horizontalPixelRatio;
+      for (let g = 0; g < this.stores.length; g++) {
+        const n = this.getLayerAlpha(g);
+        if (n <= 0) continue;
+        const d = this.stores[g].findNearest(s.time, h);
+        if (!d || v === "off" && !o.isPlottable(d.value)) continue;
+        const M = this.resolveLayerColor(g, d.value), { x, y: w } = v === "off" ? {
+          x: e.timeToBitmapXExact(d.time),
+          y: o.valueToBitmapYExact(this.effectiveValue(t, g, d.time, d.value))
+        } : this.stackedPositionAt(t, g, d.time);
+        if (!Number.isFinite(w)) continue;
+        const R = n < 1;
+        R && (i.context.save(), i.context.globalAlpha *= n), i.context.save(), i.context.globalAlpha *= 0.25, i.context.beginPath(), i.context.arc(x, w, a + 3 * l.horizontalPixelRatio, 0, Math.PI * 2), i.context.fillStyle = M, i.context.fill(), i.context.restore(), i.context.beginPath(), i.context.arc(x, w, a, 0, Math.PI * 2), i.context.fillStyle = M, i.context.fill(), R && i.context.restore();
       }
     }
-    const m = this.introWave.active && this.introDirectives?.clip !== void 0;
+    const f = 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) {
-      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);
-        if (x === "off") {
-          if (!o.isPlottable(a)) continue;
-          const L = this.trailingEndpoint(t, n);
-          if (!L) continue;
+    if (f && (c = Math.max(0, (this.introWave.linear() - (1 - K)) / K)), this.hasPulse && u > 0 && c > 0) {
+      const v = this.options.stacking;
+      for (let a = 0; a < this.stores.length; a++) {
+        const g = this.getLayerAlpha(a);
+        if (g <= 0) continue;
+        const n = this.lastFinitePoint(a);
+        if (!n) continue;
+        const d = this.resolveLayerColor(a, n.value);
+        if (v === "off") {
+          if (!o.isPlottable(n.value)) continue;
+          const w = n === this.stores[a].last() ? this.trailingEndpoint(t, a) : {
+            x: e.timeToBitmapXExact(n.time),
+            y: o.valueToBitmapYExact(this.effectiveValue(t, a, n.time, n.value))
+          };
+          if (!w) continue;
           this.drawPulse({
             ctx: i.context,
-            x: L.x,
-            y: L.y,
-            color: g,
-            pixelRatio: r.horizontalPixelRatio,
-            phase: h,
-            alpha: p * c
+            x: w.x,
+            y: w.y,
+            color: d,
+            pixelRatio: l.horizontalPixelRatio,
+            phase: r,
+            alpha: g * c
           });
           continue;
         }
-        const A = this.stores[n].last();
-        if (!A) continue;
-        const { x: E, y: B } = this.stackedPositionAt(t, n, A.time);
-        this.drawPulse({
+        const { x: M, y: x } = this.stackedPositionAt(t, a, n.time);
+        Number.isFinite(x) && this.drawPulse({
           ctx: i.context,
-          x: E,
-          y: B,
-          color: g,
-          pixelRatio: r.horizontalPixelRatio,
-          phase: h,
-          alpha: p * c
+          x: M,
+          y: x,
+          color: d,
+          pixelRatio: l.horizontalPixelRatio,
+          phase: r,
+          alpha: g * c
         });
       }
     }
@@ -871,23 +946,38 @@ class Pt extends ut {
     y: e,
     color: o,
     pixelRatio: s,
-    phase: l,
-    alpha: r = 1
+    phase: h,
+    alpha: l = 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 u = 3 * s, r = 0.4 + 0.6 * Math.abs(Math.sin(h * 2 * Math.PI)), f = u + 4 * s * r, c = l < 1;
+    c && (t.save(), t.globalAlpha *= l), t.beginPath(), t.arc(i, e, f, 0, Math.PI * 2), t.fillStyle = B(o, r * 0.3), t.fill(), t.beginPath(), t.arc(i, e, u, 0, Math.PI * 2), t.fillStyle = o, t.fill(), c && t.restore();
   }
 }
-const Bt = {
+const It = {
   type: "line",
   xTypes: ["time", "numeric", "category"],
-  create: ({ theme: y, layerCount: t }, i) => new Pt(t, {
-    colors: t === 1 ? [y.line.color] : y.seriesColors.slice(0, t),
-    strokeWidth: y.line.width,
-    ...i
-  })
+  create: ({ theme: S, layerCount: t, paletteIndex: i = 0 }, e) => new xt(
+    t,
+    {
+      colors: at({ theme: S, layerCount: t, paletteIndex: i }),
+      strokeWidth: S.line.width,
+      ...e
+    },
+    i
+  )
 };
+function yt(S) {
+  const t = [];
+  let i = 0;
+  for (let e = 0; e <= S.length; e++)
+    (e === S.length || S[e]) && (e > i && t.push({ from: i, to: e }), i = e + 1);
+  return t;
+}
+function at(S) {
+  const { theme: t, layerCount: i, paletteIndex: e } = S, o = t.seriesColors;
+  return i === 1 && e === 0 || o.length === 0 ? [t.line.color] : Array.from({ length: i }, (s, h) => o[(e + h) % o.length]);
+}
 export {
-  Pt as LineRenderer,
-  Bt as LineSeriesDef
+  xt as LineRenderer,
+  It as LineSeriesDef
 };