@wick-charts/vue 0.8.0 → 0.8.1

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

@@ -1,12 +1,12 @@
 import { Animator as k } 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 M } from "../data/store.js";
-import { resolveColor as W } from "../utils/color.js";
-import { normalizeTimePointArray as d, normalizeTime as L } from "../utils/time.js";
-import { sumStack as A, renderedStackPercentTop as b, renderedStackTop as w } from "./stack-math.js";
-const T = (m, e, t) => m + (e - m) * t;
-class F {
+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 {
   stores;
   // --- Animation state (per layer) ----------------------------------------
   /**
@@ -54,9 +54,9 @@ class F {
    *  and `1` at the deepest point. */
   historyRange = null;
   constructor(e) {
-    this.stores = Array.from({ length: e }, () => new M()), 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(
+    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: T })
+      () => new k({ initial: 1, duration: 0, lerp: S })
     );
   }
   // --- Color accessors ------------------------------------------------------
@@ -65,39 +65,39 @@ class F {
    * layer on the theme base in `options.colors`). Kept separate from the base so
    * a theme swap, which rewrites `options.colors`, leaves these untouched.
    */
-  #r = [];
+  #n = [];
   setColorOverrides(e) {
-    this.#r = e;
+    this.#n = e;
   }
   /** The active resolver for a layer — the `data` override if set, else the theme base (cycled). */
