@hybridcore/ui 1.5.89 → 1.6.0

package/dist/AxisRenderer-DTyLLA6c.js

@@ -0,0 +1,3579 @@
+import { a as ye, n as T, B as we, r as C, u as ae, C as Y, G as I, b as ge, S as pe, E as me, D as Z, F as be, j as J, H as Pe, L as _e, k as G, l as z } from "./AnimatedTheme-jnasw6rT.js";
+import { C as re, u as Ae, b as k, a as B, f as v, z as ne, l as W, p as V, A as U, w as De, k as oe, r as j, e as M, B as le, D as he, P as ue, F as ce, G as de, x as fe, _ as N, m as F, h as Q, M as Me, H as ke } from "./ColorSet-C7vpNXhM.js";
+import { S as xe, T as ve } from "./Tick-2bcLyHpF.js";
+import { B as Se } from "./Button-CcsPEIDh.js";
+class Te extends ye {
+  setupDefaultRules() {
+    super.setupDefaultRules();
+    const e = this._root.interfaceColors, i = this._root.language, t = this.rule.bind(this);
+    t("XYChart").setAll({
+      colors: re.new(this._root, {}),
+      paddingLeft: 20,
+      paddingRight: 20,
+      paddingTop: 16,
+      paddingBottom: 16,
+      panX: !1,
+      panY: !1,
+      wheelStep: 0.25,
+      arrangeTooltips: !0,
+      pinchZoomX: !1,
+      pinchZoomY: !1
+    }), t("XYSeries").setAll({
+      legendLabelText: "{name}"
+    }), t("Rectangle", ["plotbackground", "xy", "background"]).setAll({
+      fill: Ae.fromHex(0),
+      fillOpacity: 0
+    }), t("XYChart", ["scrollbar", "chart"]).setAll({
+      paddingBottom: 0,
+      paddingLeft: 0,
+      paddingTop: 0,
+      paddingRight: 0,
+      colors: re.new(this._root, {
+        saturation: 0
+      })
+    });
+    {
+      const a = t("Graphics", ["scrollbar", "overlay"]);
+      a.setAll({
+        fillOpacity: 0.5
+      }), T(a, "fill", e, "background");
+    }
+    t("RoundedRectangle", ["xy", "scrollbar", "thumb"]).setAll({
+      cornerRadiusTR: 0,
+      cornerRadiusTL: 0,
+      cornerRadiusBR: 0,
+      cornerRadiusBL: 0,
+      fillOpacity: 0,
+      focusable: !0
+    }), t("RoundedRectangle", ["xy", "scrollbar", "thumb"]).states.create("hover", { fillOpacity: 0.4 }), t("RoundedRectangle", ["xy", "scrollbar", "chart", "background"]).setAll({
+      cornerRadiusTL: 0,
+      cornerRadiusBL: 0,
+      cornerRadiusTR: 0,
+      cornerRadiusBR: 0
+    }), t("RoundedRectangle", ["xy", "scrollbar", "chart", "background", "resize", "button"]).setAll({
+      cornerRadiusBL: 40,
+      cornerRadiusBR: 40,
+      cornerRadiusTL: 40,
+      cornerRadiusTR: 40
+    }), t("AxisRendererX", ["xy", "chart", "scrollbar"]).setAll({
+      strokeOpacity: 0,
+      inside: !0
+    }), t("AxisRendererY", ["xy", "chart", "scrollbar"]).setAll({
+      strokeOpacity: 0,
+      inside: !0,
+      minGridDistance: 5
+    }), t("AxisLabel", ["xy", "scrollbar", "x"]).setAll({
+      opacity: 0.5,
+      centerY: k,
+      minPosition: 0.01,
+      maxPosition: 0.99,
+      fontSize: "0.8em"
+    }), t("AxisLabel", ["category"]).setAll({
+      text: "{category}",
+      populateText: !0
+    }), t("AxisLabel", ["x"]).setAll({
+      centerY: 0
+    }), t("AxisLabel", ["x", "inside"]).setAll({
+      centerY: k
+    }), t("AxisLabel", ["x", "inside", "opposite"]).setAll({
+      centerY: 0
+    }), t("AxisLabel", ["x", "opposite"]).setAll({
+      centerY: k
+    }), t("AxisLabel", ["y"]).setAll({
+      centerX: k
+    }), t("AxisLabel", ["y", "inside"]).setAll({
+      centerX: 0
+    }), t("AxisLabel", ["y", "inside", "opposite"]).setAll({
+      centerX: k
+    }), t("AxisLabel", ["y", "opposite"]).setAll({
+      centerX: 0
+    }), t("AxisLabel", ["minor"]).setAll({
+      fontSize: "0.6em"
+    }), t("AxisLabel", ["xy", "scrollbar", "y"]).setAll({
+      visible: !1
+    }), t("Grid", ["xy", "scrollbar", "y"]).setAll({
+      visible: !1
+    }), t("Grid", ["xy", "scrollbar", "x"]).setAll({
+      opacity: 0.5
+    }), t("XYCursor").setAll({
+      behavior: "none",
+      layer: 30,
+      exportable: !1,
+      snapToSeriesBy: "xy",
+      moveThreshold: 1
+    });
+    {
+      const a = t("Grid", ["cursor", "x"]);
+      a.setAll({
+        forceInactive: !0,
+        strokeOpacity: 0.8,
+        strokeDasharray: [2, 2],
+        role: "slider",
+        ariaLabel: i.translate("Use left and right arrows to move selection")
+      }), T(a, "stroke", e, "alternativeBackground");
+    }
+    {
+      const a = t("Grid", ["cursor", "y"]);
+      a.setAll({
+        forceInactive: !0,
+        strokeOpacity: 0.8,
+        strokeDasharray: [2, 2],
+        role: "slider",
+        ariaLabel: i.translate("Use up and down arrows to move selection")
+      }), T(a, "stroke", e, "alternativeBackground");
+    }
+    {
+      const a = t("Graphics", ["cursor", "selection"]);
+      a.setAll({
+        fillOpacity: 0.15
+      }), T(a, "fill", e, "alternativeBackground");
+    }
+    t("Axis").setAll({
+      zoomOut: !0,
+      start: 0,
+      end: 1,
+      minZoomCount: 1,
+      maxZoomCount: 1 / 0,
+      maxZoomFactor: 1e3,
+      maxDeviation: 0.1,
+      snapTooltip: !0,
+      tooltipLocation: 0.5,
+      panX: !0,
+      panY: !0,
+      zoomX: !0,
+      zoomY: !0,
+      fixAxisSize: !0
+    }), t("AxisLabel").setAll({
+      location: 0.5,
+      multiLocation: 0,
+      centerX: B,
+      centerY: B,
+      paddingTop: 3,
+      paddingBottom: 3,
+      paddingLeft: 5,
+      paddingRight: 5
+    }), t("Container", ["axis", "header"]).setAll({
+      layer: 30
+    }), t("Rectangle", ["axis", "header", "background"]).setAll({
+      crisp: !0
+    });
+    {
+      const a = t("AxisRenderer");
+      a.setAll({
+        crisp: !0,
+        strokeOpacity: 0
+      }), T(a, "stroke", e, "grid");
+    }
+    t("AxisRendererX").setAll({
+      minGridDistance: 120,
+      opposite: !1,
+      inversed: !1,
+      cellStartLocation: 0,
+      cellEndLocation: 1,
+      width: k
+    }), t("AxisRendererY").setAll({
+      minGridDistance: 40,
+      opposite: !1,
+      inversed: !1,
+      cellStartLocation: 0,
+      cellEndLocation: 1,
+      height: k
+    });
+    {
+      const a = t("Rectangle", ["axis", "thumb", "zoomgrip"]);
+      a.setAll({
+        fillOpacity: 0
+      }), T(a, "fill", e, "alternativeBackground"), a.states.create("hover", { fillOpacity: 0.1 });
+    }
+    t("Rectangle", ["axis", "thumb", "x", "zoomgrip"]).setAll({
+      cursorOverStyle: "ew-resize"
+    }), t("Rectangle", ["axis", "thumb", "y", "zoomgrip"]).setAll({
+      cursorOverStyle: "ns-resize"
+    });
+    {
+      const a = t("Grid");
+      a.setAll({
+        location: 0,
+        strokeOpacity: 0.15,
+        crisp: !0
+      }), T(a, "stroke", e, "grid");
+    }
+    {
+      const a = t("Grid", ["minor"]);
+      a.setAll({
+        location: 0,
+        strokeOpacity: 0.07,
+        crisp: !0
+      }), T(a, "stroke", e, "grid");
+    }
+    t("Grid", ["base"]).setAll({
+      strokeOpacity: 0.3
+    });
+    {
+      const a = t("Graphics", ["axis", "fill"]);
+      a.setAll({
+        visible: !1,
+        isMeasured: !1,
+        position: "absolute",
+        fillOpacity: 0.05
+      }), T(a, "fill", e, "alternativeBackground");
+    }
+    t("Graphics", ["axis", "fill", "range"]).setAll({
+      isMeasured: !0
+    }), t("Graphics", ["series", "fill", "range"]).setAll({
+      visible: !1,
+      isMeasured: !0
+    }), t("Grid", ["series", "range"]).setAll({
+      visible: !1
+    }), t("AxisTick", ["series", "range"]).setAll({
+      visible: !1
+    }), t("AxisLabel", ["series", "range"]).setAll({
+      visible: !1
+    });
+    {
+      const a = t("AxisTick");
+      a.setAll({
+        location: 0.5,
+        multiLocation: 0,
+        strokeOpacity: 1,
+        isMeasured: !1,
+        position: "absolute",
+        visible: !1
+      }), T(a, "stroke", e, "grid");
+    }
+    t("CategoryAxis").setAll({
+      startLocation: 0,
+      endLocation: 1,
+      fillRule: (a, l) => {
+        const u = a.get("axisFill");
+        u && (!v(l) || l % 2 == 0 ? u.setPrivate("visible", !0) : u.setPrivate("visible", !1));
+      }
+    });
+    const s = [
+      { timeUnit: "millisecond", count: 1 },
+      { timeUnit: "millisecond", count: 5 },
+      { timeUnit: "millisecond", count: 10 },
+      { timeUnit: "millisecond", count: 50 },
+      { timeUnit: "millisecond", count: 100 },
+      { timeUnit: "millisecond", count: 500 },
+      { timeUnit: "second", count: 1 },
+      { timeUnit: "second", count: 5 },
+      { timeUnit: "second", count: 10 },
+      { timeUnit: "second", count: 30 },
+      { timeUnit: "minute", count: 1 },
+      { timeUnit: "minute", count: 5 },
+      { timeUnit: "minute", count: 10 },
+      { timeUnit: "minute", count: 15 },
+      { timeUnit: "minute", count: 30 },
+      { timeUnit: "hour", count: 1 },
+      { timeUnit: "hour", count: 3 },
+      { timeUnit: "hour", count: 6 },
+      { timeUnit: "hour", count: 12 },
+      { timeUnit: "day", count: 1 },
+      { timeUnit: "day", count: 2 },
+      { timeUnit: "day", count: 3 },
+      { timeUnit: "day", count: 4 },
+      { timeUnit: "day", count: 5 },
+      { timeUnit: "week", count: 1 },
+      { timeUnit: "month", count: 1 },
+      { timeUnit: "month", count: 2 },
+      { timeUnit: "month", count: 3 },
+      { timeUnit: "month", count: 6 },
+      { timeUnit: "year", count: 1 },
+      { timeUnit: "year", count: 2 },
+      { timeUnit: "year", count: 5 },
+      { timeUnit: "year", count: 10 },
+      { timeUnit: "year", count: 50 },
+      { timeUnit: "year", count: 100 },
+      { timeUnit: "year", count: 200 },
+      { timeUnit: "year", count: 500 },
+      { timeUnit: "year", count: 1e3 },
+      { timeUnit: "year", count: 2e3 },
+      { timeUnit: "year", count: 5e3 },
+      { timeUnit: "year", count: 1e4 },
+      { timeUnit: "year", count: 1e5 }
+    ], r = {
+      millisecond: i.translate("_date_millisecond"),
+      second: i.translate("_date_second"),
+      minute: i.translate("_date_minute"),
+      hour: i.translate("_date_hour"),
+      day: i.translate("_date_day"),
+      week: i.translate("_date_day"),
+      month: i.translate("_date_month"),
+      year: i.translate("_date_year")
+    }, h = {
+      millisecond: i.translate("_date_millisecond"),
+      second: i.translate("_date_second"),
+      minute: i.translate("_date_minute"),
+      hour: i.translate("_date_day"),
+      day: i.translate("_date_day"),
+      week: i.translate("_date_day"),
+      month: i.translate("_date_month") + " " + i.translate("_date_year"),
+      year: i.translate("_date_year")
+    }, o = {
+      millisecond: i.translate("_date_millisecond_full"),
+      second: i.translate("_date_second_full"),
+      minute: i.translate("_date_minute_full"),
+      hour: i.translate("_date_hour_full"),
+      day: i.translate("_date_day_full"),
+      week: i.translate("_date_week_full"),
+      month: i.translate("_date_month_full"),
+      year: i.translate("_date_year")
+    };
+    t("CategoryDateAxis").setAll({
+      markUnitChange: !0,
+      gridIntervals: ne(s),
+      dateFormats: W(r),
+      periodChangeDateFormats: W(h)
+    }), t("DateAxis").setAll({
+      maxZoomFactor: null,
+      strictMinMax: !0,
+      startLocation: 0,
+      endLocation: 1,
+      markUnitChange: !0,
+      groupData: !1,
+      groupCount: 500,
+      skipFirstMinor: !0,
+      weekLabelLocation: 0,
+      gridIntervals: ne(s),
+      dateFormats: W(r),
+      periodChangeDateFormats: W(h),
+      tooltipDateFormats: o,
+      groupIntervals: [
+        { timeUnit: "millisecond", count: 1 },
+        { timeUnit: "millisecond", count: 10 },
+        { timeUnit: "millisecond", count: 100 },
+        { timeUnit: "second", count: 1 },
+        { timeUnit: "second", count: 10 },
+        { timeUnit: "minute", count: 1 },
+        { timeUnit: "minute", count: 10 },
+        { timeUnit: "hour", count: 1 },
+        { timeUnit: "day", count: 1 },
+        { timeUnit: "week", count: 1 },
+        { timeUnit: "month", count: 1 },
+        { timeUnit: "year", count: 1 }
+      ],
+      fillRule: (a) => {
+        const l = a.get("axisFill");
+        if (l) {
+          const u = a.component, n = a.get("value"), d = a.get("endValue"), c = u.intervalDuration(), m = u.getPrivate("baseInterval"), g = u.getPrivate("gridInterval", m);
+          let p = u.getPrivate("min", 0);
+          if (p = we(new Date(p), g.timeUnit, g.count, this._root.locale.firstDayOfWeek, this._root.utc, void 0, this._root.timezone).getTime(), n != null && d != null) {
+            const f = Math.round(Math.round((n - p) / c)) / 2;
+            f == Math.round(f) ? l.setPrivate("visible", !0) : l.setPrivate("visible", !1);
+          }
+        }
+      }
+    }), t("GaplessDateAxis").setAll({
+      fillRule: (a) => {
+        const l = a.get("axisFill");
+        if (l) {
+          const u = a.get("index");
+          let n = !1;
+          (!v(u) || u % 2 == 0) && (n = !0), l.setPrivate("visible", n);
+        }
+      }
+    }), t("ValueAxis").setAll({
+      baseValue: 0,
+      logarithmic: !1,
+      strictMinMax: !1,
+      autoZoom: !0,
+      fillRule: (a) => {
+        const l = a.get("axisFill");
+        if (l) {
+          const u = a.component, n = a.get("value"), d = u.getPrivate("step");
+          v(n) && v(d) && (C(n / d / 2, 5) == Math.round(n / d / 2) ? l.setPrivate("visible", !1) : l.setPrivate("visible", !0));
+        }
+      }
+    }), t("DurationAxis").setAll({
+      baseUnit: "second"
+    }), t("XYSeries").setAll({
+      maskBullets: !0,
+      stackToNegative: !0,
+      locationX: 0.5,
+      locationY: 0.5,
+      snapTooltip: !1,
+      openValueXGrouped: "open",
+      openValueYGrouped: "open",
+      valueXGrouped: "close",
+      valueYGrouped: "close",
+      seriesTooltipTarget: "series"
+    }), t("BaseColumnSeries").setAll({
+      adjustBulletPosition: !0
+    }), t("ColumnSeries").setAll({
+      clustered: !0
+    }), t("RoundedRectangle", ["series", "column"]).setAll({
+      position: "absolute",
+      isMeasured: !1,
+      width: V(70),
+      height: V(70),
+      strokeWidth: 1,
+      strokeOpacity: 1,
+      cornerRadiusBL: 0,
+      cornerRadiusTL: 0,
+      cornerRadiusBR: 0,
+      cornerRadiusTR: 0,
+      fillOpacity: 1,
+      role: "figure"
+    }), t("LineSeries").setAll({
+      connect: !0,
+      autoGapCount: 1.1,
+      stackToNegative: !1
+    }), t("Graphics", ["series", "stroke"]).setAll({
+      position: "absolute",
+      strokeWidth: 1,
+      strokeOpacity: 1,
+      isMeasured: !1
+    }), t("Graphics", ["series", "fill"]).setAll({
+      visible: !1,
+      fillOpacity: 0,
+      position: "absolute",
+      strokeWidth: 0,
+      strokeOpacity: 0,
+      isMeasured: !1
+    }), t("Graphics", ["line", "series", "legend", "marker", "stroke"]).setAll({
+      draw: (a, l) => {
+        const u = l.parent;
+        if (u) {
+          const n = u.height(), d = u.width();
+          a.moveTo(0, n / 2), a.lineTo(d, n / 2);
+        }
+      }
+    });
+    {
+      const a = t("Graphics", ["line", "series", "legend", "marker", "stroke"]).states.create("disabled", {});
+      T(a, "stroke", e, "disabled");
+    }
+    t("Graphics", ["line", "series", "legend", "marker", "fill"]).setAll({
+      draw: (a, l) => {
+        const u = l.parent;
+        if (u) {
+          const n = u.height(), d = u.width();
+          a.moveTo(0, 0), a.lineTo(d, 0), a.lineTo(d, n), a.lineTo(0, n), a.lineTo(0, 0);
+        }
+      }
+    });
+    {
+      const a = t("Graphics", ["line", "series", "legend", "marker", "fill"]).states.create("disabled", {});
+      T(a, "stroke", e, "disabled");
+    }
+    t("SmoothedXYLineSeries").setAll({
+      tension: 0.5
+    }), t("SmoothedXLineSeries").setAll({
+      tension: 0.5
+    }), t("SmoothedYLineSeries").setAll({
+      tension: 0.5
+    }), t("Candlestick").setAll({
+      position: "absolute",
+      isMeasured: !1,
+      width: V(50),
+      height: V(50),
+      strokeWidth: 1,
+      strokeOpacity: 1,
+      cornerRadiusBL: 0,
+      cornerRadiusTL: 0,
+      cornerRadiusBR: 0,
+      cornerRadiusTR: 0,
+      fillOpacity: 1,
+      role: "figure"
+    }), t("OHLC").setAll({
+      width: V(80),
+      height: V(80)
+    }), t("CandlestickSeries").setAll({
+      lowValueXGrouped: "low",
+      lowValueYGrouped: "low",
+      highValueXGrouped: "high",
+      highValueYGrouped: "high",
+      openValueXGrouped: "open",
+      openValueYGrouped: "open",
+      valueXGrouped: "close",
+      valueYGrouped: "close"
+    });
+    {
+      const a = t("Rectangle", ["column", "autocolor"]).states.create("riseFromOpen", {});
+      T(a, "fill", e, "positive"), T(a, "stroke", e, "positive");
+    }
+    {
+      const a = t("Rectangle", ["column", "autocolor"]).states.create("dropFromOpen", {});
+      T(a, "fill", e, "negative"), T(a, "stroke", e, "negative");
+    }
+    t("Rectangle", ["column", "autocolor", "pro"]).states.create("riseFromOpen", { fillOpacity: 0 }), t("Rectangle", ["column", "autocolor", "pro"]).states.create("dropFromOpen", { fillOpacity: 1 });
+    {
+      const a = t("Rectangle", ["column", "autocolor", "pro"]).states.create("riseFromPrevious", {});
+      T(a, "fill", e, "positive"), T(a, "stroke", e, "positive");
+    }
+    {
+      const a = t("Rectangle", ["column", "autocolor", "pro"]).states.create("dropFromPrevious", {});
+      T(a, "fill", e, "negative"), T(a, "stroke", e, "negative");
+    }
+    t("RoundedRectangle", ["rangegrip"]).setAll({
+      strokeOpacity: 0,
+      fillOpacity: 0,
+      strokeWidth: 1,
+      width: 12,
+      height: 12
+    });
+    {
+      const a = t("Graphics", ["rangegrip", "button", "icon"]);
+      a.setAll({
+        interactive: !1,
+        crisp: !0,
+        strokeOpacity: 0.5,
+        draw: (l) => {
+          l.moveTo(0, 0.5), l.lineTo(0, 12.5), l.moveTo(2, 0.5), l.lineTo(2, 12.5), l.moveTo(4, 0.5), l.lineTo(4, 12.5);
+        }
+      }), T(a, "stroke", e, "secondaryButtonText");
+    }
+    t("Button", ["rangegrip"]).setAll({
+      draggable: !0,
+      paddingTop: 0,
+      paddingBottom: 0
+    }), t("Button", ["rangegrip", "vertical"]).setAll({
+      rotation: 90,
+      cursorOverStyle: "ns-resize",
+      centerX: B
+    }), t("Button", ["rangegrip", "horizontal"]).setAll({
+      cursorOverStyle: "ew-resize",
+      centerX: B
+    }), t("Button", ["rangegrip", "vertical", "left"]).setAll({
+      centerY: k
+    }), t("Button", ["rangegrip", "vertical", "right"]).setAll({
+      centerY: 0
+    }), t("Button", ["rangegrip", "horizontal", "top"]).setAll({
+      centerY: 0
+    }), t("Button", ["rangegrip", "horizontal", "bottom"]).setAll({
+      centerY: k
+    });
+  }
+}
+class ee extends xe {
+  constructor() {
+    super(...arguments), Object.defineProperty(this, "xAxes", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: new ae()
+    }), Object.defineProperty(this, "yAxes", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: new ae()
+    }), Object.defineProperty(this, "topAxesContainer", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: this.chartContainer.children.push(Y.new(this._root, { width: k, layout: this._root.verticalLayout }))
+    }), Object.defineProperty(this, "yAxesAndPlotContainer", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: this.chartContainer.children.push(Y.new(this._root, { width: k, height: k, layout: this._root.horizontalLayout }))
+    }), Object.defineProperty(this, "bottomAxesContainer", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: this.chartContainer.children.push(Y.new(this._root, { width: k, layout: this._root.verticalLayout }))
+    }), Object.defineProperty(this, "leftAxesContainer", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: this.yAxesAndPlotContainer.children.push(Y.new(this._root, { height: k, layout: this._root.horizontalLayout }))
+    }), Object.defineProperty(this, "plotsContainer", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: this.yAxesAndPlotContainer.children.push(Y.new(this._root, { width: k, height: k, maskContent: !1 }))
+    }), Object.defineProperty(this, "plotContainer", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: this.plotsContainer.children.push(Y.new(this._root, { width: k, height: k }))
+    }), Object.defineProperty(this, "topPlotContainer", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: this.plotsContainer.children.push(Y.new(this._root, { width: k, height: k }))
+    }), Object.defineProperty(this, "gridContainer", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: this.plotContainer.children.push(Y.new(this._root, { width: k, height: k, isMeasured: !1 }))
+    }), Object.defineProperty(this, "topGridContainer", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: Y.new(this._root, { width: k, height: k, isMeasured: !1 })
+    }), Object.defineProperty(this, "rightAxesContainer", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: this.yAxesAndPlotContainer.children.push(Y.new(this._root, { height: k, layout: this._root.horizontalLayout }))
+    }), Object.defineProperty(this, "axisHeadersContainer", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: this.plotContainer.children.push(Y.new(this._root, {}))
+    }), Object.defineProperty(this, "zoomOutButton", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: this.topPlotContainer.children.push(Se.new(this._root, {
+        themeTags: ["zoom"],
+        icon: I.new(this._root, {
+          themeTags: ["button", "icon"]
+        })
+      }))
+    }), Object.defineProperty(this, "_movePoint", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: { x: 0, y: 0 }
+    }), Object.defineProperty(this, "_wheelDp", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_otherCharts", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_movePoints", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: {}
+    }), Object.defineProperty(this, "_downStartX", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_downEndX", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_downStartY", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_downEndY", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    });
+  }
+  _afterNew() {
+    this._defaultThemes.push(Te.new(this._root)), super._afterNew(), this._disposers.push(this.xAxes), this._disposers.push(this.yAxes);
+    const e = this._root;
+    let i = this._root.verticalLayout;
+    const t = this.zoomOutButton;
+    t.events.on("click", () => {
+      this.zoomOut();
+    }), t.hide(0), t.states.lookup("default").set("opacity", 1), this.chartContainer.set("layout", i);
+    const s = this.plotContainer;
+    s.children.push(this.seriesContainer), this._disposers.push(this._processAxis(this.xAxes, this.bottomAxesContainer)), this._disposers.push(this._processAxis(this.yAxes, this.leftAxesContainer)), s.children.push(this.topGridContainer), s.children.push(this.bulletsContainer), s.set("interactive", !0), s.set("interactiveChildren", !1), s.set("background", ge.new(e, {
+      themeTags: ["plotbackground", "xy", "background"]
+    })), this._disposers.push(s.events.on("pointerdown", (r) => {
+      this._handlePlotDown(r);
+    })), this._disposers.push(s.events.on("globalpointerup", (r) => {
+      this._handlePlotUp(r);
+    })), this._disposers.push(s.events.on("globalpointermove", (r) => {
+      this._handlePlotMove(r);
+    })), this._maskGrid(), this._setUpTouch();
+  }
+  _beforeChanged() {
+    super._beforeChanged(), (this.isDirty("pinchZoomX") || this.isDirty("pinchZoomY") || this.get("panX") || this.get("panY")) && this._setUpTouch();
+  }
+  _setUpTouch() {
+    this.plotContainer._display.cancelTouch || (this.plotContainer._display.cancelTouch = !!(this.get("pinchZoomX") || this.get("pinchZoomY") || this.get("panX") || this.get("panY")));
+  }
+  _maskGrid() {
+    this.gridContainer.set("maskContent", !0), this.topGridContainer.set("maskContent", !0);
+  }
+  _removeSeries(e) {
+    e._unstack(), e._posXDp && e._posXDp.dispose(), e._posYDp && e._posYDp.dispose(), e.set("baseAxis", void 0);
+    const i = e.get("xAxis");
+    i && (U(i.series, e), i.markDirtyExtremes());
+    const t = e.get("yAxis");
+    t && (U(t.series, e), t.markDirtyExtremes());
+    const s = this.get("cursor");
+    if (s) {
+      const r = s.get("snapToSeries");
+      r && U(r, e);
+    }
+    super._removeSeries(e);
+  }
+  /**
+   * This method is invoked when mouse wheel is used over chart's plot
+   * container, and handles zooming/pan.
+   *
+   * You can invoke this method manually, if you need to mimic chart's wheel
+   * behavior over other elements of the chart.
+   */
+  handleWheel(e) {
+    const i = this.get("wheelX"), t = this.get("wheelY"), s = this.plotContainer, r = e.originalEvent;
+    let h = !1;
+    if (De(r, this))
+      h = !0;
+    else
+      return;
+    const o = s.toLocal(e.point), a = this.get("wheelStep", 0.2), l = r.deltaY / 100, u = r.deltaX / 100, n = this.get("wheelZoomPositionX"), d = this.get("wheelZoomPositionY");
+    (i === "zoomX" || i === "zoomXY") && u != 0 && this.xAxes.each((c) => {
+      if (c.get("zoomX")) {
+        let m = c.get("start"), g = c.get("end"), p = c.fixPosition(o.x / s.width());
+        n != null && (p = n);
+        let f = c.get("maxDeviation", 0), _ = Math.min(1 + f, Math.max(-f, m - a * (g - m) * u * p)), x = Math.max(-f, Math.min(1 + f, g + a * (g - m) * u * (1 - p)));
+        _ == m && x == g && (h = !1), 1 / (x - _) < c.getPrivate("maxZoomFactor", 1 / 0) / c.get("minZoomCount", 1) ? this._handleWheelAnimation(c.zoom(_, x)) : h = !1;
+      }
+    }), (t === "zoomX" || t === "zoomXY") && l != 0 && this.xAxes.each((c) => {
+      if (c.get("zoomX")) {
+        let m = c.get("start"), g = c.get("end"), p = c.fixPosition(o.x / s.width());
+        n != null && (p = n);
+        let f = c.get("maxDeviation", 0), _ = Math.min(1 + f, Math.max(-f, m - a * (g - m) * l * p)), x = Math.max(-f, Math.min(1 + f, g + a * (g - m) * l * (1 - p)));
+        _ == m && x == g && (h = !1), 1 / (x - _) < c.getPrivate("maxZoomFactor", 1 / 0) / c.get("minZoomCount", 1) ? this._handleWheelAnimation(c.zoom(_, x)) : h = !1;
+      }
+    }), (i === "zoomY" || i === "zoomXY") && u != 0 && this.yAxes.each((c) => {
+      if (c.get("zoomY")) {
+        let m = c.get("start"), g = c.get("end"), p = c.fixPosition(o.y / s.height());
+        d != null && (p = d);
+        let f = c.get("maxDeviation", 0), _ = Math.min(1 + f, Math.max(-f, m - a * (g - m) * u * p)), x = Math.max(-f, Math.min(1 + f, g + a * (g - m) * u * (1 - p)));
+        _ == m && x == g && (h = !1), 1 / (x - _) < c.getPrivate("maxZoomFactor", 1 / 0) / c.get("minZoomCount", 1) ? this._handleWheelAnimation(c.zoom(_, x)) : h = !1;
+      }
+    }), (t === "zoomY" || t === "zoomXY") && l != 0 && this.yAxes.each((c) => {
+      if (c.get("zoomY")) {
+        let m = c.get("start"), g = c.get("end"), p = c.fixPosition(o.y / s.height());
+        d != null && (p = d);
+        let f = c.get("maxDeviation", 0), _ = Math.min(1 + f, Math.max(-f, m - a * (g - m) * l * p)), x = Math.max(-f, Math.min(1 + f, g + a * (g - m) * l * (1 - p)));
+        _ == m && x == g && (h = !1), 1 / (x - _) < c.getPrivate("maxZoomFactor", 1 / 0) / c.get("minZoomCount", 1) ? this._handleWheelAnimation(c.zoom(_, x)) : h = !1;
+      }
+    }), (i === "panX" || i === "panXY") && u != 0 && this.xAxes.each((c) => {
+      if (c.get("panX")) {
+        let m = c.get("start"), g = c.get("end"), p = this._getWheelSign(c) * a * (g - m) * u, f = m + p, _ = g + p, x = this._fixWheel(f, _);
+        f = x[0], _ = x[1], f == m && _ == g && (h = !1), this._handleWheelAnimation(c.zoom(f, _));
+      }
+    }), (t === "panX" || t === "panXY") && l != 0 && this.xAxes.each((c) => {
+      if (c.get("panX")) {
+        let m = c.get("start"), g = c.get("end"), p = this._getWheelSign(c) * a * (g - m) * l, f = m + p, _ = g + p, x = this._fixWheel(f, _);
+        f = x[0], _ = x[1], f == m && _ == g && (h = !1), this._handleWheelAnimation(c.zoom(f, _));
+      }
+    }), (i === "panY" || i === "panXY") && u != 0 && this.yAxes.each((c) => {
+      if (c.get("panY")) {
+        let m = c.get("start"), g = c.get("end"), p = this._getWheelSign(c) * a * (g - m) * u, f = m + p, _ = g + p, x = this._fixWheel(f, _);
+        f = x[0], _ = x[1], f == m && _ == g && (h = !1), this._handleWheelAnimation(c.zoom(f, _));
+      }
+    }), (t === "panY" || t === "panXY") && l != 0 && this.yAxes.each((c) => {
+      if (c.get("panY")) {
+        let m = c.get("start"), g = c.get("end"), p = this._getWheelSign(c) * a * (g - m) * l, f = m - p, _ = g - p, x = this._fixWheel(f, _);
+        f = x[0], _ = x[1], f == m && _ == g && (h = !1), this._handleWheelAnimation(c.zoom(f, _));
+      }
+    }), h && r.preventDefault();
+  }
+  _handleSetWheel() {
+    const e = this.get("wheelX"), i = this.get("wheelY"), t = this.plotContainer;
+    e !== "none" || i !== "none" ? (this._wheelDp = t.events.on("wheel", (s) => {
+      const r = s.originalEvent;
+      (e !== "none" && Math.abs(r.deltaX) != 0 || i !== "none" && Math.abs(r.deltaY) != 0) && this.handleWheel(s);
+    }), this._disposers.push(this._wheelDp)) : this._wheelDp && this._wheelDp.dispose();
+  }
+  _getWheelSign(e) {
+    let i = 1;
+    return e.get("renderer").get("inversed") && (i = -1), i;
+  }
+  _fixWheel(e, i) {
+    const t = i - e;
+    return e < 0 && (e = 0, i = e + t), i > 1 && (i = 1, e = i - t), [e, i];
+  }
+  _handlePlotDown(e) {
+    const i = e.originalEvent;
+    if (i.button == 2)
+      return;
+    const t = this.plotContainer;
+    let s = t.toLocal(e.point);
+    if ((this.get("pinchZoomX") || this.get("pinchZoomY")) && i.pointerId && oe(t._downPoints).length > 0) {
+      const h = this.xAxes.getIndex(0), o = this.yAxes.getIndex(0);
+      h && (this._downStartX = h.get("start", 0), this._downEndX = h.get("end", 1)), o && (this._downStartY = o.get("start", 0), this._downEndY = o.get("end", 1));
+    }
+    if ((this.get("panX") || this.get("panY")) && s.x >= 0 && s.y >= 0 && s.x <= t.width() && s.y <= this.height()) {
+      this._downPoint = { x: i.clientX, y: i.clientY };
+      const r = this.get("panX"), h = this.get("panY");
+      r && this.xAxes.each((a) => {
+        a._panStart = a.get("start"), a._panEnd = a.get("end");
+      }), h && this.yAxes.each((a) => {
+        a._panStart = a.get("start"), a._panEnd = a.get("end");
+      });
+      const o = "panstarted";
+      this.events.isEnabled(o) && this.events.dispatch(o, { type: o, target: this, originalEvent: e.originalEvent });
+    }
+  }
+  _handleWheelAnimation(e) {
+    e ? e.events.on("stopped", () => {
+      this._dispatchWheelAnimation();
+    }) : this._dispatchWheelAnimation();
+  }
+  _dispatchWheelAnimation() {
+    const e = "wheelended";
+    this.events.isEnabled(e) && this.events.dispatch(e, { type: e, target: this });
+  }
+  _handlePlotUp(e) {
+    const i = this._downPoint;
+    if (i && (this.get("panX") || this.get("panY"))) {
+      if (e.originalEvent.clientX == i.x && e.originalEvent.clientY == i.y) {
+        const s = "pancancelled";
+        this.events.isEnabled(s) && this.events.dispatch(s, { type: s, target: this, originalEvent: e.originalEvent });
+      }
+      const t = "panended";
+      this.events.isEnabled(t) && this.events.dispatch(t, { type: t, target: this, originalEvent: e.originalEvent });
+    }
+    this._downPoint = void 0, this.xAxes.each((t) => {
+      t._isPanning = !1;
+    }), this.yAxes.each((t) => {
+      t._isPanning = !1;
+    });
+  }
+  _handlePlotMove(e) {
+    const i = this.plotContainer;
+    if (this.get("pinchZoomX") || this.get("pinchZoomY")) {
+      const r = e.originalEvent.pointerId;
+      if (r && (this._movePoints[r] = e.point, oe(i._downPoints).length > 1)) {
+        this._handlePinch();
+        return;
+      }
+    }
+    let t = this._downPoint;
+    if (t) {
+      t = i.toLocal(this._root.documentPointToRoot(t));
+      let s = i.toLocal(e.point);
+      const r = this.get("panX"), h = this.get("panY");
+      if (r) {
+        let o = this.get("scrollbarX");
+        o && o.events.disableType("rangechanged"), this.xAxes.each((a) => {
+          if (a.get("panX")) {
+            a._isPanning = !0;
+            let l = a._panStart, u = a._panEnd, d = (u - l) * (t.x - s.x) / i.width();
+            a.get("renderer").get("inversed") && (d *= -1);
+            let c = l + d, m = u + d;
+            m - c < 1 + a.get("maxDeviation", 1) * 2 && (a.set("start", c), a.set("end", m));
+          }
+        }), o && o.events.enableType("rangechanged");
+      }
+      if (h) {
+        let o = this.get("scrollbarY");
+        o && o.events.disableType("rangechanged"), this.yAxes.each((a) => {
+          if (a.get("panY")) {
+            a._isPanning = !0;
+            let l = a._panStart, u = a._panEnd, d = (u - l) * (t.y - s.y) / i.height();
+            a.get("renderer").get("inversed") && (d *= -1);
+            let c = l - d, m = u - d;
+            m - c < 1 + a.get("maxDeviation", 1) * 2 && (a.set("start", c), a.set("end", m));
+          }
+        }), o && o.events.enableType("rangechanged");
+      }
+    }
+  }
+  _handlePinch() {
+    const e = this.plotContainer;
+    let i = 0, t = [], s = [];
+    if (j(e._downPoints, (r, h) => {
+      t[i] = h;
+      let o = this._movePoints[r];
+      o && (s[i] = o), i++;
+    }), t.length > 1 && s.length > 1) {
+      const r = e.width(), h = e.height();
+      let o = t[0], a = t[1], l = s[0], u = s[1];
+      if (o && a && l && u) {
+        if (l = e.toLocal(l), u = e.toLocal(u), o = e.toLocal(o), a = e.toLocal(a), this.get("pinchZoomX")) {
+          const n = this._downStartX, d = this._downEndX;
+          if (n != null && d != null) {
+            o.x > a.x && ([o, a] = [a, o], [l, u] = [u, l]);
+            let c = n + o.x / r * (d - n), m = n + a.x / r * (d - n), g = n + l.x / r * (d - n), p = n + u.x / r * (d - n), f = Math.max(1e-3, m - c), _ = Math.max(1e-3, p - g), x = f / _, b = n * x + c - g * x, P = d * x + m - p * x;
+            this.xAxes.each((y) => {
+              let A = y.fixPosition(b), w = y.fixPosition(P);
+              y.zoom(A, w, 0);
+            });
+          }
+        }
+        if (this.get("pinchZoomY")) {
+          const n = this._downStartY, d = this._downEndY;
+          if (n != null && d != null) {
+            o.y < a.y && ([o, a] = [a, o], [l, u] = [u, l]);
+            let c = n + (1 - o.y / h) * (d - n), m = n + (1 - a.y / h) * (d - n), g = n + (1 - l.y / h) * (d - n), p = n + (1 - u.y / h) * (d - n), f = Math.max(1e-3, m - c), _ = Math.max(1e-3, p - g), x = f / _, b = n * x + c - g * x, P = d * x + m - p * x;
+            this.yAxes.each((y) => {
+              let A = y.fixPosition(b), w = y.fixPosition(P);
+              y.zoom(A, w, 0);
+            });
+          }
+        }
+      }
+    }
+  }
+  _handleCursorPosition() {
+    const e = this.get("cursor");
+    if (e) {
+      const i = e.getPrivate("point");
+      let t = e.get("snapToSeries");
+      if (e._downPoint && (t = void 0), t && i) {
+        const s = e.get("snapToSeriesBy"), r = [];
+        M(t, (a) => {
+          if (!a.isHidden() && !a.isHiding())
+            if (s != "x!" && s != "y!") {
+              const l = a.startIndex(), u = a.endIndex();
+              for (let n = l; n < u; n++) {
+                const d = a.dataItems[n];
+                d && !d.isHidden() && r.push(d);
+              }
+            } else {
+              const l = a.get("tooltipDataItem");
+              l && r.push(l);
+            }
+        });
+        let h = 1 / 0, o;
+        if (M(r, (a) => {
+          const l = a.get("point");
+          if (l) {
+            let u = 0;
+            s == "x" || s == "x!" ? u = Math.abs(i.x - l.x) : s == "y" || s == "y!" ? u = Math.abs(i.y - l.y) : u = Math.hypot(i.x - l.x, i.y - l.y), u < h && (h = u, o = a);
+          }
+        }), M(t, (a) => {
+          const l = a.get("tooltip");
+          l && l._setDataItem(void 0);
+        }), o) {
+          let a = o.component;
+          a.showDataItemTooltip(o), a.setRaw("tooltipDataItem", o);
+          const l = o.get("point");
+          l && e.handleMove(a.toGlobal({ x: l.x - a.x(), y: l.y - a.y() }), !0);
+        }
+      }
+    }
+  }
+  _updateCursor() {
+    let e = this.get("cursor");
+    e && e.updateCursor();
+  }
+  _addCursor(e) {
+    this.plotContainer.children.push(e);
+  }
+  _prepareChildren() {
+    if (super._prepareChildren(), this.series.each((e) => {
+      this._colorize(e);
+    }), (this.isDirty("wheelX") || this.isDirty("wheelY")) && this._handleSetWheel(), this.isDirty("cursor")) {
+      const e = this._prevSettings.cursor, i = this.get("cursor");
+      i !== e && (this._disposeProperty("cursor"), e && e.dispose(), i && (i._setChart(this), this._addCursor(i), this._pushPropertyDisposer("cursor", i.events.on("selectended", () => {
+        this._handleCursorSelectEnd();
+      }))), this._prevSettings.cursor = i);
+    }
+    if (this.isDirty("scrollbarX")) {
+      const e = this._prevSettings.scrollbarX, i = this.get("scrollbarX");
+      i !== e && (this._disposeProperty("scrollbarX"), e && e.dispose(), i && (i.parent || this.topAxesContainer.children.push(i), this._pushPropertyDisposer("scrollbarX", i.events.on("rangechanged", (t) => {
+        this._handleScrollbar(this.xAxes, t.start, t.end, t.grip);
+      })), this._pushPropertyDisposer("scrollbarX", i.events.on("released", () => {
+        this.xAxes.each((t) => {
+          t.get("zoomable") && this._handleAxisSelection(t);
+        });
+      })), i.setPrivate("positionTextFunction", (t) => {
+        const s = this.xAxes.getIndex(0);
+        return s && s.getTooltipText(t, !1) || "";
+      })), this._prevSettings.scrollbarX = i);
+    }
+    if (this.isDirty("scrollbarY")) {
+      const e = this._prevSettings.scrollbarY, i = this.get("scrollbarY");
+      i !== e && (this._disposeProperty("scrollbarY"), e && e.dispose(), i && (i.parent || this.rightAxesContainer.children.push(i), this._pushPropertyDisposer("scrollbarY", i.events.on("rangechanged", (t) => {
+        this._handleScrollbar(this.yAxes, t.start, t.end, t.grip);
+      })), this._pushPropertyDisposer("scrollbarY", i.events.on("released", () => {
+        this.yAxes.each((t) => {
+          t.get("zoomable") && this._handleAxisSelection(t);
+        });
+      })), i.setPrivate("positionTextFunction", (t) => {
+        const s = this.yAxes.getIndex(0);
+        return s && s.getTooltipText(t, !1) || "";
+      })), this._prevSettings.scrollbarY = i);
+    }
+    this._handleZoomOut();
+  }
+  _processSeries(e) {
+    super._processSeries(e);
+    const i = e.get("xAxis"), t = e.get("yAxis");
+    le(i.series, e), le(t.series, e), e._posXDp = e.addDisposer(i.events.on("positionchanged", () => {
+      e._fixPosition();
+    })), e._posXDp = e.addDisposer(t.events.on("positionchanged", () => {
+      e._fixPosition();
+    })), e.get("baseAxis") || (t.isType("CategoryAxis") || t.isType("DateAxis") ? e.set("baseAxis", t) : e.set("baseAxis", i)), e.get("stacked") && (e._markDirtyKey("stacked"), M(e.dataItems, (s) => {
+      s.set("stackToItemY", void 0), s.set("stackToItemX", void 0);
+    })), e._markDirtyAxes(), t.markDirtyExtremes(), i.markDirtyExtremes(), i._seriesAdded = !0, t._seriesAdded = !0, this._colorize(e);
+  }
+  _colorize(e) {
+    const i = this.get("colors");
+    if (i && e.get("fill") == null) {
+      const s = i.next();
+      e._setSoft("stroke", s), e._setSoft("fill", s);
+    }
+    const t = this.get("patterns");
+    if (t && e.get("fillPattern") == null) {
+      const s = t.next();
+      e._setSoft("fillPattern", s);
+    }
+  }
+  _handleCursorSelectEnd() {
+    const e = this.get("cursor"), i = e.get("behavior"), t = e.getPrivate("downPositionX", 0), s = e.getPrivate("downPositionY", 0), r = Math.min(1, Math.max(0, e.getPrivate("positionX", 0.5))), h = Math.min(1, Math.max(0, e.getPrivate("positionY", 0.5)));
+    this.xAxes.each((o) => {
+      if (i === "zoomX" || i === "zoomXY") {
+        let a = o.toAxisPosition(t), l = o.toAxisPosition(r);
+        o.zoom(a, l);
+      }
+      o.setPrivate("updateScrollbar", !0);
+    }), this.yAxes.each((o) => {
+      if (i === "zoomY" || i === "zoomXY") {
+        let a = o.toAxisPosition(s), l = o.toAxisPosition(h);
+        o.zoom(a, l);
+      }
+      o.setPrivate("updateScrollbar", !0);
+    });
+  }
+  _handleScrollbar(e, i, t, s) {
+    e.each((r) => {
+      let h = r.fixPosition(i), o = r.fixPosition(t), a = r.zoom(h, o, void 0, s);
+      const l = "updateScrollbar";
+      r.setPrivateRaw(l, !1), a ? a.events.on("stopped", () => {
+        r.setPrivateRaw(l, !0);
+      }) : r.setPrivateRaw(l, !0);
+    });
+  }
+  _processAxis(e, i) {
+    return e.events.onAll((t) => {
+      if (t.type === "clear")
+        M(t.oldValues, (s) => {
+          this._removeAxis(s);
+        });
+      else if (t.type === "push")
+        i.children.push(t.newValue), t.newValue.processChart(this);
+      else if (t.type === "setIndex")
+        i.children.setIndex(t.index, t.newValue), t.newValue.processChart(this);
+      else if (t.type === "insertIndex")
+        i.children.insertIndex(t.index, t.newValue), t.newValue.processChart(this);
+      else if (t.type === "removeIndex")
+        this._removeAxis(t.oldValue);
+      else if (t.type === "moveIndex")
+        i.children.moveValue(t.value, t.newIndex), t.value.processChart(this);
+      else
+        throw new Error("Unknown IListEvent type");
+    });
+  }
+  _removeAxis(e) {
+    if (!e.isDisposed()) {
+      const i = e.parent;
+      i && i.children.removeValue(e);
+      const t = e.gridContainer, s = t.parent;
+      s && s.children.removeValue(t);
+      const r = e.topGridContainer, h = r.parent;
+      h && h.children.removeValue(r);
+    }
+  }
+  _updateChartLayout() {
+    const e = this.leftAxesContainer.width(), i = this.rightAxesContainer.width(), t = this.bottomAxesContainer;
+    t.set("paddingLeft", e), t.set("paddingRight", i);
+    const s = this.topAxesContainer;
+    s.set("paddingLeft", e), s.set("paddingRight", i);
+  }
+  /**
+   * @ignore
+   */
+  processAxis(e) {
+    var i = this.get("cursor");
+    i && (this.addDisposer(e.on("start", () => {
+      this._updateCursor();
+    })), this.addDisposer(e.on("end", () => {
+      this._updateCursor();
+    })));
+  }
+  _handleAxisSelection(e, i) {
+    let t = e.fixPosition(e.get("start", 0)), s = e.fixPosition(e.get("end", 1));
+    if (t > s && ([t, s] = [s, t]), this.xAxes.indexOf(e) != -1) {
+      if (i || e.getPrivate("updateScrollbar")) {
+        let r = this.get("scrollbarX");
+        r && (!r.getPrivate("isBusy") || i) && (r.setRaw("start", t), r.setRaw("end", s), r.updateGrips());
+      }
+    } else if (this.yAxes.indexOf(e) != -1 && (i || e.getPrivate("updateScrollbar"))) {
+      let r = this.get("scrollbarY");
+      r && (!r.getPrivate("isBusy") || i) && (r.setRaw("start", t), r.setRaw("end", s), r.updateGrips());
+    }
+    this._handleZoomOut();
+  }
+  _handleZoomOut() {
+    let e = this.zoomOutButton;
+    if (e && e.parent) {
+      let i = !1;
+      this.xAxes.each((t) => {
+        t.get("zoomOut", !0) && (C(t.get("start", 0), 5) != 0 || C(t.get("end", 1), 5) != 1) && (i = !0);
+      }), this.yAxes.each((t) => {
+        t.get("zoomOut", !0) && (C(t.get("start", 0), 5) != 0 || C(t.get("end", 1), 5) != 1) && (i = !0);
+      }), i ? e.isHidden() && e.show() : e.hide();
+    }
+  }
+  /**
+   * Checks if point is within plot area.
+   *
+   * @param   point  Reference point
+   * @return         Is within plot area?
+   */
+  inPlot(e) {
+    const i = this.plotContainer, t = this.getPrivate("otherCharts", this._otherCharts), s = i.toGlobal(e);
+    if (e.x >= -0.5 && e.y >= -0.5 && e.x <= i.width() + 0.5 && e.y <= i.height() + 0.5)
+      return !0;
+    if (t)
+      for (let r = t.length - 1; r >= 0; r--) {
+        const h = t[r];
+        if (h != this) {
+          const o = h.plotContainer, a = this._root.rootPointToDocument(s), l = h._root.documentPointToRoot(a), u = o.toLocal(l);
+          if (u.x >= -0.1 && u.y >= -0.1 && u.x <= o.width() + 0.1 && u.y <= o.height() + 0.1)
+            return !0;
+        }
+      }
+    return !1;
+  }
+  /**
+   * @ignore
+   */
+  arrangeTooltips() {
+    const e = this.plotContainer, i = e.width(), t = e.height();
+    let s = this.height();
+    const r = this._root.tooltipContainer.get("layerMargin");
+    r && r.bottom > s && (s = r.bottom);
+    let h = e._display.toGlobal({ x: 0, y: 0 }), o = e._display.toGlobal({ x: i, y: t });
+    const a = [];
+    let l = 0, u = 1 / 0, n = this._movePoint, d = this.get("maxTooltipDistance"), c = this.get("maxTooltipDistanceBy", "xy"), m, g;
+    v(d) && this.series.each((f) => {
+      if (!f.isHidden()) {
+        const _ = f.get("tooltip");
+        if (_) {
+          let x = _.get("pointTo");
+          if (x) {
+            let b = Math.hypot(n.x - x.x, n.y - x.y);
+            c == "x" ? b = Math.abs(n.x - x.x) : c == "y" && (b = Math.abs(n.y - x.y)), b < u && (u = b, m = f, g = x);
+          }
+        }
+      }
+    });
+    const p = [];
+    if (this.series.each((f) => {
+      const _ = f.get("tooltip");
+      if (_ && !_.get("forceHidden")) {
+        let x = !1, b = _.get("pointTo");
+        if (b) {
+          if (d >= 0) {
+            let P = _.get("pointTo");
+            if (P && g && f != m) {
+              let y = Math.hypot(g.x - P.x, g.y - P.y);
+              c == "x" ? y = Math.abs(g.x - P.x) : c == "y" && (y = Math.abs(g.y - P.y)), y > d && (x = !0);
+            }
+          } else d == -1 && f != m && (x = !0);
+          !this.inPlot(this._tooltipToLocal(b)) || !_.dataItem ? x = !0 : x || (l += b.y), x || f.isHidden() || f.isHiding() ? _.hide(0) : (_.show(), a.push(_), p.push(f));
+        }
+      }
+    }), this.setPrivate("tooltipSeries", p), this.get("arrangeTooltips")) {
+      let f = 0, _ = 0;
+      const x = this._root.tooltipContainer, b = a.length;
+      if (l / b > t / 2 + h.y) {
+        a.sort((A, w) => he(w.get("pointTo").y, A.get("pointTo").y));
+        let y = o.y;
+        if (M(a, (A) => {
+          let w = A.height();
+          _++, f += w;
+          let D = A.get("centerY");
+          D instanceof ue && (w *= D.value), w += A.get("marginBottom", 0), A.set("bounds", { left: h.x, top: h.y, right: o.x, bottom: y }), A.setPrivate("customData", { left: h.x, top: h.y, right: o.x, bottom: y }), y = Math.min(y - w, A._fy - w), A.parent == x && x.children.moveValue(A, 0);
+        }), y < 0) {
+          a.reverse();
+          let A = y;
+          M(a, (w) => {
+            _++;
+            let D = w.get("bounds");
+            if (D) {
+              let S = D.top - y, X = D.bottom - y;
+              S < A && (S = A, X = S + w.height()), w.set("bounds", { left: D.left, top: S, right: D.right, bottom: X }), A = D.bottom - y + w.get("marginBottom", 0);
+            }
+          });
+        }
+      } else {
+        a.reverse(), a.sort((A, w) => he(A.get("pointTo").y, w.get("pointTo").y));
+        let y = 0;
+        if (M(a, (A) => {
+          _++;
+          let w = A.height();
+          f += w;
+          let D = A.get("centerY");
+          D instanceof ue && (w *= D.value), w += A.get("marginBottom", 0), A.set("bounds", { left: h.x, top: y, right: o.x, bottom: Math.max(h.y + s, y + w) }), A.parent == x && x.children.moveValue(A, 0), y = Math.max(y + w, A._fy + w);
+        }), y > s) {
+          a.reverse();
+          let A = s;
+          M(a, (w) => {
+            _++;
+            let D = w.get("bounds");
+            if (D) {
+              let S = D.top - (s - y), X = D.bottom - (s - y);
+              X > A && (X = A, S = X - w.height()), w.set("bounds", { left: D.left, top: S, right: D.right, bottom: X }), A = X - w.height() - w.get("marginBottom", 0);
+            }
+          });
+        }
+      }
+      f == 0 && _ > 0 && this._disposers.push(this.root.events.once("frameended", () => {
+        this.arrangeTooltips();
+      }));
+    }
+  }
+  _tooltipToLocal(e) {
+    return this.plotContainer.toLocal(e);
+  }
+  /**
+   * Fully zooms out the chart.
+   */
+  zoomOut() {
+    this.xAxes.each((e) => {
+      e.get("zoomOut", !0) && (e.setPrivate("updateScrollbar", !0), e.zoom(0, 1));
+    }), this.yAxes.each((e) => {
+      e.get("zoomOut", !0) && (e.setPrivate("updateScrollbar", !0), e.zoom(0, 1));
+    });
+  }
+  _dispose() {
+    super._dispose();
+    const e = this.get("cursor");
+    e && e.dispose();
+  }
+}
+Object.defineProperty(ee, "className", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: "XYChart"
+});
+Object.defineProperty(ee, "classNames", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: xe.classNames.concat([ee.className])
+});
+class H extends I {
+  _beforeChanged() {
+    super._beforeChanged(), (this.isPrivateDirty("width") || this.isPrivateDirty("height")) && (this._clear = !0);
+  }
+}
+Object.defineProperty(H, "className", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: "Grid"
+});
+Object.defineProperty(H, "classNames", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: I.classNames.concat([H.className])
+});
+function Ce(O, e) {
+  return O == null ? e : e == null ? O : e < O ? e : O;
+}
+function Oe(O, e) {
+  return O == null ? e : e == null || O > e ? O : e;
+}
+class te extends pe {
+  constructor() {
+    super(...arguments), Object.defineProperty(this, "_xField", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_yField", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_xOpenField", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_yOpenField", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_xLowField", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_xHighField", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_yLowField", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_yHighField", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_axesDirty", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: !1
+    }), Object.defineProperty(this, "_stackDirty", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: !1
+    }), Object.defineProperty(this, "_selectionProcessed", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: !1
+    }), Object.defineProperty(this, "_dataSets", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: {}
+    }), Object.defineProperty(this, "_mainContainerMask", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_x", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: 0
+    }), Object.defineProperty(this, "_y", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: 0
+    }), Object.defineProperty(this, "_bullets", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: {}
+    }), Object.defineProperty(this, "mainContainer", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: this.children.push(Y.new(this._root, {}))
+    }), Object.defineProperty(this, "axisRanges", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: new me()
+    }), Object.defineProperty(this, "_skipped", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: !1
+    }), Object.defineProperty(this, "_couldStackTo", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: []
+    }), Object.defineProperty(this, "_reallyStackedTo", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: {}
+    }), Object.defineProperty(this, "_stackedSeries", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: {}
+    }), Object.defineProperty(this, "_aLocationX0", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: 0
+    }), Object.defineProperty(this, "_aLocationX1", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: 1
+    }), Object.defineProperty(this, "_aLocationY0", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: 0
+    }), Object.defineProperty(this, "_aLocationY1", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: 1
+    }), Object.defineProperty(this, "_showBullets", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: !0
+    }), Object.defineProperty(this, "valueXFields", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: [
+        "valueX",
+        "openValueX",
+        "lowValueX",
+        "highValueX"
+      ]
+    }), Object.defineProperty(this, "valueYFields", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: [
+        "valueY",
+        "openValueY",
+        "lowValueY",
+        "highValueY"
+      ]
+    }), Object.defineProperty(this, "_valueXFields", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_valueYFields", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_valueXShowFields", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_valueYShowFields", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "__valueXShowFields", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "__valueYShowFields", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_emptyDataItem", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: new Z(this, void 0, {})
+    }), Object.defineProperty(this, "_dataSetId", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_tooltipFieldX", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_tooltipFieldY", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_posXDp", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_posYDp", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    });
+  }
+  _afterNew() {
+    this.fields.push("categoryX", "categoryY", "openCategoryX", "openCategoryY"), this.valueFields.push("valueX", "valueY", "openValueX", "openValueY", "lowValueX", "lowValueY", "highValueX", "highValueY"), this._setRawDefault("vcx", 1), this._setRawDefault("vcy", 1), this._setRawDefault("valueXShow", "valueXWorking"), this._setRawDefault("valueYShow", "valueYWorking"), this._setRawDefault("openValueXShow", "openValueXWorking"), this._setRawDefault("openValueYShow", "openValueYWorking"), this._setRawDefault("lowValueXShow", "lowValueXWorking"), this._setRawDefault("lowValueYShow", "lowValueYWorking"), this._setRawDefault("highValueXShow", "highValueXWorking"), this._setRawDefault("highValueYShow", "highValueYWorking"), this._setRawDefault("lowValueXGrouped", "low"), this._setRawDefault("lowValueYGrouped", "low"), this._setRawDefault("highValueXGrouped", "high"), this._setRawDefault("highValueYGrouped", "high"), super._afterNew(), this.set("maskContent", !0), this._disposers.push(this.axisRanges.events.onAll((e) => {
+      if (e.type === "clear")
+        M(e.oldValues, (i) => {
+          this._removeAxisRange(i);
+        });
+      else if (e.type === "push")
+        this._processAxisRange(e.newValue);
+      else if (e.type === "setIndex")
+        this._processAxisRange(e.newValue);
+      else if (e.type === "insertIndex")
+        this._processAxisRange(e.newValue);
+      else if (e.type === "removeIndex")
+        this._removeAxisRange(e.oldValue);
+      else if (e.type === "moveIndex")
+        this._processAxisRange(e.value);
+      else
+        throw new Error("Unknown IStreamEvent type");
+    })), this.states.create("hidden", { opacity: 1, visible: !1 }), this.onPrivate("startIndex", () => {
+      this.root.events.once("frameended", () => {
+        this.updateLegendValue();
+      });
+    }), this.onPrivate("endIndex", () => {
+      this.root.events.once("frameended", () => {
+        this.updateLegendValue();
+      });
+    }), this._makeFieldNames();
+  }
+  _processAxisRange(e) {
+    const i = Y.new(this._root, {});
+    e.container = i, this.children.push(i), e.series = this;
+    const t = e.axisDataItem;
+    t.setRaw("isRange", !0);
+    const s = t.component;
+    if (s) {
+      s._processAxisRange(t, ["range", "series"]);
+      const r = t.get("bullet");
+      if (r) {
+        const o = r.get("sprite");
+        o && o.setPrivate("visible", !1);
+      }
+      const h = t.get("axisFill");
+      h && i.set("mask", h), s._seriesAxisRanges.push(t);
+    }
+  }
+  _onDataClear() {
+    super._onDataClear(), j(this._dataSets, (e, i) => {
+      M(i, (t) => {
+        t.dispose();
+      }), i.length = 0;
+    });
+  }
+  _removeAxisRange(e) {
+    const i = e.axisDataItem, t = i.component;
+    i.dispose(), U(t._seriesAxisRanges, i);
+    const s = e.container;
+    s && s.dispose();
+  }
+  _updateFields() {
+    super._updateFields(), this._valueXFields = [], this._valueYFields = [], this._valueXShowFields = [], this._valueYShowFields = [], this.__valueXShowFields = [], this.__valueYShowFields = [], this.valueXFields && M(this.valueXFields, (e) => {
+      if (this.get(e + "Field")) {
+        this._valueXFields.push(e);
+        let t = this.get(e + "Show");
+        this.__valueXShowFields.push(t), t.indexOf("Working") != -1 ? this._valueXShowFields.push(t.split("Working")[0]) : this._valueXShowFields.push(t);
+      }
+    }), this.valueYFields && M(this.valueYFields, (e) => {
+      if (this.get(e + "Field")) {
+        this._valueYFields.push(e);
+        let t = this.get(e + "Show");
+        this.__valueYShowFields.push(t), t.indexOf("Working") != -1 ? this._valueYShowFields.push(t.split("Working")[0]) : this._valueYShowFields.push(t);
+      }
+    });
+  }
+  _dispose() {
+    super._dispose(), this._bullets = {};
+    const e = this.chart;
+    e && e.series.removeValue(this), ce(this.get("xAxis").series, this), ce(this.get("yAxis").series, this);
+  }
+  // TODO use  SelectKeys<this["_privateSettings"], number | undefined>
+  _min(e, i) {
+    let t = Ce(this.getPrivate(e), i);
+    this.setPrivate(e, t);
+  }
+  // TODO use  SelectKeys<this["_privateSettings"], number | undefined>
+  _max(e, i) {
+    let t = Oe(this.getPrivate(e), i);
+    this.setPrivate(e, t);
+  }
+  _shouldMakeBullet(e) {
+    const i = this.get("xAxis"), t = this.get("yAxis"), s = this.get("baseAxis");
+    if (!i.inited || !t.inited)
+      return !1;
+    const r = this.get("minBulletDistance", 0);
+    if (r > 0) {
+      let h = this.startIndex(), a = this.endIndex() - h;
+      if (i == s) {
+        if (i.get("renderer").axisLength() / a < r / 5)
+          return !1;
+      } else if (t == s && t.get("renderer").axisLength() / a < r / 5)
+        return !1;
+    }
+    return e.get(this._xField) != null && e.get(this._yField) != null;
+  }
+  _makeFieldNames() {
+    const e = this.get("xAxis"), i = this.get("yAxis"), t = e.getPrivate("name"), s = de(t), r = i.getPrivate("name"), h = de(r), o = e.get("renderer").getPrivate("letter"), a = i.get("renderer").getPrivate("letter"), l = "open", u = "low", n = "high", d = "Show";
+    e.className === "ValueAxis" ? (this._xField = this.get(t + o + d), this._xOpenField = this.get(l + s + o + d), this._xLowField = this.get(u + s + o + d), this._xHighField = this.get(n + s + o + d)) : (this._xField = t + o, this._xOpenField = l + s + o, this._xLowField = u + s + o, this._xHighField = n + s + o), i.className === "ValueAxis" ? (this._yField = this.get(r + a + d), this._yOpenField = this.get(l + h + a + d), this._yLowField = this.get(u + h + a + d), this._yHighField = this.get(n + h + a + d)) : (this._yField = r + a, this._yOpenField = l + h + a, this._yLowField = u + h + a, this._yHighField = n + h + a);
+  }
+  _fixVC() {
+    const e = this.get("xAxis"), i = this.get("yAxis"), t = this.get("baseAxis"), s = this.states.lookup("hidden"), r = this.get("sequencedInterpolation");
+    if (s) {
+      let h = 0;
+      r && (h = 0.999999999999), e === t ? s.set("vcy", h) : (i === t || s.set("vcy", h), s.set("vcx", h));
+    }
+  }
+  _handleMaskBullets() {
+    this.isDirty("maskBullets") && this.bulletsContainer.set("maskContent", this.get("maskBullets"));
+  }
+  _fixPosition() {
+    const e = this.get("xAxis"), i = this.get("yAxis");
+    this.set("x", e.x() - fe(e.get("centerX", 0), e.width()) - e.parent.get("paddingLeft", 0)), this.set("y", i.y() - fe(i.get("centerY", 0), i.height()) - i.parent.get("paddingTop", 0)), this.bulletsContainer.set("y", this.y()), this.bulletsContainer.set("x", this.x());
+  }
+  _prepareChildren() {
+    super._prepareChildren(), this._bullets = {}, (this.isDirty("valueYShow") || this.isDirty("valueXShow") || this.isDirty("openValueYShow") || this.isDirty("openValueXShow") || this.isDirty("lowValueYShow") || this.isDirty("lowValueXShow") || this.isDirty("highValueYShow") || this.isDirty("highValueXShow")) && (this._updateFields(), this._makeFieldNames(), this._valuesDirty = !0), (this.isDirty("xAxis") || this.isDirty("yAxis")) && (this._valuesDirty = !0), this.set("width", this.get("xAxis").width()), this.set("height", this.get("yAxis").height()), this._handleMaskBullets();
+    const e = this.get("xAxis"), i = this.get("yAxis"), t = this.get("baseAxis"), s = this.get("tooltipPositionX");
+    let r;
+    switch (s) {
+      case "open":
+        r = this._xOpenField;
+        break;
+      case "low":
+        r = this._xLowField;
+        break;
+      case "high":
+        r = this._xHighField;
+        break;
+      default:
+        r = this._xField;
+    }
+    this._tooltipFieldX = r;
+    const h = this.get("tooltipPositionY");
+    let o;
+    switch (h) {
+      case "open":
+        o = this._yOpenField;
+        break;
+      case "low":
+        o = this._yLowField;
+        break;
+      case "high":
+        o = this._yHighField;
+        break;
+      default:
+        o = this._yField;
+    }
+    this._tooltipFieldY = o, this.isDirty("baseAxis") && this._fixVC(), this._fixPosition();
+    const a = this.get("stacked");
+    if (this.isDirty("stacked") && (a ? this._valuesDirty && !this._dataProcessed || this._stack() : this._unstack()), this._valuesDirty && !this._dataProcessed && (this._dataProcessed = !0, a && this._stack(), M(this.dataItems, (l) => {
+      M(this._valueXShowFields, (u) => {
+        let n = l.get(u);
+        n != null && (a && (n += this.getStackedXValue(l, u)), this._min("minX", n), this._max("maxX", n));
+      }), M(this._valueYShowFields, (u) => {
+        let n = l.get(u);
+        n != null && (a && (n += this.getStackedYValue(l, u)), this._min("minY", n), this._max("maxY", n));
+      }), e.processSeriesDataItem(l, this._valueXFields), i.processSeriesDataItem(l, this._valueYFields);
+    }), e._seriesValuesDirty = !0, i._seriesValuesDirty = !0, this.get("ignoreMinMax") || ((this.isPrivateDirty("minX") || this.isPrivateDirty("maxX")) && e.markDirtyExtremes(), (this.isPrivateDirty("minY") || this.isPrivateDirty("maxY")) && i.markDirtyExtremes()), this._markStakedDirtyStack(), this.get("tooltipDataItem") || this.updateLegendValue(void 0)), (this.isDirty("vcx") || this.isDirty("vcy")) && this._markStakedDirtyStack(), this._dataGrouped || (e._groupSeriesData(this), i._groupSeriesData(this), this._dataGrouped = !0), this._valuesDirty || this.isPrivateDirty("startIndex") || this.isPrivateDirty("adjustedStartIndex") || this.isPrivateDirty("endIndex") || this.isDirty("vcx") || this.isDirty("vcy") || this._stackDirty || this._sizeDirty) {
+      let l = this.startIndex(), u = this.endIndex(), n = this.get("minBulletDistance", 0);
+      if (n > 0 && t && (t.get("renderer").axisLength() / (u - l) > n ? this._showBullets = !0 : this._showBullets = !1), (this._psi != l || this._pei != u || this.isDirty("vcx") || this.isDirty("vcy") || this.isPrivateDirty("adjustedStartIndex") || this._stackDirty || this._valuesDirty) && !this._selectionProcessed) {
+        this._selectionProcessed = !0;
+        const d = this.get("vcx", 1), c = this.get("vcy", 1), m = this.get("stacked", !1), g = this.getPrivate("outOfSelection");
+        if (t === e || !t)
+          if (i._calculateTotals(), this.setPrivateRaw("selectionMinY", void 0), this.setPrivateRaw("selectionMaxY", void 0), g)
+            i.markDirtySelectionExtremes();
+          else
+            for (let p = l; p < u; p++)
+              this.processYSelectionDataItem(this.dataItems[p], c, m);
+        if (t === i || !t)
+          if (e._calculateTotals(), this.setPrivateRaw("selectionMinX", void 0), this.setPrivateRaw("selectionMaxX", void 0), g)
+            i.markDirtySelectionExtremes();
+          else
+            for (let p = l; p < u; p++)
+              this.processXSelectionDataItem(this.dataItems[p], d, m);
+        if ((t === e || !t) && (this.get("valueYShow") !== "valueYWorking" || this.get("useSelectionExtremes"))) {
+          const p = this.getPrivate("selectionMinY");
+          p != null && (this.setPrivateRaw("minY", p), i.markDirtyExtremes());
+          const f = this.getPrivate("selectionMaxY");
+          f != null && (this.setPrivateRaw("maxY", f), i.markDirtyExtremes());
+        }
+        if ((t === i || !t) && (this.get("valueXShow") !== "valueXWorking" || this.get("useSelectionExtremes"))) {
+          const p = this.getPrivate("selectionMinX");
+          p != null && (this.setPrivateRaw("minX", p), i.markDirtyExtremes());
+          const f = this.getPrivate("selectionMaxX");
+          f != null && (this.setPrivateRaw("maxX", f), e.markDirtyExtremes());
+        }
+        (this.isPrivateDirty("selectionMinX") || this.isPrivateDirty("selectionMaxX")) && e.markDirtySelectionExtremes(), (this.isPrivateDirty("selectionMinY") || this.isPrivateDirty("selectionMaxY")) && i.markDirtySelectionExtremes();
+      }
+    }
+  }
+  _makeRangeMask() {
+    if (this.axisRanges.length > 0) {
+      let e = this._mainContainerMask;
+      e == null && (e = this.children.push(I.new(this._root, {})), this._mainContainerMask = e, e.set("draw", (i, t) => {
+        const s = this.parent;
+        if (s) {
+          const r = this._root.container.width(), h = this._root.container.height();
+          i.moveTo(-r, -h), i.lineTo(-r, h * 2), i.lineTo(r * 2, h * 2), i.lineTo(r * 2, -h), i.lineTo(-r, -h), this.axisRanges.each((o) => {
+            const a = o.axisDataItem.get("axisFill");
+            if (s && a) {
+              let l = a.get("draw");
+              l && l(i, t);
+            }
+          });
+        }
+        this.mainContainer._display.mask = e._display;
+      })), e.markDirty(), e._markDirtyKey("fill");
+    } else
+      this.mainContainer._display.mask = null;
+  }
+  _updateChildren() {
+    super._updateChildren(), this._x = this.x(), this._y = this.y(), this._makeRangeMask();
+  }
+  _stack() {
+    const e = this.chart;
+    if (e) {
+      const i = e.series.indexOf(this);
+      if (this._couldStackTo = [], i > 0) {
+        let t;
+        for (let s = i - 1; s >= 0 && (t = e.series.getIndex(s), !(t.get("xAxis") === this.get("xAxis") && t.get("yAxis") === this.get("yAxis") && t.className === this.className && (this._couldStackTo.push(t), !t.get("stacked")))); s--)
+          ;
+      }
+      this._stackDataItems();
+    }
+  }
+  _unstack() {
+    j(this._reallyStackedTo, (e, i) => {
+      delete i._stackedSeries[this.uid];
+    }), this._reallyStackedTo = {}, M(this.dataItems, (e) => {
+      e.setRaw("stackToItemY", void 0), e.setRaw("stackToItemX", void 0);
+    });
+  }
+  _handleRemoved() {
+    const e = this.get("xAxis");
+    e && e._handleSeriesRemoved();
+    const i = this.get("yAxis");
+    i && i._handleSeriesRemoved();
+  }
+  _stackDataItems() {
+    const e = this.get("baseAxis"), i = this.get("xAxis"), t = this.get("yAxis");
+    let s, r;
+    e === i ? (s = "valueY", r = "stackToItemY") : e === t && (s = "valueX", r = "stackToItemX");
+    let h = this._couldStackTo.length, o = 0;
+    const a = this.get("stackToNegative");
+    this._reallyStackedTo = {}, M(this.dataItems, (l) => {
+      for (let u = 0; u < h; u++) {
+        let n = this._couldStackTo[u], d = n.dataItems[o], c = l.get(s);
+        if (d) {
+          let m = d.get(s);
+          if (a)
+            if (v(c)) {
+              if (v(m)) {
+                if (u == h - 1 && l.setRaw(r, void 0), c >= 0 && m >= 0) {
+                  l.setRaw(r, d), this._reallyStackedTo[n.uid] = n, n._stackedSeries[this.uid] = this;
+                  break;
+                }
+                if (c < 0 && m < 0) {
+                  l.setRaw(r, d), this._reallyStackedTo[n.uid] = n, n._stackedSeries[this.uid] = this;
+                  break;
+                }
+              }
+            } else
+              break;
+          else if (v(c) && v(m)) {
+            l.setRaw(r, d), this._reallyStackedTo[n.uid] = n, n._stackedSeries[this.uid] = this;
+            break;
+          }
+        }
+      }
+      o++;
+    });
+  }
+  processXSelectionDataItem(e, i, t) {
+    M(this.__valueXShowFields, (s) => {
+      let r = e.get(s);
+      r != null && (t && (r += this.getStackedXValueWorking(e, s)), this._min("selectionMinX", r), this._max("selectionMaxX", r * i));
+    });
+  }
+  processYSelectionDataItem(e, i, t) {
+    M(this.__valueYShowFields, (s) => {
+      let r = e.get(s);
+      r != null && (t && (r += this.getStackedYValueWorking(e, s)), this._min("selectionMinY", r), this._max("selectionMaxY", r * i));
+    });
+  }
+  /**
+   * @ignore
+   */
+  getStackedYValueWorking(e, i) {
+    const t = e.get("stackToItemY");
+    if (t) {
+      const s = t.component;
+      return t.get(i, 0) * s.get("vcy", 1) + this.getStackedYValueWorking(t, i);
+    }
+    return 0;
+  }
+  /**
+   * @ignore
+   */
+  getStackedXValueWorking(e, i) {
+    const t = e.get("stackToItemX");
+    if (t) {
+      const s = t.component;
+      return t.get(i, 0) * s.get("vcx", 1) + this.getStackedXValueWorking(t, i);
+    }
+    return 0;
+  }
+  /**
+   * @ignore
+   */
+  getStackedYValue(e, i) {
+    const t = e.get("stackToItemY");
+    return t ? t.get(i, 0) + this.getStackedYValue(t, i) : 0;
+  }
+  /**
+   * @ignore
+   */
+  getStackedXValue(e, i) {
+    const t = e.get("stackToItemX");
+    return t ? t.get(i, 0) + this.getStackedXValue(t, i) : 0;
+  }
+  /**
+   * @ignore
+   */
+  createLegendMarker(e) {
+    this.updateLegendMarker();
+  }
+  _markDirtyAxes() {
+    this._axesDirty = !0, this.markDirty();
+  }
+  _markDataSetDirty() {
+    this._afterDataChange(), this._valuesDirty = !0, this._dataProcessed = !1, this._aggregatesCalculated = !1, this.markDirty();
+  }
+  _clearDirty() {
+    super._clearDirty(), this._axesDirty = !1, this._selectionProcessed = !1, this._stackDirty = !1, this._dataProcessed = !1;
+  }
+  _positionBullet(e) {
+    let i = e.get("sprite");
+    if (i) {
+      let t = i.dataItem, s = e.get("locationX", t.get("locationX", 0.5)), r = e.get("locationY", t.get("locationY", 0.5)), h = this.get("xAxis"), o = this.get("yAxis"), a = this.get("exactLocationX", !1), l = this.get("exactLocationY", !1), u = h.getDataItemPositionX(t, this._xField, s, this.get("vcx", 1), a), n = o.getDataItemPositionY(t, this._yField, r, this.get("vcy", 1), l), d = this.getPoint(u, n), c = t.get("left", d.x), m = t.get("right", d.x), g = t.get("top", d.y), p = t.get("bottom", d.y), f = 0, _ = 0, x = m - c, b = p - g;
+      if (this._shouldShowBullet(u, n)) {
+        i.setPrivate("visible", !e.getPrivate("hidden"));
+        let P = e.get("field");
+        const y = this.get("baseAxis"), A = this.get("xAxis"), w = this.get("yAxis");
+        if (P != null) {
+          let S;
+          y == A ? (P == "value" ? S = this._yField : P == "open" ? S = this._yOpenField : P == "high" ? S = this._yHighField : P == "low" && (S = this._yLowField), S && (n = w.getDataItemPositionY(t, S, 0, this.get("vcy", 1), l), d = w.get("renderer").positionToPoint(n), _ = d.y, f = c + x * s)) : (P == "value" ? S = this._xField : P == "open" ? S = this._xOpenField : P == "high" ? S = this._xHighField : P == "low" && (S = this._xLowField), S && (u = A.getDataItemPositionX(t, S, 0, this.get("vcx", 1), a), d = A.get("renderer").positionToPoint(u), f = d.x, _ = p - b * r));
+        } else
+          f = c + x * s, _ = p - b * r;
+        const D = e.get("stacked");
+        if (D) {
+          const S = this.chart;
+          if (y == A) {
+            let X = this._bullets[u + "_" + n];
+            if (X) {
+              let R = X.bounds(), L = i.localBounds(), $ = _;
+              _ = R.top, D == "down" ? _ = R.bottom - L.top : D == "auto" ? S && ($ < S.plotContainer.height() / 2 ? _ = R.bottom - L.top : _ += L.bottom) : _ += L.bottom;
+            }
+            this._bullets[u + "_" + n] = i;
+          } else {
+            let X = this._bullets[u + "_" + n];
+            if (X) {
+              let R = X.bounds(), L = i.localBounds(), $ = f;
+              f = R.right, D == "down" ? f = R.left - L.right : D == "auto" ? S && ($ < S.plotContainer.width() / 2 ? f = R.left - L.right : f -= L.left) : f -= L.left;
+            }
+            this._bullets[u + "_" + n] = i;
+          }
+        }
+        i.isType("Label") && (i.setPrivate("maxWidth", Math.abs(x)), i.setPrivate("maxHeight", Math.abs(b))), i.setAll({ x: f, y: _ });
+      } else
+        i.setPrivate("visible", !1);
+    }
+  }
+  _shouldShowBullet(e, i) {
+    return this._showBullets;
+  }
+  /**
+   * @ignore
+   */
+  setDataSet(e) {
+    if (this._dataSets[e]) {
+      this._handleDataSetChange(), this._dataItems = this._dataSets[e], this._markDataSetDirty(), this._dataSetId = e;
+      const i = "datasetchanged";
+      this.events.isEnabled(i) && this.events.dispatch(i, { type: i, target: this, id: e });
+    }
+  }
+  /**
+   * @ignore
+   */
+  resetGrouping() {
+    j(this._dataSets, (e, i) => {
+      i != this._mainDataItems && M(i, (t) => {
+        t.dispose();
+      });
+    }), this._dataSets = {}, this._dataItems = this.mainDataItems;
+  }
+  _handleDataSetChange() {
+    M(this._dataItems, (e) => {
+      let i = e.bullets;
+      i && M(i, (t) => {
+        if (t) {
+          let s = t.get("sprite");
+          s && s.setPrivate("visible", !1);
+        }
+      });
+    }), this._selectionProcessed = !1;
+  }
+  /**
+   * Shows hidden series.
+   *
+   * @param   duration  Duration of animation in milliseconds
+   * @return            Animation promise
+   */
+  show(e) {
+    const i = Object.create(null, {
+      show: { get: () => super.show }
+    });
+    return N(this, void 0, void 0, function* () {
+      this._fixVC();
+      let t = [];
+      t.push(i.show.call(this, e).then(() => {
+        this._isShowing = !1;
+        let s = this.get("xAxis"), r = this.get("yAxis"), h = this.get("baseAxis");
+        r !== h && r.markDirtySelectionExtremes(), s !== h && s.markDirtySelectionExtremes();
+      })), t.push(this.bulletsContainer.show(e)), t.push(this._sequencedShowHide(!0, e)), yield Promise.all(t);
+    });
+  }
+  /**
+   * Hides series.
+   *
+   * @param   duration  Duration of animation in milliseconds
+   * @return            Animation promise
+   */
+  hide(e) {
+    const i = Object.create(null, {
+      hide: { get: () => super.hide }
+    });
+    return N(this, void 0, void 0, function* () {
+      this._fixVC();
+      let t = [];
+      t.push(i.hide.call(this, e).then(() => {
+        this._isHiding = !1;
+      })), t.push(this.bulletsContainer.hide(e)), t.push(this._sequencedShowHide(!1, e)), yield Promise.all(t);
+    });
+  }
+  /**
+   * Shows series's data item.
+   *
+   * @param   dataItem  Data item
+   * @param   duration  Animation duration in milliseconds
+   * @return            Promise
+   */
+  showDataItem(e, i) {
+    const t = Object.create(null, {
+      showDataItem: { get: () => super.showDataItem }
+    });
+    return N(this, void 0, void 0, function* () {
+      const s = [t.showDataItem.call(this, e, i)];
+      v(i) || (i = this.get("stateAnimationDuration", 0));
+      const r = this.get("stateAnimationEasing");
+      M(this._valueFields, (h) => {
+        s.push(e.animate({ key: h + "Working", to: e.get(h), duration: i, easing: r }).waitForStop());
+      }), yield Promise.all(s);
+    });
+  }
+  /**
+   * Hides series's data item.
+   *
+   * @param   dataItem  Data item
+   * @param   duration  Animation duration in milliseconds
+   * @return            Promise
+   */
+  hideDataItem(e, i) {
+    const t = Object.create(null, {
+      hideDataItem: { get: () => super.hideDataItem }
+    });
+    return N(this, void 0, void 0, function* () {
+      const s = [t.hideDataItem.call(this, e, i)];
+      let r = this.states.lookup("hidden");
+      r || (r = this.states.create("hidden", {})), v(i) || (i = r.get("stateAnimationDuration", this.get("stateAnimationDuration", 0)));
+      const h = r.get("stateAnimationEasing", this.get("stateAnimationEasing")), o = this.get("xAxis"), a = this.get("yAxis"), l = this.get("baseAxis"), u = this.get("stacked");
+      if ((l === o || !l) && M(this._valueYFields, (n) => {
+        let d = a.getPrivate("min"), c = a.baseValue();
+        v(d) && d > c && (c = d), u && (c = 0), e.get(n) != null && s.push(e.animate({ key: n + "Working", to: c, duration: i, easing: h }).waitForStop());
+      }), l === a || !l) {
+        let n = o.getPrivate("min"), d = o.baseValue();
+        v(n) && n > d && (d = n), u && (d = 0), M(this._valueXFields, (c) => {
+          e.get(c) != null && s.push(e.animate({ key: c + "Working", to: d, duration: i, easing: h }).waitForStop());
+        });
+      }
+      yield Promise.all(s);
+    });
+  }
+  _markDirtyStack() {
+    this._stackDirty = !0, this.markDirty(), this._markStakedDirtyStack();
+  }
+  _markStakedDirtyStack() {
+    const e = this._stackedSeries;
+    e && j(e, (i, t) => {
+      t._stackDirty || t._markDirtyStack();
+    });
+  }
+  _afterChanged() {
+    super._afterChanged(), this._skipped && (this._markDirtyAxes(), this._skipped = !1);
+  }
+  /**
+   * Shows a tooltip for specific data item.
+   *
+   * @param  dataItem  Data item
+   */
+  showDataItemTooltip(e) {
+    this.getPrivate("doNotUpdateLegend") || (this.updateLegendMarker(e), this.updateLegendValue(e));
+    const i = this.get("tooltip"), t = this.get("exactLocationX", !1), s = this.get("exactLocationY", !1);
+    if (i)
+      if (!this.isHidden() && this.get("visible")) {
+        if (i._setDataItem(e), e) {
+          let r = this.get("locationX", 0), h = this.get("locationY", 1), o = e.get("locationX", r), a = e.get("locationY", h);
+          const l = this.get("xAxis"), u = this.get("yAxis"), n = this.get("vcx", 1), d = this.get("vcy", 1), c = l.getDataItemPositionX(e, this._tooltipFieldX, this._aLocationX0 + (this._aLocationX1 - this._aLocationX0) * o, n, t), m = u.getDataItemPositionY(e, this._tooltipFieldY, this._aLocationY0 + (this._aLocationY1 - this._aLocationY0) * a, d, s), g = this.getPoint(c, m);
+          let p = !0;
+          if (M(this._valueFields, (f) => {
+            e.get(f) == null && (p = !1);
+          }), p) {
+            const f = this.chart;
+            f && f.inPlot(g) ? (i.label.text.markDirtyText(), i.set("tooltipTarget", this._getTooltipTarget(e)), i.set("pointTo", this._display.toGlobal({ x: g.x, y: g.y }))) : i._setDataItem(void 0);
+          } else
+            i._setDataItem(void 0);
+        }
+      } else
+        this.hideTooltip();
+  }
+  hideTooltip() {
+    const e = this.get("tooltip");
+    return e && e.set("tooltipTarget", this), super.hideTooltip();
+  }
+  _getTooltipTarget(e) {
+    if (this.get("seriesTooltipTarget") == "bullet") {
+      const i = e.bullets;
+      if (i && i.length > 0) {
+        const s = i[0].get("sprite");
+        if (s)
+          return s;
+      }
+    }
+    return this;
+  }
+  /**
+   * @ignore
+   */
+  updateLegendValue(e) {
+    const i = this.get("legendDataItem");
+    if (i) {
+      const t = i.get("label");
+      if (t) {
+        let r = "";
+        e ? (t._setDataItem(e), r = this.get("legendLabelText", t.get("text", this.get("name", "")))) : (t._setDataItem(this._emptyDataItem), r = this.get("legendRangeLabelText", this.get("legendLabelText", t.get("text", this.get("name", ""))))), t.set("text", r);
+      }
+      const s = i.get("valueLabel");
+      if (s) {
+        let r = "";
+        e ? (s._setDataItem(e), r = this.get("legendValueText", s.get("text", ""))) : (s._setDataItem(this._emptyDataItem), r = this.get("legendRangeValueText", s.get("text", ""))), s.set("text", r);
+      }
+    }
+  }
+  _getItemReaderLabel() {
+    let e = "X: {" + this._xField;
+    return this.get("xAxis").isType("DateAxis") && (e += ".formatDate()"), e += "}; Y: {" + this._yField, this.get("yAxis").isType("DateAxis") && (e += ".formatDate()"), e += "}", e;
+  }
+  /**
+   * @ignore
+   */
+  getPoint(e, i) {
+    let t = this.get("xAxis").get("renderer").positionToCoordinate(e), s = this.get("yAxis").get("renderer").positionToCoordinate(i), r = 999999999;
+    return s < -r && (s = -r), s > r && (s = r), t < -r && (t = -r), t > r && (t = r), { x: t, y: s };
+  }
+  _shouldInclude(e) {
+    return !0;
+  }
+  /**
+   * @ignore
+   */
+  handleCursorHide() {
+    this.hideTooltip(), this.updateLegendValue(void 0), this.updateLegendMarker(void 0);
+  }
+  _afterDataChange() {
+    super._afterDataChange(), this.get("xAxis")._markDirtyKey("start"), this.get("yAxis")._markDirtyKey("start"), this.resetExtremes();
+  }
+  /**
+   * Resets cached axis scale values.
+   */
+  resetExtremes() {
+    this.setPrivate("selectionMinX", void 0), this.setPrivate("selectionMaxX", void 0), this.setPrivate("selectionMinY", void 0), this.setPrivate("selectionMaxY", void 0), this.setPrivate("minX", void 0), this.setPrivate("minY", void 0), this.setPrivate("maxX", void 0), this.setPrivate("maxY", void 0);
+  }
+  /**
+   * Creates and returns an axis range object.
+   *
+   * @see {@link https://www.amcharts.com/docs/v5/charts/xy-chart/axes/axis-ranges/} for more info
+   * @param   axisDataItem  Axis data item
+   * @return                Axis range
+   */
+  createAxisRange(e) {
+    return this.axisRanges.push({
+      axisDataItem: e
+    });
+  }
+  /**
+   * A list of series's main (ungrouped) data items.
+   *
+   * @return  Data items
+   */
+  get mainDataItems() {
+    return this._mainDataItems;
+  }
+  /**
+   * @ignore
+   */
+  _adjustStartIndex(e) {
+    const i = this.get("xAxis");
+    if (this.get("baseAxis") == i && i.isType("DateAxis")) {
+      const s = i.baseDuration(), r = i.getPrivate("selectionMin", i.getPrivate("min", 0)), h = s * this.get("locationX", 0.5);
+      let o = -1 / 0;
+      for (; o < r; ) {
+        const a = this.dataItems[e];
+        if (a) {
+          const l = a.open;
+          if (l ? o = l.valueX : o = a.get("valueX", 0), o += h, o < r)
+            e++;
+          else
+            break;
+        } else
+          break;
+      }
+    }
+    return e;
+  }
+}
+Object.defineProperty(te, "className", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: "XYSeries"
+});
+Object.defineProperty(te, "classNames", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: pe.classNames.concat([te.className])
+});
+class E extends be {
+  constructor() {
+    super(...arguments), Object.defineProperty(this, "_series", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: []
+    }), Object.defineProperty(this, "_isPanning", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: !1
+    }), Object.defineProperty(this, "minorDataItems", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: []
+    }), Object.defineProperty(this, "labelsContainer", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: this.children.push(Y.new(this._root, {}))
+    }), Object.defineProperty(this, "gridContainer", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: Y.new(this._root, { width: k, height: k })
+    }), Object.defineProperty(this, "topGridContainer", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: Y.new(this._root, { width: k, height: k })
+    }), Object.defineProperty(this, "bulletsContainer", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: this.children.push(Y.new(this._root, { isMeasured: !1, width: k, height: k, position: "absolute" }))
+    }), Object.defineProperty(this, "chart", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_rangesDirty", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: !1
+    }), Object.defineProperty(this, "_panStart", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: 0
+    }), Object.defineProperty(this, "_panEnd", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: 1
+    }), Object.defineProperty(this, "_sAnimation", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_eAnimation", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_skipSync", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: !1
+    }), Object.defineProperty(this, "axisRanges", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: new me()
+    }), Object.defineProperty(this, "_seriesAxisRanges", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: []
+    }), Object.defineProperty(this, "ghostLabel", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_cursorPosition", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: -1
+    }), Object.defineProperty(this, "_snapToSeries", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_seriesValuesDirty", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: !1
+    }), Object.defineProperty(this, "_seriesAdded", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: !1
+    }), Object.defineProperty(this, "axisHeader", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: this.children.push(Y.new(this._root, {
+        themeTags: ["axis", "header"],
+        position: "absolute",
+        background: ge.new(this._root, {
+          themeTags: ["header", "background"],
+          fill: this._root.interfaceColors.get("background")
+        })
+      }))
+    }), Object.defineProperty(this, "_bullets", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: {}
+    });
+  }
+  _dispose() {
+    this.gridContainer.dispose(), this.topGridContainer.dispose(), this.bulletsContainer.dispose(), this.labelsContainer.dispose(), this.axisHeader.dispose(), super._dispose();
+  }
+  _afterNew() {
+    super._afterNew(), this.setPrivate("updateScrollbar", !0), this._disposers.push(this.axisRanges.events.onAll((i) => {
+      if (i.type === "clear")
+        M(i.oldValues, (t) => {
+          t.dispose();
+        });
+      else if (i.type === "push")
+        this._processAxisRange(i.newValue, ["range"]);
+      else if (i.type === "setIndex")
+        this._processAxisRange(i.newValue, ["range"]);
+      else if (i.type === "insertIndex")
+        this._processAxisRange(i.newValue, ["range"]);
+      else if (i.type === "removeIndex")
+        this.disposeDataItem(i.oldValue);
+      else if (i.type === "moveIndex")
+        this._processAxisRange(i.value, ["range"]);
+      else
+        throw new Error("Unknown IStreamEvent type");
+    }));
+    const e = this.get("renderer");
+    e && (e.axis = this, e.processAxis()), this.children.push(e), this._createGhostLabel();
+  }
+  _createGhostLabel() {
+    const i = this.get("renderer").makeLabel(new Z(this, void 0, {}), []);
+    i.adapters.disable("text"), i.setAll({ opacity: 0, tooltipText: void 0, tooltipHTML: void 0, interactive: !1 }), i.events.disable(), this.ghostLabel = i;
+  }
+  _updateFinals(e, i) {
+  }
+  /**
+   * Zooms the axis to relative locations.
+   *
+   * Both `start` and `end` are relative: 0 means start of the axis, 1 - end.
+   *
+   * @param   start     Relative start
+   * @param   end       Relative end
+   * @param   duration  Duration of the zoom animation in milliseconds
+   * @return            Zoom animation
+   */
+  zoom(e, i, t, s) {
+    if (this.get("zoomable", !0))
+      if (this._updateFinals(e, i), this.get("start") !== e || this.get("end") != i) {
+        let r = this._sAnimation, h = this._eAnimation;
+        e > i && ([e, i] = [i, e]);
+        let o = this.get("maxDeviation", 0.5) * Math.min(1, i - e);
+        e < -o && (e = -o), i > 1 + o && (i = 1 + o);
+        let a = this.getPrivate("maxZoomFactor", this.get("maxZoomFactor", 100)), l = a;
+        v(t) || (t = this.get("interpolationDuration", 0)), s || (s = "end"), i === 1 && e !== 0 && (e < this.get("start", 0) ? s = "start" : s = "end"), e === 0 && i !== 1 && (i > this.get("end", 1) ? s = "end" : s = "start");
+        let u = this.get("minZoomCount", 0);
+        const n = this.dataItems;
+        n && n.length < u && (u = n.length);
+        let d = this.get("maxZoomCount", 1 / 0);
+        v(u) && (a = l / u);
+        let c = 1;
+        if (v(d) && (c = l / d), e > i && ([e, i] = [i, e]), s === "start" ? (d > 0 && 1 / (i - e) < c && (i = e + 1 / c), 1 / (i - e) > a && (i = e + 1 / a), i > 1 && i - e < 1 / a && (e = i - 1 / a)) : (d > 0 && 1 / (i - e) < c && (e = i - 1 / c), 1 / (i - e) > a && (e = i - 1 / a), e < 0 && i - e < 1 / a && (i = e + 1 / a)), 1 / (i - e) > a && (i = e + 1 / a), 1 / (i - e) > a && (e = i - 1 / a), d != null && u != null && e == this.get("start") && i == this.get("end")) {
+          const m = this.chart;
+          m && m._handleAxisSelection(this, !0);
+        }
+        if ((r && r.playing && r.to == e || this.get("start") == e) && (h && h.playing && h.to == i || this.get("end") == i))
+          return;
+        if (t > 0) {
+          let m = this.get("interpolationEasing"), g, p;
+          if (this.get("start") != e && (g = this.animate({ key: "start", to: e, duration: t, easing: m })), this.get("end") != i && (p = this.animate({ key: "end", to: i, duration: t, easing: m })), this._sAnimation = g, this._eAnimation = p, g)
+            return g;
+          if (p)
+            return p;
+        } else
+          this.set("start", e), this.set("end", i), this.root.events.once("frameended", () => {
+            this.markDirtyKey("start");
+          });
+      } else
+        this._sAnimation && this._sAnimation.stop(), this._eAnimation && this._eAnimation.stop();
+  }
+  /**
+   * A list of series using this axis.
+   *
+   * @return Series
+   */
+  get series() {
+    return this._series;
+  }
+  _processAxisRange(e, i) {
+    e.setRaw("isRange", !0), this._createAssets(e, i), this._rangesDirty = !0, this._prepareDataItem(e);
+    const t = e.get("above"), s = this.topGridContainer, r = e.get("grid");
+    t && r && s.children.moveValue(r);
+    const h = e.get("axisFill");
+    t && h && s.children.moveValue(h);
+  }
+  _prepareDataItem(e, i) {
+  }
+  /**
+   * @ignore
+   */
+  markDirtyExtremes() {
+  }
+  /**
+   * @ignore
+   */
+  markDirtySelectionExtremes() {
+  }
+  _calculateTotals() {
+  }
+  _updateAxisRanges() {
+    this._bullets = {}, this.axisRanges.each((e) => {
+      this._prepareDataItem(e);
+    }), M(this._seriesAxisRanges, (e) => {
+      this._prepareDataItem(e);
+    });
+  }
+  _prepareChildren() {
+    super._prepareChildren();
+    const e = this.ghostLabel;
+    if (e && (this.get("fixAxisSize") ? e.set("visible", !0) : e.set("visible", !1)), this.isDirty("start") || this.isDirty("end")) {
+      const t = this.chart;
+      t && t._updateCursor();
+      let s = this.get("start", 0), r = this.get("end", 1), h = this.get("maxDeviation", 0.5) * Math.min(1, r - s);
+      if (s < -h) {
+        let o = s + h;
+        s = -h, this.setRaw("start", s), this.isDirty("end") && this.setRaw("end", r - o);
+      }
+      if (r > 1 + h) {
+        let o = r - 1 - h;
+        r = 1 + h, this.setRaw("end", r), this.isDirty("start") && this.setRaw("start", s - o);
+      }
+    }
+    const i = this.get("renderer");
+    if (i._start = this.get("start"), i._end = this.get("end"), i._inversed = i.get("inversed", !1), i._axisLength = i.axisLength() / (i._end - i._start), i._updateLC(), this.isDirty("tooltip")) {
+      const t = this.get("tooltip");
+      if (t) {
+        const s = i.get("themeTags");
+        t.addTag("axis"), t.addTag(this.className.toLowerCase()), t._applyThemes(), s && (t.set("themeTags", F(t.get("themeTags"), s)), t.label._applyThemes());
+      }
+    }
+  }
+  _updateTooltipBounds() {
+    const e = this.get("tooltip");
+    e && this.get("renderer").updateTooltipBounds(e);
+  }
+  _updateBounds() {
+    super._updateBounds(), this._updateTooltipBounds();
+  }
+  /**
+   * @ignore
+   */
+  processChart(e) {
+    this.chart = e;
+    const i = this.get("renderer");
+    i.chart = e, e.gridContainer.children.push(this.gridContainer), e.topGridContainer.children.push(this.topGridContainer), e.axisHeadersContainer.children.push(this.axisHeader), this.on("start", () => {
+      e._handleAxisSelection(this);
+    }), this.on("end", () => {
+      e._handleAxisSelection(this);
+    }), e.plotContainer.onPrivate("width", () => {
+      this.markDirtySize();
+    }), e.plotContainer.onPrivate("height", () => {
+      this.markDirtySize();
+    }), e.processAxis(this);
+  }
+  /**
+   * @ignore
+   */
+  hideDataItem(e) {
+    return this._toggleFHDataItem(e, !0), super.hideDataItem(e);
+  }
+  /**
+   * @ignore
+   */
+  showDataItem(e) {
+    return this._toggleFHDataItem(e, !1), super.showDataItem(e);
+  }
+  _toggleFHDataItem(e, i) {
+    const t = "forceHidden", s = e.get("label");
+    s && s.set(t, i);
+    const r = e.get("grid");
+    r && r.set(t, i);
+    const h = e.get("tick");
+    h && h.set(t, i);
+    const o = e.get("axisFill");
+    o && o.set(t, i);
+    const a = e.get("bullet");
+    if (a) {
+      const l = a.get("sprite");
+      l && l.set(t, i);
+    }
+  }
+  _toggleDataItem(e, i) {
+    const t = e.get("label"), s = "visible";
+    t && t.setPrivate(s, i);
+    const r = e.get("grid");
+    r && r.setPrivate(s, i);
+    const h = e.get("tick");
+    h && h.setPrivate(s, i);
+    const o = e.get("axisFill");
+    o && o.setPrivate(s, i);
+    const a = e.get("bullet");
+    if (a) {
+      const l = a.get("sprite");
+      l && l.setPrivate(s, i);
+    }
+  }
+  _createAssets(e, i, t) {
+    var s, r, h;
+    const o = this.get("renderer");
+    let a = "minor";
+    const l = e.get("label");
+    if (!l)
+      o.makeLabel(e, i);
+    else {
+      let d = l.get("themeTags"), c = !1;
+      t ? (d == null ? void 0 : d.indexOf(a)) == -1 && (c = !0) : (d == null ? void 0 : d.indexOf(a)) != -1 && (c = !0), c && ((s = l.parent) === null || s === void 0 || s.children.removeValue(l), o.makeLabel(e, i), l.dispose(), o.labels.removeValue(l));
+    }
+    const u = e.get("grid");
+    if (!u)
+      o.makeGrid(e, i);
+    else {
+      let d = u.get("themeTags"), c = !1;
+      t ? (d == null ? void 0 : d.indexOf(a)) == -1 && (c = !0) : (d == null ? void 0 : d.indexOf(a)) != -1 && (c = !0), c && ((r = u.parent) === null || r === void 0 || r.children.removeValue(u), o.makeGrid(e, i), u.dispose(), o.grid.removeValue(u));
+    }
+    const n = e.get("tick");
+    if (!n)
+      o.makeTick(e, i);
+    else {
+      let d = !1, c = n.get("themeTags");
+      t ? (c == null ? void 0 : c.indexOf(a)) == -1 && (d = !0) : (c == null ? void 0 : c.indexOf(a)) != -1 && (d = !0), d && ((h = n.parent) === null || h === void 0 || h.children.removeValue(n), o.makeTick(e, i), n.dispose(), o.ticks.removeValue(n));
+    }
+    (!t && !e.get("axisFill") || t && !e.get("axisFill") && this.get("minorAxisFillsEnabled")) && o.makeAxisFill(e, i), this._processBullet(e);
+  }
+  _processBullet(e) {
+    let i = e.get("bullet"), t = this.get("bullet");
+    if (!i && t && !e.get("isRange") && (i = t(this._root, this, e)), i) {
+      i.axis = this;
+      const s = i.get("sprite");
+      s && (s._setDataItem(e), e.setRaw("bullet", i), s.parent || this.bulletsContainer.children.push(s));
+    }
+  }
+  _afterChanged() {
+    super._afterChanged();
+    const e = this.chart;
+    e && (e._updateChartLayout(), e.axisHeadersContainer.markDirtySize()), this.get("renderer")._updatePositions(), this._seriesAdded = !1;
+  }
+  /**
+   * @ignore
+   */
+  disposeDataItem(e) {
+    super.disposeDataItem(e);
+    const i = this.get("renderer"), t = e.get("label");
+    t && (i.labels.removeValue(t), t.dispose());
+    const s = e.get("tick");
+    s && (i.ticks.removeValue(s), s.dispose());
+    const r = e.get("grid");
+    r && (i.grid.removeValue(r), r.dispose());
+    const h = e.get("axisFill");
+    h && (i.axisFills.removeValue(h), h.dispose());
+    const o = e.get("bullet");
+    o && o.dispose();
+  }
+  _updateGhost() {
+    this.setPrivate("cellWidth", this.getCellWidthPosition() * this.get("renderer").axisLength());
+    const e = this.ghostLabel;
+    if (e) {
+      if (!e.isHidden()) {
+        const s = e.localBounds(), r = Math.ceil(s.right - s.left);
+        let h = e.get("text");
+        M(this.dataItems, (o) => {
+          const a = o.get("label");
+          if (a && !a.isHidden()) {
+            const l = a.localBounds();
+            Math.ceil(l.right - l.left) > r && (h = a.text._getText());
+          }
+        }), e.set("text", h);
+      }
+      let i = this.get("start", 0), t = this.get("end", 1);
+      this.get("renderer").updateLabel(e, i + (t - i) * 0.5);
+    }
+  }
+  _handleCursorPosition(e, i) {
+    e = this.get("renderer").toAxisPosition(e), this._cursorPosition = e, this._snapToSeries = i, this.updateTooltip();
+  }
+  /**
+   * Can be called when axis zoom changes and you need to update tooltip
+   * position.
+   */
+  updateTooltip() {
+    const e = this._snapToSeries;
+    let i = this._cursorPosition;
+    const t = this.get("tooltip"), s = this.get("renderer");
+    v(i) && (M(this.series, (r) => {
+      if (r.get("baseAxis") === this) {
+        const h = this.getSeriesItem(r, i, this.get("tooltipLocation"));
+        e && e.indexOf(r) != -1 ? (r.updateLegendMarker(h), r.updateLegendValue(h), r._settings.tooltipDataItem = h) : (r.showDataItemTooltip(h), r.setRaw("tooltipDataItem", h));
+      }
+    }), this.get("snapTooltip") && (i = this.roundAxisPosition(i, this.get("tooltipLocation", 0.5))), this.setPrivateRaw("tooltipPosition", i), t && (s.updateTooltipBounds(t), Q(i) ? t.hide(0) : (this._updateTooltipText(t, i), s.positionTooltip(t, i), i < this.get("start", 0) || i > this.get("end", 1) ? t.hide(0) : t.show(0))));
+  }
+  _updateTooltipText(e, i) {
+    e.label.set("text", this.getTooltipText(i));
+  }
+  /**
+   * @ignore
+   */
+  roundAxisPosition(e, i) {
+    return e;
+  }
+  _handleSeriesRemoved() {
+  }
+  /**
+   * @ignore
+   */
+  handleCursorShow() {
+    let e = this.get("tooltip");
+    e && e.show();
+  }
+  /**
+   * @ignore
+   */
+  handleCursorHide() {
+    let e = this.get("tooltip");
+    e && e.hide();
+  }
+  /**
+   * @ignore
+   */
+  processSeriesDataItem(e, i) {
+  }
+  _clearDirty() {
+    super._clearDirty(), this._sizeDirty = !1, this._rangesDirty = !1;
+  }
+  /**
+   * Converts pixel coordinate to a relative position on axis.
+   *
+   * @param   coordinate  Coordinate
+   * @return              Relative position
+   */
+  coordinateToPosition(e) {
+    const i = this.get("renderer");
+    return i.toAxisPosition(e / i.axisLength());
+  }
+  /**
+   * Converts relative position of the plot area to relative position of the
+   * axis with zoom taken into account.
+   *
+   * @param position Position
+   * @return Relative position
+   */
+  toAxisPosition(e) {
+    return this.get("renderer").toAxisPosition(e);
+  }
+  /**
+   * Converts relative position of the axis to a global position taking current
+   * zoom into account (opposite to what `toAxisPosition` does).
+   *
+   * @since 5.4.2
+   * @param position Position
+   * @return Global position
+   */
+  toGlobalPosition(e) {
+    return this.get("renderer").toGlobalPosition(e);
+  }
+  /**
+   * Adjusts position with inversed taken into account.
+   *
+   * @ignore
+   */
+  fixPosition(e) {
+    return this.get("renderer").fixPosition(e);
+  }
+  /**
+   * @ignore
+   */
+  shouldGap(e, i, t, s) {
+    return !1;
+  }
+  /**
+   * Creates and returns an axis range object.
+   *
+   * @see {@link https://www.amcharts.com/docs/v5/charts/xy-chart/axes/axis-ranges/} for more info
+   * @param   axisDataItem  Axis data item
+   * @return                Axis range
+   */
+  createAxisRange(e) {
+    return this.axisRanges.push(e);
+  }
+  /**
+   * @ignore
+   */
+  _groupSeriesData(e) {
+  }
+  /**
+   * Returns relative position between two grid lines of the axis.
+   *
+   * @return Position
+   */
+  getCellWidthPosition() {
+    return 0.05;
+  }
+}
+Object.defineProperty(E, "className", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: "Axis"
+});
+Object.defineProperty(E, "classNames", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: be.classNames.concat([E.className])
+});
+class ie extends E {
+  constructor() {
+    super(...arguments), Object.defineProperty(this, "_dirtyExtremes", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: !1
+    }), Object.defineProperty(this, "_dirtySelectionExtremes", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: !1
+    }), Object.defineProperty(this, "_dseHandled", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: !1
+    }), Object.defineProperty(this, "_deltaMinMax", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: 1
+    }), Object.defineProperty(this, "_minReal", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_maxReal", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_minRealLog", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_baseValue", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: 0
+    }), Object.defineProperty(this, "_syncDp", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_minLogAdjusted", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: 1
+    });
+  }
+  /**
+   * @ignore
+   */
+  markDirtyExtremes() {
+    this._dirtyExtremes = !0, this.markDirty();
+  }
+  /**
+   * @ignore
+   */
+  markDirtySelectionExtremes() {
+    this._dirtySelectionExtremes = !0, this.markDirty();
+  }
+  _afterNew() {
+    this._settings.themeTags = F(this._settings.themeTags, ["axis"]), this.setPrivateRaw("name", "value"), this.addTag("value"), super._afterNew();
+  }
+  _prepareChildren() {
+    var e;
+    if (super._prepareChildren(), this.isDirty("syncWithAxis")) {
+      this._prevSettings.syncWithAxis && this._syncDp && this._syncDp.dispose();
+      let s = this.get("syncWithAxis");
+      s && (this._syncDp = new Me([
+        s.onPrivate("selectionMinFinal", () => {
+          this._dirtySelectionExtremes = !0;
+        }),
+        s.onPrivate("selectionMaxFinal", () => {
+          this._dirtySelectionExtremes = !0;
+        })
+      ]));
+    }
+    let i = !1;
+    if ((this.isDirty("min") || this.isDirty("max") || this.isDirty("maxPrecision") || this.isDirty("numberFormat")) && (i = !0, (e = this.ghostLabel) === null || e === void 0 || e.set("text", "")), (this._sizeDirty || this._dirtyExtremes || this._valuesDirty || i || this.isPrivateDirty("width") || this.isPrivateDirty("height") || this.isDirty("extraMin") || this.isDirty("extraMax") || this.isDirty("logarithmic") || this.isDirty("treatZeroAs") || this.isDirty("baseValue") || this.isDirty("strictMinMax") || this.isDirty("strictMinMaxSelection")) && (this._getMinMax(), this._dirtyExtremes = !1), this._handleSizeDirty(), this._dirtySelectionExtremes && !this._isPanning && this.get("autoZoom", !0)) {
+      const t = this.chart;
+      let s = !1;
+      if (t) {
+        const r = this.get("renderer").getPrivate("letter");
+        r == "Y" ? t.xAxes.each((h) => {
+          h.className != "ValueAxis" && (s = !0);
+        }) : r == "X" && t.yAxes.each((h) => {
+          h.className != "ValueAxis" && (s = !0);
+        });
+      }
+      s && this._getSelectionMinMax(), this._dirtySelectionExtremes = !1;
+    }
+    this._groupData(), (this._sizeDirty || this._valuesDirty || this.isDirty("start") || this.isDirty("end") || this.isPrivateDirty("min") || this.isPrivateDirty("selectionMax") || this.isPrivateDirty("selectionMin") || this.isPrivateDirty("max") || this.isPrivateDirty("step") || this.isPrivateDirty("width") || this.isPrivateDirty("height") || this.isDirty("logarithmic")) && (this._handleRangeChange(), this._prepareAxisItems(), this._updateAxisRanges()), this._baseValue = this.baseValue();
+  }
+  _handleSizeDirty() {
+    this._sizeDirty && !this._dseHandled && (this._dirtySelectionExtremes = !0, this._dseHandled = !0, (this.getPrivate("selectionMinFinal") != this.getPrivate("selectionMin") || this.getPrivate("selectionMaxFinal") != this.getPrivate("selectionMax")) && (this._dirtySelectionExtremes = !1));
+  }
+  _clearDirty() {
+    super._clearDirty(), this._dseHandled = !1;
+  }
+  _groupData() {
+  }
+  _formatText(e) {
+    const i = this.get("numberFormat"), t = this.getNumberFormatter();
+    let s = "";
+    return i ? s = t.format(e, i) : s = t.format(e, void 0, this.getPrivate("stepDecimalPlaces")), s;
+  }
+  _prepareAxisItems() {
+    const e = this.getPrivate("min"), i = this.getPrivate("max");
+    if (v(e) && v(i)) {
+      const t = this.get("logarithmic"), s = this.getPrivate("step"), r = this.getPrivate("selectionMin"), h = this.getPrivate("selectionMax") + s;
+      let o = r - s, a = 1, l = e;
+      if (t) {
+        if (o = this._minLogAdjusted, o < r)
+          for (; o < r; )
+            o += s;
+        if (l = o, l <= 0) {
+          let b = this._minRealLog;
+          v(b) || (b = 1), l = Math.pow(10, Math.log(b) * Math.LOG10E), s < 1 && (v(this._minRealLog) ? l = this._minRealLog : l = Math.pow(10, -50));
+        }
+        a = Math.log(h - s) * Math.LOG10E - Math.log(l) * Math.LOG10E, a > 2 && (o = Math.pow(10, Math.log(l) * Math.LOG10E - 50));
+      }
+      const u = this.get("renderer"), n = u.get("minorLabelsEnabled"), d = u.get("minorGridEnabled", n);
+      let c = Math.pow(10, Math.floor(Math.log(Math.abs(s)) * Math.LOG10E));
+      const m = Math.round(s / c);
+      let g = 2;
+      C(m / 5, 10) % 1 == 0 && (g = 5), C(m / 10, 10) % 1 == 0 && (g = 10);
+      let p = s / g, f = 0, _ = 0, x = -1 / 0;
+      for (; o < h; ) {
+        let b;
+        this.dataItems.length < f + 1 ? (b = new Z(this, void 0, {}), this._dataItems.push(b), this.processDataItem(b)) : b = this.dataItems[f], this._createAssets(b, []), this._toggleDataItem(b, !0), b.setRaw("value", o);
+        const P = b.get("label");
+        P && P.set("text", this._formatText(o)), this._prepareDataItem(b);
+        let y = o;
+        if (t && a > 2 ? y = Math.pow(10, Math.log(l) * Math.LOG10E + f - 50) : y += s, d) {
+          let w = o + p;
+          for (t && (a > 2 && (p = this._adjustMinMax(o, y, 10).step), w = o + p); w < y - s * 1e-11; ) {
+            let D;
+            this.minorDataItems.length < _ + 1 ? (D = new Z(this, void 0, {}), this.minorDataItems.push(D), this.processDataItem(D)) : D = this.minorDataItems[_], this._createAssets(D, ["minor"], !0), this._toggleDataItem(D, !0), D.setRaw("value", w);
+            const S = D.get("label");
+            S && (n ? S.set("text", this._formatText(w)) : S.setPrivate("visible", !1)), this._prepareDataItem(D), w += p, _++;
+          }
+        }
+        if (o = y, x == o)
+          break;
+        let A = Math.pow(10, Math.floor(Math.log(Math.abs(s)) * Math.LOG10E));
+        if (A < 1 && !t) {
+          let w = Math.round(Math.abs(Math.log(Math.abs(A)) * Math.LOG10E)) + 2;
+          o = C(o, w);
+        }
+        f++, t && a <= 2 && o - s < s && (o = s), x = o;
+      }
+      for (let b = f; b < this.dataItems.length; b++)
+        this._toggleDataItem(this.dataItems[b], !1);
+      for (let b = _; b < this.minorDataItems.length; b++)
+        this._toggleDataItem(this.minorDataItems[b], !1);
+      M(this.series, (b) => {
+        b.inited && b._markDirtyAxes();
+      }), this._updateGhost();
+    }
+  }
+  _prepareDataItem(e, i) {
+    let t = this.get("renderer"), s = e.get("value"), r = e.get("endValue"), h = this.valueToPosition(s), o = h, a = this.valueToPosition(s + this.getPrivate("step"));
+    v(r) && (o = this.valueToPosition(r), a = o), e.get("isRange") && r == null && (a = h);
+    let l = o, u = e.get("labelEndValue");
+    u != null && (l = this.valueToPosition(u)), t.updateLabel(e.get("label"), h, l, i);
+    const n = e.get("grid");
+    if (t.updateGrid(n, h, o), n && (s == this.get("baseValue", 0) ? (n.addTag("base"), n._applyThemes()) : n.hasTag("base") && (n.removeTag("base"), n._applyThemes())), t.updateTick(e.get("tick"), h, l, i), t.updateFill(e.get("axisFill"), h, a), this._processBullet(e), t.updateBullet(e.get("bullet"), h, o), !e.get("isRange")) {
+      const d = this.get("fillRule");
+      d && d(e);
+    }
+  }
+  _handleRangeChange() {
+    let e = this.positionToValue(this.get("start", 0)), i = this.positionToValue(this.get("end", 1));
+    const t = this.get("renderer").gridCount();
+    let s = this._adjustMinMax(e, i, t, !0), r = ke(s.step);
+    this.setPrivateRaw("stepDecimalPlaces", r), e = C(e, r), i = C(i, r), s = this._adjustMinMax(e, i, t, !0);
+    let h = s.step;
+    e = s.min, i = s.max, (this.getPrivate("selectionMin") !== e || this.getPrivate("selectionMax") !== i || this.getPrivate("step") !== h) && (this.setPrivateRaw("selectionMin", e), this.setPrivateRaw("selectionMax", i), this.setPrivateRaw("step", h));
+  }
+  /**
+   * Converts a relative position to a corresponding numeric value from axis
+   * scale.
+   *
+   * @param   position  Relative position
+   * @return            Value
+   */
+  positionToValue(e) {
+    const i = this.getPrivate("min"), t = this.getPrivate("max");
+    return this.get("logarithmic") ? Math.pow(Math.E, (e * (Math.log(t) * Math.LOG10E - Math.log(i) * Math.LOG10E) + Math.log(i) * Math.LOG10E) / Math.LOG10E) : e * (t - i) + i;
+  }
+  /**
+   * Convers value to a relative position on axis.
+   *
+   * @param   value  Value
+   * @return         Relative position
+   */
+  valueToPosition(e) {
+    const i = this.getPrivate("min"), t = this.getPrivate("max");
+    if (this.get("logarithmic")) {
+      if (e <= 0) {
+        let s = this.get("treatZeroAs");
+        v(s) && (e = s);
+      }
+      return (Math.log(e) * Math.LOG10E - Math.log(i) * Math.LOG10E) / (Math.log(t) * Math.LOG10E - Math.log(i) * Math.LOG10E);
+    } else
+      return (e - i) / (t - i);
+  }
+  /**
+   * @ignore
+   */
+  valueToFinalPosition(e) {
+    const i = this.getPrivate("minFinal"), t = this.getPrivate("maxFinal");
+    if (this.get("logarithmic")) {
+      if (e <= 0) {
+        let s = this.get("treatZeroAs");
+        v(s) && (e = s);
+      }
+      return (Math.log(e) * Math.LOG10E - Math.log(i) * Math.LOG10E) / (Math.log(t) * Math.LOG10E - Math.log(i) * Math.LOG10E);
+    } else
+      return (e - i) / (t - i);
+  }
+  /**
+   * Returns X coordinate in pixels corresponding to specific value.
+   *
+   * @param   value     Numeric value
+   * @param   location  Location
+   * @param   baseValue Base value
+   * @return            X coordinate
+   */
+  getX(e, i, t) {
+    e = t + (e - t) * i;
+    const s = this.valueToPosition(e);
+    return this._settings.renderer.positionToCoordinate(s);
+  }
+  /**
+   * Returns X coordinate in pixels corresponding to specific value.
+   *
+   * @param   value     Numeric value
+   * @param   location  Location
+   * @param   baseValue Base value
+   * @return            X coordinate
+   */
+  getY(e, i, t) {
+    e = t + (e - t) * i;
+    const s = this.valueToPosition(e);
+    return this._settings.renderer.positionToCoordinate(s);
+  }
+  /**
+   * @ignore
+   */
+  getDataItemCoordinateX(e, i, t, s) {
+    return this._settings.renderer.positionToCoordinate(this.getDataItemPositionX(e, i, t, s));
+  }
+  /**
+   * @ignore
+   */
+  getDataItemPositionX(e, i, t, s) {
+    let r = e.get(i);
+    if (e.get("stackToItemX")) {
+      const o = e.component;
+      r = r * s + o.getStackedXValueWorking(e, i);
+    } else
+      r = this._baseValue + (r - this._baseValue) * s;
+    return this.valueToPosition(r);
+  }
+  /**
+   * @ignore
+   */
+  getDataItemCoordinateY(e, i, t, s) {
+    return this._settings.renderer.positionToCoordinate(this.getDataItemPositionY(e, i, t, s));
+  }
+  /**
+   * @ignore
+   */
+  getDataItemPositionY(e, i, t, s) {
+    let r = e.get(i);
+    if (e.get("stackToItemY")) {
+      const o = e.component;
+      r = r * s + o.getStackedYValueWorking(e, i);
+    } else
+      r = this._baseValue + (r - this._baseValue) * s;
+    return this.valueToPosition(r);
+  }
+  /**
+   * Returns relative position of axis' `baseValue`.
+   *
+   * @return  Base value position
+   */
+  basePosition() {
+    return this.valueToPosition(this.baseValue());
+  }
+  /**
+   * Base value of the [[ValueAxis]], which determines positive and negative
+   * values.
+   *
+   * @return Base value
+   */
+  baseValue() {
+    const e = Math.min(this.getPrivate("minFinal", -1 / 0), this.getPrivate("selectionMin", -1 / 0)), i = Math.max(this.getPrivate("maxFinal", 1 / 0), this.getPrivate("selectionMax", 1 / 0));
+    let t = this.get("baseValue", 0);
+    return t < e && (t = e), t > i && (t = i), t;
+  }
+  /**
+   * @ignore
+   */
+  cellEndValue(e) {
+    return e;
+  }
+  fixSmallStep(e) {
+    return 1 + e === 1 ? (e *= 2, this.fixSmallStep(e)) : e;
+  }
+  _fixMin(e) {
+    return e;
+  }
+  _fixMax(e) {
+    return e;
+  }
+  _calculateTotals() {
+    if (this.get("calculateTotals")) {
+      let e = this.series[0];
+      if (e) {
+        let i = e.startIndex();
+        if (e.dataItems.length > 0) {
+          i > 0 && i--;
+          let t = e.endIndex();
+          t < e.dataItems.length && t++;
+          let s, r;
+          e.get("yAxis") == this ? (s = "valueY", r = "vcy") : e.get("xAxis") == this && (s = "valueX", r = "vcx");
+          let h = s + "Working";
+          if (s)
+            for (let o = i; o < t; o++) {
+              let a = 0, l = 0;
+              M(this.series, (u) => {
+                if (!u.get("excludeFromTotal")) {
+                  let n = u.dataItems[o];
+                  if (n) {
+                    let d = n.get(h) * u.get(r);
+                    Q(d) || (a += d, l += Math.abs(d));
+                  }
+                }
+              }), M(this.series, (u) => {
+                if (!u.get("excludeFromTotal")) {
+                  let n = u.dataItems[o];
+                  if (n) {
+                    let d = n.get(h) * u.get(r);
+                    if (!Q(d)) {
+                      n.set(s + "Total", l), n.set(s + "Sum", a);
+                      let c = d / l * 100;
+                      l == 0 && (c = 0), n.set(s + "TotalPercent", c);
+                    }
+                  }
+                }
+              });
+            }
+        }
+      }
+    }
+  }
+  _getSelectionMinMax() {
+    const e = this.getPrivate("minFinal"), i = this.getPrivate("maxFinal"), t = this.get("min"), s = this.get("max");
+    let r = this.get("extraMin", 0), h = this.get("extraMax", 0);
+    this.get("logarithmic") && (this.get("extraMin") == null && (r = 0.1), this.get("extraMax") == null && (h = 0.2));
+    const o = this.get("renderer").gridCount(), a = this.get("strictMinMaxSelection");
+    let l = this.get("strictMinMax");
+    if (v(e) && v(i)) {
+      let u = i, n = e;
+      if (M(this.series, (b) => {
+        if (!b.get("ignoreMinMax")) {
+          let P, y;
+          const A = b.getPrivate("outOfSelection");
+          if (b.get("xAxis") === this) {
+            if (!A) {
+              let w = b.getPrivate("minX"), D = b.getPrivate("maxX");
+              (b.startIndex() != 0 || b.endIndex() != b.dataItems.length) && (w = void 0, D = void 0), P = b.getPrivate("selectionMinX", w), y = b.getPrivate("selectionMaxX", D);
+            }
+          } else if (b.get("yAxis") === this && !A) {
+            let w = b.getPrivate("minY"), D = b.getPrivate("maxY");
+            (b.startIndex() != 0 || b.endIndex() != b.dataItems.length) && (w = void 0, D = void 0), P = b.getPrivate("selectionMinY", w), y = b.getPrivate("selectionMaxY", D);
+          }
+          !b.isHidden() && !b.isShowing() && (v(P) && (u = Math.min(u, P)), v(y) && (n = Math.max(n, y)));
+        }
+      }), this.axisRanges.each((b) => {
+        if (b.get("affectsMinMax")) {
+          let P = b.get("value");
+          P != null && (u = Math.min(u, P), n = Math.max(n, P)), P = b.get("endValue"), P != null && (u = Math.min(u, P), n = Math.max(n, P));
+        }
+      }), u > n && ([u, n] = [n, u]), v(t) ? l ? u = t : u = e : l && v(this._minReal) && (u = this._minReal), v(s) ? l ? n = s : n = i : l && v(this._maxReal) && (n = this._maxReal), u === n) {
+        let b = u;
+        if (u -= this._deltaMinMax, n += this._deltaMinMax, u < e) {
+          let y = b - e;
+          y == 0 && (y = this._deltaMinMax), u = b - y, n = b + y, l = !0;
+        }
+        let P = this._adjustMinMax(u, n, o, l);
+        u = P.min, n = P.max;
+      }
+      let d = u, c = n, m = n - u;
+      u -= m * r, n += m * h;
+      let g = this._adjustMinMax(u, n, o);
+      u = g.min, n = g.max, u = J(u, e, i), n = J(n, e, i), g = this._adjustMinMax(u, n, o, !0), l || (u = g.min, n = g.max);
+      const p = this.get("syncWithAxis");
+      if (p && (g = this._syncAxes(u, n, g.step, p.getPrivate("selectionMinFinal", p.getPrivate("minFinal", 0)), p.getPrivate("selectionMaxFinal", p.getPrivate("maxFinal", 1)), p.getPrivate("selectionStepFinal", p.getPrivate("step", 1))), g.min < e && (g.min = e), g.max > i && (g.max = i), u = g.min, n = g.max), l && (v(t) && (u = Math.max(u, t)), v(s) && (n = Math.min(n, s))), a && (u = d - (c - d) * r, n = c + (c - d) * h), l) {
+        v(t) ? u = t : u = d, v(s) ? n = s : n = c, n - u <= 1e-8 && (u -= this._deltaMinMax, n += this._deltaMinMax);
+        let b = n - u;
+        u -= b * r, n += b * h;
+      }
+      this.get("logarithmic") && (u <= 0 && (u = d * (1 - Math.min(r, 0.99))), u < e && (u = e), n > i && (n = i));
+      let f = Math.min(20, Math.ceil(Math.log(this.getPrivate("maxZoomFactor", 100) + 1) / Math.LN10) + 2), _ = C(this.valueToFinalPosition(u), f), x = C(this.valueToFinalPosition(n), f);
+      this.setPrivateRaw("selectionMinFinal", u), this.setPrivateRaw("selectionMaxFinal", n), this.setPrivateRaw("selectionStepFinal", g.step), this.zoom(_, x);
+    }
+  }
+  _getMinMax() {
+    let e = this.get("min"), i = this.get("max"), t = 1 / 0, s = -1 / 0, r = this.get("extraMin", 0), h = this.get("extraMax", 0);
+    this.get("logarithmic") && (this.get("strictMinMax") || (this.get("extraMin") == null && (r = 0.1), this.get("extraMax") == null && (h = 0.2)));
+    let o = 1 / 0;
+    if (M(this.series, (x) => {
+      if (!x.get("ignoreMinMax")) {
+        let b, P;
+        if (x.get("xAxis") === this ? (b = x.getPrivate("minX"), P = x.getPrivate("maxX")) : x.get("yAxis") === this && (b = x.getPrivate("minY"), P = x.getPrivate("maxY")), v(b) && v(P)) {
+          t = Math.min(t, b), s = Math.max(s, P);
+          let y = P - b;
+          y <= 0 && (y = Math.abs(P / 100)), y < o && (o = y);
+        }
+      }
+    }), this.axisRanges.each((x) => {
+      if (x.get("affectsMinMax")) {
+        let b = x.get("value");
+        b != null && (t = Math.min(t, b), s = Math.max(s, b)), b = x.get("endValue"), b != null && (t = Math.min(t, b), s = Math.max(s, b));
+      }
+    }), this.get("logarithmic")) {
+      let x = this.get("treatZeroAs");
+      v(x) && t <= 0 && (t = x);
+    }
+    if (t === 0 && s === 0 && (s = 0.9, t = -0.9), v(e) && (t = e), v(i) && (s = i), t === 1 / 0 || s === -1 / 0) {
+      this.setPrivate("minFinal", void 0), this.setPrivate("maxFinal", void 0);
+      return;
+    }
+    t > s && ([t, s] = [s, t]);
+    const a = t, l = s;
+    let u = this.adapters.fold("min", t), n = this.adapters.fold("max", s);
+    this._minRealLog = t, v(u) && (t = u), v(n) && (s = n), t = this._fixMin(t), s = this._fixMax(s), s - t <= 1 / Math.pow(10, 15) && (s - t !== 0 ? this._deltaMinMax = (s - t) / 2 : this._getDelta(s), t -= this._deltaMinMax, s += this._deltaMinMax), t -= (s - t) * r, s += (s - t) * h, this.get("logarithmic") && (t < 0 && a >= 0 && (t = 0), s > 0 && l <= 0 && (s = 0)), this._minReal = t, this._maxReal = s;
+    let d = this.get("strictMinMax"), c = this.get("strictMinMaxSelection", !1);
+    c && (d = c);
+    let m = d;
+    v(i) && (m = !0);
+    let g = this.get("renderer").gridCount(), p = this._adjustMinMax(t, s, g, m);
+    if (t = p.min, s = p.max, p = this._adjustMinMax(t, s, g, !0), t = p.min, s = p.max, d) {
+      v(e) ? t = e : t = this._minReal, v(i) ? s = i : s = this._maxReal, s - t <= 1e-8 && (t -= this._deltaMinMax, s += this._deltaMinMax);
+      let x = s - t;
+      t -= x * r, s += x * h;
+    }
+    u = this.adapters.fold("min", t), n = this.adapters.fold("max", s), v(u) && (t = u), v(n) && (s = n), o == 1 / 0 && (o = s - t);
+    let f = Math.round(Math.abs(Math.log(Math.abs(s - t)) * Math.LOG10E)) + 5;
+    t = C(t, f), s = C(s, f);
+    const _ = this.get("syncWithAxis");
+    if (_ && (p = this._syncAxes(t, s, p.step, _.getPrivate("minFinal", _.getPrivate("min", 0)), _.getPrivate("maxFinal", _.getPrivate("max", 1)), _.getPrivate("step", 1)), t = p.min, s = p.max), this.setPrivateRaw("maxZoomFactor", Math.max(1, Math.ceil((s - t) / o * this.get("maxZoomFactor", 100)))), this._fixZoomFactor(), this.get("logarithmic") && (this._minLogAdjusted = t, t = this._minReal, s = this._maxReal, t <= 0 && (t = a * (1 - Math.min(r, 0.99)))), v(t) && v(s) && (this.getPrivate("minFinal") !== t || this.getPrivate("maxFinal") !== s)) {
+      this.setPrivate("minFinal", t), this.setPrivate("maxFinal", s), this._saveMinMax(t, s);
+      const x = this.get("interpolationDuration", 0), b = this.get("interpolationEasing");
+      this.animatePrivate({ key: "min", to: t, duration: x, easing: b }), this.animatePrivate({ key: "max", to: s, duration: x, easing: b });
+    }
+  }
+  _fixZoomFactor() {
+  }
+  _getDelta(e) {
+    let i = Math.log(Math.abs(e)) * Math.LOG10E, t = Math.pow(10, Math.floor(i));
+    t = t / 10, this._deltaMinMax = t;
+  }
+  _saveMinMax(e, i) {
+  }
+  _adjustMinMax(e, i, t, s) {
+    t <= 1 && (t = 1), t = Math.round(t);
+    let r = e, h = i, o = i - e;
+    o === 0 && (o = Math.abs(i));
+    let a = Math.log(Math.abs(o)) * Math.LOG10E, l = Math.pow(10, Math.floor(a));
+    l = l / 10;
+    let u = l;
+    s && (u = 0), s ? (e = Math.floor(e / l) * l, i = Math.ceil(i / l) * l) : (e = Math.ceil(e / l) * l - u, i = Math.floor(i / l) * l + u), e < 0 && r >= 0 && (e = 0), i > 0 && h <= 0 && (i = 0), a = Math.log(Math.abs(o)) * Math.LOG10E, l = Math.pow(10, Math.floor(a)), l = l / 100;
+    let n = Math.ceil(o / t / l) * l, d = Math.pow(10, Math.floor(Math.log(Math.abs(n)) * Math.LOG10E)), c = Math.ceil(n / d);
+    c > 5 ? c = 10 : c <= 5 && c > 2 && (c = 5), n = Math.ceil(n / (d * c)) * d * c;
+    let m = this.get("maxPrecision");
+    if (v(m)) {
+      let _ = Pe(n, m);
+      m < Number.MAX_VALUE && n !== _ && (n = _, n == 0 && (n = 1));
+    }
+    let g = 0;
+    d < 1 && (g = Math.round(Math.abs(Math.log(Math.abs(d)) * Math.LOG10E)) + 1, n = C(n, g));
+    let p = Math.floor(e / n);
+    e = C(n * p, g);
+    let f;
+    return s ? f = Math.floor(i / n) : f = Math.ceil(i / n), f === p && f++, i = C(n * f, g), i < h && (i = i + n), e > r && (e = e - n), n = this.fixSmallStep(n), { min: e, max: i, step: n };
+  }
+  /**
+   * Returns text to be used in an axis tooltip for specific relative position.
+   *
+   * @param   position  Position
+   * @return            Tooltip text
+   */
+  getTooltipText(e, i) {
+    const t = this.get("tooltipNumberFormat", this.get("numberFormat")), s = this.getNumberFormatter(), r = this.get("extraTooltipPrecision", 0), h = this.getPrivate("stepDecimalPlaces", 0) + r, o = C(this.positionToValue(e), h);
+    return t ? s.format(o, t) : s.format(o, void 0, h);
+  }
+  /**
+   * Returns a data item from series that is closest to the `position`.
+   *
+   * @param   series    Series
+   * @param   position  Relative position
+   * @return            Data item
+   */
+  getSeriesItem(e, i) {
+    let t = this.getPrivate("name") + this.get("renderer").getPrivate("letter"), s = this.positionToValue(i), r, h;
+    if (M(e.dataItems, (o, a) => {
+      const l = Math.abs(o.get(t) - s);
+      (r === void 0 || l < h) && (r = a, h = l);
+    }), r != null)
+      return e.dataItems[r];
+  }
+  /**
+   * Zooms the axis to specific `start` and `end` values.
+   *
+   * Optional `duration` specifies duration of zoom animation in milliseconds.
+   *
+   * @param  start     Start value
+   * @param  end       End value
+   * @param  duration  Duration in milliseconds
+   */
+  zoomToValues(e, i, t) {
+    const s = this.getPrivate("minFinal", this.getPrivate("min", 0)), r = this.getPrivate("maxFinal", this.getPrivate("max", 1));
+    this.getPrivate("min") != null && this.getPrivate("max") != null && this.zoom((e - s) / (r - s), (i - s) / (r - s), t);
+  }
+  /**
+   * Syncs with a target axis.
+   *
+   * @param  min  Min
+   * @param  max  Max
+   * @param  step Step
+   */
+  _syncAxes(e, i, t, s, r, h) {
+    if (this.get("syncWithAxis")) {
+      let a = Math.round(r - s) / h, l = Math.round((i - e) / t), u = this.get("renderer").gridCount();
+      if (v(a) && v(l)) {
+        let n = !1, d = 0, c = (i - e) * 0.01, m = e, g = i, p = t;
+        for (; n != !0; )
+          if (n = this._checkSync(m, g, p, a), d++, d > 500 && (n = !0), n)
+            e = m, i = g, t = p;
+          else {
+            d / 3 == Math.round(d / 3) ? (m = e - c * d, e >= 0 && m < 0 && (m = 0)) : (g = i + c * d, g <= 0 && g > 0 && (g = 0));
+            let f = this._adjustMinMax(m, g, u, !0);
+            m = f.min, g = f.max, p = f.step;
+          }
+      }
+    }
+    return { min: e, max: i, step: t };
+  }
+  /**
+   * Returns `true` if axis needs to be resunced with some other axis.
+   */
+  _checkSync(e, i, t, s) {
+    let r = (i - e) / t;
+    for (let h = 1; h < s; h++)
+      if (C(r / h, 1) == s || r * h == s)
+        return !0;
+    return !1;
+  }
+  /**
+   * Returns relative position between two grid lines of the axis.
+   *
+   * @return Position
+   */
+  getCellWidthPosition() {
+    let e = this.getPrivate("selectionMax", this.getPrivate("max")), i = this.getPrivate("selectionMin", this.getPrivate("min"));
+    return v(e) && v(i) ? this.getPrivate("step", 1) / (e - i) : 0.05;
+  }
+  /**
+   * @ignore
+   */
+  nextPosition(e) {
+    e == null && (e = 1), this.get("renderer").getPrivate("letter") == "Y" && (e *= -1);
+    let i = this.positionToValue(this.getPrivate("tooltipPosition", 0));
+    return i += this.getPrivate("step", 1) * e, i = J(i, this.getPrivate("selectionMin", 0), this.getPrivate("selectionMax", 1)), this.toGlobalPosition(this.valueToPosition(i));
+  }
+}
+Object.defineProperty(ie, "className", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: "ValueAxis"
+});
+Object.defineProperty(ie, "classNames", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: E.classNames.concat([ie.className])
+});
+class K extends _e {
+  constructor() {
+    super(...arguments), Object.defineProperty(this, "_tickPoints", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: []
+    });
+  }
+}
+Object.defineProperty(K, "className", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: "AxisLabel"
+});
+Object.defineProperty(K, "classNames", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: _e.classNames.concat([K.className])
+});
+class q extends ve {
+  constructor() {
+    super(...arguments), Object.defineProperty(this, "_tickPoints", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: []
+    });
+  }
+}
+Object.defineProperty(q, "className", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: "AxisTick"
+});
+Object.defineProperty(q, "classNames", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: ve.classNames.concat([q.className])
+});
+class se extends I {
+  constructor() {
+    super(...arguments), Object.defineProperty(this, "_axisLength", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: 100
+    }), Object.defineProperty(this, "_start", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: 0
+    }), Object.defineProperty(this, "_end", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: 1
+    }), Object.defineProperty(this, "_inversed", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: !1
+    }), Object.defineProperty(this, "_minSize", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: 0
+    }), Object.defineProperty(this, "chart", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_lc", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: 1
+    }), Object.defineProperty(this, "_ls", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: 0
+    }), Object.defineProperty(this, "_thumbDownPoint", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_downStart", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_downEnd", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "ticks", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: this.addDisposer(new G(z.new({}), () => q._new(this._root, {
+        themeTags: F(this.ticks.template.get("themeTags", []), this.get("themeTags", []))
+      }, [this.ticks.template])))
+    }), Object.defineProperty(this, "grid", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: this.addDisposer(new G(z.new({}), () => H._new(this._root, {
+        themeTags: F(this.grid.template.get("themeTags", []), this.get("themeTags", []))
+      }, [this.grid.template])))
+    }), Object.defineProperty(this, "axisFills", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: this.addDisposer(new G(z.new({}), () => I._new(this._root, {
+        themeTags: F(this.axisFills.template.get("themeTags", ["axis", "fill"]), this.get("themeTags", []))
+      }, [this.axisFills.template])))
+    }), Object.defineProperty(this, "labels", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: this.addDisposer(new G(z.new({}), () => K._new(this._root, {
+        themeTags: F(this.labels.template.get("themeTags", []), this.get("themeTags", []))
+      }, [this.labels.template])))
+    }), Object.defineProperty(this, "axis", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "thumb", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    });
+  }
+  /**
+   * @ignore
+   */
+  makeTick(e, i) {
+    const t = this.ticks.make();
+    return t._setDataItem(e), e.setRaw("tick", t), t.set("themeTags", F(t.get("themeTags"), i)), this.axis.labelsContainer.children.push(t), this.ticks.push(t), t;
+  }
+  /**
+   * @ignore
+   */
+  makeGrid(e, i) {
+    const t = this.grid.make();
+    return t._setDataItem(e), e.setRaw("grid", t), t.set("themeTags", F(t.get("themeTags"), i)), this.axis.gridContainer.children.push(t), this.grid.push(t), t;
+  }
+  /**
+   * @ignore
+   */
+  makeAxisFill(e, i) {
+    const t = this.axisFills.make();
+    return t._setDataItem(e), t.set("themeTags", F(t.get("themeTags"), i)), this.axis.gridContainer.children.push(t), e.setRaw("axisFill", t), this.axisFills.push(t), t;
+  }
+  /**
+   * @ignore
+   */
+  makeLabel(e, i) {
+    const t = this.labels.make();
+    return t.set("themeTags", F(t.get("themeTags"), i)), this.axis.labelsContainer.children.moveValue(t, 0), t._setDataItem(e), e.setRaw("label", t), this.labels.push(t), t;
+  }
+  axisLength() {
+    return 0;
+  }
+  /**
+   * @ignore
+   */
+  gridCount() {
+    return this.axisLength() / this.get("minGridDistance", 50);
+  }
+  _updatePositions() {
+  }
+  _afterNew() {
+    super._afterNew(), this.set("isMeasured", !1);
+    const e = this.thumb;
+    e && (this._disposers.push(e.events.on("pointerdown", (i) => {
+      this._handleThumbDown(i);
+    })), this._disposers.push(e.events.on("globalpointerup", (i) => {
+      this._handleThumbUp(i);
+    })), this._disposers.push(e.events.on("globalpointermove", (i) => {
+      this._handleThumbMove(i);
+    })));
+  }
+  _beforeChanged() {
+    super._beforeChanged(), this.isDirty("minGridDistance") && this.root.events.once("frameended", () => {
+      this.axis.markDirtySize();
+    });
+  }
+  _changed() {
+    if (super._changed(), this.isDirty("pan")) {
+      const e = this.thumb;
+      if (e) {
+        const i = this.axis.labelsContainer, t = this.get("pan");
+        t == "zoom" ? i.children.push(e) : t == "none" && i.children.removeValue(e);
+      }
+    }
+  }
+  _handleThumbDown(e) {
+    this._thumbDownPoint = this.toLocal(e.point);
+    const i = this.axis;
+    this._downStart = i.get("start"), this._downEnd = i.get("end");
+  }
+  _handleThumbUp(e) {
+    this._thumbDownPoint = void 0;
+  }
+  _handleThumbMove(e) {
+    const i = this._thumbDownPoint;
+    if (i) {
+      const t = this.toLocal(e.point), s = this._downStart, r = this._downEnd, h = this._getPan(t, i) * Math.min(1, r - s) / 2 * this.get("panSensitivity", 1);
+      this.axis.zoom(s - h, r + h, 0);
+    }
+  }
+  _getPan(e, i) {
+    return 0;
+  }
+  /**
+   * Converts relative position (0-1) on axis to a pixel coordinate.
+   *
+   * @param position  Position (0-1)
+   * @return Coordinate (px)
+   */
+  positionToCoordinate(e) {
+    return this._inversed ? (this._end - e) * this._axisLength : (e - this._start) * this._axisLength;
+  }
+  /**
+   * @ignore
+   */
+  updateTooltipBounds(e) {
+  }
+  _updateSize() {
+    this.markDirty(), this._clear = !0;
+  }
+  /**
+   * @ignore
+   */
+  toAxisPosition(e) {
+    const i = this._start || 0, t = this._end || 1;
+    return e = e * (t - i), this.get("inversed") ? e = t - e : e = i + e, e;
+  }
+  /**
+   * @ignore
+   */
+  toGlobalPosition(e) {
+    const i = this._start || 0, t = this._end || 1;
+    return this.get("inversed") ? e = t - e : e = e - i, e = e / (t - i), e;
+  }
+  /**
+   * @ignore
+   */
+  fixPosition(e) {
+    return this.get("inversed") ? 1 - e : e;
+  }
+  /**
+   * @ignore
+   */
+  _updateLC() {
+  }
+  toggleVisibility(e, i, t, s) {
+    let r = this.axis;
+    const h = r.get("start", 0), o = r.get("end", 1);
+    let a = h + (o - h) * (t - 1e-4), l = h + (o - h) * (s + 1e-4);
+    i < a || i > l ? e.setPrivate("visible", !1) : e.setPrivate("visible", !0);
+  }
+  _positionTooltip(e, i) {
+    const t = this.chart;
+    t && (e.set("pointTo", this._display.toGlobal(i)), t.inPlot(i) || e.hide());
+  }
+  processAxis() {
+  }
+}
+Object.defineProperty(se, "className", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: "AxisRenderer"
+});
+Object.defineProperty(se, "classNames", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: I.classNames.concat([se.className])
+});
+export {
+  E as A,
+  H as G,
+  ie as V,
+  ee as X,
+  se as a,
+  te as b
+};