@wick-charts/vue 0.6.2 → 0.6.4

package/dist/core/dist/series/candlestick.js

@@ -1,21 +1,21 @@
-import { Animator as st } from "../animation/animator.js";
-import { DEFAULT_HISTORY_REVEAL as tt, DEFAULT_CANDLESTICK_INTRO as it, DEFAULT_CANDLESTICK_SMOOTH as et, DEFAULT_CANDLESTICK_ENTRY as ot } from "../animation/config.js";
-import { easeOutCubic as nt } from "../animation/easing.js";
+import { Animator as nt } from "../animation/animator.js";
+import { DEFAULT_HISTORY_REVEAL as it, DEFAULT_CANDLESTICK_INTRO as et, DEFAULT_CANDLESTICK_SMOOTH as ot, DEFAULT_CANDLESTICK_ENTRY as st } from "../animation/config.js";
+import { easeOutCubic as at } from "../animation/easing.js";
 import { IntroWave as U } from "../animation/intro-wave.js";
-import { ScalarSpring as V } from "../animation/scalar-spring.js";
-import { decimateOHLCData as at } from "../data/decimation.js";
-import { TimeSeriesStore as rt } from "../data/store.js";
+import { ScalarSpring as $ } from "../animation/scalar-spring.js";
+import { decimateOHLCData as rt } from "../data/decimation.js";
+import { TimeSeriesStore as lt } from "../data/store.js";
 import { resolveCandlestickBodyColor as I } from "../theme/resolve.js";
 import { hexToRgba as K, mixColors as G } from "../utils/color.js";
-import { clamp as _, lerp as z } from "../utils/math.js";
+import { clamp as F, lerp as z } from "../utils/math.js";
 import { isPoisonedNumber as N, reportPoisonedData as ht } from "../utils/poisoned-data-reporter.js";
 import { normalizeOHLCArray as J, normalizeTime as Q } from "../utils/time.js";
-import { candleUnfoldIntro as lt } from "./candlestick-intro.js";
+import { candleUnfoldIntro as ct } from "./candlestick-intro.js";
 import { fillRoundedRect as Z } from "./painters/canvas-path.js";
 import { resolveCandlePainter as mt } from "./painters/resolve.js";