-  #n(e) {
-    const t = this.#r[e];
+  #r(e) {
+    const t = this.#n[e];
     if (t !== void 0) return t;
     const s = this.options.colors;
     return s[e % s.length];
   }
   /** The first layer's color resolver (string or value-fn). */
   getColor() {
-    return this.#n(0);
+    return this.#r(0);
   }
   getColors() {
     return this.options.colors;
   }
   /** Resolve one layer's color for a given datum value. */
   resolveLayerColor(e, t) {
-    return W(this.#n(e), t);
+    return M(this.#r(e), t);
   }
   // --- Data ingest ----------------------------------------------------------
   setData(e, t = 0) {
     const s = this.stores[t];
     if (!s) return;
     let i = !1;
-    for (const o of this.stores)
-      o.length > 0 && (i = !0);
-    const r = d(e ?? []);
-    s.setData(r), !i && r.length > 0 && this.introWave.arm(this.options.introMs);
-    const n = s.last();
-    this.displayedLastValues[t] = n ? n.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 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;
   }
   /**
    * Replace a layer like {@link setData}, but ease each point that keeps its
@@ -114,42 +114,42 @@ class F {
     const i = /* @__PURE__ */ new Map();
     for (const h of s.getAll())
       i.set(h.time, this.liveValue(t, h.time, h.value));
-    const r = d(e ?? []);
-    s.setData(r);
-    const n = this.options.smoothMs, o = this.isEntryEnabled() && this.options.entryMs > 0, l = this.entries[t], u = this.#s[t], a = /* @__PURE__ */ new Map();
-    for (const h of r) {
+    const n = d(e ?? []);
+    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();
+    for (const h of n) {
       const g = i.get(h.time);
       if (g === void 0) {
-        o && l.set(h.time, { startTime: performance.now() });
+        r && o.set(h.time, { startTime: performance.now() });
         continue;
       }
       const p = h.value;
-      if (g === p || n <= 0 || !Number.isFinite(g) || !Number.isFinite(p)) continue;
+      if (g === p || l <= 0 || !Number.isFinite(g) || !Number.isFinite(p)) continue;
       const v = u.get(h.time) ?? new V(g);
-      v.target !== p && v.retarget(p, { settleMs: n }), a.set(h.time, v);
+      v.target !== p && v.retarget(p, { settleMs: l }), a.set(h.time, v);
     }
-    const c = new Set(r.map((h) => h.time));
-    for (const h of l.keys())
-      c.has(h) || l.delete(h);
+    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 f = s.last();
-    this.displayedLastValues[t] = f ? f.value : null, this.#t[t] = null, this.#e[t] = null;
+    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];
     if (!s) return;
-    const i = e, r = L(i.time), n = s.last(), o = s.length;
-    s.append({ ...i, time: r });
-    const l = this.#t[t];
-    l !== null && n !== void 0 && s.length > o && (this.#e[t] = { time: n.time, anim: l }), this.displayedLastValues[t] = i.value, this.#t[t] = null;
+    const i = e, n = L(i.time), l = s.last(), r = 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 u = this.options.entryMs;
-    this.isEntryEnabled() && u > 0 && this.entries[t].set(r, { startTime: performance.now() });
+    this.isEntryEnabled() && u > 0 && this.entries[t].set(n, { startTime: performance.now() });
   }
   prependPoints(e, t = 0) {
     const s = this.stores[t];
     if (!s || e.length === 0) return;
-    const i = d(e), r = s.first()?.time;
-    s.prepend(i), this.#o(i[0]?.time, r);
+    const i = d(e), n = s.first()?.time;
+    s.prepend(i), this.#o(i[0]?.time, n);
   }
   /**
    * Arm (or extend) the history-reveal wave for freshly prepended points.
@@ -170,21 +170,21 @@ class F {
   updateLastPoint(e, t = 0) {
     const s = this.stores[t];
     if (!s) return;
-    const i = e, r = s.last()?.time;
+    const i = e, n = s.last()?.time;
     s.updateLast({ ...i, time: L(i.time) });
-    const n = this.#s[t], o = r === void 0 ? void 0 : n.get(r);
-    r !== void 0 && o !== void 0 && (n.delete(r), this.displayedLastValues[t] = o.current, this.#t[t] = o);
-    const l = i.value, u = this.options.smoothMs;
+    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;
     if (u <= 0) {
-      this.displayedLastValues[t] = l, this.#t[t] = null;
+      this.displayedLastValues[t] = o, this.#t[t] = null;
       return;
     }
     let a = this.#t[t];
     if (a === null) {
-      const c = this.displayedLastValues[t] ?? l;
-      a = new V(c), this.#t[t] = a;
+      const f = this.displayedLastValues[t] ?? o;
+      a = new V(f), this.#t[t] = a;
     }
-    a.retarget(l, { settleMs: u });
+    a.retarget(o, { settleMs: u });
   }
   keepLast(e, t = 0) {
     const s = this.stores[t];
@@ -208,7 +208,7 @@ class F {
   getLayerColors() {
     const e = [];
     for (let t = 0; t < this.stores.length; t++) {
-      const s = this.stores[t]?.last()?.value ?? 0;
+      const s = this.lastFinitePoint(t)?.value ?? 0;
       e.push(this.resolveLayerColor(t, s));
     }
     return e;
@@ -236,8 +236,8 @@ class F {
     if (s === void 0) return 1;
     const i = this.options.entryMs;
     if (i <= 0) return 1;
-    const r = performance.now() - s.startTime;
-    return r <= 0 ? 0 : r >= i ? 1 : r / i;
+    const n = performance.now() - s.startTime;
+    return n <= 0 ? 0 : n >= i ? 1 : n / i;
   }
   /**
    * Initial-load reveal progress for a datum, keyed by its normalized
@@ -249,8 +249,8 @@ class F {
    */
   introProgressAt(e, t) {
     if (!this.introWave.active) return 1;
-    const s = e.timeScale.getRange(), i = s.to - s.from, r = i > 0 ? (t - s.from) / i : 0;
-    return this.introWave.progressAt(r);
+    const s = e.timeScale.getRange(), i = s.to - s.from, n = i > 0 ? (t - s.from) / i : 0;
+    return this.introWave.progressAt(n);
   }
   /**
    * History-prepend reveal progress for a datum. Stagger position is
@@ -280,9 +280,9 @@ class F {
     if (!t || t.length < 2) return [];
     const s = [];
     for (let i = t.length - 1; i >= 1; i--) {
-      const r = this.entranceProgress(e, t[i].time);
-      if (r >= 1) break;
-      s.unshift({ time: t[i].time, progress: r });
+      const n = this.entranceProgress(e, t[i].time);
+      if (n >= 1) break;
+      s.unshift({ time: t[i].time, progress: n });
     }
     return s;
   }
@@ -307,11 +307,11 @@ class F {
   liveValue(e, t, s) {
     const i = this.#s[e]?.get(t);
     if (i !== void 0) return i.current;
-    const r = this.stores[e]?.last()?.time;
-    if (r !== void 0 && t === r)
+    const n = this.stores[e]?.last()?.time;
+    if (n !== void 0 && t === n)
       return this.displayedLastValues[e] ?? s;
-    const n = this.#e[e];
-    return n !== null && n.time === t ? n.anim.current : s;
+    const l = this.#e[e];
+    return l !== null && l.time === t ? l.anim.current : s;
   }
   /**
    * Value a last-value/tooltip query should report for `time` — defaults to
@@ -336,22 +336,22 @@ class F {
     for (let t = 0; t < this.stores.length; t++) {
       const s = this.#t[t];
       if (s !== null) {
-        const l = s.tick(e);
-        this.displayedLastValues[t] = s.current, l || (this.#t[t] = null);
+        const o = s.tick(e);
+        this.displayedLastValues[t] = s.current, o || (this.#t[t] = null);
       }
       const i = this.#e[t];
       i !== null && !i.anim.tick(e) && (this.#e[t] = null);
-      const r = this.#s[t];
-      for (const [l, u] of r)
-        u.tick(e) || r.delete(l);
-      const n = this.options.entryMs;
-      if (n <= 0) {
+      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();
         continue;
       }
-      const o = this.entries[t];
-      for (const [l, u] of o)
-        e - u.startTime >= n && o.delete(l);
+      const r = this.entries[t];
+      for (const [o, u] of r)
+        e - u.startTime >= l && r.delete(o);
     }
   }
   /** True while any layer has an active chase, unsettled entry, alpha fade,
@@ -424,9 +424,23 @@ class F {
     return this.#i[e]?.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;
+    for (let n = s.length - 1; n >= 0; n--)
+      if (Number.isFinite(s[n].value)) {
+        if (i === 0) return s[n];
+        i--;
+      }
+    return null;
+  }
   getLastValue() {
     for (let e = this.stores.length - 1; e >= 0; e--) {
-      const t = this.stores[e].last();
+      const t = this.lastFinitePoint(e);
       if (t) return t.value;
     }
     return null;
@@ -439,87 +453,104 @@ class F {
     const s = [];
     for (let i = 0; i < this.stores.length; i++) {
       if (!this.stores[i].isVisible()) continue;
-      const r = this.stores[i].findNearest(e, t);
-      if (r === null) continue;
-      const n = {
+      const n = this.stores[i].findNearest(e, t);
+      if (n === null) continue;
+      const l = {
         layerIndex: i,
-        time: r.time,
+        time: n.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, r.time, r.value),
+        value: this.snapshotValue(i, n.time, n.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, r.value)
+        color: this.resolveLayerColor(i, n.value)
       };
-      r.x !== void 0 && (n.x = r.x), s.push(n);
+      n.x !== void 0 && (l.x = n.x), s.push(l);
     }
     return s.length > 0 ? s : null;
   }
   getStackedLastValue() {
     if (this.stores.length <= 1) {
-      const r = this.stores[0]?.last();
-      return r ? { value: this.snapshotValue(0, r.time, r.value), isLive: !0 } : null;
+      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") {
-      for (let r = this.stores.length - 1; r >= 0; r--) {
-        if (!this.stores[r].isVisible()) continue;
-        const n = this.stores[r].last();
-        if (n) return { value: this.snapshotValue(r, n.time, n.value), isLive: !0 };
+      for (let i = this.stores.length - 1; i >= 0; i--) {
+        if (!this.stores[i].isVisible()) continue;
+        const n = this.lastFinitePoint(i);
+        if (n) return { value: this.snapshotValue(i, n.time, n.value), isLive: !0 };
       }
       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 };
+  }
+  /** Stack contributions at the newest time any visible layer has a finite point. */
+  lastDrawnRowValues() {
+    let e = 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);
+    }
+    if (e === null) return null;
+    const t = e;
+    return this.stackHeadValues((s) => this.stores[s].findNearest(t, 0));
+  }
+  /** Each visible layer's stack contribution at `pick(layer)`, or `null` when none is finite. */
+  stackHeadValues(e) {
     let t = !1;
     const s = [];
-    for (let r = 0; r < this.stores.length; r++) {
-      if (!this.stores[r].isVisible()) continue;
-      const n = this.stores[r].last();
-      if (!n) {
+    for (let i = 0; i < this.stores.length; i++) {
+      if (!this.stores[i].isVisible()) continue;
+      const n = e(i);
+      if (!n || !Number.isFinite(n.value)) {
         s.push(0);
         continue;
       }
-      t = !0, s.push(this.snapshotValue(r, n.time, n.value));
+      t = !0, s.push(this.snapshotValue(i, n.time, n.value));
     }
-    if (!t) return null;
-    const i = A(s);
-    return { value: e === "percent" ? b(i) : w(i), isLive: !0 };
+    return t ? s : null;
   }
   getStackedValueAtTime(e, t) {
     if (this.stores.length <= 1) {
-      const o = this.stores[0]?.findNearest(e, t);
-      return o ? this.snapshotValue(0, o.time, o.value) : null;
+      const r = this.stores[0]?.findNearest(e, t);
+      return r ? this.snapshotValue(0, r.time, r.value) : null;
     }
     const s = this.options.stacking;
     if (s === "off") {
-      for (let o = this.stores.length - 1; o >= 0; o--) {
-        if (!this.stores[o].isVisible()) continue;
-        const l = this.stores[o].findNearest(e, t);
-        if (l) return this.snapshotValue(o, l.time, l.value);
+      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);
       }
       return null;
     }
     let i = !1;
-    const r = [];
-    for (let o = 0; o < this.stores.length; o++) {
-      if (!this.stores[o].isVisible()) continue;
-      const l = this.stores[o].findNearest(e, t);
-      if (!l) {
-        r.push(0);
+    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) {
+        n.push(0);
         continue;
       }
-      i = !0, r.push(this.snapshotValue(o, l.time, l.value));
+      i = !0, n.push(this.snapshotValue(r, o.time, o.value));
     }
     if (!i) return null;
-    const n = A(r);
-    return s === "percent" ? b(n) : w(n);
+    const l = A(n);
+    return s === "percent" ? w(l) : b(l);
   }
   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.stores[t].last();
+      const s = this.lastFinitePoint(t);
       if (!s) continue;
       const i = {
         layerIndex: t,
@@ -546,32 +577,31 @@ class F {
     for (const s of this.stores) {
       const i = s.first();
       if (!i) continue;
-      const r = s.last() ?? i;
-      i.time < e && (e = i.time), r.time > t && (t = r.time);
+      const n = s.last() ?? i;
+      i.time < e && (e = i.time), n.time > t && (t = n.time);
     }
     return e === 1 / 0 ? null : { first: e, last: t };
   }
   /**
-   * Last data point of **layer 0 (`stores[0]`) only** — preserves the behavior
+   * Last finite data point of **layer 0 (`stores[0]`) only** — preserves the behavior
    * of the deleted `get store()` getter. NOTE: this is intentionally NOT the
    * same as {@link getStackedLastValue}, which for non-stacked multi-layer
    * reports the top visible layer and for stacked reports the cumulative sum.
    * Last-data / previous-close semantics stay pinned to layer 0 for back-compat.
    */
   getLastDataPoint() {
-    return this.stores[0]?.last() ?? null;
+    return this.lastFinitePoint(0);
   }
   /** Second-to-last point of layer 0 (`stores[0]`). See {@link getLastDataPoint}. */
   getSecondLastDataPoint() {
-    const e = this.stores[0]?.getAll();
-    return !e || e.length < 2 ? null : e[e.length - 2];
-  }
-  /** First `maxCount` sample times from the first populated layer. */
-  sampleTimes(e) {
-    for (const t of this.stores) {
-      const s = t.getAll();
-      if (s.length !== 0)
-        return s.slice(0, e).map((i) => i.time);
+    return this.lastFinitePoint(0, 1);
+  }
+  /** First (or with `'end'`, last) `maxCount` sample times from the first populated layer. */
+  sampleTimes(e, t = "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 [];
   }
@@ -586,51 +616,51 @@ class F {
     const i = this.options.stacking;
     if (i === "percent")
       return { min: 0, max: 100 };
-    const r = this.stores.map((a) => a.isVisible() ? a.getVisibleData(e, t) : []), n = s?.plottable;
+    const n = this.stores.map((a) => a.isVisible() ? a.getVisibleData(e, t) : []), l = s?.plottable;
     if (i === "off") {
-      let a = 1 / 0, c = -1 / 0;
-      for (const f of r)
-        for (const h of f)
-          Number.isFinite(h.value) && (n && !n(h.value) || (h.value < a && (a = h.value), h.value > c && (c = h.value)));
-      return a < 1 / 0 ? { min: a, max: c } : null;
+      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;
     }
-    if (n) return S(r, n);
-    const o = /* @__PURE__ */ new Map();
-    for (let a = 0; a < r.length; a++)
-      for (const c of r[a]) {
-        let f = o.get(c.time);
-        f || (f = new Array(r.length).fill(0), o.set(c.time, f)), f[a] = Number.isFinite(c.value) ? c.value : 0;
+    if (l) return T(n, l);
+    const r = /* @__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;
       }
-    let l = 0, u = 0;
-    for (const a of o.values()) {
-      let c = 0, f = 0;
+    let o = 0, u = 0;
+    for (const a of r.values()) {
+      let f = 0, c = 0;
       for (const h of a)
-        h > 0 ? c += h : f += h;
-      c > u && (u = c), f < l && (l = f);
+        h > 0 ? f += h : c += h;
+      f > u && (u = f), c < o && (o = c);
     }
-    return u > l ? { min: l, max: u } : null;
+    return u > o ? { min: o, max: u } : null;
   }
 }
-function S(m, e) {
+function T(m, e) {
   const t = /* @__PURE__ */ new Map();
-  for (let n = 0; n < m.length; n++)
-    for (const o of m[n]) {
-      let l = t.get(o.time);
-      l || (l = new Array(m.length).fill(0), t.set(o.time, l)), l[n] = e(o.value) ? o.value : 0;
+  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;
     }
   const s = e(0);
-  let i = s ? 0 : 1 / 0, r = s ? 0 : -1 / 0;
-  for (const n of t.values()) {
-    let o = 0, l = 0;
-    for (const u of n) {
+  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) {
       if (u === 0) continue;
-      u > 0 ? o += u : l += u;
-      const a = u > 0 ? o : l;
-      e(a) && (a < i && (i = a), a > r && (r = a));
+      u > 0 ? r += u : o += u;
+      const a = u > 0 ? r : o;
+      e(a) && (a < i && (i = a), a > n && (n = a));
     }
   }
-  return i < 1 / 0 ? { min: i, max: r } : null;
+  return i < 1 / 0 ? { min: i, max: n } : null;
 }
 export {
-  F as BaseMultiLayerSeries
+  z as BaseMultiLayerSeries
 };