@wick-charts/vue 0.8.1 → 0.8.2

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

@@ -1,83 +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 U } from "../animation/easing.js";
-import { decimateLineData as q } from "../data/decimation.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 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";
-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 = ft();
-function j(y, t, 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];
+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 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);
+  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() {
@@ -98,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 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());
+    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
@@ -119,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, 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();
+    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), m && 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
@@ -137,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: 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;
+    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");
@@ -164,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 = mt()), 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
@@ -200,45 +204,45 @@ class Pt extends ut {
     });
   }
   buildFrame(t, i) {
-    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 f = (l) => {
-      let g = p[l];
-      return g === void 0 && (g = this.stores[l]?.getVisibleData(r.from, r.to) ?? [], p[l] = 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: a,
-      range: r,
-      width: m,
+      progress: h,
+      range: l,
+      width: u,
       height: o.getMediaHeight() * s.verticalPixelRatio,
       stacking: this.options.stacking,
-      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),
+      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: 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;
+      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 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((b) => ({
-                x: e.timeToBitmapXExact(b.time),
-                y: o.valueToBitmapYExact(b.value),
-                time: b.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;
       }
     };
   }
@@ -252,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: 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 }));
+    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
@@ -266,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 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 p = 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 f = j(n, h, { resolve: (l) => l.value });
-        f === null || !i.isPlottable(f) || (r[c] = f * x, p += f * 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 (!(p <= 0)) {
-        m++;
+      if (!(f <= 0)) {
+        u++;
         for (let c = 0; c < e; c++) {
-          const x = r[c];
-          x !== null && (s[c] += x / p * 100, a[c] = !0);
+          const v = l[c];
+          v !== null && (s[c] += v / f * 100, h[c] = !0);
         }
       }
     }
-    return s.map((h, p) => a[p] ? h / m : 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, 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 a({ 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 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 });
+    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
@@ -324,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 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 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;
+    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 m;
+    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 ? z(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
@@ -349,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), a = Math.max(0, Math.min(o, s));
-    if (a <= 0) return;
-    const { scope: r } = t;
-    for (const m of i)
-      for (let h = 0; h < this.stores.length; h++) {
-        const p = this.getLayerAlpha(h);
-        if (p <= 0 || !this.stores[h].isVisible()) continue;
-        const c = this.introHeadAnchor(t, h, m);
+    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: a * p
+          alpha: h * f
         });
       }
   }