-import { fadeIntro as ct } from "./wave-intro.js";
-const pt = 0.15, ut = 5e-3;
-class dt {
+import { fadeIntro as pt } from "./wave-intro.js";
+const ut = 0.15, dt = 5e-3;
+class ft {
   #t;
   #i;
   #s;
@@ -25,16 +25,16 @@ class dt {
   // Sticky once any seen candle carries volume — mirrors the old lerp, which
   // only emitted `volume` when a side had it, so a volume-less candle stays
   // volume-less and the histogram keeps skipping it.
-  #h;
+  #l;
   constructor(t) {
-    this.#t = new V(t.open), this.#i = new V(t.high), this.#s = new V(t.low), this.#r = new V(t.close), this.#e = new V(t.volume ?? 0), this.#n = t.time, this.#h = t.volume !== void 0;
+    this.#t = new $(t.open), this.#i = new $(t.high), this.#s = new $(t.low), this.#r = new $(t.close), this.#e = new $(t.volume ?? 0), this.#n = t.time, this.#l = t.volume !== void 0;
   }
   retarget(t, i = {}) {
-    this.#n = t.time, t.volume !== void 0 && (this.#h = !0), this.#t.retarget(t.open, i), this.#i.retarget(t.high, i), this.#s.retarget(t.low, i), this.#r.retarget(t.close, i), this.#e.retarget(t.volume ?? 0, i);
+    this.#n = t.time, t.volume !== void 0 && (this.#l = !0), this.#t.retarget(t.open, i), this.#i.retarget(t.high, i), this.#s.retarget(t.low, i), this.#r.retarget(t.close, i), this.#e.retarget(t.volume ?? 0, i);
   }
   tick(t) {
-    const i = this.#t.tick(t), e = this.#i.tick(t), o = this.#s.tick(t), a = this.#r.tick(t), s = this.#e.tick(t);
-    return i || e || o || a || s;
+    const i = this.#t.tick(t), e = this.#i.tick(t), o = this.#s.tick(t), h = this.#r.tick(t), n = this.#e.tick(t);
+    return i || e || o || h || n;
   }
   get current() {
     const t = {
@@ -44,26 +44,29 @@ class dt {
       low: this.#s.current,
       close: this.#r.current
     };
-    return this.#h && (t.volume = this.#e.current), t;
+    return this.#l && (t.volume = this.#e.current), t;
   }
 }
-const O = 2, ft = { tl: !0, tr: !0, br: !0, bl: !0 }, j = { tl: !0, tr: !0, br: !1, bl: !1 }, bt = lt(), Yt = ct(), gt = {
+const _ = 2, bt = { tl: !0, tr: !0, br: !0, bl: !0 }, j = { tl: !0, tr: !0, br: !1, bl: !1 }, Yt = ct(), gt = pt(), yt = {
   up: { body: "#26a69a", wick: "#26a69a" },
   down: { body: "#ef5350", wick: "#ef5350" },
   bodyWidthRatio: 0.6,
-  cornerRadius: O,
-  entryMs: ot,
-  smoothMs: et,
-  introMs: it,
-  historyRevealMs: tt
+  cornerRadius: _,
+  entryMs: st,
+  smoothMs: ot,
+  introMs: et,
+  historyRevealMs: it
 };
-function q(h) {
+function q(a, t) {
+  return [a.open, a.high, a.low, a.close].every((i) => Number.isFinite(i) && t(i));
+}
+function tt(a) {
   return {
-    ...h,
-    entryMs: h.entryMs === !1 ? 0 : h.entryMs ?? ot,
-    smoothMs: h.smoothMs === !1 ? 0 : h.smoothMs ?? et,
-    introMs: h.introMs === !1 ? 0 : h.introMs ?? it,
-    historyRevealMs: h.historyRevealMs === !1 ? 0 : h.historyRevealMs ?? tt
+    ...a,
+    entryMs: a.entryMs === !1 ? 0 : a.entryMs ?? st,
+    smoothMs: a.smoothMs === !1 ? 0 : a.smoothMs ?? ot,
+    introMs: a.introMs === !1 ? 0 : a.introMs ?? et,
+    historyRevealMs: a.historyRevealMs === !1 ? 0 : a.historyRevealMs ?? it
   };
 }
 class xt {
@@ -89,7 +92,7 @@ class xt {
    *  clamps every bar to full band height for ~30 frames. */
   #r = !1;
   /** Series-level alpha for visibility cross-fade. Chart calls {@link setAlpha} on hide. */
-  #e = new st({
+  #e = new nt({
     initial: 1,
     duration: 0,
     lerp: (t, i, e) => t + (i - t) * e
@@ -102,7 +105,7 @@ class xt {
   #n = null;
   /** Visible range captured alongside {@link #introDirectives} — positions
    *  the per-element wave stagger. */
-  #h = null;
+  #l = null;
   /** History-prepend reveal clock — armed by {@link prependPoints} so the
    *  new candles wave in from the data boundary instead of popping. */
   #o = new U();
@@ -111,25 +114,25 @@ class xt {
    *  boundary and `1` at the deepest point. */
   #a = null;
   /** Per-frame history-reveal directives; `null` when no reveal is in flight. */
-  #l = null;
+  #h = null;
   /** Loading-indicator placeholder shapes handed over by the chart right
    *  before a prepend (media px relative to `anchorTime`, the data boundary
    *  they were measured against) — mapped into bitmap space each frame and
    *  exposed to the reveal fn as {@link CandleIntroFrame.placeholders}.
    *  Cleared once the reveal settles. */
-  #m = null;
+  #c = null;
   /** Body gradients keyed by `top|bottom|height` — built once at y=0..h and
    *  positioned per candle via `ctx.translate`, instead of a fresh
    *  `createLinearGradient` for every body on every frame. */
-  #c = /* @__PURE__ */ new Map();
+  #m = /* @__PURE__ */ new Map();
   constructor(t, i) {
-    this.store = t, this.options = q({ ...gt, ...i }), this.displayedLast = t.last() ?? null;
+    this.store = t, this.options = tt({ ...yt, ...i }), this.displayedLast = t.last() ?? null;
   }
   isEntryEnabled() {
     return (this.options.entryAnimation ?? "unfold") !== "none";
   }
   updateOptions(t) {
-    this.options = q({ ...this.options, ...t });
+    this.options = tt({ ...this.options, ...t });
   }
   getColor() {
     return I(this.options.up.body);
@@ -139,13 +142,13 @@ class xt {
     const i = this.store.length > 0;
     this.store.setData(J(t ?? [])), !i && this.store.length > 0 && this.introWave.arm(this.options.introMs);
     const e = this.store.last();
-    this.displayedLast = e ?? null, this.#t = null, this.entries.clear(), this.#i = null, this.#o.finish(), this.#a = null, this.#m = null;
+    this.displayedLast = e ?? null, this.#t = null, this.entries.clear(), this.#i = null, this.#o.finish(), this.#a = null, this.#c = null;
   }
   appendPoint(t) {
     const i = t, e = Q(i.time), o = { ...i, time: e };
     this.store.append(o), this.displayedLast = o, this.#t = null;
-    const a = this.options.entryMs;
-    this.isEntryEnabled() && a > 0 && this.entries.set(e, { startTime: performance.now() });
+    const h = this.options.entryMs;
+    this.isEntryEnabled() && h > 0 && this.entries.set(e, { startTime: performance.now() });
   }
   prependPoints(t) {
     if (t.length === 0) return;
@@ -169,22 +172,22 @@ class xt {
   }
   setHistoryHandoff(t) {
     const i = this.store.first()?.time;
-    i !== void 0 && (this.#m = { bars: t, anchorTime: i });
+    i !== void 0 && (this.#c = { bars: t, anchorTime: i });
   }
   updateLastPoint(t) {
     const i = t, e = Q(i.time), o = { ...i, time: e };
     this.store.updateLast(o);
-    const a = this.options.smoothMs;
-    if (a <= 0) {
+    const h = this.options.smoothMs;
+    if (h <= 0) {
       this.displayedLast = o, this.#t = null;
       return;
     }
-    let s = this.#t;
-    if (s === null) {
-      const u = this.displayedLast ?? o;
-      s = new dt(u), this.#t = s;
+    let n = this.#t;
+    if (n === null) {
+      const l = this.displayedLast ?? o;
+      n = new ft(l), this.#t = n;
     }
-    s.retarget(o, { settleMs: a });
+    n.retarget(o, { settleMs: h });
   }
   keepLast(t) {
     if (t < 0) return;
@@ -220,7 +223,7 @@ class xt {
    * fully-settled entrance entries. Called from `render()` once per frame.
    */
   tickAnimations(t) {
-    this.introWave.tick(t), this.#o.tick(t), this.#o.active || (this.#m = null), this.#e.tick(t);
+    this.introWave.tick(t), this.#o.tick(t), this.#o.active || (this.#c = null), this.#e.tick(t);
     const i = this.#t;
     if (i !== null) {
       const o = i.tick(t);
@@ -231,8 +234,8 @@ class xt {
       this.entries.clear();
       return;
     }
-    for (const [o, a] of this.entries)
-      t - a.startTime >= e && this.entries.delete(o);
+    for (const [o, h] of this.entries)
+      t - h.startTime >= e && this.entries.delete(o);
   }
   /** True while OHLC chase, any per-candle entrance, the initial reveal,
    *  alpha fade, or the volume scale is unsettled. */
@@ -279,134 +282,134 @@ class xt {
   getVisibleDataPoints(t, i) {
     return this.store.getVisibleData(t, i);
   }
-  getValueRange(t, i) {
-    const e = this.store.getVisibleData(t, i);
-    let o = 1 / 0, a = -1 / 0;
-    for (const s of e)
-      Number.isFinite(s.low) && s.low < o && (o = s.low), Number.isFinite(s.high) && s.high > a && (a = s.high);
-    return o === 1 / 0 || a === -1 / 0 ? null : { min: o, max: a };
+  getValueRange(t, i, e) {
+    const o = this.store.getVisibleData(t, i), h = e?.plottable;
+    let n = 1 / 0, l = -1 / 0;
+    for (const p of o)
+      h && !q(p, h) || (Number.isFinite(p.low) && p.low < n && (n = p.low), Number.isFinite(p.high) && p.high > l && (l = p.high));
+    return n === 1 / 0 || l === -1 / 0 ? null : { min: n, max: l };
   }
   render(t) {
     this.tickAnimations(performance.now());
-    const { scope: i, timeScale: e, yScale: o, dataInterval: a } = t, { context: s, horizontalPixelRatio: u } = i, y = e.getRange();
-    let m = this.store.getVisibleData(y.from, y.to);
-    const b = i.mediaSize.width, w = m.length > b * 2;
-    if (w && (m = at(m, Math.round(b * 1.5))), m.length === 0) return;
+    const { scope: i, timeScale: e, yScale: o, dataInterval: h } = t, { context: n, horizontalPixelRatio: l } = i, p = e.getRange();
+    let m = this.store.getVisibleData(p.from, p.to);
+    const Y = i.mediaSize.width, M = m.length > Y * 2;
+    if (M && (m = rt(m, Math.round(Y * 1.5))), o.getTransform() !== null && (m = m.filter((r) => q(r, (c) => o.isPlottable(c)))), m.length === 0) return;
     const S = this.displayedLast;
-    if (!w && S !== null) {
+    if (!M && S !== null) {
       const r = m.length - 1;
       m[r].time === S.time && (m = [...m.slice(0, r), S]);
     }
-    if (this.#n = null, this.#h = null, this.introWave.active) {
-      const r = this.options.introAnimation ?? bt;
-      this.#h = y, this.#n = r({
+    if (this.#n = null, this.#l = null, this.introWave.active) {
+      const r = this.options.introAnimation ?? Yt;
+      this.#l = p, this.#n = r({
         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: e.getMediaWidth() * i.horizontalPixelRatio,
         height: o.getMediaHeight() * i.verticalPixelRatio,
-        range: y,
-        timeToX: (l) => e.timeToBitmapX(l)
+        range: p,
+        timeToX: (c) => e.timeToBitmapX(c)
       });
     }
-    this.#l = null;
-    const c = this.#a;
-    if (this.#o.active && c !== null) {
-      const r = this.options.historyReveal ?? Yt;
+    this.#h = null;
+    const u = this.#a;
+    if (this.#o.active && u !== null) {
+      const r = this.options.historyReveal ?? gt;
       if (r !== "none") {
-        let l;
-        const x = this.#m;
+        let c;
+        const x = this.#c;
         if (x !== null && x.bars.length > 0) {
           const P = e.timeToBitmapX(x.anchorTime);
-          l = x.bars.map((k) => ({
+          c = x.bars.map((k) => ({
             x: P - k.offsetX * i.horizontalPixelRatio,
             y: k.y * i.verticalPixelRatio,
             halfHeight: k.halfHeight * i.verticalPixelRatio,
             width: k.width * i.horizontalPixelRatio
           }));
         }
-        this.#l = r({
+        this.#h = r({
           progress: this.#o.linear(),
-          width: Math.abs(e.timeToBitmapX(c.to) - e.timeToBitmapX(c.from)),
+          width: Math.abs(e.timeToBitmapX(u.to) - e.timeToBitmapX(u.from)),
           height: o.getMediaHeight() * i.verticalPixelRatio,
-          range: c,
+          range: u,
           timeToX: (P) => e.timeToBitmapX(P),
-          placeholders: l
+          placeholders: c
         });
       }
     }
     let W = null;
     if (this.entries.size > 0) {
-      const r = this.options.entryMs, l = performance.now();
+      const r = this.options.entryMs, c = performance.now();
       for (const x of m) {
         const P = this.entries.get(x.time);
         if (P === void 0 || r <= 0) continue;
-        const k = l - P.startTime, $ = Math.min(1, Math.max(0, k / r));
-        $ >= 1 || (W === null && (W = /* @__PURE__ */ new Map()), W.set(x.time, nt($)));
+        const k = c - P.startTime, V = Math.min(1, Math.max(0, k / r));
+        V >= 1 || (W === null && (W = /* @__PURE__ */ new Map()), W.set(x.time, at(V)));
       }
     }
-    const X = e.barWidthBitmap(a), f = Math.round(30 * u), M = m.length <= 2 ? Math.min(f, X) : X, d = Math.max(1, Math.round(u));
-    let Y = Math.max(1, Math.round(M * this.options.bodyWidthRatio) - 2);
-    (Y & 1) !== (d & 1) && (Y = Y > 1 ? Y - 1 : 2);
-    const R = Math.floor(Y / 2), v = this.#n?.clip;
+    const X = e.barWidthBitmap(h), b = Math.round(30 * l), w = m.length <= 2 ? Math.min(b, X) : X, f = Math.max(1, Math.round(l));
+    let g = Math.max(1, Math.round(w * this.options.bodyWidthRatio) - 2);
+    (g & 1) !== (f & 1) && (g = g > 1 ? g - 1 : 2);
+    const R = Math.floor(g / 2), v = this.#n?.clip;
     if (v !== void 0) {
-      const r = v.fromX ?? 0, l = v.toX ?? i.bitmapSize.width;
-      s.save(), s.beginPath(), s.rect(r, 0, Math.max(0, l - r), i.bitmapSize.height), s.clip();
+      const r = v.fromX ?? 0, c = v.toX ?? i.bitmapSize.width;
+      n.save(), n.beginPath(), n.rect(r, 0, Math.max(0, c - r), i.bitmapSize.height), n.clip();
     }
-    const T = this.#l?.clip;
+    const T = this.#h?.clip;
     let A = !1;
-    if (T !== void 0 && c !== null) {
-      const r = e.timeToBitmapX(c.to), l = Math.abs(r - e.timeToBitmapX(c.from)), x = M, P = T.fromX ?? 0, k = T.toX ?? l;
-      s.save(), s.beginPath(), s.rect(r - k - x, 0, Math.max(0, k - P + x), i.bitmapSize.height), s.rect(r, 0, Math.max(0, i.bitmapSize.width - r), i.bitmapSize.height), s.clip(), A = !0;
+    if (T !== void 0 && u !== null) {
+      const r = e.timeToBitmapX(u.to), c = Math.abs(r - e.timeToBitmapX(u.from)), x = w, P = T.fromX ?? 0, k = T.toX ?? c;
+      n.save(), n.beginPath(), n.rect(r - k - x, 0, Math.max(0, k - P + x), i.bitmapSize.height), n.rect(r, 0, Math.max(0, i.bitmapSize.width - r), i.bitmapSize.height), n.clip(), A = !0;
     }
-    const n = w !== this.#r;
-    this.#r = w;
-    const p = Math.round(o.getMediaHeight() * i.verticalPixelRatio);
+    const s = M !== this.#r;
+    this.#r = M;
+    const d = Math.round(o.getMediaHeight() * i.verticalPixelRatio);
     this.drawVolume({
-      ctx: s,
+      ctx: n,
       data: m,
       timeScale: e,
-      chartHeight: p,
-      barWidth: M,
-      wickWidth: d,
+      chartHeight: d,
+      barWidth: w,
+      wickWidth: f,
       entranceByTime: W,
-      snapVolScale: n,
-      radius: (this.options.cornerRadius ?? O) * u
+      snapVolScale: s,
+      radius: (this.options.cornerRadius ?? _) * l
     });
-    const g = [], L = [], B = [];
+    const y = [], L = [], B = [];
     let C = null;
     for (let r = 0; r < m.length; r++) {
-      const l = m[r];
-      if (N(l.open) || N(l.close) || N(l.high) || N(l.low)) {
-        B.push(r), C === null && (C = l);
+      const c = m[r];
+      if (N(c.open) || N(c.close) || N(c.high) || N(c.low)) {
+        B.push(r), C === null && (C = c);
         continue;
       }
-      l.close >= l.open ? g.push(l) : L.push(l);
+      c.close >= c.open ? y.push(c) : L.push(c);
     }
     C !== null && ht(this, "candlestick", B, `time ${C.time}`);
     const E = {
       painter: mt(this.options.candlePainter),
       env: {
-        ctx: s,
+        ctx: n,
         theme: t.theme,
-        horizontalPixelRatio: u,
+        horizontalPixelRatio: l,
         verticalPixelRatio: i.verticalPixelRatio
       },
-      radius: (this.options.cornerRadius ?? O) * u
+      radius: (this.options.cornerRadius ?? _) * l
     }, D = {
-      ctx: s,
+      ctx: n,
       timeScale: e,
       yScale: o,
       halfBody: R,
-      bodyWidth: Y,
-      wickWidth: d,
+      bodyWidth: g,
+      wickWidth: f,
       entranceByTime: W,
       candlePass: E
     };
     this.drawCandles({
       ...D,
-      candles: g,
+      candles: y,
       body: this.options.up.body,
       wickColor: this.options.up.wick
     }), this.drawCandles({
@@ -414,7 +417,7 @@ class xt {
       candles: L,
       body: this.options.down.body,
       wickColor: this.options.down.wick
-    }), A && s.restore(), v !== void 0 && s.restore();
+    }), A && n.restore(), v !== void 0 && n.restore();
   }
   /**
    * Apply the intro's per-element directive to one element's settled (or
@@ -422,15 +425,15 @@ class xt {
    * is in flight this frame.
    */
   introTransform(t) {
-    const i = this.#l?.element, e = this.#a;
+    const i = this.#h?.element, e = this.#a;
     if (i !== void 0 && e !== null && t.time < e.to) {
-      const m = e.to - e.from, b = m > 0 ? _((e.to - t.time) / m, 0, 1) : 0, w = i({ ...t, position: b, progress: this.#o.progressAt(b) });
-      return this.#p(w, t);
+      const m = e.to - e.from, Y = m > 0 ? F((e.to - t.time) / m, 0, 1) : 0, M = i({ ...t, position: Y, progress: this.#o.progressAt(Y) });
+      return this.#p(M, t);
     }
-    const o = this.#n?.element, a = this.#h;
-    if (o === void 0 || a === null) return null;
-    const s = a.to - a.from, u = s > 0 ? _((t.time - a.from) / s, 0, 1) : 0, y = o({ ...t, position: u, progress: this.introWave.progressAt(u) });
-    return this.#p(y, t);
+    const o = this.#n?.element, h = this.#l;
+    if (o === void 0 || h === null) return null;
+    const n = h.to - h.from, l = n > 0 ? F((t.time - h.from) / n, 0, 1) : 0, p = o({ ...t, position: l, progress: this.introWave.progressAt(l) });
+    return this.#p(p, t);
   }
   /** Map a directive's declarative transform onto the element's settled
    *  geometry. Absolute `topY`/`bottomY` overrides (a morph's arbitrary
@@ -451,65 +454,65 @@ class xt {
     data: i,
     timeScale: e,
     chartHeight: o,
-    barWidth: a,
-    wickWidth: s,
-    entranceByTime: u,
-    snapVolScale: y,
+    barWidth: h,
+    wickWidth: n,
+    entranceByTime: l,
+    snapVolScale: p,
     radius: m
   }) {
-    let b = 0;
-    for (const d of i)
-      Number.isFinite(d.volume) && d.volume > b && (b = d.volume);
-    if (b === 0) {
+    let Y = 0;
+    for (const f of i)
+      Number.isFinite(f.volume) && f.volume > Y && (Y = f.volume);
+    if (Y === 0) {
       this.#i = null, this.#s = !0;
       return;
     }
-    this.#i === null || y ? this.#i = b : this.#i += (b - this.#i) * pt, this.#s = Math.abs(b - this.#i) <= b * ut;
-    const w = this.#i, S = o * 0.2;
-    let c = Math.max(1, a - 2);
-    (c & 1) !== (s & 1) && (c = c > 1 ? c - 1 : 2);
-    const W = Math.floor(c / 2), X = K(I(this.options.up.body), 0.2), f = K(I(this.options.down.body), 0.2), M = this.options.entryAnimation ?? "unfold";
-    for (const d of i) {
-      if (!Number.isFinite(d.volume) || d.volume <= 0) continue;
-      const Y = d.volume, R = e.timeToBitmapX(d.time), v = Math.min(S, Math.max(1, Y / w * S)), T = d.close >= d.open;
-      t.fillStyle = T ? X : f;
-      const A = u?.get(d.time) ?? 1;
-      let n = { x: R - W, topY: o - v, bottomY: o, alpha: 1 };
-      if (A < 1 && M !== "none") {
-        const g = F(A, M, {
-          x: n.x,
-          barWidth: c,
+    this.#i === null || p ? this.#i = Y : this.#i += (Y - this.#i) * ut, this.#s = Math.abs(Y - this.#i) <= Y * dt;
+    const M = this.#i, S = o * 0.2;
+    let u = Math.max(1, h - 2);
+    (u & 1) !== (n & 1) && (u = u > 1 ? u - 1 : 2);
+    const W = Math.floor(u / 2), X = K(I(this.options.up.body), 0.2), b = K(I(this.options.down.body), 0.2), w = this.options.entryAnimation ?? "unfold";
+    for (const f of i) {
+      if (!Number.isFinite(f.volume) || f.volume <= 0) continue;
+      const g = f.volume, R = e.timeToBitmapX(f.time), v = Math.min(S, Math.max(1, g / M * S)), T = f.close >= f.open;
+      t.fillStyle = T ? X : b;
+      const A = l?.get(f.time) ?? 1;
+      let s = { x: R - W, topY: o - v, bottomY: o, alpha: 1 };
+      if (A < 1 && w !== "none") {
+        const y = O(A, w, {
+          x: s.x,
+          barWidth: u,
           anchorY: o,
-          topY: n.topY,
-          bottomY: n.bottomY
+          topY: s.topY,
+          bottomY: s.bottomY
         });
-        n = { x: g.x, topY: g.topY, bottomY: g.bottomY, alpha: g.alpha };
+        s = { x: y.x, topY: y.topY, bottomY: y.bottomY, alpha: y.alpha };
       }
-      const p = this.introTransform({
+      const d = this.introTransform({
         element: "volume",
-        time: d.time,
-        x: n.x,
-        topY: n.topY,
-        bottomY: n.bottomY,
+        time: f.time,
+        x: s.x,
+        topY: s.topY,
+        bottomY: s.bottomY,
         anchorY: o,
-        barWidth: c
+        barWidth: u
       });
-      if (p !== null && (n = { x: p.x, topY: p.topY, bottomY: p.bottomY, alpha: n.alpha * p.alpha }), n.alpha >= 1) {
+      if (d !== null && (s = { x: d.x, topY: d.topY, bottomY: d.bottomY, alpha: s.alpha * d.alpha }), s.alpha >= 1) {
         Z(t, {
-          x: n.x,
-          y: n.topY,
-          width: c,
-          height: Math.max(1, n.bottomY - n.topY),
+          x: s.x,
+          y: s.topY,
+          width: u,
+          height: Math.max(1, s.bottomY - s.topY),
           radius: m,
           corners: j
         });
         continue;
       }
-      t.save(), t.globalAlpha = n.alpha, Z(t, {
-        x: n.x,
-        y: n.topY,
-        width: c,
-        height: Math.max(1, n.bottomY - n.topY),
+      t.save(), t.globalAlpha = s.alpha, Z(t, {
+        x: s.x,
+        y: s.topY,
+        width: u,
+        height: Math.max(1, s.bottomY - s.topY),
         radius: m,
         corners: j
       }), t.restore();
@@ -520,85 +523,85 @@ class xt {
     candles: i,
     timeScale: e,
     yScale: o,
-    halfBody: a,
-    bodyWidth: s,
-    wickWidth: u,
-    body: y,
+    halfBody: h,
+    bodyWidth: n,
+    wickWidth: l,
+    body: p,
     wickColor: m,
-    entranceByTime: b,
-    candlePass: w
+    entranceByTime: Y,
+    candlePass: M
   }) {
     if (i.length === 0) return;
-    const S = this.options.entryAnimation ?? "unfold", c = s + 2, W = w.env.theme.axis.textColor ?? "#787b86";
+    const S = this.options.entryAnimation ?? "unfold", u = n + 2, W = M.env.theme.axis.textColor ?? "#787b86";
     t.fillStyle = m;
-    for (const f of i) {
-      const M = b?.get(f.time) ?? 1, d = e.timeToBitmapX(f.time), Y = o.valueToBitmapY(f.open), R = o.valueToBitmapY(f.high), v = o.valueToBitmapY(f.low), T = d - Math.floor(u / 2);
-      let A = !1, n = { x: T, topY: R, bottomY: v, alpha: 1 };
-      if (M < 1 && S !== "none") {
-        const L = F(M, S, {
+    for (const b of i) {
+      const w = Y?.get(b.time) ?? 1, f = e.timeToBitmapX(b.time), g = o.valueToBitmapY(b.open), R = o.valueToBitmapY(b.high), v = o.valueToBitmapY(b.low), T = f - Math.floor(l / 2);
+      let A = !1, s = { x: T, topY: R, bottomY: v, alpha: 1 };
+      if (w < 1 && S !== "none") {
+        const L = O(w, S, {
           x: T,
-          barWidth: c,
-          anchorY: Y,
+          barWidth: u,
+          anchorY: g,
           topY: R,
           bottomY: v
         });
-        n = { x: L.x, topY: L.topY, bottomY: L.bottomY, alpha: L.alpha }, A = !0;
+        s = { x: L.x, topY: L.topY, bottomY: L.bottomY, alpha: L.alpha }, A = !0;
       }
-      const p = this.introTransform({
+      const d = this.introTransform({
         element: "wick",
-        time: f.time,
-        x: n.x,
-        topY: n.topY,
-        bottomY: n.bottomY,
-        anchorY: Y,
-        barWidth: c
+        time: b.time,
+        x: s.x,
+        topY: s.topY,
+        bottomY: s.bottomY,
+        anchorY: g,
+        barWidth: u
       });
-      let g = 0;
-      if (p !== null && (n = { x: p.x, topY: p.topY, bottomY: p.bottomY, alpha: n.alpha * p.alpha }, g = p.tint ?? 0, A = !0), !A) {
-        t.fillRect(T, R, u, v - R);
+      let y = 0;
+      if (d !== null && (s = { x: d.x, topY: d.topY, bottomY: d.bottomY, alpha: s.alpha * d.alpha }, y = d.tint ?? 0, A = !0), !A) {
+        t.fillRect(T, R, l, v - R);
         continue;
       }
-      t.save(), t.globalAlpha = n.alpha, g > 0 && (t.fillStyle = G(m, W, g)), t.fillRect(n.x, n.topY, u, Math.max(1, n.bottomY - n.topY)), t.restore();
+      t.save(), t.globalAlpha = s.alpha, y > 0 && (t.fillStyle = G(m, W, y)), t.fillRect(s.x, s.topY, l, Math.max(1, s.bottomY - s.topY)), t.restore();
     }
-    const X = Array.isArray(y);
-    for (const f of i) {
-      const M = b?.get(f.time) ?? 1, d = e.timeToBitmapX(f.time), Y = o.valueToBitmapY(f.open), R = o.valueToBitmapY(f.close), v = Math.min(Y, R), T = Math.max(Y, R), A = Math.max(1, T - v);
-      let n = d - a, p = v, g = T, L = 1, B = !1;
-      if (M < 1 && S !== "none") {
-        const H = F(M, S, {
-          x: n,
-          barWidth: c,
-          anchorY: Y,
+    const X = Array.isArray(p);
+    for (const b of i) {
+      const w = Y?.get(b.time) ?? 1, f = e.timeToBitmapX(b.time), g = o.valueToBitmapY(b.open), R = o.valueToBitmapY(b.close), v = Math.min(g, R), T = Math.max(g, R), A = Math.max(1, T - v);
+      let s = f - h, d = v, y = T, L = 1, B = !1;
+      if (w < 1 && S !== "none") {
+        const H = O(w, S, {
+          x: s,
+          barWidth: u,
+          anchorY: g,
           topY: v,
           bottomY: T
         });
-        n = H.x, p = H.topY, g = H.bottomY, L = H.alpha, B = !0;
+        s = H.x, d = H.topY, y = H.bottomY, L = H.alpha, B = !0;
       }
       const C = this.introTransform({
         element: "body",
-        time: f.time,
-        x: n,
-        topY: p,
-        bottomY: g,
-        anchorY: Y,
-        barWidth: c
+        time: b.time,
+        x: s,
+        topY: d,
+        bottomY: y,
+        anchorY: g,
+        barWidth: u
       });
       let E = 0;
-      C !== null && (n = C.x, p = C.topY, g = C.bottomY, L *= C.alpha, E = C.tint ?? 0, B = !0);
-      const D = B ? Math.max(1, g - p) : A;
+      C !== null && (s = C.x, d = C.topY, y = C.bottomY, L *= C.alpha, E = C.tint ?? 0, B = !0);
+      const D = B ? Math.max(1, y - d) : A;
       B && t.save();
-      const r = Array.isArray(y) ? y[0] : y, l = E > 0 ? G(r, W, E) : r, x = X && D > 2 && E <= 0, P = x ? this.#d(t, y, D) : l;
-      t.fillStyle = P, B && (t.globalAlpha = L), x && t.translate(0, p);
-      const k = x ? 0 : p, $ = _(w.radius, 0, Math.min(s, D) / 2);
-      $ < 1 && !this.options.candlePainter ? t.fillRect(n, k, s, D) : w.painter(w.env, {
-        geom: { x: n, y: k, width: s, height: D },
+      const r = Array.isArray(p) ? p[0] : p, c = E > 0 ? G(r, W, E) : r, x = X && D > 2 && E <= 0, P = x ? this.#d(t, p, D) : c;
+      t.fillStyle = P, B && (t.globalAlpha = L), x && t.translate(0, d);
+      const k = x ? 0 : d, V = F(M.radius, 0, Math.min(n, D) / 2);
+      V < 1 && !this.options.candlePainter ? t.fillRect(s, k, n, D) : M.painter(M.env, {
+        geom: { x: s, y: k, width: n, height: D },
         fillStyle: P,
-        color: l,
-        corners: ft,
-        radius: $,
-        progress: M,
-        isBullish: f.close >= f.open
-      }), x && t.translate(0, -p), B && t.restore();
+        color: c,
+        corners: bt,
+        radius: V,
+        progress: w,
+        isBullish: b.close >= b.open
+      }), x && t.translate(0, -d), B && t.restore();
     }
   }
   /**
@@ -609,51 +612,51 @@ class xt {
    * continuously, and a full clear is cheaper than an eviction policy.
    */
   #d(t, i, e) {
-    const o = Math.max(3, Math.round(e)), a = `${i[0]}|${i[1]}|${o}`, s = this.#c.get(a);
-    if (s !== void 0) return s;
-    this.#c.size >= 512 && this.#c.clear();
-    const u = t.createLinearGradient(0, 0, 0, o);
-    return u.addColorStop(0, i[0]), u.addColorStop(1, i[1]), this.#c.set(a, u), u;
+    const o = Math.max(3, Math.round(e)), h = `${i[0]}|${i[1]}|${o}`, n = this.#m.get(h);
+    if (n !== void 0) return n;
+    this.#m.size >= 512 && this.#m.clear();
+    const l = t.createLinearGradient(0, 0, 0, o);
+    return l.addColorStop(0, i[0]), l.addColorStop(1, i[1]), this.#m.set(h, l), l;
   }
 }
-function F(h, t, i) {
+function O(a, t, i) {
   switch (t) {
     case "none":
       return { x: i.x, topY: i.topY, bottomY: i.bottomY, alpha: 1 };
     case "fade":
-      return { x: i.x, topY: i.topY, bottomY: i.bottomY, alpha: h };
+      return { x: i.x, topY: i.topY, bottomY: i.bottomY, alpha: a };
     case "unfold":
       return {
         x: i.x,
-        topY: z(i.anchorY, i.topY, h),
-        bottomY: z(i.anchorY, i.bottomY, h),
+        topY: z(i.anchorY, i.topY, a),
+        bottomY: z(i.anchorY, i.bottomY, a),
         alpha: 1
       };
     case "slide":
       return {
-        x: i.x + (1 - h) * i.barWidth,
+        x: i.x + (1 - a) * i.barWidth,
         topY: i.topY,
         bottomY: i.bottomY,
-        alpha: h
+        alpha: a
       };
     case "fade-unfold":
       return {
         x: i.x,
-        topY: z(i.anchorY, i.topY, h),
-        bottomY: z(i.anchorY, i.bottomY, h),
-        alpha: h
+        topY: z(i.anchorY, i.topY, a),
+        bottomY: z(i.anchorY, i.bottomY, a),
+        alpha: a
       };
   }
 }
-const Et = {
+const zt = {
   type: "candlestick",
-  create: ({ theme: h }, t) => new xt(new rt(), {
-    up: { ...h.candlestick.up },
-    down: { ...h.candlestick.down },
+  create: ({ theme: a }, t) => new xt(new lt(), {
+    up: { ...a.candlestick.up },
+    down: { ...a.candlestick.down },
     ...t
   })
 };
 export {
   xt as CandlestickRenderer,
-  Et as CandlestickSeriesDef
+  zt as CandlestickSeriesDef
 };