igniteui-webcomponents-charts 4.3.0-beta.0 → 4.3.0-beta.2

package/esm2015/lib/CategoryChart.js

@@ -35,120 +35,120 @@ import { stringIsNullOrEmpty } from "igniteui-webcomponents-core";
  */
 export let CategoryChart = /*@__PURE__*/ (() => {
     class CategoryChart extends XYChart {
-        r5() {
-            super.r5();
+        r9() {
+            super.r9();
             if (this.dataChart == null) {
                 return;
             }
             let a = this.dataChart.cu.j.e();
-            this.acy = a.d;
-            this.acz = a.e;
-            if (this.ab8 == null) {
-                this.ab8 = a.k;
-            }
-            if (this.acf == null) {
-                this.acf = a.k;
-            }
-            this.x7 = 0;
-            this.acg = AxisDefaults.h;
-            this.acj = null;
-            this.acc = AxisDefaults.g;
-            this.ab9 = null;
-            this.xq = AxisDefaults.f;
-            this.acd = AxisDefaults.j;
-            this.xr = AxisDefaults.e;
-            this.fj = true;
-            this.fk = true;
+            this.ac2 = a.d;
+            this.ac3 = a.e;
+            if (this.acc == null) {
+                this.acc = a.k;
+            }
+            if (this.acj == null) {
+                this.acj = a.k;
+            }
+            this.yb = 0;
+            this.ack = AxisDefaults.h;
+            this.acn = null;
+            this.acg = AxisDefaults.g;
+            this.acd = null;
+            this.xu = AxisDefaults.f;
+            this.ach = AxisDefaults.j;
+            this.xv = AxisDefaults.e;
+            this.fm = true;
+            this.fn = true;
             this.a9 = 0;
-            this.h6 = Defaults.j;
-            this.uk = Defaults.ae;
-            this.uf = Defaults.af;
-            this.ug = Defaults.ag;
-            this.ad0 = true;
-        }
-        r7(a, b) {
-            super.r7(a, b);
-            a.hs = this.afh;
-            a.ch = this.adl;
-        }
-        su(a, b, c) {
-            super.su(a, b, c);
+            this.h9 = Defaults.j;
+            this.uo = Defaults.ae;
+            this.uj = Defaults.af;
+            this.uk = Defaults.ag;
+            this.ad4 = true;
+        }
+        sb(a, b) {
+            super.sb(a, b);
+            a.hs = this.afl;
+            a.ch = this.adp;
+        }
+        sy(a, b, c) {
+            super.sy(a, b, c);
             switch (a) {
                 case "TransitionInDuration":
-                    this.ru((d) => d.hs = this.afh);
+                    this.ry((d) => d.hs = this.afl);
                     break;
                 case "TransitionInEasingFunction":
-                    this.ru((d) => d.ch = this.adl);
+                    this.ry((d) => d.ch = this.adp);
                     break;
             }
         }
-        get afh() {
-            return this.aff;
+        get afl() {
+            return this.afj;
         }
-        set afh(a) {
-            let b = this.afh;
+        set afl(a) {
+            let b = this.afl;
             if (a != b) {
-                this.aff = a;
-                this.sr("TransitionInDuration", b, this.afh);
+                this.afj = a;
+                this.sv("TransitionInDuration", b, this.afl);
             }
         }
-        get adl() {
-            return this.adk;
+        get adp() {
+            return this.ado;
         }
-        set adl(a) {
-            let b = this.adl;
+        set adp(a) {
+            let b = this.adp;
             if (a != b) {
-                this.adk = a;
-                this.sr("TransitionInEasingFunction", b, this.adl);
+                this.ado = a;
+                this.sv("TransitionInEasingFunction", b, this.adp);
             }
         }
-        afn() {
-            let cvd_ = this.j6();
+        afr() {
+            let cvd_ = this.j9();
             cvd_.scaleByViewport();
             return (cvd_.serialize());
         }
-        r0(a) {
-            super.r0(a);
-            a.ds = this.ff;
-            a.ur = this.ad1;
-            a.uu = this.ad2;
-            a.vh = this.aeq;
-            a.vi = this.aer;
-            a.tw = this.ac1;
-        }
-        r6(a, b) {
-            super.r6(a, b);
+        r4(a) {
+            super.r4(a);
+            a.ds = this.fh;
+            a.ur = this.ad5;
+            a.uu = this.ad6;
+            a.vh = this.aeu;
+            a.vi = this.aev;
+            a.tw = this.ac5;
+        }
+        sa(a, b) {
+            super.sa(a, b);
             let c = typeCast(HorizontalAnchoredCategorySeries.$, a);
             if (c == null) {
                 return;
             }
-            c.tr = this.ac7;
-            c.so = this.ad0;
-            c.r8 = this.ac9;
-            c.cb = this.adj;
+            c.tr = this.adb;
+            c.so = this.ad4;
+            c.r8 = this.add;
+            c.cb = this.adn;
             c.trendLineBrush = ArrayExtension.getModulus$1(Brush.$, this.ah, b);
-            c.trendLineType = this.dp;
-            c.trendLineThickness = this.i4;
+            c.trendLineType = this.dq;
+            c.trendLineThickness = this.i7;
             c.ql = this.cr(a, b);
             if (a.d6) {
-                a.ms(ArrayExtension.getModulus$1(Brush.$, this.acy, b), ArrayExtension.getModulus$1(Brush.$, this.acz, b));
+                a.ms(ArrayExtension.getModulus$1(Brush.$, this.ac2, b), ArrayExtension.getModulus$1(Brush.$, this.ac3, b));
             }
         }
-        ada() {
+        ade() {
             return new CategoryXAxis();
         }
-        ade() {
+        adi() {
             return new NumericYAxis();
         }
-        rj() {
-            this.xAxis = this.ada();
+        rn() {
+            this.xAxis = this.ade();
             this.xAxis.name = "xAxis";
             let a = this.xAxis;
-            a.propertyChanged = delegateCombine(a.propertyChanged, runOn(this, this.agp));
-            this.yAxis = this.ade();
+            a.propertyChanged = delegateCombine(a.propertyChanged, runOn(this, this.agt));
+            this.yAxis = this.adi();
             this.yAxis.name = "yAxis";
             let b = this.yAxis;
-            b.propertyChanged = delegateCombine(b.propertyChanged, runOn(this, this.agq));
+            b.propertyChanged = delegateCombine(b.propertyChanged, runOn(this, this.agu));
             if (this.xAxis.ay == null) {
                 this.xAxis.ay = new AxisLabelSettings();
             }
@@ -156,20 +156,20 @@ export let CategoryChart = /*@__PURE__*/ (() => {
                 this.yAxis.ay = new AxisLabelSettings();
             }
         }
-        aa8(a) {
-            super.aa8(a);
-            a.k9 = this.ad4;
-            a.lc = this.ad6;
-            a.b0 = this.ad5;
+        abc(a) {
+            super.abc(a);
+            a.k9 = this.ad8;
+            a.lc = this.aea;
+            a.b0 = this.ad9;
         }
-        aa6(a) {
-            super.aa6(a);
-            a.b0 = this.ad3;
-            a.zoomMaximumCategoryRange = this.ae4;
-            a.zoomToCategoryRange = this.ae6;
-            a.zoomToCategoryStart = this.ae7;
-            a.zoomMaximumItemSpan = this.ae5;
-            a.zoomToItemSpan = this.ae8;
+        aba(a) {
+            super.aba(a);
+            a.b0 = this.ad7;
+            a.zoomMaximumCategoryRange = this.ae8;
+            a.zoomToCategoryRange = this.afa;
+            a.zoomToCategoryStart = this.afb;
+            a.zoomMaximumItemSpan = this.ae9;
+            a.zoomToItemSpan = this.afc;
         }
         get_b1() {
             return 0;
@@ -177,74 +177,84 @@ export let CategoryChart = /*@__PURE__*/ (() => {
         get b1() {
             return this.get_b1();
         }
-        get ac5() {
-            return this.ac4;
+        get ac9() {
+            return this.ac8;
         }
-        set ac5(a) {
-            if (a != this.ac4) {
-                let b = this.ac5;
-                this.ac4 = a;
-                this.sr("ChartType", enumGetBox(CategoryChartType_$type, b), enumGetBox(CategoryChartType_$type, this.ac5));
+        set ac9(a) {
+            if (a != this.ac8) {
+                let b = this.ac9;
+                this.ac8 = a;
+                this.sv("ChartType", enumGetBox(CategoryChartType_$type, b), enumGetBox(CategoryChartType_$type, this.ac9));
             }
         }
-        get ac7() {
-            return this.ac6;
+        get adb() {
+            return this.ada;
         }
-        set ac7(a) {
-            let b = this.ac7;
+        set adb(a) {
+            let b = this.adb;
             if (a != b) {
-                this.ac6 = a;
-                this.sr("MarkerCollisionAvoidance", enumGetBox(CategorySeriesMarkerCollisionAvoidance_$type, b), enumGetBox(CategorySeriesMarkerCollisionAvoidance_$type, this.ac7));
+                this.ada = a;
+                this.sv("MarkerCollisionAvoidance", enumGetBox(CategorySeriesMarkerCollisionAvoidance_$type, b), enumGetBox(CategorySeriesMarkerCollisionAvoidance_$type, this.adb));
             }
         }
-        get adz() {
-            return this.ado;
+        get ad3() {
+            return this.ads;
         }
-        set adz(a) {
-            let b = this.adz;
+        set ad3(a) {
+            let b = this.ad3;
             if (a != b) {
-                this.ado = a;
-                this.sr("IsSplineShapePartOfRange", b, this.adz);
+                this.ads = a;
+                this.sv("IsSplineShapePartOfRange", b, this.ad3);
             }
         }
-        get ad0() {
-            return this.adp;
+        get ad4() {
+            return this.adt;
         }
-        set ad0(a) {
-            let b = this.ad0;
+        set ad4(a) {
+            let b = this.ad4;
             if (a != b) {
-                this.adp = a;
-                this.sr("IsTransitionInEnabled", b, this.ad0);
+                this.adt = a;
+                this.sv("IsTransitionInEnabled", b, this.ad4);
             }
         }
-        get ac9() {
-            return this.ac8;
+        get add() {
+            return this.adc;
         }
-        set ac9(a) {
-            let b = this.ac9;
+        set add(a) {
+            let b = this.add;
             if (a != b) {
-                this.ac8 = a;
-                this.sr("TransitionInMode", enumGetBox(CategoryTransitionInMode_$type, b), enumGetBox(CategoryTransitionInMode_$type, this.ac9));
+                this.adc = a;
+                this.sv("TransitionInMode", enumGetBox(CategoryTransitionInMode_$type, b), enumGetBox(CategoryTransitionInMode_$type, this.add));
             }
         }
-        get adj() {
-            return this.adi;
+        get adn() {
+            return this.adm;
         }
-        set adj(a) {
-            let b = this.adj;
+        set adn(a) {
+            let b = this.adn;
             if (a != b) {
-                this.adi = a;
-                this.sr("TransitionInSpeedType", enumGetBox(TransitionInSpeedType_$type, b), enumGetBox(TransitionInSpeedType_$type, this.adj));
+                this.adm = a;
+                this.sv("TransitionInSpeedType", enumGetBox(TransitionInSpeedType_$type, b), enumGetBox(TransitionInSpeedType_$type, this.adn));
             }
         }
-        get aez() {
-            return this.aec;
+        get ae3() {
+            return this.aeg;
         }
-        set aez(a) {
-            let b = this.aez;
+        set ae3(a) {
+            let b = this.ae3;
             if (a != b) {
-                this.aec = a;
-                this.sr("XAxisInterval", b, this.aez);
+                this.aeg = a;
+                this.sv("XAxisInterval", b, this.ae3);
+            }
+        }
+        get ae6() {
+            return this.aej;
+        }
+        set ae6(a) {
+            let b = this.ae6;
+            if (a != b) {
+                this.aej = a;
+                this.sv("XAxisMinorInterval", b, this.ae6);
             }
         }
         get ae2() {
@@ -254,374 +264,364 @@ export let CategoryChart = /*@__PURE__*/ (() => {
             let b = this.ae2;
             if (a != b) {
                 this.aef = a;
-                this.sr("XAxisMinorInterval", b, this.ae2);
-            }
-        }
-        get aey() {
-            return this.aeb;
-        }
-        set aey(a) {
-            let b = this.aey;
-            if (a != b) {
-                this.aeb = a;
-                this.sr("XAxisGap", b, this.aey);
+                this.sv("XAxisGap", b, this.ae2);
             }
         }
-        get ae1() {
-            return this.aee;
+        get ae5() {
+            return this.aei;
         }
-        set ae1(a) {
-            let b = this.ae1;
+        set ae5(a) {
+            let b = this.ae5;
             if (a != b) {
-                this.aee = a;
-                this.sr("XAxisMinimumGapSize", b, this.ae1);
+                this.aei = a;
+                this.sv("XAxisMinimumGapSize", b, this.ae5);
             }
         }
-        get ae0() {
-            return this.aed;
+        get ae4() {
+            return this.aeh;
         }
-        set ae0(a) {
-            let b = this.ae0;
+        set ae4(a) {
+            let b = this.ae4;
             if (a != b) {
-                this.aed = a;
-                this.sr("XAxisMaximumGap", b, this.ae0);
+                this.aeh = a;
+                this.sv("XAxisMaximumGap", b, this.ae4);
             }
         }
-        get ae3() {
-            return this.aeg;
+        get ae7() {
+            return this.aek;
         }
-        set ae3(a) {
-            let b = this.ae3;
+        set ae7(a) {
+            let b = this.ae7;
             if (a != b) {
-                this.aeg = a;
-                this.sr("XAxisOverlap", b, this.ae3);
+                this.aek = a;
+                this.sv("XAxisOverlap", b, this.ae7);
             }
         }
-        get afb() {
-            return this.aem;
+        get aff() {
+            return this.aeq;
         }
-        set afb(a) {
-            let b = this.afb;
+        set aff(a) {
+            let b = this.aff;
             if (a != b) {
-                this.aem = a;
-                this.sr("YAxisInterval", b, this.afb);
+                this.aeq = a;
+                this.sv("YAxisInterval", b, this.aff);
             }
         }
-        get ac1() {
-            return this.ac0;
+        get ac5() {
+            return this.ac4;
         }
-        set ac1(a) {
-            let b = this.ac1;
+        set ac5(a) {
+            let b = this.ac5;
             if (a != b) {
-                this.ac0 = a;
-                this.sr("AutoMarginAndAngleUpdateMode", enumGetBox(AutoMarginsAndAngleUpdateMode_$type, b), enumGetBox(AutoMarginsAndAngleUpdateMode_$type, this.ac1));
+                this.ac4 = a;
+                this.sv("AutoMarginAndAngleUpdateMode", enumGetBox(AutoMarginsAndAngleUpdateMode_$type, b), enumGetBox(AutoMarginsAndAngleUpdateMode_$type, this.ac5));
             }
         }
-        agr() {
+        agv() {
             if (this.dataChart != null) {
                 this.dataChart.w2();
             }
         }
-        get ad1() {
-            return this.adq;
+        get ad5() {
+            return this.adu;
         }
-        set ad1(a) {
-            let b = this.ad1;
+        set ad5(a) {
+            let b = this.ad5;
             if (a != b) {
-                this.adq = a;
-                this.sr("ShouldAutoExpandMarginForInitialLabels", b, this.ad1);
+                this.adu = a;
+                this.sv("ShouldAutoExpandMarginForInitialLabels", b, this.ad5);
             }
         }
-        get ad2() {
-            return this.adr;
+        get ad6() {
+            return this.adv;
         }
-        set ad2(a) {
-            let b = this.ad2;
+        set ad6(a) {
+            let b = this.ad6;
             if (a != b) {
-                this.adr = a;
-                this.sr(CategoryChart.afw, b, this.ad2);
+                this.adv = a;
+                this.sv(CategoryChart.af0, b, this.ad6);
             }
         }
-        get aeq() {
-            return this.ad9;
+        get aeu() {
+            return this.aed;
         }
-        set aeq(a) {
-            let b = this.aeq;
+        set aeu(a) {
+            let b = this.aeu;
             if (a != b) {
-                this.ad9 = a;
-                this.sr("AutoExpandMarginExtraPadding", b, this.aeq);
+                this.aed = a;
+                this.sv("AutoExpandMarginExtraPadding", b, this.aeu);
             }
         }
-        get aer() {
-            return this.aea;
+        get aev() {
+            return this.aee;
         }
-        set aer(a) {
-            let b = this.aer;
+        set aev(a) {
+            let b = this.aev;
             if (a != b) {
-                this.aea = a;
-                this.sr("AutoExpandMarginMaximumValue", b, this.aer);
+                this.aee = a;
+                this.sv("AutoExpandMarginMaximumValue", b, this.aev);
             }
         }
-        get ad6() {
-            return this.adv;
+        get aea() {
+            return this.adz;
         }
-        set ad6(a) {
-            let b = this.ad6;
+        set aea(a) {
+            let b = this.aea;
             if (a != b) {
-                this.adv = a;
-                this.sr("YAxisFavorLabellingScaleEnd", b, this.ad6);
+                this.adz = a;
+                this.sv("YAxisFavorLabellingScaleEnd", b, this.aea);
             }
         }
-        get ad3() {
-            return this.ads;
+        get ad7() {
+            return this.adw;
         }
-        set ad3(a) {
-            let b = this.ad3;
+        set ad7(a) {
+            let b = this.ad7;
             if (a != b) {
-                this.ads = a;
-                this.sr(CategoryChart.af1, b, this.ad3);
+                this.adw = a;
+                this.sv(CategoryChart.af5, b, this.ad7);
             }
         }
-        get ad5() {
-            return this.adu;
+        get ad9() {
+            return this.ady;
         }
-        set ad5(a) {
-            let b = this.ad5;
+        set ad9(a) {
+            let b = this.ad9;
             if (a != b) {
-                this.adu = a;
-                this.sr(CategoryChart.agf, b, this.ad5);
+                this.ady = a;
+                this.sv(CategoryChart.agj, b, this.ad9);
             }
         }
-        get ac3() {
-            return this.ac2;
+        get ac7() {
+            return this.ac6;
         }
-        set ac3(a) {
-            let b = this.ac3;
+        set ac7(a) {
+            let b = this.ac7;
             if (a != b) {
-                this.ac2 = a;
-                this.sr("YAxisAutoRangeBufferMode", enumGetBox(AxisRangeBufferMode_$type, b), enumGetBox(AxisRangeBufferMode_$type, this.ac3));
+                this.ac6 = a;
+                this.sv("YAxisAutoRangeBufferMode", enumGetBox(AxisRangeBufferMode_$type, b), enumGetBox(AxisRangeBufferMode_$type, this.ac7));
             }
         }
-        get ad7() {
-            return this.adw;
+        get aeb() {
+            return this.ad0;
         }
-        set ad7(a) {
-            let b = this.ad7;
+        set aeb(a) {
+            let b = this.aeb;
             if (a != b) {
-                this.adw = a;
-                this.sr("YAxisIsLogarithmic", b, this.ad7);
+                this.ad0 = a;
+                this.sv("YAxisIsLogarithmic", b, this.aeb);
             }
         }
-        get afi() {
-            return this.afg;
+        get afm() {
+            return this.afk;
         }
-        set afi(a) {
-            let b = this.afi;
+        set afm(a) {
+            let b = this.afm;
             if (a != b) {
-                this.afg = a;
-                this.sr("YAxisLogarithmBase", b, this.afi);
+                this.afk = a;
+                this.sv("YAxisLogarithmBase", b, this.afm);
             }
         }
-        get afd() {
-            return this.aeo;
+        get afh() {
+            return this.aes;
         }
-        set afd(a) {
-            let b = this.afd;
+        set afh(a) {
+            let b = this.afh;
             if (a != b) {
-                this.aeo = a;
-                this.sr("YAxisMinimumValue", b, this.afd);
+                this.aes = a;
+                this.sv("YAxisMinimumValue", b, this.afh);
             }
         }
-        get afc() {
-            return this.aen;
+        get afg() {
+            return this.aer;
         }
-        set afc(a) {
-            let b = this.afc;
+        set afg(a) {
+            let b = this.afg;
             if (a != b) {
-                this.aen = a;
-                this.sr("YAxisMaximumValue", b, this.afc);
+                this.aer = a;
+                this.sv("YAxisMaximumValue", b, this.afg);
             }
         }
-        get afe() {
-            return this.aep;
+        get afi() {
+            return this.aet;
         }
-        set afe(a) {
-            let b = this.afe;
+        set afi(a) {
+            let b = this.afi;
             if (a != b) {
-                this.aep = a;
-                this.sr("YAxisMinorInterval", b, this.afe);
+                this.aet = a;
+                this.sv("YAxisMinorInterval", b, this.afi);
             }
         }
-        get aex() {
+        get ae1() {
             return this.xAxis.mv;
         }
-        get aew() {
+        get ae0() {
             return this.xAxis.mu;
         }
-        aet() {
-            return this.aex;
+        aex() {
+            return this.ae1;
         }
-        aev() {
-            return this.afa;
+        aez() {
+            return this.afe;
         }
-        aes() {
-            return this.aew;
+        aew() {
+            return this.ae0;
         }
-        aeu() {
-            return this.ae9;
+        aey() {
+            return this.afd;
         }
-        get afa() {
+        get afe() {
             return this.yAxis.lw;
         }
-        get ae9() {
+        get afd() {
             return this.yAxis.lv;
         }
-        get acy() {
-            return this.acw;
+        get ac2() {
+            return this.ac0;
         }
-        set acy(a) {
-            let b = this.acy;
+        set ac2(a) {
+            let b = this.ac2;
             if (a != b) {
-                this.acw = a;
-                this.sr("NegativeBrushes", b, this.acy);
+                this.ac0 = a;
+                this.sv("NegativeBrushes", b, this.ac2);
             }
         }
-        get acz() {
-            return this.acx;
+        get ac3() {
+            return this.ac1;
         }
-        set acz(a) {
-            let b = this.acz;
+        set ac3(a) {
+            let b = this.ac3;
             if (a != b) {
-                this.acx = a;
-                this.sr("NegativeOutlines", b, this.acz);
+                this.ac1 = a;
+                this.sv("NegativeOutlines", b, this.ac3);
             }
         }
-        get ad4() {
-            return this.adt;
+        get ad8() {
+            return this.adx;
         }
-        set ad4(a) {
-            let b = this.ad4;
+        set ad8(a) {
+            let b = this.ad8;
             if (a != b) {
-                this.adt = a;
-                this.sr("YAxisAbbreviateLargeNumbers", b, this.ad4);
+                this.adx = a;
+                this.sv("YAxisAbbreviateLargeNumbers", b, this.ad8);
             }
         }
-        get ae4() {
-            return this.aeh;
+        get ae8() {
+            return this.ael;
         }
-        set ae4(a) {
-            let b = this.ae4;
+        set ae8(a) {
+            let b = this.ae8;
             if (a != b) {
-                this.aeh = a;
-                this.sr("XAxisZoomMaximumCategoryRange", b, this.ae4);
+                this.ael = a;
+                this.sv("XAxisZoomMaximumCategoryRange", b, this.ae8);
             }
         }
-        get ae5() {
-            return this.aei;
+        get ae9() {
+            return this.aem;
         }
-        set ae5(a) {
-            let b = this.ae5;
+        set ae9(a) {
+            let b = this.ae9;
             if (a != b) {
-                this.aei = a;
-                this.sr("XAxisZoomMaximumItemSpan", b, this.ae5);
+                this.aem = a;
+                this.sv("XAxisZoomMaximumItemSpan", b, this.ae9);
             }
         }
-        get ae6() {
-            return this.aej;
+        get afa() {
+            return this.aen;
         }
-        set ae6(a) {
-            let b = this.ae6;
+        set afa(a) {
+            let b = this.afa;
             if (a != b) {
-                this.aej = a;
-                this.sr("XAxisZoomToCategoryRange", b, this.ae6);
+                this.aen = a;
+                this.sv("XAxisZoomToCategoryRange", b, this.afa);
             }
         }
-        get ae7() {
-            return this.aek;
+        get afb() {
+            return this.aeo;
         }
-        set ae7(a) {
-            let b = this.ae7;
+        set afb(a) {
+            let b = this.afb;
             if (a != b) {
-                this.aek = a;
-                this.sr("XAxisZoomToCategoryStart", b, this.ae7);
+                this.aeo = a;
+                this.sv("XAxisZoomToCategoryStart", b, this.afb);
             }
         }
-        get ae8() {
-            return this.ael;
+        get afc() {
+            return this.aep;
         }
-        set ae8(a) {
-            let b = this.ae8;
+        set afc(a) {
+            let b = this.afc;
             if (a != b) {
-                this.ael = a;
-                this.sr("XAxisZoomToItemSpan", b, this.ae8);
+                this.aep = a;
+                this.sv("XAxisZoomToItemSpan", b, this.afc);
             }
         }
-        get adx() {
-            return this.adm;
+        get ad1() {
+            return this.adq;
         }
-        set adx(a) {
-            let b = this.adx;
+        set ad1(a) {
+            let b = this.ad1;
             if (a != b) {
-                this.adm = a;
-                this.sr("IsCategoryHighlightingEnabled", b, this.adx);
+                this.adq = a;
+                this.sv("IsCategoryHighlightingEnabled", b, this.ad1);
             }
         }
-        get ady() {
-            return this.adn;
+        get ad2() {
+            return this.adr;
         }
-        set ady(a) {
-            let b = this.ady;
+        set ad2(a) {
+            let b = this.ad2;
             if (a != b) {
-                this.adn = a;
-                this.sr("IsItemHighlightingEnabled", b, this.ady);
+                this.adr = a;
+                this.sv("IsItemHighlightingEnabled", b, this.ad2);
             }
         }
         constructor() {
             super();
-            this.aff = 1000;
-            this.adk = null;
-            this.ac4 = 9;
-            this.ac6 = 1;
-            this.ado = false;
-            this.adp = true;
-            this.ac8 = 0;
-            this.adi = 0;
-            this.aec = 0;
-            this.aef = 0;
-            this.aeb = 0;
-            this.aee = 0;
-            this.aed = 1;
+            this.afj = 1000;
+            this.ado = null;
+            this.ac8 = 9;
+            this.ada = 1;
+            this.ads = false;
+            this.adt = true;
+            this.adc = 0;
+            this.adm = 0;
             this.aeg = 0;
-            this.aem = NaN;
-            this.ac0 = 1;
-            this.adq = true;
-            this.adr = true;
-            this.ad9 = DeviceUtils.g(2);
-            this.aea = DeviceUtils.g(60);
+            this.aej = 0;
+            this.aef = 0;
+            this.aei = 0;
+            this.aeh = 1;
+            this.aek = 0;
+            this.aeq = NaN;
+            this.ac4 = 1;
+            this.adu = true;
             this.adv = true;
-            this.ads = true;
-            this.adu = false;
-            this.ac2 = 0;
-            this.adw = false;
-            this.afg = 10;
-            this.aeo = NaN;
+            this.aed = DeviceUtils.g(2);
+            this.aee = DeviceUtils.g(60);
+            this.adz = true;
+            this.adw = true;
+            this.ady = false;
+            this.ac6 = 0;
+            this.ad0 = false;
+            this.afk = 10;
+            this.aes = NaN;
+            this.aer = NaN;
+            this.aet = 0;
+            this.ac0 = null;
+            this.ac1 = null;
+            this.adx = true;
+            this.ael = 3;
+            this.aem = NaN;
             this.aen = NaN;
-            this.aep = 0;
-            this.acw = null;
-            this.acx = null;
-            this.adt = true;
-            this.aeh = 3;
-            this.aei = NaN;
-            this.aej = NaN;
-            this.aek = NaN;
-            this.ael = NaN;
-            this.adm = false;
-            this.adn = false;
-            this.ad8 = null;
+            this.aeo = NaN;
+            this.aep = NaN;
+            this.adq = false;
+            this.adr = false;
+            this.aec = null;
             DVContainer.instance.registerIfLoaded("CategoryChartToolbarFactoryManager");
-            this.rn();
+            this.rr();
         }
-        get_go() {
+        get_gr() {
             let a = new List$1(DataSeriesType_$type, 0);
             if (TypeRegistrar.isRegistered("AreaSeries")) {
                 a.add(2);
@@ -652,55 +652,66 @@ export let CategoryChart = /*@__PURE__*/ (() => {
             }
             return a;
         }
-        get go() {
-            return this.get_go();
+        get gr() {
+            return this.get_gr();
         }
-        gs() {
-            if (this.ad8 == null) {
-                this.ad8 = CategoryChartMockDataGenerator.a();
+        gv() {
+            if (this.aec == null) {
+                this.aec = CategoryChartMockDataGenerator.a();
             }
-            return this.ad8;
+            return this.aec;
         }
         cq(a) {
             if (a != null) {
                 let b = super.cq(a);
                 if (b == 2) {
-                    if (a.d5 && this.fu) {
+                    if (a.d5 && this.fx) {
                         return 13;
                     }
                 }
             }
             return super.cq(a);
         }
-        get_gb() {
+        cs(a) {
+            if (a != null) {
+                let b = super.cq(a);
+                if (b == 2) {
+                    if (a.d5 && this.fx) {
+                        return 13;
+                    }
+                }
+            }
+            return super.cs(a);
+        }
+        get_ge() {
             return this.xAxis != null && this.xAxis.categoryMode != 0;
         }
-        agp(a, b) {
+        agt(a, b) {
             switch (b.propertyName) {
                 case "ActualMinimum":
-                    this.s1("XAxisActualMinimum");
+                    this.s5("XAxisActualMinimum");
                     break;
                 case "ActualMaximum":
-                    this.s1("XAxisActualMaximum");
+                    this.s5("XAxisActualMaximum");
                     break;
             }
         }
-        agq(a, b) {
+        agu(a, b) {
             switch (b.propertyName) {
                 case "ActualMinimumValue":
-                    this.s1("YAxisActualMinimum");
+                    this.s5("YAxisActualMinimum");
                     break;
                 case "ActualMaximumValue":
-                    this.s1("YAxisActualMaximum");
+                    this.s5("YAxisActualMaximum");
                     break;
             }
         }
-        td() {
-            super.td();
-            this.xAxis.fz = this.yh == null ? XYChart.yt(this.xAxis, this.bd.dataSeries) : this.yh;
+        th() {
+            super.th();
+            this.xAxis.fz = this.yl == null ? XYChart.yx(this.xAxis, this.bd.dataSeries) : this.yl;
             this.xAxis.itemsSource = this.dataChart != null && this.dataChart.series.count > 0 ? this.dataChart.series._inner[0].itemsSource : null;
-            if (this.ad1) {
-                this.sj((a) => a.w2());
+            if (this.ad5) {
+                this.sn((a) => a.w2());
             }
         }
         get xAxis() {
@@ -715,26 +726,26 @@ export let CategoryChart = /*@__PURE__*/ (() => {
         set yAxis(a) {
             this._yAxis = a;
         }
-        add(a, b) {
+        adh(a, b) {
             switch (a) {
-                case 2: return this.c2(1);
-                case 3: return this.c2(10);
-                case 0: return this.c2(0);
-                case 1: return this.c2(2);
-                case 6: return this.c2(6);
-                case 7: return this.c2(7);
-                case 4: return this.c2(4);
-                case 5: return this.c2(5);
-                case 8: return this.c2(8);
-                case 9: return this.adc(b);
-                default: return this.c2(1);
-            }
-        }
-        adc(a) {
-            return this.c2(a);
+                case 2: return this.c3(1);
+                case 3: return this.c3(10);
+                case 0: return this.c3(0);
+                case 1: return this.c3(2);
+                case 6: return this.c3(6);
+                case 7: return this.c3(7);
+                case 4: return this.c3(4);
+                case 5: return this.c3(5);
+                case 8: return this.c3(8);
+                case 9: return this.adg(b);
+                default: return this.c3(1);
+            }
+        }
+        adg(a) {
+            return this.c3(a);
         }
         bc(a) {
-            switch (this.ac5) {
+            switch (this.ac9) {
                 case 1: return 2;
                 case 0: return 0;
                 case 3: return 10;
@@ -748,24 +759,24 @@ export let CategoryChart = /*@__PURE__*/ (() => {
                 case 2: return 1;
             }
         }
-        c0(a, b) {
-            let c = this.add(this.ac5, a.suggestedSeries);
+        c1(a, b) {
+            let c = this.adh(this.ac9, a.suggestedSeries);
             c.uc = a.findMatchingHint(0).path;
             c.xAxis = this.xAxis;
             c.yAxis = this.yAxis;
             return c;
         }
-        tb(a) {
+        tf(a) {
             if (a.suggestedSecondaryAxis == 2) {
                 this.yAxis.lh = true;
                 this.yAxis.l8 = 10;
             }
         }
-        te() {
-            this.yAxis.lh = this.ad7;
-            this.yAxis.l8 = this.afi;
+        ti() {
+            this.yAxis.lh = this.aeb;
+            this.yAxis.l8 = this.afm;
         }
-        get_gn() {
+        get_gq() {
             return ((() => {
                 let $ret = new List$1(IDataSeriesAdapterRule_$type, 0);
                 $ret.add(new SimpleCategorySeriesRule());
@@ -773,20 +784,20 @@ export let CategoryChart = /*@__PURE__*/ (() => {
                 return $ret;
             })());
         }
-        get gn() {
-            return this.get_gn();
+        get gq() {
+            return this.get_gq();
         }
-        rf(a, b) {
+        rj(a, b) {
             let c = typeCast(HorizontalAnchoredCategorySeries.$, a);
             if (c != null) {
-                c.tr = this.ac7;
+                c.tr = this.adb;
                 c.ql = this.cr(a, b);
             }
         }
-        agn(a) {
-            this.ago((b, c) => a(b));
+        agr(a) {
+            this.ags((b, c) => a(b));
         }
-        ago(a) {
+        ags(a) {
             if (this.dataChart == null) {
                 return;
             }
@@ -798,27 +809,27 @@ export let CategoryChart = /*@__PURE__*/ (() => {
                 a(c, b);
             }
         }
-        vz() {
+        v3() {
             return this.xAxis;
         }
-        v0() {
+        v4() {
             return this.yAxis;
         }
-        adg() {
-            return this.c2(30);
+        adk() {
+            return this.c3(30);
         }
-        adh() {
-            return this.c2(31);
+        adl() {
+            return this.c3(31);
         }
-        gk(a, b) {
-            let c = super.gk(a, b);
+        gn(a, b) {
+            let c = super.gn(a, b);
             if (c != null) {
                 let d = new List$1(Series.$, 0);
-                if (this.adm) {
-                    d.add(this.adg());
+                if (this.adq) {
+                    d.add(this.adk());
                 }
-                if (this.adn) {
-                    d.add(this.adh());
+                if (this.adr) {
+                    d.add(this.adl());
                 }
                 for (let e = 0; e < d.count; e++) {
                     let f = d._inner[e];
@@ -836,32 +847,32 @@ export let CategoryChart = /*@__PURE__*/ (() => {
                 return this.a6;
             }
         }
-        tj(a, b, c) {
-            super.tj(a, b, c);
+        tn(a, b, c) {
+            super.tn(a, b, c);
             if (this.bd.dataSeries.count > 0) {
-                if (stringIsNullOrEmpty(this.li)) {
+                if (stringIsNullOrEmpty(this.lm)) {
                     this.b3.setXMemberPath(a, c.getMemberPathFor(16));
                 }
-                if (stringIsNullOrEmpty(this.lk)) {
+                if (stringIsNullOrEmpty(this.lo)) {
                     this.b3.setYMemberPath(a, c.getMemberPathFor(0));
                 }
-                if (stringIsNullOrEmpty(this.le)) {
+                if (stringIsNullOrEmpty(this.li)) {
                     this.b3.setLabelMemberPath(a, c.getMemberPathFor(0));
                 }
-                if (stringIsNullOrEmpty(this.lb)) {
+                if (stringIsNullOrEmpty(this.lf)) {
                     this.b3.setContentMemberPath(a, c.getMemberPathFor(0));
                 }
             }
         }
-        fx() {
+        f0() {
             if (this.a9 == 4 || this.a9 == 3) {
                 return true;
             }
             else if (this.a9 == 0) {
-                if (this.ac5 == 2 || this.ac5 == 8) {
+                if (this.ac9 == 2 || this.ac9 == 8) {
                     return false;
                 }
-                else if (this.ac5 == 9 && this.bd != null && this.bd.dataSeries != null && this.bd.dataSeries.count > 0) {
+                else if (this.ac9 == 9 && this.bd != null && this.bd.dataSeries != null && this.bd.dataSeries.count > 0) {
                     let a = this.bd.dataSeries._inner[0].suggestedSeries;
                     if (a == 1 || a == 8) {
                         return false;
@@ -871,133 +882,133 @@ export let CategoryChart = /*@__PURE__*/ (() => {
             }
             return false;
         }
-        get_f3() {
+        get_f6() {
             return DVContainer.instance.checkLoaded("CategoryChartToolbarFactoryManager");
         }
-        sr(a, b, c) {
-            super.sr(a, b, c);
+        sv(a, b, c) {
+            super.sv(a, b, c);
             switch (a) {
                 case "ChartType":
-                    this.td();
+                    this.th();
                     break;
                 case "MarkerCollisionAvoidance":
-                    this.agn((d) => d.tr = this.ac7);
+                    this.agr((d) => d.tr = this.adb);
                     break;
                 case "IsTransitionInEnabled":
-                    this.agn((d) => d.so = this.ad0);
+                    this.agr((d) => d.so = this.ad4);
                     break;
                 case "IsSplineShapePartOfRange":
-                    this.agn((d) => {
+                    this.agr((d) => {
                         if (d.ej) {
-                            d.mt(this.adz);
+                            d.mt(this.ad3);
                         }
                     });
                     break;
                 case "TransitionInMode":
-                    this.agn((d) => d.r8 = this.ac9);
+                    this.agr((d) => d.r8 = this.add);
                     break;
                 case "TransitionInSpeedType":
-                    this.agn((d) => d.cb = this.adj);
+                    this.agr((d) => d.cb = this.adn);
                     break;
                 case "XAxisInterval":
-                    this.xAxis.mq = this.aez;
+                    this.xAxis.mq = this.ae3;
                     break;
                 case "XAxisMinorInterval":
-                    this.xAxis.mr = this.ae2;
+                    this.xAxis.mr = this.ae6;
                     break;
                 case "XAxisGap":
-                    this.xAxis.k0 = this.aey;
+                    this.xAxis.k0 = this.ae2;
                     break;
                 case "XAxisOverlap":
-                    this.xAxis.k9 = this.ae3;
+                    this.xAxis.k9 = this.ae7;
                     break;
                 case "XAxisMinimumGapSize":
-                    this.xAxis.k8 = this.ae1;
+                    this.xAxis.k8 = this.ae5;
                     break;
                 case "XAxisMaximumGap":
-                    this.xAxis.k7 = this.ae0;
+                    this.xAxis.k7 = this.ae4;
                     break;
                 case "XAxisZoomMaximumCategoryRange":
-                    this.xAxis.zoomMaximumCategoryRange = this.ae4;
+                    this.xAxis.zoomMaximumCategoryRange = this.ae8;
                     break;
                 case "XAxisZoomMaximumItemSpan":
-                    this.xAxis.zoomMaximumItemSpan = this.ae5;
+                    this.xAxis.zoomMaximumItemSpan = this.ae9;
                     break;
                 case "XAxisZoomToCategoryRange":
-                    this.xAxis.zoomToCategoryRange = this.ae6;
+                    this.xAxis.zoomToCategoryRange = this.afa;
                     break;
                 case "XAxisZoomToCategoryStart":
-                    this.xAxis.zoomToCategoryStart = this.ae7;
+                    this.xAxis.zoomToCategoryStart = this.afb;
                     break;
                 case "XAxisZoomToItemSpan":
-                    this.xAxis.zoomToItemSpan = this.ae8;
+                    this.xAxis.zoomToItemSpan = this.afc;
                     break;
                 case "YAxisInterval":
-                    this.yAxis.l0 = this.afb;
+                    this.yAxis.l0 = this.aff;
                     break;
                 case "YAxisFavorLabellingScaleEnd":
-                    this.yAxis.lc = this.ad6;
+                    this.yAxis.lc = this.aea;
                     break;
                 case "YAxisAutoRangeBufferMode":
-                    this.yAxis.kt = this.ac3;
+                    this.yAxis.kt = this.ac7;
                     break;
                 case "YAxisIsLogarithmic":
-                    this.yAxis.lh = this.ad7;
+                    this.yAxis.lh = this.aeb;
                     break;
                 case "YAxisLogarithmBase":
-                    this.yAxis.l8 = this.afi;
+                    this.yAxis.l8 = this.afm;
                     break;
                 case "YAxisMinimumValue":
-                    this.yAxis.l4 = this.afd;
+                    this.yAxis.l4 = this.afh;
                     break;
                 case "YAxisMaximumValue":
-                    this.yAxis.l3 = this.afc;
+                    this.yAxis.l3 = this.afg;
                     break;
                 case "YAxisMinorInterval":
-                    this.yAxis.l5 = this.afe;
+                    this.yAxis.l5 = this.afi;
                     break;
                 case "NegativeBrushes":
                 case "NegativeOutlines":
-                    this.ago((d, e) => {
+                    this.ags((d, e) => {
                         if (d.d6) {
-                            d.ms(ArrayExtension.getModulus$1(Brush.$, this.acy, e), ArrayExtension.getModulus$1(Brush.$, this.acz, e));
+                            d.ms(ArrayExtension.getModulus$1(Brush.$, this.ac2, e), ArrayExtension.getModulus$1(Brush.$, this.ac3, e));
                         }
                     });
                     break;
                 case "YAxisAbbreviateLargeNumbers":
-                    this.abf((d) => d.k9 = this.ad4);
+                    this.abj((d) => d.k9 = this.ad8);
                     break;
                 case "IsCategoryHighlightingEnabled":
                 case "IsItemHighlightingEnabled":
-                    this.td();
+                    this.th();
                     break;
                 case "AutoMarginAndAngleUpdateMode":
-                    this.sj((d) => d.tw = this.ac1);
+                    this.sn((d) => d.tw = this.ac5);
                     break;
                 case "ShouldAutoExpandMarginForInitialLabels":
-                    this.sj((d) => d.ur = this.ad1);
+                    this.sn((d) => d.ur = this.ad5);
                     break;
-                case CategoryChart.afw:
-                    this.sj((d) => d.uu = this.ad2);
+                case CategoryChart.af0:
+                    this.sn((d) => d.uu = this.ad6);
                     break;
                 case "AutoExpandMarginExtraPadding":
-                    this.sj((d) => d.vh = this.aeq);
+                    this.sn((d) => d.vh = this.aeu);
                     break;
                 case "AutoExpandMarginMaximumValue":
-                    this.sj((d) => d.vi = this.aer);
+                    this.sn((d) => d.vi = this.aev);
                     break;
-                case CategoryChart.af1:
-                    this.abb((d) => d.b0 = this.ad3, a);
+                case CategoryChart.af5:
+                    this.abf((d) => d.b0 = this.ad7, a);
                     break;
-                case CategoryChart.agf:
-                    this.abf((d) => d.b0 = this.ad5);
+                case CategoryChart.agj:
+                    this.abj((d) => d.b0 = this.ad9);
                     break;
             }
         }
     }
     CategoryChart.$t = /*@__PURE__*/ markType(CategoryChart, 'CategoryChart', XYChart.$);
-    CategoryChart.afw = "ShouldConsiderAutoRotationForInitialLabels";
-    CategoryChart.af1 = "XAxisEnhancedIntervalPreferMoreCategoryLabels";
-    CategoryChart.agf = "YAxisEnhancedIntervalPreferMoreCategoryLabels";
+    CategoryChart.af0 = "ShouldConsiderAutoRotationForInitialLabels";
+    CategoryChart.af5 = "XAxisEnhancedIntervalPreferMoreCategoryLabels";
+    CategoryChart.agj = "YAxisEnhancedIntervalPreferMoreCategoryLabels";
     return CategoryChart;
 })();