@@ -380,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, a = o.getRange(), r = this.stores[i].getVisibleData(a.from, a.to);
-    if (r.length === 0) return null;
-    const m = this.stores[i].last();
-    if (m !== void 0 && e.time >= m.time) {
-      if (!s.isPlottable(m.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: m.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 p = 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 p === null || !s.isPlottable(p) ? null : { x: e.x, y: s.valueToBitmapYExact(p), value: p };
+    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
@@ -428,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", a = 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 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)
+      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 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);
+    }, { 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 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;
+    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 += p(n) ?? 0;
-    let x = 0;
-    for (let n = 0; n <= i; n++) {
-      const f = p(n);
-      if (f !== 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 l = this.introShare(t, { layerIndex: n, time: e, value: f, total: c });
-          x = Math.min(100, x + l);
+          const n = this.introShare(t, { layerIndex: a, time: e, value: g, total: c });
+          v = Math.min(100, v + n);
         } else
-          x += f;
+          v += g;
     }
-    return x;
+    return v;
   }
   /**
    * Bitmap position for layer `li`'s stacked boundary at time `t`.
@@ -488,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: 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 = z(x, s.timeToBitmapXExact(p[c + 1 + n].time), U(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: a, growChain: r, collapse: m } = o, h = yt(a, e);
-    if (h < 0) return null;
-    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++)
-      b = z(b, p.timeToBitmapXExact(a[g + E]), r[E]);
-    return { x: b, y: l };
+    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: 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 { 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 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;
+    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;
   }
@@ -539,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, 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 };
+    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
@@ -554,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: 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 };
+    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
@@ -570,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: a } = 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 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();
+      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, 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 = {
+    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 f = this.getLayerAlpha(n);
-      if (f <= 0) continue;
-      let l = this.stores[n].getVisibleData(a.from, a.to);
-      const g = i.mediaSize.width;
-      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 < _; d++) {
-        const S = l[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(l[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 W = o.valueToBitmapYExact(this.effectiveValue(t, n, l[d].time, S));
-          v.push({ x: e.timeToBitmapXExact(l[d].time), y: W });
+          const E = o.valueToBitmapYExact(this.effectiveValue(t, a, n[p].time, y));
+          V.push({ x: e.timeToBitmapXExact(n[p].time), y: E });
         }
       }
-      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)) {
+      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 === M });
-        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 (m) {
-        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), 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 }));
+          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 === M }), 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: 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 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) f.add(v.time);
-    const l = Array.from(f).sort((u, v) => u - v);
-    if (l.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", b = n.map((u, v) => {
+    const d = this.options.entryAnimation ?? "grow", M = a.map((m, b) => {
       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);
+      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 T;
-    }), E = this.stores.map((u, v) => this.getLayerAlpha(v)), B = (u, v) => {
-      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 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;
+    }), 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 T = 0;
       if (i)
-        for (let P = 0; P < this.stores.length; P++) {
-          const M = B(P, v);
-          M !== void 0 && s.isPlottable(M) && (T += M);
+        for (let p = 0; p < this.stores.length; p++) {
+          const y = w(p, b);
+          y !== void 0 && s.isPlottable(y) && (T += y);
         }
-      let A = 0;
-      for (let P = 0; P < this.stores.length; P++) {
-        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 && 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: T });
-            A = Math.min(100, A + w);
+            const I = this.introShare(t, { layerIndex: p, time: b, value: P, total: T });
+            k = Math.min(100, k + I);
           } else
-            A += d;
-        Y[P][u] = A;
+            k += P;
+        C[p][m] = k;
       }
     }
-    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), T = v.length;
+    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 A = !0;
-      for (let P = 0; P < T; P++)
-        if (D.get(v[P].time) !== l.length - T + P) {
-          A = !1;
+      let k = !0;
+      for (let p = 0; p < T; p++)
+        if (H.get(b[p].time) !== n.length - T + p) {
+          k = !1;
           break;
         }
-      A && (N[u] = v[T - 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 = 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;
+    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 || A >= 1) break;
-        I.unshift(U(A));
+        if (!p || k >= 1) break;
+        N.unshift(J(k));
       }
     }
-    const H = (u, v) => {
-      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]);
+    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]);
         }
-    }, F = e.bitmapSize.height;
-    let X = -1, $ = -1;
-    for (let u = 0; u < this.stores.length; u++)
-      if (!(this.getLayerAlpha(u) <= 0))
-        if (X < 0)
-          X = 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 = 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 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]);
+    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 < 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]);
+      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), 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] > 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 (a.beginPath(), a.moveTo(w[0].x, w[0].y), et(a, W), P)
-          for (let k = d.length - 1; k >= 0; k--)
-            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];
-          a.lineTo(Z.x, Z.y), gt(a, k, ct);
-        }
-        a.closePath(), a.fillStyle = O, a.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 }
+        });
+      }
+      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();
+      }
+      I && h.restore();
+    }
+    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;
       }
-      const Q = h && v < 1;
-      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 && (a.save(), a.globalAlpha *= v), this.drawPointMarkers({ context: a, points: w, pixelRatio: e.horizontalPixelRatio, color: A }), R && a.restore();
+      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);
       }
-      K && a.restore();
+      o.closePath(), o.fillStyle = M, o.fill();
     }
-    this.stackedEdges = { times: l, cumulative: Y, growChain: I, collapse: _ };
+    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.
@@ -814,58 +882,60 @@ class Pt extends ut {
    */
   drawOverlay(t) {
     this.tickAnimations(performance.now());
-    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;
+    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 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 b = this.resolveLayerColor(f, g.value), { x: E, y: B } = x === "off" ? {
-          x: e.timeToBitmapXExact(g.time),
-          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 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 p = this.introWave.active && this.introDirectives?.clip !== void 0;
+    const f = this.introWave.active && this.introDirectives?.clip !== void 0;
     let c = 1;
-    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 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(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 (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 (!B) continue;
+          if (!w) continue;
           this.drawPulse({
             ctx: i.context,
-            x: B.x,
-            y: B.y,
-            color: g,
-            pixelRatio: r.horizontalPixelRatio,
-            phase: h,
-            alpha: f * c
+            x: w.x,
+            y: w.y,
+            color: d,
+            pixelRatio: l.horizontalPixelRatio,
+            phase: r,
+            alpha: g * c
           });
           continue;
         }
-        const { x: b, y: E } = this.stackedPositionAt(t, n, l.time);
-        this.drawPulse({
+        const { x: M, y: x } = this.stackedPositionAt(t, a, n.time);
+        Number.isFinite(x) && this.drawPulse({
           ctx: i.context,
-          x: b,
-          y: E,
-          color: g,
-          pixelRatio: r.horizontalPixelRatio,
-          phase: h,
-          alpha: f * c
+          x: M,
+          y: x,
+          color: d,
+          pixelRatio: l.horizontalPixelRatio,
+          phase: r,
+          alpha: g * c
         });
       }
     }
@@ -876,23 +946,38 @@ class Pt extends ut {
     y: e,
     color: o,
     pixelRatio: s,
-    phase: a,
-    alpha: r = 1
+    phase: h,
+    alpha: l = 1
   }) {
-    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 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 Lt = {
+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,
-  Lt as LineSeriesDef
+  xt as LineRenderer,
+  It as LineSeriesDef
 };