@wick-charts/vue 0.8.1 → 0.8.2

package/dist/core/dist/series/base-multi-layer.js

@@ -1,12 +1,12 @@
-import { Animator as k } from "../animation/animator.js";
+import { Animator as b } from "../animation/animator.js";
 import { IntroWave as y } from "../animation/intro-wave.js";
 import { ScalarSpring as V } from "../animation/scalar-spring.js";
 import { TimeSeriesStore as P } from "../data/store.js";
-import { resolveColor as M } from "../utils/color.js";
-import { normalizeTimePointArray as d, normalizeTime as L, sliceSample as F } from "../utils/time.js";
-import { sumStack as A, renderedStackPercentTop as w, renderedStackTop as b } from "./stack-math.js";
-const S = (m, e, t) => m + (e - m) * t;
-class z {
+import { resolveColor as S } from "../utils/color.js";
+import { normalizeTimePointArray as d, normalizeTime as L, sliceSample as M } from "../utils/time.js";
+import { sumStack as w, renderedStackPercentTop as A, renderedStackTop as k } from "./stack-math.js";
+const F = (m, t, e) => m + (t - m) * e;
+class I {
   stores;
   // --- Animation state (per layer) ----------------------------------------
   /**
@@ -53,10 +53,10 @@ class z {
    *  (the pre-prepend first point). Stagger position is `0` at the boundary
    *  and `1` at the deepest point. */
   historyRange = null;
-  constructor(e) {
-    this.stores = Array.from({ length: e }, () => new P()), this.entries = Array.from({ length: e }, () => /* @__PURE__ */ new Map()), this.displayedLastValues = new Array(e).fill(null), this.#t = new Array(e).fill(null), this.#e = new Array(e).fill(null), this.#s = Array.from({ length: e }, () => /* @__PURE__ */ new Map()), this.#i = Array.from(
-      { length: e },
-      () => new k({ initial: 1, duration: 0, lerp: S })
+  constructor(t) {
+    this.stores = Array.from({ length: t }, () => new P()), this.entries = Array.from({ length: t }, () => /* @__PURE__ */ new Map()), this.displayedLastValues = new Array(t).fill(null), this.#t = new Array(t).fill(null), this.#e = new Array(t).fill(null), this.#s = Array.from({ length: t }, () => /* @__PURE__ */ new Map()), this.#i = Array.from(
+      { length: t },
+      () => new b({ initial: 1, duration: 0, lerp: F })
     );
   }
   // --- Color accessors ------------------------------------------------------
@@ -66,15 +66,15 @@ class z {
    * a theme swap, which rewrites `options.colors`, leaves these untouched.
    */
   #n = [];
-  setColorOverrides(e) {
-    this.#n = e;
+  setColorOverrides(t) {
+    this.#n = t;
   }
   /** The active resolver for a layer — the `data` override if set, else the theme base (cycled). */
-  #r(e) {
-    const t = this.#n[e];
-    if (t !== void 0) return t;
+  #r(t) {
+    const e = this.#n[t];
+    if (e !== void 0) return e;
     const s = this.options.colors;
-    return s[e % s.length];
+    return s[t % s.length];
   }
   /** The first layer's color resolver (string or value-fn). */
   getColor() {
@@ -84,71 +84,71 @@ class z {
     return this.options.colors;
   }
   /** Resolve one layer's color for a given datum value. */
-  resolveLayerColor(e, t) {
-    return M(this.#r(e), t);
+  resolveLayerColor(t, e) {
+    return S(this.#r(t), e);
   }
   // --- Data ingest ----------------------------------------------------------
-  setData(e, t = 0) {
-    const s = this.stores[t];
+  setData(t, e = 0) {
+    const s = this.stores[e];
     if (!s) return;
     let i = !1;
-    for (const r of this.stores)
-      r.length > 0 && (i = !0);
-    const n = d(e ?? []);
-    s.setData(n), !i && n.length > 0 && this.introWave.arm(this.options.introMs);
-    const l = s.last();
-    this.displayedLastValues[t] = l ? l.value : null, this.#t[t] = null, this.#e[t] = null, this.#s[t].clear(), this.entries[t].clear(), this.historyWave.finish(), this.historyRange = null;
+    for (const o of this.stores)
+      o.length > 0 && (i = !0);
+    const n = d(t ?? []);
+    !i && n.length > 0 && this.introWave.arm(this.options.introMs), s.setData(n);
+    const r = s.last();
+    this.displayedLastValues[e] = r ? r.value : null, this.#t[e] = null, this.#e[e] = null, this.#s[e].clear(), this.entries[e].clear(), this.historyWave.finish(), this.historyRange = null;
   }
   /**
    * Replace a layer like {@link setData}, but ease each point that keeps its
    * `time` from the value on screen to its new one over `smoothMs`; a point
    * with a new `time` plays its entrance.
    */
-  morphData(e, t = 0) {
-    const s = this.stores[t];
+  morphData(t, e = 0) {
+    const s = this.stores[e];
     if (!s) return;
     if (!this.stores.some((h) => h.length > 0)) {
-      this.setData(e, t);
+      this.setData(t, e);
       return;
     }
     const i = /* @__PURE__ */ new Map();
     for (const h of s.getAll())
-      i.set(h.time, this.liveValue(t, h.time, h.value));
-    const n = d(e ?? []);
+      i.set(h.time, this.liveValue(e, h.time, h.value));
+    const n = d(t ?? []);
     s.setData(n);
-    const l = this.options.smoothMs, r = this.isEntryEnabled() && this.options.entryMs > 0, o = this.entries[t], u = this.#s[t], a = /* @__PURE__ */ new Map();
+    const r = this.options.smoothMs, o = this.isEntryEnabled() && this.options.entryMs > 0, l = this.entries[e], u = this.#s[e], a = /* @__PURE__ */ new Map();
     for (const h of n) {
       const g = i.get(h.time);
       if (g === void 0) {
-        r && o.set(h.time, { startTime: performance.now() });
+        o && l.set(h.time, { startTime: performance.now() });
         continue;
       }
       const p = h.value;
-      if (g === p || l <= 0 || !Number.isFinite(g) || !Number.isFinite(p)) continue;
+      if (g === p || r <= 0 || !Number.isFinite(g) || !Number.isFinite(p)) continue;
       const v = u.get(h.time) ?? new V(g);
-      v.target !== p && v.retarget(p, { settleMs: l }), a.set(h.time, v);
+      v.target !== p && v.retarget(p, { settleMs: r }), a.set(h.time, v);
     }
-    const f = new Set(n.map((h) => h.time));
-    for (const h of o.keys())
-      f.has(h) || o.delete(h);
-    this.#s[t] = a;
-    const c = s.last();
-    this.displayedLastValues[t] = c ? c.value : null, this.#t[t] = null, this.#e[t] = null;
-  }
-  appendPoint(e, t = 0) {
-    const s = this.stores[t];
+    const c = new Set(n.map((h) => h.time));
+    for (const h of l.keys())
+      c.has(h) || l.delete(h);
+    this.#s[e] = a;
+    const f = s.last();
+    this.displayedLastValues[e] = f ? f.value : null, this.#t[e] = null, this.#e[e] = null;
+  }
+  appendPoint(t, e = 0) {
+    const s = this.stores[e];
     if (!s) return;
-    const i = e, n = L(i.time), l = s.last(), r = s.length;
+    const i = t, n = L(i.time), r = s.last(), o = s.length;
     s.append({ ...i, time: n });
-    const o = this.#t[t];
-    o !== null && l !== void 0 && s.length > r && (this.#e[t] = { time: l.time, anim: o }), this.displayedLastValues[t] = i.value, this.#t[t] = null;
+    const l = this.#t[e];
+    l !== null && r !== void 0 && s.length > o && (this.#e[e] = { time: r.time, anim: l }), this.displayedLastValues[e] = i.value, this.#t[e] = null;
     const u = this.options.entryMs;
-    this.isEntryEnabled() && u > 0 && this.entries[t].set(n, { startTime: performance.now() });
+    this.isEntryEnabled() && u > 0 && this.entries[e].set(n, { startTime: performance.now() });
   }
-  prependPoints(e, t = 0) {
-    const s = this.stores[t];
-    if (!s || e.length === 0) return;
-    const i = d(e), n = s.first()?.time;
+  prependPoints(t, e = 0) {
+    const s = this.stores[e];
+    if (!s || t.length === 0) return;
+    const i = d(t), n = s.first()?.time;
     s.prepend(i), this.#o(i[0]?.time, n);
   }
   /**
@@ -157,71 +157,71 @@ class z {
    * another layer — only the range grows; restarting the clock would snap
    * half-revealed points back to invisible.
    */
-  #o(e, t) {
+  #o(t, e) {
     const s = this.options.historyRevealMs;
-    if (!(this.options.historyReveal === "none" || s <= 0) && !(e === void 0 || t === void 0)) {
+    if (!(this.options.historyReveal === "none" || s <= 0) && !(t === void 0 || e === void 0)) {
       if (this.historyWave.active && this.historyRange !== null) {
-        this.historyRange = { from: Math.min(this.historyRange.from, e), to: this.historyRange.to };
+        this.historyRange = { from: Math.min(this.historyRange.from, t), to: this.historyRange.to };
         return;
       }
-      this.historyRange = { from: e, to: t }, this.historyWave.arm(s);
+      this.historyRange = { from: t, to: e }, this.historyWave.arm(s);
     }
   }
-  updateLastPoint(e, t = 0) {
-    const s = this.stores[t];
+  updateLastPoint(t, e = 0) {
+    const s = this.stores[e];
     if (!s) return;
-    const i = e, n = s.last()?.time;
+    const i = t, n = s.last()?.time;
     s.updateLast({ ...i, time: L(i.time) });
-    const l = this.#s[t], r = n === void 0 ? void 0 : l.get(n);
-    n !== void 0 && r !== void 0 && (l.delete(n), this.displayedLastValues[t] = r.current, this.#t[t] = r);
-    const o = i.value, u = this.options.smoothMs;
+    const r = this.#s[e], o = n === void 0 ? void 0 : r.get(n);
+    n !== void 0 && o !== void 0 && (r.delete(n), this.displayedLastValues[e] = o.current, this.#t[e] = o);
+    const l = i.value, u = this.options.smoothMs;
     if (u <= 0) {
-      this.displayedLastValues[t] = o, this.#t[t] = null;
+      this.displayedLastValues[e] = l, this.#t[e] = null;
       return;
     }
-    let a = this.#t[t];
+    let a = this.#t[e];
     if (a === null) {
-      const f = this.displayedLastValues[t] ?? o;
-      a = new V(f), this.#t[t] = a;
+      const c = this.displayedLastValues[e] ?? l;
+      a = new V(c), this.#t[e] = a;
     }
-    a.retarget(o, { settleMs: u });
+    a.retarget(l, { settleMs: u });
   }
-  keepLast(e, t = 0) {
-    const s = this.stores[t];
-    if (!s || e < 0) return;
-    const i = s.length - e;
+  keepLast(t, e = 0) {
+    const s = this.stores[e];
+    if (!s || t < 0) return;
+    const i = s.length - t;
     i <= 0 || s.trimStart(i);
   }
   // --- Layer model ----------------------------------------------------------
   getLayerCount() {
     return this.stores.length;
   }
-  setLayerVisible(e, t) {
-    this.stores[e]?.setVisible(t);
+  setLayerVisible(t, e) {
+    this.stores[t]?.setVisible(e);
   }
-  isLayerVisible(e) {
-    return this.stores[e]?.isVisible() ?? !0;
+  isLayerVisible(t) {
+    return this.stores[t]?.isVisible() ?? !0;
   }
   /** Representative concrete color per layer — value-fns are resolved at the
    *  layer's last value, giving the legend swatch / color-change detection a
    *  stable string. Honors per-layer `data` overrides. */
   getLayerColors() {
-    const e = [];
-    for (let t = 0; t < this.stores.length; t++) {
-      const s = this.lastFinitePoint(t)?.value ?? 0;
-      e.push(this.resolveLayerColor(t, s));
+    const t = [];
+    for (let e = 0; e < this.stores.length; e++) {
+      const s = this.lastFinitePoint(e)?.value ?? 0;
+      t.push(this.resolveLayerColor(e, s));
     }
-    return e;
+    return t;
   }
   // --- Lifecycle ------------------------------------------------------------
-  onDataChanged(e) {
-    for (const t of this.stores) t.on("update", e);
+  onDataChanged(t) {
+    for (const e of this.stores) e.on("update", t);
     return () => {
-      for (const t of this.stores) t.off("update", e);
+      for (const e of this.stores) e.off("update", t);
     };
   }
   dispose() {
-    for (const e of this.stores) e.removeAllListeners();
+    for (const t of this.stores) t.removeAllListeners();
   }
   // --- Animation primitives — renderer-owned state --------------------------
   /**
@@ -231,8 +231,8 @@ class z {
    * pure function of wall time — so tooltip/last-value queries (which have
    * no context to hand) can read it too.
    */
-  entranceProgress(e, t) {
-    const s = this.entries[e]?.get(t);
+  entranceProgress(t, e) {
+    const s = this.entries[t]?.get(e);
     if (s === void 0) return 1;
     const i = this.options.entryMs;
     if (i <= 0) return 1;
@@ -247,9 +247,9 @@ class z {
    * (bar) fold this into their {@link entranceProgress} override; the line
    * renders its own continuous sweep instead.
    */
-  introProgressAt(e, t) {
+  introProgressAt(t, e) {
     if (!this.introWave.active) return 1;
-    const s = e.timeScale.getRange(), i = s.to - s.from, n = i > 0 ? (t - s.from) / i : 0;
+    const s = t.timeScale.getRange(), i = s.to - s.from, n = i > 0 ? (e - s.from) / i : 0;
     return this.introWave.progressAt(n);
   }
   /**
@@ -258,10 +258,10 @@ class z {
    * point — so the wave travels into history. `1` for points outside the
    * prepended span or when no reveal is in flight.
    */
-  historyProgressAt(e) {
-    const t = this.historyRange;
-    if (!this.historyWave.active || t === null || e >= t.to) return 1;
-    const s = t.to - t.from, i = s > 0 ? (t.to - e) / s : 0;
+  historyProgressAt(t) {
+    const e = this.historyRange;
+    if (!this.historyWave.active || e === null || t >= e.to) return 1;
+    const s = e.to - e.from, i = s > 0 ? (e.to - t) / s : 0;
     return this.historyWave.progressAt(i);
   }
   /**
@@ -275,14 +275,14 @@ class z {
    * on every append. Renderers lerp each chain link from the previous
    * link's *rendered* position instead, so geometry stays continuous.
    */
-  unsettledTail(e) {
-    const t = this.stores[e]?.getAll();
-    if (!t || t.length < 2) return [];
+  unsettledTail(t) {
+    const e = this.stores[t]?.getAll();
+    if (!e || e.length < 2) return [];
     const s = [];
-    for (let i = t.length - 1; i >= 1; i--) {
-      const n = this.entranceProgress(e, t[i].time);
+    for (let i = e.length - 1; i >= 1; i--) {
+      const n = this.entranceProgress(t, e[i].time);
       if (n >= 1) break;
-      s.unshift({ time: t[i].time, progress: n });
+      s.unshift({ time: e[i].time, progress: n });
     }
     return s;
   }
@@ -294,8 +294,8 @@ class z {
    * Falls back to `rawValue` when the store is empty or no smoothing has
    * happened yet.
    */
-  effectiveValue(e, t, s, i) {
-    return this.liveValue(t, s, i);
+  effectiveValue(t, e, s, i) {
+    return this.liveValue(e, s, i);
   }
   /**
    * The ctx-independent core of {@link effectiveValue} — used directly by the
@@ -304,14 +304,14 @@ class z {
    * transform). Those queries only need the live smoothing/chase this base
    * method already provides, never the intro's positional transform.
    */
-  liveValue(e, t, s) {
-    const i = this.#s[e]?.get(t);
+  liveValue(t, e, s) {
+    const i = this.#s[t]?.get(e);
     if (i !== void 0) return i.current;
-    const n = this.stores[e]?.last()?.time;
-    if (n !== void 0 && t === n)
-      return this.displayedLastValues[e] ?? s;
-    const l = this.#e[e];
-    return l !== null && l.time === t ? l.anim.current : s;
+    const n = this.stores[t]?.last()?.time;
+    if (n !== void 0 && e === n)
+      return this.displayedLastValues[t] ?? s;
+    const r = this.#e[t];
+    return r !== null && r.time === e ? r.anim.current : s;
   }
   /**
    * Value a last-value/tooltip query should report for `time` — defaults to
@@ -320,8 +320,8 @@ class z {
    * override) without that lerp feeding back into `effectiveValue`, which
    * the renderer's own per-point draws use as an unlerp'd target.
    */
-  snapshotValue(e, t, s) {
-    return this.liveValue(e, t, s);
+  snapshotValue(t, e, s) {
+    return this.liveValue(t, e, s);
   }
   // --- Animation lifecycle --------------------------------------------------
   /**
@@ -330,44 +330,44 @@ class z {
    * subclass passes its own clock so test harnesses (which stub
    * `performance.now`) can drive progression deterministically.
    */
-  tickAnimations(e) {
-    this.introWave.tick(e), this.historyWave.tick(e);
-    for (const t of this.#i) t.tick(e);
-    for (let t = 0; t < this.stores.length; t++) {
-      const s = this.#t[t];
+  tickAnimations(t) {
+    this.introWave.tick(t), this.historyWave.tick(t);
+    for (const e of this.#i) e.tick(t);
+    for (let e = 0; e < this.stores.length; e++) {
+      const s = this.#t[e];
       if (s !== null) {
-        const o = s.tick(e);
-        this.displayedLastValues[t] = s.current, o || (this.#t[t] = null);
+        const l = s.tick(t);
+        this.displayedLastValues[e] = s.current, l || (this.#t[e] = null);
       }
-      const i = this.#e[t];
-      i !== null && !i.anim.tick(e) && (this.#e[t] = null);
-      const n = this.#s[t];
-      for (const [o, u] of n)
-        u.tick(e) || n.delete(o);
-      const l = this.options.entryMs;
-      if (l <= 0) {
-        this.entries[t].clear();
+      const i = this.#e[e];
+      i !== null && !i.anim.tick(t) && (this.#e[e] = null);
+      const n = this.#s[e];
+      for (const [l, u] of n)
+        u.tick(t) || n.delete(l);
+      const r = this.options.entryMs;
+      if (r <= 0) {
+        this.entries[e].clear();
         continue;
       }
-      const r = this.entries[t];
-      for (const [o, u] of r)
-        e - u.startTime >= l && r.delete(o);
+      const o = this.entries[e];
+      for (const [l, u] of o)
+        t - u.startTime >= r && o.delete(l);
     }
   }
   /** True while any layer has an active chase, unsettled entry, alpha fade,
    *  or the initial-load reveal is still sweeping. */
   get needsAnimation() {
     if (this.introWave.active || this.historyWave.active) return !0;
-    for (const e of this.#i)
-      if (e.animating) return !0;
-    for (const e of this.#t)
-      if (e !== null) return !0;
-    for (const e of this.#e)
-      if (e !== null) return !0;
-    for (const e of this.#s)
-      if (e.size > 0) return !0;
-    for (const e of this.entries)
-      if (e.size > 0) return !0;
+    for (const t of this.#i)
+      if (t.animating) return !0;
+    for (const t of this.#t)
+      if (t !== null) return !0;
+    for (const t of this.#e)
+      if (t !== null) return !0;
+    for (const t of this.#s)
+      if (t.size > 0) return !0;
+    for (const t of this.entries)
+      if (t.size > 0) return !0;
     return !1;
   }
   /** Reveal-front position of the initial-load intro; `1` once settled. */
@@ -382,16 +382,16 @@ class z {
    */
   cancelEntranceAnimations() {
     this.introWave.finish();
-    for (const e of this.entries) e.clear();
+    for (const t of this.entries) t.clear();
   }
   /**
    * Start a series-wide fade toward `target` over `durationMs`. Fans out
    * across every per-layer animator so a `setSeriesVisible` toggle is just
    * "set every layer to the same target". `durationMs <= 0` snaps.
    */
-  setAlpha(e, t) {
+  setAlpha(t, e) {
     for (const s of this.#i)
-      s.setTarget(e, { duration: t });
+      s.setTarget(t, { duration: e });
   }
   /**
    * `1` while any layer has alpha > 0 OR is animating, `0` when every layer
@@ -407,8 +407,8 @@ class z {
    * would deadlock at `0`.
    */
   getAlpha() {
-    for (const e of this.#i)
-      if (e.current > 0 || e.animating) return 1;
+    for (const t of this.#i)
+      if (t.current > 0 || t.animating) return 1;
     return 0;
   }
   /**
@@ -416,21 +416,21 @@ class z {
    * Subclass draw loops multiply this into `globalAlpha` per layer so the
    * fade lives next to the geometry it affects.
    */
-  setLayerAlpha(e, t, s) {
-    this.#i[e]?.setTarget(t, { duration: s });
+  setLayerAlpha(t, e, s) {
+    this.#i[t]?.setTarget(e, { duration: s });
   }
   /** Latest rendered per-layer alpha. Defaults to 1 for out-of-range indices. */
-  getLayerAlpha(e) {
-    return this.#i[e]?.current ?? 1;
+  getLayerAlpha(t) {
+    return this.#i[t]?.current ?? 1;
   }
   // --- Data queries ---------------------------------------------------------
   /**
    * The layer's newest point with a finite value, after skipping `skip` such
    * points — a trailing `null` / `NaN` is a gap, not the latest reading.
    */
-  lastFinitePoint(e, t = 0) {
-    const s = this.stores[e]?.getAll() ?? [];
-    let i = t;
+  lastFinitePoint(t, e = 0) {
+    const s = this.stores[t]?.getAll() ?? [];
+    let i = e;
     for (let n = s.length - 1; n >= 0; n--)
       if (Number.isFinite(s[n].value)) {
         if (i === 0) return s[n];
@@ -439,44 +439,45 @@ class z {
     return null;
   }
   getLastValue() {
-    for (let e = this.stores.length - 1; e >= 0; e--) {
-      const t = this.lastFinitePoint(e);
-      if (t) return t.value;
+    for (let t = this.stores.length - 1; t >= 0; t--) {
+      const e = this.lastFinitePoint(t);
+      if (e) return e.value;
     }
     return null;
   }
-  getDataAtTime(e, t) {
-    return this.stores[0]?.findNearest(e, t) ?? null;
+  getDataAtTime(t, e) {
+    return this.stores[0]?.findNearest(t, e) ?? null;
   }
-  getLayerSnapshots(e, t) {
+  getLayerSnapshots(t, e) {
     if (this.stores.length <= 1) return null;
     const s = [];
-    for (let i = 0; i < this.stores.length; i++) {
-      if (!this.stores[i].isVisible()) continue;
-      const n = this.stores[i].findNearest(e, t);
-      if (n === null) continue;
-      const l = {
-        layerIndex: i,
-        time: n.time,
+    for (let n = 0; n < this.stores.length; n++) {
+      if (!this.stores[n].isVisible()) continue;
+      const r = this.stores[n].findNearest(t, e);
+      if (r === null) continue;
+      const o = {
+        layerIndex: n,
+        time: r.time,
         // Routes through the same live/pinned-chase smoothing the renderer
         // paints, so hovering the live edge mid-animation doesn't jump ahead
         // to the raw target before the on-screen marker gets there.
-        value: this.snapshotValue(i, n.time, n.value),
+        value: this.snapshotValue(n, r.time, r.value),
         // Resolve the layer's color at the hovered datum's value so a value-fn
         // colors the tooltip dot to match the bar / segment under the cursor.
-        color: this.resolveLayerColor(i, n.value)
+        color: this.resolveLayerColor(n, r.value)
       };
-      n.x !== void 0 && (l.x = n.x), s.push(l);
+      r.x !== void 0 && (o.x = r.x), s.push(o);
     }
-    return s.length > 0 ? s : null;
+    const i = this.withShares({ rows: s, keepGaps: !1 });
+    return i.length > 0 ? i : null;
   }
   getStackedLastValue() {
     if (this.stores.length <= 1) {
       const i = this.lastFinitePoint(0);
       return i ? { value: this.snapshotValue(0, i.time, i.value), isLive: !0 } : null;
     }
-    const e = this.options.stacking;
-    if (e === "off") {
+    const t = this.options.stacking;
+    if (t === "off") {
       for (let i = this.stores.length - 1; i >= 0; i--) {
         if (!this.stores[i].isVisible()) continue;
         const n = this.lastFinitePoint(i);
@@ -484,88 +485,105 @@ class z {
       }
       return null;
     }
-    const t = this.stackHeadValues((i) => this.stores[i].last() ?? null) ?? this.lastDrawnRowValues();
-    if (!t) return null;
-    const s = A(t);
-    return { value: e === "percent" ? w(s) : b(s), isLive: !0 };
+    const e = this.stackHeadValues((i) => this.stores[i].last() ?? null) ?? this.lastDrawnRowValues();
+    if (!e) return null;
+    const s = w(e);
+    return { value: t === "percent" ? A(s) : k(s), isLive: !0 };
   }
   /** Stack contributions at the newest time any visible layer has a finite point. */
   lastDrawnRowValues() {
-    let e = null;
+    let t = null;
     for (let s = 0; s < this.stores.length; s++) {
       if (!this.stores[s].isVisible()) continue;
       const i = this.lastFinitePoint(s);
-      i !== null && (e === null || i.time > e) && (e = i.time);
+      i !== null && (t === null || i.time > t) && (t = i.time);
     }
-    if (e === null) return null;
-    const t = e;
-    return this.stackHeadValues((s) => this.stores[s].findNearest(t, 0));
+    if (t === null) return null;
+    const e = t;
+    return this.stackHeadValues((s) => this.stores[s].findNearest(e, 0));
   }
   /** Each visible layer's stack contribution at `pick(layer)`, or `null` when none is finite. */
-  stackHeadValues(e) {
-    let t = !1;
+  stackHeadValues(t) {
+    let e = !1;
     const s = [];
     for (let i = 0; i < this.stores.length; i++) {
       if (!this.stores[i].isVisible()) continue;
-      const n = e(i);
+      const n = t(i);
       if (!n || !Number.isFinite(n.value)) {
         s.push(0);
         continue;
       }
-      t = !0, s.push(this.snapshotValue(i, n.time, n.value));
+      e = !0, s.push(this.snapshotValue(i, n.time, n.value));
     }
-    return t ? s : null;
+    return e ? s : null;
   }
-  getStackedValueAtTime(e, t) {
+  getStackedValueAtTime(t, e) {
     if (this.stores.length <= 1) {
-      const r = this.stores[0]?.findNearest(e, t);
-      return r ? this.snapshotValue(0, r.time, r.value) : null;
+      const o = this.stores[0]?.findNearest(t, e);
+      return o ? this.snapshotValue(0, o.time, o.value) : null;
     }
     const s = this.options.stacking;
     if (s === "off") {
-      for (let r = this.stores.length - 1; r >= 0; r--) {
-        if (!this.stores[r].isVisible()) continue;
-        const o = this.stores[r].findNearest(e, t);
-        if (o) return this.snapshotValue(r, o.time, o.value);
+      for (let o = this.stores.length - 1; o >= 0; o--) {
+        if (!this.stores[o].isVisible()) continue;
+        const l = this.stores[o].findNearest(t, e);
+        if (l) return this.snapshotValue(o, l.time, l.value);
       }
       return null;
     }
     let i = !1;
     const n = [];
-    for (let r = 0; r < this.stores.length; r++) {
-      if (!this.stores[r].isVisible()) continue;
-      const o = this.stores[r].findNearest(e, t);
-      if (!o) {
+    for (let o = 0; o < this.stores.length; o++) {
+      if (!this.stores[o].isVisible()) continue;
+      const l = this.stores[o].findNearest(t, e);
+      if (!l) {
         n.push(0);
         continue;
       }
-      i = !0, n.push(this.snapshotValue(r, o.time, o.value));
+      i = !0, n.push(this.snapshotValue(o, l.time, l.value));
     }
     if (!i) return null;
-    const l = A(n);
-    return s === "percent" ? w(l) : b(l);
+    const r = w(n);
+    return s === "percent" ? A(r) : k(r);
   }
   getLayerLastSnapshots() {
     if (this.stores.length <= 1) return null;
-    const e = [];
-    for (let t = 0; t < this.stores.length; t++) {
-      if (!this.stores[t].isVisible()) continue;
-      const s = this.lastFinitePoint(t);
-      if (!s) continue;
-      const i = {
-        layerIndex: t,
-        time: s.time,
-        value: this.snapshotValue(t, s.time, s.value),
-        color: this.resolveLayerColor(t, s.value)
+    const t = [];
+    for (let s = 0; s < this.stores.length; s++) {
+      if (!this.stores[s].isVisible()) continue;
+      const i = this.lastFinitePoint(s);
+      if (!i) continue;
+      const n = {
+        layerIndex: s,
+        time: i.time,
+        value: this.snapshotValue(s, i.time, i.value),
+        color: this.resolveLayerColor(s, i.value)
       };
-      s.x !== void 0 && (i.x = s.x), e.push(i);
+      i.x !== void 0 && (n.x = i.x), t.push(n);
     }
+    const e = this.withShares({ rows: t, keepGaps: !0 });
     return e.length > 0 ? e : null;
   }
+  /**
+   * On a percent stack, give each row its share of the column at the row's own
+   * time — ragged layers end at different columns. A row whose column is a gap
+   * is dropped, or kept without a share when `keepGaps`.
+   */
+  withShares(t) {
+    if (this.options.stacking !== "percent") return t.rows;
+    const e = /* @__PURE__ */ new Map(), s = [];
+    for (const i of t.rows) {
+      let n = e.get(i.time);
+      n === void 0 && (n = this.percentShares(i.time), e.set(i.time, n));
+      const r = n?.get(i.layerIndex);
+      r !== void 0 && (i.share = r), (r !== void 0 || t.keepGaps) && s.push(i);
+    }
+    return s;
+  }
   getTotalLength() {
-    let e = 0;
-    for (const t of this.stores) e += t.length;
-    return e;
+    let t = 0;
+    for (const e of this.stores) t += e.length;
+    return t;
   }
   // --- TimeSeriesRenderer data queries --------------------------------------
   /** Earliest first-sample / latest last-sample across ALL layers, skipping
@@ -573,14 +591,14 @@ class z {
    *  the multi-layer time-range leak: a populated layer 1 with an empty layer 0
    *  still reports the real bounds. */
   getTimeBounds() {
-    let e = 1 / 0, t = -1 / 0;
+    let t = 1 / 0, e = -1 / 0;
     for (const s of this.stores) {
       const i = s.first();
       if (!i) continue;
       const n = s.last() ?? i;
-      i.time < e && (e = i.time), n.time > t && (t = n.time);
+      i.time < t && (t = i.time), n.time > e && (e = n.time);
     }
-    return e === 1 / 0 ? null : { first: e, last: t };
+    return t === 1 / 0 ? null : { first: t, last: e };
   }
   /**
    * Last finite data point of **layer 0 (`stores[0]`) only** — preserves the behavior
@@ -597,70 +615,70 @@ class z {
     return this.lastFinitePoint(0, 1);
   }
   /** First (or with `'end'`, last) `maxCount` sample times from the first populated layer. */
-  sampleTimes(e, t = "start") {
+  sampleTimes(t, e = "start") {
     for (const s of this.stores) {
       const i = s.getAll();
       if (i.length !== 0)
-        return F(i, { maxCount: e, from: t }).map((n) => n.time);
+        return M(i, { maxCount: t, from: e }).map((n) => n.time);
     }
     return [];
   }
   /** Visible points of layer 0 (`stores[0]`). See {@link getLastDataPoint}. */
-  getVisibleDataPoints(e, t) {
-    return this.stores[0]?.getVisibleData(e, t) ?? [];
+  getVisibleDataPoints(t, e) {
+    return this.stores[0]?.getVisibleData(t, e) ?? [];
   }
   get stacking() {
     return this.options.stacking;
   }
-  getValueRange(e, t, s) {
+  getValueRange(t, e, s) {
     const i = this.options.stacking;
     if (i === "percent")
       return { min: 0, max: 100 };
-    const n = this.stores.map((a) => a.isVisible() ? a.getVisibleData(e, t) : []), l = s?.plottable;
+    const n = this.stores.map((a) => a.isVisible() ? a.getVisibleData(t, e) : []), r = s?.plottable;
     if (i === "off") {
-      let a = 1 / 0, f = -1 / 0;
-      for (const c of n)
-        for (const h of c)
-          Number.isFinite(h.value) && (l && !l(h.value) || (h.value < a && (a = h.value), h.value > f && (f = h.value)));
-      return a < 1 / 0 ? { min: a, max: f } : null;
+      let a = 1 / 0, c = -1 / 0;
+      for (const f of n)
+        for (const h of f)
+          Number.isFinite(h.value) && (r && !r(h.value) || (h.value < a && (a = h.value), h.value > c && (c = h.value)));
+      return a < 1 / 0 ? { min: a, max: c } : null;
     }
-    if (l) return T(n, l);
-    const r = /* @__PURE__ */ new Map();
+    if (r) return T(n, r);
+    const o = /* @__PURE__ */ new Map();
     for (let a = 0; a < n.length; a++)
-      for (const f of n[a]) {
-        let c = r.get(f.time);
-        c || (c = new Array(n.length).fill(0), r.set(f.time, c)), c[a] = Number.isFinite(f.value) ? f.value : 0;
+      for (const c of n[a]) {
+        let f = o.get(c.time);
+        f || (f = new Array(n.length).fill(0), o.set(c.time, f)), f[a] = Number.isFinite(c.value) ? c.value : 0;
       }
-    let o = 0, u = 0;
-    for (const a of r.values()) {
-      let f = 0, c = 0;
+    let l = 0, u = 0;
+    for (const a of o.values()) {
+      let c = 0, f = 0;
       for (const h of a)
-        h > 0 ? f += h : c += h;
-      f > u && (u = f), c < o && (o = c);
+        h > 0 ? c += h : f += h;
+      c > u && (u = c), f < l && (l = f);
     }
-    return u > o ? { min: o, max: u } : null;
+    return u > l ? { min: l, max: u } : null;
   }
 }
-function T(m, e) {
-  const t = /* @__PURE__ */ new Map();
-  for (let l = 0; l < m.length; l++)
-    for (const r of m[l]) {
-      let o = t.get(r.time);
-      o || (o = new Array(m.length).fill(0), t.set(r.time, o)), o[l] = e(r.value) ? r.value : 0;
+function T(m, t) {
+  const e = /* @__PURE__ */ new Map();
+  for (let r = 0; r < m.length; r++)
+    for (const o of m[r]) {
+      let l = e.get(o.time);
+      l || (l = new Array(m.length).fill(0), e.set(o.time, l)), l[r] = t(o.value) ? o.value : 0;
     }
-  const s = e(0);
+  const s = t(0);
   let i = s ? 0 : 1 / 0, n = s ? 0 : -1 / 0;
-  for (const l of t.values()) {
-    let r = 0, o = 0;
-    for (const u of l) {
+  for (const r of e.values()) {
+    let o = 0, l = 0;
+    for (const u of r) {
       if (u === 0) continue;
-      u > 0 ? r += u : o += u;
-      const a = u > 0 ? r : o;
-      e(a) && (a < i && (i = a), a > n && (n = a));
+      u > 0 ? o += u : l += u;
+      const a = u > 0 ? o : l;
+      t(a) && (a < i && (i = a), a > n && (n = a));
     }
   }
   return i < 1 / 0 ? { min: i, max: n } : null;
 }
 export {
-  z as BaseMultiLayerSeries
+  I as BaseMultiLayerSeries
 };