velo-plot 3.0.0 → 4.0.0-alpha.1

package/dist/plugins/broken-axis.js

@@ -1,16 +1,17 @@
-var A = Object.defineProperty;
-var T = (d, e, r) => e in d ? A(d, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : d[e] = r;
-var x = (d, e, r) => T(d, typeof e != "symbol" ? e + "" : e, r);
-class v {
+var M = Object.defineProperty;
+var T = (s, e, r) => e in s ? M(s, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : s[e] = r;
+var $ = (s, e, r) => T(s, typeof e != "symbol" ? e + "" : e, r);
+import { f as u } from "../SVGDocumentBuilder-C-uLkcFW.js";
+class A {
   constructor(e, r) {
-    x(this, "domain", [0, 1]);
-    x(this, "range", [0, 100]);
-    x(this, "type", "linear");
+    $(this, "domain", [0, 1]);
+    $(this, "range", [0, 100]);
+    $(this, "type", "linear");
     // Compatible with linear for renderer selection
-    x(this, "underlying");
-    x(this, "sortedBreaks", []);
-    x(this, "visibleRanges", []);
-    x(this, "availableVisualRatio", 1);
+    $(this, "underlying");
+    $(this, "sortedBreaks", []);
+    $(this, "visibleRanges", []);
+    $(this, "availableVisualRatio", 1);
     this.breaks = r, this.underlying = e, this.domain = [...e.domain], this.range = [...e.range], this.refresh();
   }
   setDomain(e, r) {
@@ -24,180 +25,221 @@ class v {
   }
   refresh() {
     const [e, r] = this.domain;
-    this.sortedBreaks = this.breaks.filter((i) => i.start < r && i.end > e).map((i) => ({
-      ...i,
-      start: Math.max(e, i.start),
-      end: Math.min(r, i.end),
-      visualRatio: i.visualRatio ?? 0.02
-    })).sort((i, f) => i.start - f.start);
-    const l = [];
-    let n = e;
-    for (const i of this.sortedBreaks)
-      i.start > n && l.push({ start: n, end: i.start }), n = i.end;
-    n < r && l.push({ start: n, end: r });
-    const p = l.reduce((i, f) => i + (f.end - f.start), 0) || 1e-10, u = this.sortedBreaks.reduce((i, f) => i + (f.visualRatio || 0.02), 0);
-    this.availableVisualRatio = Math.max(0.1, 1 - u);
+    this.sortedBreaks = this.breaks.filter((n) => n.start < r && n.end > e).map((n) => ({
+      ...n,
+      start: Math.max(e, n.start),
+      end: Math.min(r, n.end),
+      visualRatio: n.visualRatio ?? 0.02
+    })).sort((n, h) => n.start - h.start);
+    const o = [];
+    let a = e;
+    for (const n of this.sortedBreaks)
+      n.start > a && o.push({ start: a, end: n.start }), a = n.end;
+    a < r && o.push({ start: a, end: r });
+    const m = o.reduce((n, h) => n + (h.end - h.start), 0) || 1e-10, f = this.sortedBreaks.reduce((n, h) => n + (h.visualRatio || 0.02), 0);
+    this.availableVisualRatio = Math.max(0.1, 1 - f);
     let c = 0;
-    this.visibleRanges = l.map((i) => {
-      const f = i.end - i.start, b = f / p * this.availableVisualRatio, R = {
-        start: i.start,
-        end: i.end,
+    this.visibleRanges = o.map((n) => {
+      const h = n.end - n.start, g = h / m * this.availableVisualRatio, x = {
+        start: n.start,
+        end: n.end,
         pixelOffset: c,
-        pixelScale: b / f
-      }, t = this.sortedBreaks.find((s) => Math.abs(s.start - i.end) < 1e-10);
-      return c += b + ((t == null ? void 0 : t.visualRatio) ?? 0), R;
+        pixelScale: g / h
+      }, t = this.sortedBreaks.find((i) => Math.abs(i.start - n.end) < 1e-10);
+      return c += g + ((t == null ? void 0 : t.visualRatio) ?? 0), x;
     });
   }
   transform(e) {
-    const [r, l] = this.domain, [n, p] = this.range, u = p < n;
+    const [r, o] = this.domain, [a, m] = this.range, f = m < a;
     let c = 0;
     if (e <= r) c = 0;
-    else if (e >= l) c = 1;
+    else if (e >= o) c = 1;
     else {
-      let i = !1;
-      for (const f of this.visibleRanges)
-        if (e >= f.start && e <= f.end) {
-          c = f.pixelOffset + (e - f.start) * f.pixelScale, i = !0;
+      let n = !1;
+      for (const h of this.visibleRanges)
+        if (e >= h.start && e <= h.end) {
+          c = h.pixelOffset + (e - h.start) * h.pixelScale, n = !0;
           break;
         }
-      if (!i) {
-        for (const f of this.sortedBreaks)
-          if (e >= f.start && e <= f.end) {
-            const b = this.visibleRanges.find((t) => Math.abs(t.end - f.start) < 1e-10);
-            c = (b ? b.pixelOffset + (b.end - b.start) * b.pixelScale : 0) + (e - f.start) / (f.end - f.start) * (f.visualRatio ?? 0.02), i = !0;
+      if (!n) {
+        for (const h of this.sortedBreaks)
+          if (e >= h.start && e <= h.end) {
+            const g = this.visibleRanges.find((t) => Math.abs(t.end - h.start) < 1e-10);
+            c = (g ? g.pixelOffset + (g.end - g.start) * g.pixelScale : 0) + (e - h.start) / (h.end - h.start) * (h.visualRatio ?? 0.02), n = !0;
             break;
           }
       }
-      i || (c = 0);
+      n || (c = 0);
     }
-    return u ? n - c * (n - p) : n + c * (p - n);
+    return f ? a - c * (a - m) : a + c * (m - a);
   }
   /** Map data value to 0-1 ratio space (handles breaks) */
   mapToRatio(e) {
-    const [r, l] = this.domain;
+    const [r, o] = this.domain;
     if (e <= r) return 0;
-    if (e >= l) return 1;
-    for (const n of this.visibleRanges)
-      if (e >= n.start && e <= n.end)
-        return n.pixelOffset + (e - n.start) * n.pixelScale;
-    for (const n of this.sortedBreaks)
-      if (e >= n.start && e <= n.end) {
-        const p = this.visibleRanges.find((c) => Math.abs(c.end - n.start) < 1e-10);
-        return (p ? p.pixelOffset + (p.end - p.start) * p.pixelScale : 0) + (e - n.start) / (n.end - n.start) * (n.visualRatio ?? 0.02);
+    if (e >= o) return 1;
+    for (const a of this.visibleRanges)
+      if (e >= a.start && e <= a.end)
+        return a.pixelOffset + (e - a.start) * a.pixelScale;
+    for (const a of this.sortedBreaks)
+      if (e >= a.start && e <= a.end) {
+        const m = this.visibleRanges.find((c) => Math.abs(c.end - a.start) < 1e-10);
+        return (m ? m.pixelOffset + (m.end - m.start) * m.pixelScale : 0) + (e - a.start) / (a.end - a.start) * (a.visualRatio ?? 0.02);
       }
     return 0;
   }
   invert(e) {
-    const [r, l] = this.range, n = (e - r) / (l - r), p = Math.max(0, Math.min(1, n));
-    for (const u of this.visibleRanges) {
-      const c = u.pixelOffset + (u.end - u.start) * u.pixelScale;
-      if (p >= u.pixelOffset && p <= c)
-        return u.start + (p - u.pixelOffset) / u.pixelScale;
+    const [r, o] = this.range, a = (e - r) / (o - r), m = Math.max(0, Math.min(1, a));
+    for (const f of this.visibleRanges) {
+      const c = f.pixelOffset + (f.end - f.start) * f.pixelScale;
+      if (m >= f.pixelOffset && m <= c)
+        return f.start + (m - f.pixelOffset) / f.pixelScale;
     }
-    for (let u = 0; u < this.sortedBreaks.length; u++) {
-      const c = this.sortedBreaks[u], i = this.visibleRanges.find((b) => Math.abs(b.end - c.start) < 1e-10), f = i ? i.pixelOffset + (i.end - i.start) * i.pixelScale : 0;
-      if (p >= f && p <= f + (c.visualRatio ?? 0.02))
+    for (let f = 0; f < this.sortedBreaks.length; f++) {
+      const c = this.sortedBreaks[f], n = this.visibleRanges.find((g) => Math.abs(g.end - c.start) < 1e-10), h = n ? n.pixelOffset + (n.end - n.start) * n.pixelScale : 0;
+      if (m >= h && m <= h + (c.visualRatio ?? 0.02))
         return c.start;
     }
     return this.domain[0];
   }
   ticks(e = 10) {
     const r = [];
-    for (const l of this.visibleRanges) {
-      const n = (l.end - l.start) / (this.domain[1] - this.domain[0]), p = Math.max(2, Math.round(e * n / this.availableVisualRatio)), u = this.generateSegmentTicks(l.start, l.end, p);
-      r.push(...u);
+    for (const o of this.visibleRanges) {
+      const a = (o.end - o.start) / (this.domain[1] - this.domain[0]), m = Math.max(2, Math.round(e * a / this.availableVisualRatio)), f = this.generateSegmentTicks(o.start, o.end, m);
+      r.push(...f);
     }
-    return Array.from(new Set(r)).sort((l, n) => l - n);
-  }
-  generateSegmentTicks(e, r, l) {
-    const n = r - e;
-    if (n <= 0 || !isFinite(n)) return [];
-    const p = n / l, u = Math.pow(10, Math.floor(Math.log10(p))), c = p / u;
-    let i;
-    c < 1.5 ? i = 1 : c < 3 ? i = 2 : c < 7 ? i = 5 : i = 10, i *= u;
-    const f = Math.ceil(e / i) * i, b = [];
-    let R = f;
-    for (; R <= r + i * 0.1; )
-      b.push(Math.round(R * 1e12) / 1e12), R += i;
-    return b;
+    return Array.from(new Set(r)).sort((o, a) => o - a);
+  }
+  generateSegmentTicks(e, r, o) {
+    const a = r - e;
+    if (a <= 0 || !isFinite(a)) return [];
+    const m = a / o, f = Math.pow(10, Math.floor(Math.log10(m))), c = m / f;
+    let n;
+    c < 1.5 ? n = 1 : c < 3 ? n = 2 : c < 7 ? n = 5 : n = 10, n *= f;
+    const h = Math.ceil(e / n) * n, g = [];
+    let x = h;
+    for (; x <= r + n * 0.1; )
+      g.push(Math.round(x * 1e12) / 1e12), x += n;
+    return g;
   }
 }
-const B = {
+function v(s, e, r, o) {
+  return r === "diagonal" ? `M ${u(s - 6)} ${u(e + 6 / 2)} L ${u(s + 6)} ${u(e - 6 / 2)} M ${u(s - 6 + 3)} ${u(e + 6 / 2)} L ${u(s + 6 + 3)} ${u(e - 6 / 2)}` : r === "zigzag" ? `M ${u(s - 6)} ${u(e)} L ${u(s - 6 / 2)} ${u(e - 6 / 2)} L ${u(s + 6 / 2)} ${u(e + 6 / 2)} L ${u(s + 6)} ${u(e)}` : o === "top" || o === "bottom" ? `M ${u(s - 6)} ${u(e - 2)} L ${u(s + 6)} ${u(e + 2)} M ${u(s - 6)} ${u(e - 6)} L ${u(s + 6)} ${u(e - 2)}` : `M ${u(s - 6)} ${u(e)} L ${u(s)} ${u(e - 6)} L ${u(s + 6)} ${u(e)}`;
+}
+function B(s, e) {
+  if (!s.builder) return;
+  const { plotArea: r } = s;
+  for (const o of e) {
+    const a = o.color ?? s.theme.xAxis.lineColor, m = o.style ?? "diagonal";
+    if (o.axis === "x") {
+      const f = s.xScale.transform(o.position), c = r.y, n = r.y + r.height;
+      s.builder.push(
+        "plugins",
+        `<path d="${v(f, c, m, "top")}" fill="none" stroke="${a}" stroke-width="1.5"/>`
+      ), s.builder.push(
+        "plugins",
+        `<path d="${v(f, n, m, "bottom")}" fill="none" stroke="${a}" stroke-width="1.5"/>`
+      );
+    } else {
+      const f = s.yScales.values().next().value;
+      if (!f) continue;
+      const c = f.transform(o.position), n = r.x, h = 6;
+      s.builder.push(
+        "plugins",
+        `<path d="M ${u(n)} ${u(c - h)} L ${u(n + h)} ${u(c)} L ${u(n)} ${u(c + h)}" fill="none" stroke="${a}" stroke-width="1.5"/>`
+      );
+    }
+  }
+}
+function _(s, e) {
+  const r = [];
+  for (const [o, a] of Object.entries(e))
+    if (o === "default" || o === "xAxis")
+      for (const f of a.breaks)
+        r.push({
+          axis: "x",
+          position: (f.start + f.end) / 2,
+          style: f.symbol ?? a.defaultSymbol,
+          color: a.symbolColor
+        });
+  B(s, r);
+}
+const O = {
   name: "velo-plot-broken-axis",
   version: "1.0.1",
   description: "Support for gaps/breaks in axes with visual indicators",
   provides: ["broken-axis", "coordinate-transform"],
   tags: ["axis", "layout", "visualization"]
 };
-function _(d = { axes: {} }) {
-  d.enabled === void 0 && (d.enabled = !0);
-  let e = null, r = null, l = null;
-  const n = /* @__PURE__ */ new Map();
-  function p() {
-    let t = 1 / 0, s = -1 / 0;
-    for (const o of n.values())
-      for (let a = 0; a < o.x.length; a++) {
-        const h = o.x[a];
-        h < t && (t = h), h > s && (s = h);
+function L(s = { axes: {} }) {
+  s.enabled === void 0 && (s.enabled = !0);
+  let e = null, r = null, o = null;
+  const a = /* @__PURE__ */ new Map();
+  function m() {
+    let t = 1 / 0, i = -1 / 0;
+    for (const d of a.values())
+      for (let l = 0; l < d.x.length; l++) {
+        const p = d.x[l];
+        p < t && (t = p), p > i && (i = p);
       }
-    return !Number.isFinite(t) || !Number.isFinite(s) || t === s ? null : [t, s];
+    return !Number.isFinite(t) || !Number.isFinite(i) || t === i ? null : [t, i];
   }
-  function u() {
-    if (!e || !d.enabled) return;
-    const t = d.axes.default || d.axes.xAxis;
-    t && l && (l.updateBreaks(t.breaks), c({ syncView: !0 }));
+  function f() {
+    if (!e || !s.enabled) return;
+    const t = s.axes.default || s.axes.xAxis;
+    t && o && (o.updateBreaks(t.breaks), c({ syncView: !0 }));
   }
   function c(t = {}) {
-    if (!e || !l || !d.enabled) return;
-    const s = e.chart, o = p();
-    if (!o) return;
-    const [a, h] = o, g = h - a || 1;
-    l.setDomain(a, h);
-    for (const [m, S] of n.entries()) {
-      const y = new Float32Array(S.x.length);
-      for (let k = 0; k < S.x.length; k++)
-        y[k] = a + l.mapToRatio(S.x[k]) * g;
-      s._originalUpdateSeries && s._originalUpdateSeries(m, { x: y, y: S.y });
+    if (!e || !o || !s.enabled) return;
+    const i = e.chart, d = m();
+    if (!d) return;
+    const [l, p] = d, z = p - l || 1;
+    o.setDomain(l, p);
+    for (const [b, k] of a.entries()) {
+      const R = new Float32Array(k.x.length);
+      for (let S = 0; S < k.x.length; S++)
+        R[S] = l + o.mapToRatio(k.x[S]) * z;
+      i._originalUpdateSeries && i._originalUpdateSeries(b, { x: R, y: k.y });
     }
-    t.syncView && typeof s.zoom == "function" && s.zoom({ x: [a, h], animate: !1 });
-  }
-  function i(t) {
-    const { render: s } = t, { ctx2d: o, plotArea: a } = s;
-    if (!(!o || !l))
-      for (const [h, g] of Object.entries(d.axes)) {
-        const m = h === "default" || h === "xAxis" ? "horizontal" : "vertical";
-        m === "horizontal" && g.breaks.forEach((S) => {
-          const y = l.transform(S.start), k = l.transform(S.end), z = (y + k) / 2, w = S.symbol || g.defaultSymbol || "diagonal";
-          o.save(), o.lineWidth = 1.5, o.strokeStyle = g.symbolColor || "#ff00ff", m === "horizontal" && (f(o, z, a.y, w, "top"), f(o, z, a.y + a.height, w, "bottom")), o.restore();
+    t.syncView && typeof i.zoom == "function" && i.zoom({ x: [l, p], animate: !1 });
+  }
+  function n(t) {
+    const { render: i } = t, { ctx2d: d, plotArea: l } = i;
+    if (!(!d || !o))
+      for (const [p, z] of Object.entries(s.axes)) {
+        const b = p === "default" || p === "xAxis" ? "horizontal" : "vertical";
+        b === "horizontal" && z.breaks.forEach((k) => {
+          const R = o.transform(k.start), S = o.transform(k.end), w = (R + S) / 2, y = k.symbol || z.defaultSymbol || "diagonal";
+          d.save(), d.lineWidth = 1.5, d.strokeStyle = z.symbolColor || "#ff00ff", b === "horizontal" && (h(d, w, l.y, y, "top"), h(d, w, l.y + l.height, y, "bottom")), d.restore();
         });
       }
   }
-  function f(t, s, o, a, h) {
-    t.beginPath(), a === "diagonal" ? (t.moveTo(s - 6, o + 6 / 2), t.lineTo(s + 6, o - 6 / 2), t.moveTo(s - 6 + 3, o + 6 / 2), t.lineTo(s + 6 + 3, o - 6 / 2)) : a === "zigzag" ? (t.moveTo(s - 6, o), t.lineTo(s - 6 / 2, o - 6 / 2), t.lineTo(s + 6 / 2, o + 6 / 2), t.lineTo(s + 6, o)) : h === "top" || h === "bottom" ? (t.moveTo(s - 6, o - 2), t.lineTo(s + 6, o + 2), t.moveTo(s - 6, o - 6), t.lineTo(s + 6, o - 2)) : (t.moveTo(s - 2, o - 6), t.lineTo(s + 2, o + 6)), t.stroke();
+  function h(t, i, d, l, p) {
+    t.beginPath(), l === "diagonal" ? (t.moveTo(i - 6, d + 6 / 2), t.lineTo(i + 6, d - 6 / 2), t.moveTo(i - 6 + 3, d + 6 / 2), t.lineTo(i + 6 + 3, d - 6 / 2)) : l === "zigzag" ? (t.moveTo(i - 6, d), t.lineTo(i - 6 / 2, d - 6 / 2), t.lineTo(i + 6 / 2, d + 6 / 2), t.lineTo(i + 6, d)) : p === "top" || p === "bottom" ? (t.moveTo(i - 6, d - 2), t.lineTo(i + 6, d + 2), t.moveTo(i - 6, d - 6), t.lineTo(i + 6, d - 2)) : (t.moveTo(i - 2, d - 6), t.lineTo(i + 2, d + 6)), t.stroke();
   }
   return {
-    manifest: B,
+    manifest: O,
     onInit(t) {
       e = t;
-      const s = e.chart;
-      s._originalUpdateSeries = s.updateSeries.bind(s), s._originalAddSeries = s.addSeries.bind(s), s._originalAppendData = s.appendData.bind(s);
-      const o = (a) => a instanceof Float32Array ? a : new Float32Array(typeof a == "number" ? [a] : a);
-      if (s.updateSeries = (a, h) => {
-        h.x && h.y && n.set(a, { x: o(h.x), y: o(h.y) }), d.enabled && l && h.x ? c({ syncView: !0 }) : s._originalUpdateSeries(a, h);
-      }, s.addSeries = (a) => {
-        var h, g, m;
-        a.id && ((h = a.data) != null && h.x) && ((g = a.data) != null && g.y) && n.set(a.id, { x: o(a.data.x), y: o(a.data.y) }), d.enabled && l && ((m = a.data) != null && m.x) ? (s._originalAddSeries(a), c({ syncView: !0 })) : s._originalAddSeries(a);
-      }, s.appendData = (a, h, g) => {
-        const m = n.get(a);
-        if (m) {
-          const S = o(h), y = o(g), k = new Float32Array(m.x.length + S.length), z = new Float32Array(m.y.length + y.length);
-          k.set(m.x), k.set(S, m.x.length), z.set(m.y), z.set(y, m.y.length), n.set(a, { x: k, y: z });
+      const i = e.chart;
+      i._originalUpdateSeries = i.updateSeries.bind(i), i._originalAddSeries = i.addSeries.bind(i), i._originalAppendData = i.appendData.bind(i);
+      const d = (l) => l instanceof Float32Array ? l : new Float32Array(typeof l == "number" ? [l] : l);
+      if (i.updateSeries = (l, p) => {
+        p.x && p.y && a.set(l, { x: d(p.x), y: d(p.y) }), s.enabled && o && p.x ? c({ syncView: !0 }) : i._originalUpdateSeries(l, p);
+      }, i.addSeries = (l) => {
+        var p, z, b;
+        l.id && ((p = l.data) != null && p.x) && ((z = l.data) != null && z.y) && a.set(l.id, { x: d(l.data.x), y: d(l.data.y) }), s.enabled && o && ((b = l.data) != null && b.x) ? (i._originalAddSeries(l), c({ syncView: !0 })) : i._originalAddSeries(l);
+      }, i.appendData = (l, p, z) => {
+        const b = a.get(l);
+        if (b) {
+          const k = d(p), R = d(z), S = new Float32Array(b.x.length + k.length), w = new Float32Array(b.y.length + R.length);
+          S.set(b.x), S.set(k, b.x.length), w.set(b.y), w.set(R, b.y.length), a.set(l, { x: S, y: w });
         }
-        d.enabled && l ? c({ syncView: !0 }) : s._originalAppendData(a, h, g);
-      }, d.enabled) {
-        r = s.xScale;
-        const a = d.axes.default || d.axes.xAxis;
-        l = new v(r, (a == null ? void 0 : a.breaks) || []), s.setXScale(l);
+        s.enabled && o ? c({ syncView: !0 }) : i._originalAppendData(l, p, z);
+      }, s.enabled) {
+        r = i.xScale;
+        const l = s.axes.default || s.axes.xAxis;
+        o = new A(r, (l == null ? void 0 : l.breaks) || []), i.setXScale(o);
       }
     },
     onDestroy() {
@@ -205,47 +247,51 @@ function _(d = { axes: {} }) {
         const t = e.chart;
         r && t.setXScale(r), t.updateSeries = t._originalUpdateSeries, t.addSeries = t._originalAddSeries, t.appendData = t._originalAppendData, delete t._originalUpdateSeries, delete t._originalAddSeries, delete t._originalAppendData;
       }
-      e = null, n.clear();
+      e = null, a.clear();
     },
     onRenderOverlay(t) {
-      d.enabled && i(t);
+      s.enabled && n(t);
+    },
+    onExportSVG(t) {
+      var i;
+      !s.enabled || !t.builder || ((i = t.exportContext) == null ? void 0 : i.options.includeOverlays) === !1 || _(t, s.axes);
     },
     onViewChange() {
     },
     api: {
-      addBreak(t, s) {
-        d.axes[t] || (d.axes[t] = { breaks: [] }), d.axes[t].breaks.push(s), u(), e == null || e.requestRender();
+      addBreak(t, i) {
+        s.axes[t] || (s.axes[t] = { breaks: [] }), s.axes[t].breaks.push(i), f(), e == null || e.requestRender();
       },
       clearBreaks(t) {
-        d.axes[t] && (d.axes[t].breaks = []), u(), e == null || e.requestRender();
+        s.axes[t] && (s.axes[t].breaks = []), f(), e == null || e.requestRender();
       },
       setEnabled(t) {
-        var o;
-        const s = d.enabled;
-        if (d.enabled = t, e && s !== t) {
-          const a = e.chart;
+        var d;
+        const i = s.enabled;
+        if (s.enabled = t, e && i !== t) {
+          const l = e.chart;
           if (t)
-            r = a.xScale, l = new v(r, ((o = d.axes.default || d.axes.xAxis) == null ? void 0 : o.breaks) || []), a.setXScale(l), c({ syncView: !0 });
+            r = l.xScale, o = new A(r, ((d = s.axes.default || s.axes.xAxis) == null ? void 0 : d.breaks) || []), l.setXScale(o), c({ syncView: !0 });
           else if (r) {
-            a.setXScale(r), l = null;
-            for (const [h, g] of n.entries())
-              a._originalUpdateSeries(h, g);
+            l.setXScale(r), o = null;
+            for (const [p, z] of a.entries())
+              l._originalUpdateSeries(p, z);
           }
         }
         e == null || e.requestRender();
       },
       getBreaks(t) {
-        var s;
-        return ((s = d.axes[t]) == null ? void 0 : s.breaks) || [];
+        var i;
+        return ((i = s.axes[t]) == null ? void 0 : i.breaks) || [];
       },
       updateConfig(t) {
-        Object.assign(d, t), u(), e == null || e.requestRender();
+        Object.assign(s, t), f(), e == null || e.requestRender();
       }
     }
   };
 }
 export {
-  _ as PluginBrokenAxis,
-  _ as default
+  L as PluginBrokenAxis,
+  L as default
 };
 //# sourceMappingURL=broken-axis.js.map