@wick-charts/vue 0.8.1 → 0.8.2

package/dist/core/dist/series/bar.js

@@ -1,9 +1,9 @@
-import { DEFAULT_HISTORY_REVEAL as I, DEFAULT_BAR_INTRO as O, DEFAULT_BAR_SMOOTH as C, DEFAULT_BAR_ENTRY as _ } from "../animation/config.js";
-import { growIntro as U } from "./bar-intro.js";
-import { BaseMultiLayerSeries as N } from "./base-multi-layer.js";
-import { resolveBarPainter as $ } from "./painters/resolve.js";
+import { DEFAULT_HISTORY_REVEAL as D, DEFAULT_BAR_INTRO as C, DEFAULT_BAR_SMOOTH as O, DEFAULT_BAR_ENTRY as _ } from "../animation/config.js";
+import { growIntro as N } from "./bar-intro.js";
+import { BaseMultiLayerSeries as U } from "./base-multi-layer.js";
+import { resolveBarPainter as G } from "./painters/resolve.js";
 import { ScaleStack as z } from "./scale-stack.js";
-import { fadeIntro as G } from "./wave-intro.js";
+import { fadeIntro as $ } from "./wave-intro.js";
 const F = 2, J = {
   // Single fallback resolver; the definition's `create` swaps in `theme.bar.color`.
   colors: ["#26a69a"],
@@ -12,34 +12,34 @@ const F = 2, J = {
   anchor: "center",
   cornerRadius: F,
   entryMs: _,
-  smoothMs: C,
-  introMs: O,
-  historyRevealMs: I
+  smoothMs: O,
+  introMs: C,
+  historyRevealMs: D
 };
-function D(y) {
+function I(y) {
   return {
     ...y,
     entryMs: y.entryMs === !1 ? 0 : y.entryMs ?? _,
-    smoothMs: y.smoothMs === !1 ? 0 : y.smoothMs ?? C,
-    introMs: y.introMs === !1 ? 0 : y.introMs ?? O,
-    historyRevealMs: y.historyRevealMs === !1 ? 0 : y.historyRevealMs ?? I
+    smoothMs: y.smoothMs === !1 ? 0 : y.smoothMs ?? O,
+    introMs: y.introMs === !1 ? 0 : y.introMs ?? C,
+    historyRevealMs: y.historyRevealMs === !1 ? 0 : y.historyRevealMs ?? D
   };
 }
-const Q = U(), Z = G(), q = {
+const Q = N(), Z = $(), q = {
   top: { tl: !0, tr: !0, br: !1, bl: !1 },
   bottom: { tl: !1, tr: !1, br: !0, bl: !0 },
   none: { tl: !1, tr: !1, br: !1, bl: !1 }
 };
 function K(y) {
   const e = [], t = [];
-  let o = 0, r = 0;
+  let o = 0, s = 0;
   for (const i of y) {
-    const l = i > 0 ? o : r;
-    e.push(l), t.push(l + i), i > 0 ? o += i : r += i;
+    const h = i > 0 ? o : s;
+    e.push(h), t.push(h + i), i > 0 ? o += i : s += i;
   }
   return { base: e, end: t };
 }
-class tt extends N {
+class tt extends U {
   kind = "bar";
   /** Resolved drawing context for the in-flight render pass. Set at the top of
    *  {@link render}, read by {@link drawAnimatedBar}. */
@@ -53,10 +53,14 @@ class tt extends N {
   /** Per-frame history-reveal directives; `null` when no reveal is in flight. */
   #t = null;
   constructor(e, t) {
-    super(e), this.options = D({ ...J, ...t });
+    super(e), this.options = I({ ...J, ...t });
   }
   updateOptions(e) {
-    this.options = D({ ...this.options, ...e });
+    this.options = I({ ...this.options, ...e });
+  }
+  getValueRange(e, t, o) {
+    const s = super.getValueRange(e, t, o), i = o?.plottable?.(0) ?? !0;
+    return s === null || !i ? s : { min: Math.min(0, s.min), max: Math.max(0, s.max) };
   }
   isEntryEnabled() {
     return (this.options.entryAnimation ?? "fade-grow") !== "none";
@@ -65,10 +69,10 @@ class tt extends N {
    * Normalized x-position + eased wave progress for the intro's callbacks.
    * `null` when no intro is in flight this frame.
    */
-  #a(e) {
+  #s(e) {
     const t = this.#i;
     if (t === null) return null;
-    const o = t.to - t.from, r = o > 0 ? (e - t.from) / o : 0, i = Math.min(1, Math.max(0, r));
+    const o = t.to - t.from, s = o > 0 ? (e - t.from) / o : 0, i = Math.min(1, Math.max(0, s));
     return { position: i, progress: this.introWave.progressAt(i) };
   }
   /**
@@ -77,10 +81,10 @@ class tt extends N {
    * the deepest prepended point). `null` for bars outside the prepended
    * span or when no reveal is in flight this frame.
    */
-  #s(e) {
+  #a(e) {
     const t = this.historyRange;
     if (this.#t === null || t === null || e >= t.to) return null;
-    const o = t.to - t.from, r = o > 0 ? (t.to - e) / o : 0, i = Math.min(1, Math.max(0, r));
+    const o = t.to - t.from, s = o > 0 ? (t.to - e) / o : 0, i = Math.min(1, Math.max(0, s));
     return { position: i, progress: this.historyWave.progressAt(i) };
   }
   /**
@@ -95,19 +99,44 @@ class tt extends N {
     if (this.isProjectedTime(e.time)) return e.value;
     const t = this.#t?.value;
     if (t !== void 0) {
-      const i = this.#s(e.time);
+      const i = this.#a(e.time);
       if (i !== null) return t({ ...e, ...i });
     }
     const o = this.#e?.value;
     if (o === void 0) return e.value;
-    const r = this.#a(e.time);
-    return r === null ? e.value : o({ ...e, ...r });
+    const s = this.#s(e.time);
+    return s === null ? e.value : o({ ...e, ...s });
   }
   applyTheme(e, t) {
-    const o = this.stores.length === 1, r = e.seriesColors[0] ?? "#26a69a", i = o ? [e.bar?.color ?? r] : e.seriesColors.slice(0, this.stores.length);
+    const o = this.stores.length === 1, s = e.seriesColors[0] ?? "#26a69a", i = o ? [e.bar?.color ?? s] : e.seriesColors.slice(0, this.stores.length);
     this.updateOptions({ colors: i });
   }
   /** True when `time` is at/after the configured `projectedFrom` forecast cut. */
+  /**
+   * The bar stack's reading of a percent column (see `renderStacked`): each
+   * layer's sample at `time` as drawn — smoothed, faded, growing in, intro applied — with
+   * positives scaled to 100% and negatives to -100% on their own; `null` when
+   * the column draws nothing.
+   */
+  percentShares(e) {
+    const t = this.options.entryAnimation ?? "fade-grow", o = (t === "grow" || t === "fade-grow") && !this.isProjectedTime(e), s = /* @__PURE__ */ new Map();
+    let i = 0, h = 0;
+    for (let c = 0; c < this.stores.length; c++) {
+      const m = this.getLayerAlpha(c);
+      if (m <= 0) continue;
+      const l = this.stores[c].findNearest(e, 0);
+      if (l === null || !Number.isFinite(l.value)) continue;
+      const r = o ? this.entranceProgress(c, e) : 1, u = this.liveValue(c, e, l.value) * m * r, a = this.introValue({ layerIndex: c, time: e, value: u });
+      s.set(c, a), a > 0 && (i += a), a < 0 && (h += a);
+    }
+    if (i === 0 && h === 0) return null;
+    const d = /* @__PURE__ */ new Map();
+    for (const [c, m] of s) {
+      let l = 0;
+      m > 0 && (l = m / i * 100), m < 0 && (l = m / h * -100), d.set(c, l);
+    }
+    return d;
+  }
   isProjectedTime(e) {
     const t = this.options.projectedFrom;
     return t !== void 0 && e >= t;
@@ -118,21 +147,21 @@ class tt extends N {
    * each render path.
    */
   applyBarTransform(e, t) {
-    const { baselineY: o, topY: r, barHeight: i, x: l, barWidth: m } = e, d = this.options.entryAnimation ?? "fade-grow";
-    if (t >= 1 || d === "none")
-      return { topY: r, barHeight: i, x: l, barWidth: m, alpha: 1 };
-    let u = r, h = i, s = l, g = 1;
-    if ((d === "fade" || d === "fade-grow") && (g = t), (d === "grow" || d === "fade-grow") && !e.growBaked) {
-      const n = i * t;
-      r < o ? u = o - n : u = o, h = Math.max(1, n);
+    const { baselineY: o, topY: s, barHeight: i, x: h, barWidth: d } = e, c = this.options.entryAnimation ?? "fade-grow";
+    if (t >= 1 || c === "none")
+      return { topY: s, barHeight: i, x: h, barWidth: d, alpha: 1 };
+    let m = s, l = i, r = h, u = 1;
+    if ((c === "fade" || c === "fade-grow") && (u = t), (c === "grow" || c === "fade-grow") && !e.growBaked) {
+      const a = i * t;
+      s < o ? m = o - a : m = o, l = Math.max(1, a);
     }
-    return d === "slide" && (s = l + (1 - t) * m, g = t), { topY: u, barHeight: h, x: s, barWidth: m, alpha: g };
+    return c === "slide" && (r = h + (1 - t) * d, u = t), { topY: m, barHeight: l, x: r, barWidth: d, alpha: u };
   }
   render(e) {
     this.tickAnimations(performance.now());
-    const { scope: t, timeScale: o, yScale: r } = e;
+    const { scope: t, timeScale: o, yScale: s } = e;
     this.#o = {
-      painter: $(this.options.barPainter),
+      painter: G(this.options.barPainter),
       env: {
         ctx: t.context,
         theme: e.theme,
@@ -142,46 +171,46 @@ class tt extends N {
       radius: (this.options.cornerRadius ?? F) * t.horizontalPixelRatio
     };
     const i = {
-      baseline: r.baselineValue(),
-      lerpValue: (h, s, g) => r.lerpValue(h, s, g)
+      baseline: s.baselineValue(),
+      lerpValue: (l, r, u) => s.lerpValue(l, r, u)
     };
     if (this.#e = null, this.#i = null, this.introWave.active) {
-      const h = this.options.introAnimation ?? Q, s = o.getRange();
-      this.#i = s, this.#e = h({
+      const l = this.options.introAnimation ?? Q, r = o.getRange();
+      this.#i = r, this.#e = l({
         progress: this.introWave.linear(),
         // Plot-area extent, not the canvas bitmap — the canvas also carries
         // the axis strips, so a width-based front (wipeIntro) would overshoot
         // the data area.
         width: o.getMediaWidth() * t.horizontalPixelRatio,
-        height: r.getMediaHeight() * t.verticalPixelRatio,
-        range: s,
-        timeToX: (g) => o.timeToBitmapX(g),
+        height: s.getMediaHeight() * t.verticalPixelRatio,
+        range: r,
+        timeToX: (u) => o.timeToBitmapX(u),
         ...i
       });
     }
     this.#t = null;
-    const l = this.historyRange;
-    if (this.historyWave.active && l !== null) {
-      const h = this.options.historyReveal ?? Z;
-      h !== "none" && (this.#t = h({
+    const h = this.historyRange;
+    if (this.historyWave.active && h !== null) {
+      const l = this.options.historyReveal ?? Z;
+      l !== "none" && (this.#t = l({
         progress: this.historyWave.linear(),
-        width: Math.abs(o.timeToBitmapX(l.to) - o.timeToBitmapX(l.from)),
-        height: r.getMediaHeight() * t.verticalPixelRatio,
-        range: l,
-        timeToX: (s) => o.timeToBitmapX(s),
+        width: Math.abs(o.timeToBitmapX(h.to) - o.timeToBitmapX(h.from)),
+        height: s.getMediaHeight() * t.verticalPixelRatio,
+        range: h,
+        timeToX: (r) => o.timeToBitmapX(r),
         ...i
       }));
     }
-    const m = this.#e?.clip;
-    if (m !== void 0) {
-      const h = m.fromX ?? 0, s = m.toX ?? t.bitmapSize.width;
-      t.context.save(), t.context.beginPath(), t.context.rect(h, 0, Math.max(0, s - h), t.bitmapSize.height), t.context.clip();
+    const d = this.#e?.clip;
+    if (d !== void 0) {
+      const l = d.fromX ?? 0, r = d.toX ?? t.bitmapSize.width;
+      t.context.save(), t.context.beginPath(), t.context.rect(l, 0, Math.max(0, r - l), t.bitmapSize.height), t.context.clip();
     }
-    const d = this.#t?.clip;
-    let u = !1;
-    if (d !== void 0 && l !== null) {
-      const h = o.timeToBitmapX(l.to), s = Math.abs(h - o.timeToBitmapX(l.from)), g = o.barWidthBitmap(e.dataInterval), n = d.fromX ?? 0, A = d.toX ?? s;
-      t.context.save(), t.context.beginPath(), t.context.rect(h - A - g, 0, Math.max(0, A - n + g), t.bitmapSize.height), t.context.rect(h, 0, Math.max(0, t.bitmapSize.width - h), t.bitmapSize.height), t.context.clip(), u = !0;
+    const c = this.#t?.clip;
+    let m = !1;
+    if (c !== void 0 && h !== null) {
+      const l = o.timeToBitmapX(h.to), r = Math.abs(l - o.timeToBitmapX(h.from)), u = o.barWidthBitmap(e.dataInterval), a = c.fromX ?? 0, A = c.toX ?? r;
+      t.context.save(), t.context.beginPath(), t.context.rect(l - A - u, 0, Math.max(0, A - a + u), t.bitmapSize.height), t.context.rect(l, 0, Math.max(0, t.bitmapSize.width - l), t.bitmapSize.height), t.context.clip(), m = !0;
     }
     switch (this.options.stacking) {
       case "normal":
@@ -194,7 +223,7 @@ class tt extends N {
         this.renderOff(e);
         break;
     }
-    u && t.context.restore(), m !== void 0 && t.context.restore();
+    m && t.context.restore(), d !== void 0 && t.context.restore();
   }
   /**
    * Bar body width in bitmap px. On a category axis a bar fills its band;
@@ -203,53 +232,53 @@ class tt extends N {
    * zooms must keep wide bars. See the matching comment in candlestick.ts.
    */
   #r(e) {
-    const { scope: t, timeScale: o, dataInterval: r } = e;
+    const { scope: t, timeScale: o, dataInterval: s } = e;
     if (o.getType() === "category") return o.bandWidthBitmap();
     const i = o.getRange();
-    let l = 0;
-    for (const h of this.stores) {
-      if (!h.isVisible()) continue;
-      const s = h.getVisibleData(i.from, i.to).length;
-      if (s > l && (l = s), l > 2) break;
+    let h = 0;
+    for (const l of this.stores) {
+      if (!l.isVisible()) continue;
+      const r = l.getVisibleData(i.from, i.to).length;
+      if (r > h && (h = r), h > 2) break;
     }
-    const m = o.barWidthBitmap(r), d = Math.round(30 * t.horizontalPixelRatio), u = l <= 2 ? Math.min(d, m) : m;
-    return Math.max(1, Math.round(u * this.options.barWidthRatio) - 2);
+    const d = o.barWidthBitmap(s), c = Math.round(30 * t.horizontalPixelRatio), m = h <= 2 ? Math.min(c, d) : d;
+    return Math.max(1, Math.round(m * this.options.barWidthRatio));
   }
   /** Stacking off — each layer drawn independently from zero, overlapping */
   renderOff(e) {
-    const { scope: t, timeScale: o, yScale: r } = e, { context: i } = t, l = o.getRange(), m = this.#r(e), d = Math.floor(m / 2), u = this.options.anchor === "right" ? m : d, h = r.getRange().min < 0, s = h ? r.valueToBitmapY(0) : t.bitmapSize.height;
+    const { scope: t, timeScale: o, yScale: s } = e, { context: i } = t, h = o.getRange(), d = this.#r(e), c = Math.floor(d / 2), m = this.options.anchor === "right" ? d : c, l = s.getRange().min < 0, r = l ? s.valueToBitmapY(0) : t.bitmapSize.height;
     if (this.stores.length === 1) {
       if (!this.stores[0].isVisible()) return;
-      const g = this.stores[0].getVisibleData(l.from, l.to);
-      for (const n of g) {
-        if (!r.isPlottable(n.value)) continue;
-        const A = this.effectiveValue(e, 0, n.time, n.value), p = this.introValue({ layerIndex: 0, time: n.time, value: A }), b = this.entranceProgress(0, n.time), v = this.isProjectedTime(n.time), B = o.timeToBitmapX(n.time), M = this.resolveLayerColor(0, A);
-        if (p >= 0) {
-          const a = r.valueToBitmapY(p), f = Math.max(1, s - a);
+      const u = this.stores[0].getVisibleData(h.from, h.to);
+      for (const a of u) {
+        if (!s.isPlottable(a.value)) continue;
+        const A = this.effectiveValue(e, 0, a.time, a.value), g = this.introValue({ layerIndex: 0, time: a.time, value: A }), b = this.entranceProgress(0, a.time), v = this.isProjectedTime(a.time), w = o.timeToBitmapX(a.time), M = this.resolveLayerColor(0, A);
+        if (g >= 0) {
+          const n = s.valueToBitmapY(g), f = Math.max(1, r - n);
           this.drawAnimatedBar({
             context: i,
-            time: n.time,
+            time: a.time,
             progress: b,
-            baselineY: s,
-            topY: a,
+            baselineY: r,
+            topY: n,
             barHeight: f,
-            x: B - u,
-            barWidth: m,
+            x: w - m,
+            barWidth: d,
             color: M,
             roundEdge: "top",
             isProjected: v
           });
         } else {
-          const a = r.valueToBitmapY(p), f = Math.max(1, a - s);
+          const n = s.valueToBitmapY(g), f = Math.max(1, n - r);
           this.drawAnimatedBar({
             context: i,
-            time: n.time,
+            time: a.time,
             progress: b,
-            baselineY: s,
-            topY: s,
+            baselineY: r,
+            topY: r,
             barHeight: f,
-            x: B - u,
-            barWidth: m,
+            x: w - m,
+            barWidth: d,
             color: M,
             roundEdge: "bottom",
             isProjected: v
@@ -257,19 +286,19 @@ class tt extends N {
         }
       }
     } else {
-      const g = this.stores.map(
-        (p, b) => this.getLayerAlpha(b) > 0 ? p.getVisibleData(l.from, l.to) : []
-      ), n = /* @__PURE__ */ new Map(), A = r.baselineValue();
-      for (let p = 0; p < g.length; p++) {
-        const b = this.getLayerAlpha(p);
-        for (const v of g[p]) {
-          if (!r.isPlottable(v.value)) continue;
-          let B = n.get(v.time);
-          B || (B = [], n.set(v.time, B));
-          const M = this.effectiveValue(e, p, v.time, v.value), a = b === 1 ? M : r.lerpValue(A, M, b);
-          B.push({
-            layer: p,
-            value: this.introValue({ layerIndex: p, time: v.time, value: a }),
+      const u = this.stores.map(
+        (g, b) => this.getLayerAlpha(b) > 0 ? g.getVisibleData(h.from, h.to) : []
+      ), a = /* @__PURE__ */ new Map(), A = s.baselineValue();
+      for (let g = 0; g < u.length; g++) {
+        const b = this.getLayerAlpha(g);
+        for (const v of u[g]) {
+          if (!s.isPlottable(v.value)) continue;
+          let w = a.get(v.time);
+          w || (w = [], a.set(v.time, w));
+          const M = this.effectiveValue(e, g, v.time, v.value), n = b === 1 ? M : s.lerpValue(A, M, b);
+          w.push({
+            layer: g,
+            value: this.introValue({ layerIndex: g, time: v.time, value: n }),
             // Color resolves from the settled data value — same contract as
             // the single-layer path — so a threshold value-fn doesn't flicker
             // hues while the intro sweeps the drawn value from 0 to final.
@@ -277,135 +306,135 @@ class tt extends N {
           });
         }
       }
-      for (const [p, b] of n) {
+      for (const [g, b] of a) {
         b.sort(
-          (M, a) => Math.abs(a.value) - Math.abs(M.value)
+          (M, n) => Math.abs(n.value) - Math.abs(M.value)
         );
-        const v = o.timeToBitmapX(p), B = this.isProjectedTime(p);
+        const v = o.timeToBitmapX(g), w = this.isProjectedTime(g);
         for (let M = 0; M < b.length; M++) {
-          const { layer: a, value: f, colorValue: c } = b[M], Y = this.resolveLayerColor(a, c), x = this.entranceProgress(a, p);
+          const { layer: n, value: f, colorValue: p } = b[M], B = this.resolveLayerColor(n, p), x = this.entranceProgress(n, g);
           if (f >= 0) {
-            const R = r.valueToBitmapY(f), T = Math.max(1, s - R);
+            const R = s.valueToBitmapY(f), T = Math.max(1, r - R);
             this.drawAnimatedBar({
               context: i,
-              time: p,
+              time: g,
               progress: x,
-              baselineY: s,
+              baselineY: r,
               topY: R,
               barHeight: T,
-              x: v - u,
-              barWidth: m,
-              color: Y,
+              x: v - m,
+              barWidth: d,
+              color: B,
               roundEdge: "top",
-              isProjected: B
+              isProjected: w
             });
           } else {
-            const R = r.valueToBitmapY(f), T = Math.max(1, R - s);
+            const R = s.valueToBitmapY(f), T = Math.max(1, R - r);
             this.drawAnimatedBar({
               context: i,
-              time: p,
+              time: g,
               progress: x,
-              baselineY: s,
-              topY: s,
+              baselineY: r,
+              topY: r,
               barHeight: T,
-              x: v - u,
-              barWidth: m,
-              color: Y,
+              x: v - m,
+              barWidth: d,
+              color: B,
               roundEdge: "bottom",
-              isProjected: B
+              isProjected: w
             });
           }
         }
       }
     }
-    if (h) {
+    if (l) {
       i.strokeStyle = e.theme.grid.color, i.lineWidth = 1;
-      const g = Math.round(s) + 0.5;
-      i.beginPath(), i.moveTo(0, g), i.lineTo(t.bitmapSize.width, g), i.stroke();
+      const u = Math.round(r) + 0.5;
+      i.beginPath(), i.moveTo(0, u), i.lineTo(t.bitmapSize.width, u), i.stroke();
     }
   }
   /** Stacked (normal or percent) rendering */
   renderStacked(e, t) {
-    const { scope: o, timeScale: r, yScale: i } = e, { context: l } = o, m = r.getRange(), d = this.#r(e), u = Math.floor(d / 2), h = this.options.anchor === "right" ? d : u, s = this.stores.map(
-      (a, f) => this.getLayerAlpha(f) > 0 ? a.getVisibleData(m.from, m.to) : []
+    const { scope: o, timeScale: s, yScale: i } = e, { context: h } = o, d = s.getRange(), c = this.#r(e), m = Math.floor(c / 2), l = this.options.anchor === "right" ? c : m, r = this.stores.map(
+      (n, f) => this.getLayerAlpha(f) > 0 ? n.getVisibleData(d.from, d.to) : []
     );
-    if (s.every((a) => a.length === 0)) return;
-    const g = this.options.entryAnimation ?? "fade-grow", n = g === "grow" || g === "fade-grow", A = i.getTransform() !== null && !t, p = /* @__PURE__ */ new Map(), b = /* @__PURE__ */ new Map();
-    for (let a = 0; a < s.length; a++) {
-      const f = this.getLayerAlpha(a);
-      for (const c of s[a]) {
-        let Y = b.get(c.time);
-        Y || (Y = new Array(s.length).fill(0), b.set(c.time, Y));
-        const x = i.isPlottable(c.value) ? c.value : 0, R = this.effectiveValue(e, a, c.time, x);
+    if (r.every((n) => n.length === 0)) return;
+    const u = this.options.entryAnimation ?? "fade-grow", a = u === "grow" || u === "fade-grow", A = i.getTransform() !== null && !t, g = /* @__PURE__ */ new Map(), b = /* @__PURE__ */ new Map();
+    for (let n = 0; n < r.length; n++) {
+      const f = this.getLayerAlpha(n);
+      for (const p of r[n]) {
+        let B = b.get(p.time);
+        B || (B = new Array(r.length).fill(0), b.set(p.time, B));
+        const x = i.isPlottable(p.value) ? p.value : 0, R = this.effectiveValue(e, n, p.time, x);
         let T = R * f, V = f;
-        if (n && !this.isProjectedTime(c.time)) {
-          const P = this.entranceProgress(a, c.time);
+        if (a && !this.isProjectedTime(p.time)) {
+          const P = this.entranceProgress(n, p.time);
           T *= P, V *= P;
         }
         if (A) {
-          Y[a] = T;
-          let P = p.get(c.time);
-          P || (P = { settled: new Array(s.length).fill(0), weights: new Array(s.length).fill(0) }, p.set(c.time, P)), P.settled[a] = R, P.weights[a] = V;
+          B[n] = T;
+          let P = g.get(p.time);
+          P || (P = { settled: new Array(r.length).fill(0), weights: new Array(r.length).fill(0) }, g.set(p.time, P)), P.settled[n] = R, P.weights[n] = V;
           continue;
         }
-        Y[a] = this.introValue({ layerIndex: a, time: c.time, value: T });
+        B[n] = this.introValue({ layerIndex: n, time: p.time, value: T });
       }
     }
     const v = /* @__PURE__ */ new Map();
     if (!t)
-      for (const [a, f] of b) {
-        const c = p.get(a);
-        v.set(a, c === void 0 ? K(f) : this.scaleEdges({ time: a, share: c, yScale: i }));
+      for (const [n, f] of b) {
+        const p = g.get(n);
+        v.set(n, p === void 0 ? K(f) : this.scaleEdges({ time: n, share: p, yScale: i }));
       }
-    const B = /* @__PURE__ */ new Map(), M = /* @__PURE__ */ new Map();
-    for (const [a, f] of b) {
-      let c = -1, Y = -1;
+    const w = /* @__PURE__ */ new Map(), M = /* @__PURE__ */ new Map();
+    for (const [n, f] of b) {
+      let p = -1, B = -1;
       for (let x = 0; x < f.length; x++)
-        f[x] > 0 && (c = x), f[x] < 0 && (Y = x);
-      c >= 0 && B.set(a, c), Y >= 0 && M.set(a, Y);
+        f[x] > 0 && (p = x), f[x] < 0 && (B = x);
+      p >= 0 && w.set(n, p), B >= 0 && M.set(n, B);
     }
-    for (let a = 0; a < s.length; a++) {
-      const f = this.resolveLayerColor(a, this.lastFinitePoint(a)?.value ?? 0);
-      for (const [c, Y] of b) {
-        const x = Y[a];
+    for (let n = 0; n < r.length; n++) {
+      const f = this.resolveLayerColor(n, this.lastFinitePoint(n)?.value ?? 0);
+      for (const [p, B] of b) {
+        const x = B[n];
         if (x === 0) continue;
-        const R = r.timeToBitmapX(c), T = this.entranceProgress(a, c), V = this.isProjectedTime(c), P = x > 0 ? B.get(c) === a ? "top" : "none" : M.get(c) === a ? "bottom" : "none";
+        const R = s.timeToBitmapX(p), T = this.entranceProgress(n, p), V = this.isProjectedTime(p), P = x > 0 ? w.get(p) === n ? "top" : "none" : M.get(p) === n ? "bottom" : "none";
         if (t) {
-          let E = 0, k = 0;
-          for (let w = 0; w < a; w++) {
-            const S = Y[w];
-            S > 0 ? E += S : k += S;
+          let H = 0, E = 0;
+          for (let Y = 0; Y < n; Y++) {
+            const S = B[Y];
+            S > 0 ? H += S : E += S;
           }
-          let H = 0, W = 0;
-          for (const w of Y)
-            w > 0 ? H += w : W += w;
-          if (x > 0 && H > 0) {
-            const w = E / H * 100, S = (E + x) / H * 100, j = i.valueToBitmapY(S), X = i.valueToBitmapY(w), L = Math.max(1, X - j);
+          let k = 0, W = 0;
+          for (const Y of B)
+            Y > 0 ? k += Y : W += Y;
+          if (x > 0 && k > 0) {
+            const Y = H / k * 100, S = (H + x) / k * 100, j = i.valueToBitmapY(S), X = i.valueToBitmapY(Y), L = Math.max(1, X - j);
             this.drawAnimatedBar({
-              context: l,
-              time: c,
+              context: h,
+              time: p,
               progress: T,
               baselineY: X,
               topY: j,
               barHeight: L,
-              x: R - h,
-              barWidth: d,
+              x: R - l,
+              barWidth: c,
               color: f,
               roundEdge: P,
               isProjected: V,
               growBaked: !0
             });
           } else if (x < 0 && W < 0) {
-            const w = k / W * -100, S = (k + x) / W * -100, j = i.valueToBitmapY(w), X = i.valueToBitmapY(S), L = Math.max(1, X - j);
+            const Y = E / W * -100, S = (E + x) / W * -100, j = i.valueToBitmapY(Y), X = i.valueToBitmapY(S), L = Math.max(1, X - j);
             this.drawAnimatedBar({
-              context: l,
-              time: c,
+              context: h,
+              time: p,
               progress: T,
               baselineY: j,
               topY: j,
               barHeight: L,
-              x: R - h,
-              barWidth: d,
+              x: R - l,
+              barWidth: c,
               color: f,
               roundEdge: P,
               isProjected: V,
@@ -413,36 +442,36 @@ class tt extends N {
             });
           }
         } else {
-          const E = v.get(c);
-          if (E === void 0) continue;
-          const k = E.base[a], H = E.end[a];
+          const H = v.get(p);
+          if (H === void 0) continue;
+          const E = H.base[n], k = H.end[n];
           if (x > 0) {
-            const W = i.valueToBitmapY(H), w = i.valueToBitmapY(k), S = Math.max(1, w - W);
+            const W = i.valueToBitmapY(k), Y = i.valueToBitmapY(E), S = Math.max(1, Y - W);
             this.drawAnimatedBar({
-              context: l,
-              time: c,
+              context: h,
+              time: p,
               progress: T,
-              baselineY: w,
+              baselineY: Y,
               topY: W,
               barHeight: S,
-              x: R - h,
-              barWidth: d,
+              x: R - l,
+              barWidth: c,
               color: f,
               roundEdge: P,
               isProjected: V,
               growBaked: !0
             });
           } else {
-            const W = i.valueToBitmapY(k), w = i.valueToBitmapY(H), S = Math.max(1, w - W);
+            const W = i.valueToBitmapY(E), Y = i.valueToBitmapY(k), S = Math.max(1, Y - W);
             this.drawAnimatedBar({
-              context: l,
-              time: c,
+              context: h,
+              time: p,
               progress: T,
               baselineY: W,
               topY: W,
               barHeight: S,
-              x: R - h,
-              barWidth: d,
+              x: R - l,
+              barWidth: c,
               color: f,
               roundEdge: P,
               isProjected: V,
@@ -459,12 +488,12 @@ class tt extends N {
    * so the column grows from the floor as one unit at an even pixel speed.
    */
   scaleEdges(e) {
-    const { time: t, share: o, yScale: r } = e, i = { positive: new z(r), negative: new z(r) }, l = { positive: i.positive.edge, negative: i.negative.edge }, m = [], d = [];
-    for (let u = 0; u < o.settled.length; u++) {
-      const h = o.settled[u], s = h < 0 ? "negative" : "positive", g = i[s].push(h, o.weights[u]), n = this.introValue({ layerIndex: u, time: t, value: g });
-      m.push(l[s]), d.push(n), l[s] = n;
+    const { time: t, share: o, yScale: s } = e, i = { positive: new z(s), negative: new z(s) }, h = { positive: i.positive.edge, negative: i.negative.edge }, d = [], c = [];
+    for (let m = 0; m < o.settled.length; m++) {
+      const l = o.settled[m], r = l < 0 ? "negative" : "positive", u = i[r].push(l, o.weights[m]), a = this.introValue({ layerIndex: m, time: t, value: u });
+      d.push(h[r]), c.push(a), h[r] = a;
     }
-    return { base: m, end: d };
+    return { base: d, end: c };
   }
   /**
    * Paint one bar through the resolved painter, applying any entrance transform
@@ -475,41 +504,41 @@ class tt extends N {
   drawAnimatedBar(e) {
     const t = this.#o;
     if (t === null) return;
-    const { context: o, baselineY: r, topY: i, barHeight: l, x: m, barWidth: d, color: u, roundEdge: h } = e, s = e.isProjected ? 1 : e.progress, g = this.options.entryAnimation ?? "fade-grow";
-    let n = s >= 1 || g === "none" ? { x: m, topY: i, barWidth: d, barHeight: l, alpha: 1 } : this.applyBarTransform(e, s);
+    const { context: o, baselineY: s, topY: i, barHeight: h, x: d, barWidth: c, color: m, roundEdge: l } = e, r = e.isProjected ? 1 : e.progress, u = this.options.entryAnimation ?? "fade-grow";
+    let a = r >= 1 || u === "none" ? { x: d, topY: i, barWidth: c, barHeight: h, alpha: 1 } : this.applyBarTransform(e, r);
     if (!e.isProjected) {
-      const p = this.#t?.element, b = p !== void 0 ? this.#s(e.time) : null, v = b !== null ? p : this.#e?.element, B = b ?? (v !== void 0 ? this.#a(e.time) : null);
-      if (v !== void 0 && B !== null) {
+      const g = this.#t?.element, b = g !== void 0 ? this.#a(e.time) : null, v = b !== null ? g : this.#e?.element, w = b ?? (v !== void 0 ? this.#s(e.time) : null);
+      if (v !== void 0 && w !== null) {
         const M = v({
-          ...B,
+          ...w,
           time: e.time,
-          x: n.x,
-          topY: n.topY,
-          barHeight: n.barHeight,
-          baselineY: r,
-          barWidth: n.barWidth
+          x: a.x,
+          topY: a.topY,
+          barHeight: a.barHeight,
+          baselineY: s,
+          barWidth: a.barWidth
         });
-        n = {
-          ...n,
-          x: n.x + (M.offsetX ?? 0),
-          topY: n.topY + (M.offsetY ?? 0),
-          alpha: n.alpha * (M.alpha ?? 1)
+        a = {
+          ...a,
+          x: a.x + (M.offsetX ?? 0),
+          topY: a.topY + (M.offsetY ?? 0),
+          alpha: a.alpha * (M.alpha ?? 1)
         };
       }
     }
     const A = {
-      geom: { x: n.x, y: n.topY, width: n.barWidth, height: n.barHeight, baselineY: r },
-      color: u,
-      corners: q[h],
+      geom: { x: a.x, y: a.topY, width: a.barWidth, height: a.barHeight, baselineY: s },
+      color: m,
+      corners: q[l],
       // Clamp to this bar's geometry so `radius` honors its pre-clamped contract
       // for custom painters; `fillRoundedRect` re-clamps to the same bound, so
       // the built-in output is unchanged.
-      radius: Math.min(t.radius, n.barWidth / 2, n.barHeight / 2),
-      progress: s,
+      radius: Math.min(t.radius, a.barWidth / 2, a.barHeight / 2),
+      progress: r,
       isProjected: e.isProjected
     };
-    if (n.alpha < 1) {
-      o.save(), o.globalAlpha = n.alpha, t.painter(t.env, A), o.restore();
+    if (a.alpha < 1) {
+      o.save(), o.globalAlpha = a.alpha, t.painter(t.env, A), o.restore();
       return;
     }
     t.painter(t.env, A);