igniteui-webcomponents-charts 4.3.3-beta.1 → 4.6.0

package/esm2015/lib/CategoryChart.js

@@ -35,120 +35,120 @@ import { stringIsNullOrEmpty } from "igniteui-webcomponents-core";
  */
 export let CategoryChart = /*@__PURE__*/ (() => {
     class CategoryChart extends XYChart {
-        r9() {
-            super.r9();
+        sb() {
+            super.sb();
             if (this.dataChart == null) {
                 return;
             }
             let a = this.dataChart.cu.j.e();
-            this.ac3 = a.d;
-            this.ac4 = a.e;
-            if (this.acd == null) {
-                this.acd = a.k;
-            }
-            if (this.ack == null) {
-                this.ack = a.k;
-            }
-            this.yc = 0;
-            this.acl = AxisDefaults.h;
-            this.aco = null;
-            this.ach = AxisDefaults.g;
-            this.ace = null;
-            this.xv = AxisDefaults.f;
-            this.aci = AxisDefaults.j;
-            this.xw = AxisDefaults.e;
-            this.fm = true;
-            this.fn = true;
+            this.ac5 = a.d;
+            this.ac6 = a.e;
+            if (this.acf == null) {
+                this.acf = a.k;
+            }
+            if (this.acm == null) {
+                this.acm = a.k;
+            }
+            this.ye = 0;
+            this.acn = AxisDefaults.h;
+            this.acq = null;
+            this.acj = AxisDefaults.g;
+            this.acg = null;
+            this.xx = AxisDefaults.f;
+            this.ack = AxisDefaults.j;
+            this.xy = AxisDefaults.e;
+            this.fo = true;
+            this.fp = true;
             this.a9 = 0;
-            this.h9 = Defaults.j;
-            this.up = Defaults.ae;
-            this.uk = Defaults.af;
-            this.ul = Defaults.ag;
-            this.ad5 = true;
-        }
-        sb(a, b) {
-            super.sb(a, b);
-            a.hs = this.afm;
-            a.ch = this.adq;
-        }
-        sz(a, b, c) {
-            super.sz(a, b, c);
+            this.ib = Defaults.j;
+            this.ur = Defaults.ae;
+            this.um = Defaults.af;
+            this.un = Defaults.ag;
+            this.ad7 = true;
+        }
+        sd(a, b) {
+            super.sd(a, b);
+            a.hs = this.afo;
+            a.ch = this.ads;
+        }
+        s1(a, b, c) {
+            super.s1(a, b, c);
             switch (a) {
                 case "TransitionInDuration":
-                    this.ry((d) => d.hs = this.afm);
+                    this.r0((d) => d.hs = this.afo);
                     break;
                 case "TransitionInEasingFunction":
-                    this.ry((d) => d.ch = this.adq);
+                    this.r0((d) => d.ch = this.ads);
                     break;
             }
         }
-        get afm() {
-            return this.afk;
+        get afo() {
+            return this.afm;
         }
-        set afm(a) {
-            let b = this.afm;
+        set afo(a) {
+            let b = this.afo;
             if (a != b) {
-                this.afk = a;
-                this.sw("TransitionInDuration", b, this.afm);
+                this.afm = a;
+                this.sy("TransitionInDuration", b, this.afo);
             }
         }
-        get adq() {
-            return this.adp;
+        get ads() {
+            return this.adr;
         }
-        set adq(a) {
-            let b = this.adq;
+        set ads(a) {
+            let b = this.ads;
             if (a != b) {
-                this.adp = a;
-                this.sw("TransitionInEasingFunction", b, this.adq);
+                this.adr = a;
+                this.sy("TransitionInEasingFunction", b, this.ads);
             }
         }
-        afs() {
-            let cvd_ = this.j9();
+        afu() {
+            let cvd_ = this.kb();
             cvd_.scaleByViewport();
             return (cvd_.serialize());
         }
-        r4(a) {
-            super.r4(a);
-            a.dt = this.fh;
-            a.u0 = this.ad6;
-            a.u3 = this.ad7;
-            a.vq = this.aev;
-            a.vr = this.aew;
-            a.t5 = this.ac6;
-        }
-        sa(a, b) {
-            super.sa(a, b);
+        r6(a) {
+            super.r6(a);
+            a.du = this.fj;
+            a.u1 = this.ad8;
+            a.u4 = this.ad9;
+            a.vr = this.aex;
+            a.vs = this.aey;
+            a.t6 = this.ac8;
+        }
+        sc(a, b) {
+            super.sc(a, b);
             let c = typeCast(HorizontalAnchoredCategorySeries.$, a);
             if (c == null) {
                 return;
             }
-            c.tr = this.adc;
-            c.so = this.ad5;
-            c.r8 = this.ade;
-            c.cb = this.ado;
+            c.tr = this.ade;
+            c.so = this.ad7;
+            c.r8 = this.adg;
+            c.cb = this.adq;
             c.trendLineBrush = ArrayExtension.getModulus$1(Brush.$, this.ah, b);
             c.trendLineType = this.dq;
-            c.trendLineThickness = this.i7;
+            c.trendLineThickness = this.i9;
             c.ql = this.cr(a, b);
             if (a.d6) {
-                a.ms(ArrayExtension.getModulus$1(Brush.$, this.ac3, b), ArrayExtension.getModulus$1(Brush.$, this.ac4, b));
+                a.ms(ArrayExtension.getModulus$1(Brush.$, this.ac5, b), ArrayExtension.getModulus$1(Brush.$, this.ac6, b));
             }
         }
-        adf() {
+        adh() {
             return new CategoryXAxis();
         }
-        adj() {
+        adl() {
             return new NumericYAxis();
         }
-        rn() {
-            this.xAxis = this.adf();
+        rp() {
+            this.xAxis = this.adh();
             this.xAxis.name = "xAxis";
             let a = this.xAxis;
-            a.propertyChanged = delegateCombine(a.propertyChanged, runOn(this, this.agu));
-            this.yAxis = this.adj();
+            a.propertyChanged = delegateCombine(a.propertyChanged, runOn(this, this.agw));
+            this.yAxis = this.adl();
             this.yAxis.name = "yAxis";
             let b = this.yAxis;
-            b.propertyChanged = delegateCombine(b.propertyChanged, runOn(this, this.agv));
+            b.propertyChanged = delegateCombine(b.propertyChanged, runOn(this, this.agx));
             if (this.xAxis.az == null) {
                 this.xAxis.az = new AxisLabelSettings();
             }
@@ -156,20 +156,20 @@ export let CategoryChart = /*@__PURE__*/ (() => {
                 this.yAxis.az = new AxisLabelSettings();
             }
         }
+        abf(a) {
+            super.abf(a);
+            a.la = this.aeb;
+            a.ld = this.aed;
+            a.b1 = this.aec;
+        }
         abd(a) {
             super.abd(a);
-            a.la = this.ad9;
-            a.ld = this.aeb;
             a.b1 = this.aea;
-        }
-        abb(a) {
-            super.abb(a);
-            a.b1 = this.ad8;
-            a.zoomMaximumCategoryRange = this.ae9;
-            a.zoomToCategoryRange = this.afb;
-            a.zoomToCategoryStart = this.afc;
-            a.zoomMaximumItemSpan = this.afa;
-            a.zoomToItemSpan = this.afd;
+            a.zoomMaximumCategoryRange = this.afb;
+            a.zoomToCategoryRange = this.afd;
+            a.zoomToCategoryStart = this.afe;
+            a.zoomMaximumItemSpan = this.afc;
+            a.zoomToItemSpan = this.aff;
         }
         get_b1() {
             return 0;
@@ -177,44 +177,14 @@ export let CategoryChart = /*@__PURE__*/ (() => {
         get b1() {
             return this.get_b1();
         }
-        get ada() {
-            return this.ac9;
-        }
-        set ada(a) {
-            if (a != this.ac9) {
-                let b = this.ada;
-                this.ac9 = a;
-                this.sw("ChartType", enumGetBox(CategoryChartType_$type, b), enumGetBox(CategoryChartType_$type, this.ada));
-            }
-        }
         get adc() {
             return this.adb;
         }
         set adc(a) {
-            let b = this.adc;
-            if (a != b) {
+            if (a != this.adb) {
+                let b = this.adc;
                 this.adb = a;
-                this.sw("MarkerCollisionAvoidance", enumGetBox(CategorySeriesMarkerCollisionAvoidance_$type, b), enumGetBox(CategorySeriesMarkerCollisionAvoidance_$type, this.adc));
-            }
-        }
-        get ad4() {
-            return this.adt;
-        }
-        set ad4(a) {
-            let b = this.ad4;
-            if (a != b) {
-                this.adt = a;
-                this.sw("IsSplineShapePartOfRange", b, this.ad4);
-            }
-        }
-        get ad5() {
-            return this.adu;
-        }
-        set ad5(a) {
-            let b = this.ad5;
-            if (a != b) {
-                this.adu = a;
-                this.sw("IsTransitionInEnabled", b, this.ad5);
+                this.sy("ChartType", enumGetBox(CategoryChartType_$type, b), enumGetBox(CategoryChartType_$type, this.adc));
             }
         }
         get ade() {
@@ -224,47 +194,47 @@ export let CategoryChart = /*@__PURE__*/ (() => {
             let b = this.ade;
             if (a != b) {
                 this.add = a;
-                this.sw("TransitionInMode", enumGetBox(CategoryTransitionInMode_$type, b), enumGetBox(CategoryTransitionInMode_$type, this.ade));
+                this.sy("MarkerCollisionAvoidance", enumGetBox(CategorySeriesMarkerCollisionAvoidance_$type, b), enumGetBox(CategorySeriesMarkerCollisionAvoidance_$type, this.ade));
             }
         }
-        get ado() {
-            return this.adn;
+        get ad6() {
+            return this.adv;
         }
-        set ado(a) {
-            let b = this.ado;
+        set ad6(a) {
+            let b = this.ad6;
             if (a != b) {
-                this.adn = a;
-                this.sw("TransitionInSpeedType", enumGetBox(TransitionInSpeedType_$type, b), enumGetBox(TransitionInSpeedType_$type, this.ado));
+                this.adv = a;
+                this.sy("IsSplineShapePartOfRange", b, this.ad6);
             }
         }
-        get ae4() {
-            return this.aeh;
+        get ad7() {
+            return this.adw;
         }
-        set ae4(a) {
-            let b = this.ae4;
+        set ad7(a) {
+            let b = this.ad7;
             if (a != b) {
-                this.aeh = a;
-                this.sw("XAxisInterval", b, this.ae4);
+                this.adw = a;
+                this.sy("IsTransitionInEnabled", b, this.ad7);
             }
         }
-        get ae7() {
-            return this.aek;
+        get adg() {
+            return this.adf;
         }
-        set ae7(a) {
-            let b = this.ae7;
+        set adg(a) {
+            let b = this.adg;
             if (a != b) {
-                this.aek = a;
-                this.sw("XAxisMinorInterval", b, this.ae7);
+                this.adf = a;
+                this.sy("TransitionInMode", enumGetBox(CategoryTransitionInMode_$type, b), enumGetBox(CategoryTransitionInMode_$type, this.adg));
             }
         }
-        get ae3() {
-            return this.aeg;
+        get adq() {
+            return this.adp;
         }
-        set ae3(a) {
-            let b = this.ae3;
+        set adq(a) {
+            let b = this.adq;
             if (a != b) {
-                this.aeg = a;
-                this.sw("XAxisGap", b, this.ae3);
+                this.adp = a;
+                this.sy("TransitionInSpeedType", enumGetBox(TransitionInSpeedType_$type, b), enumGetBox(TransitionInSpeedType_$type, this.adq));
             }
         }
         get ae6() {
@@ -274,7 +244,17 @@ export let CategoryChart = /*@__PURE__*/ (() => {
             let b = this.ae6;
             if (a != b) {
                 this.aej = a;
-                this.sw("XAxisMinimumGapSize", b, this.ae6);
+                this.sy("XAxisInterval", b, this.ae6);
+            }
+        }
+        get ae9() {
+            return this.aem;
+        }
+        set ae9(a) {
+            let b = this.ae9;
+            if (a != b) {
+                this.aem = a;
+                this.sy("XAxisMinorInterval", b, this.ae9);
             }
         }
         get ae5() {
@@ -284,7 +264,7 @@ export let CategoryChart = /*@__PURE__*/ (() => {
             let b = this.ae5;
             if (a != b) {
                 this.aei = a;
-                this.sw("XAxisMaximumGap", b, this.ae5);
+                this.sy("XAxisGap", b, this.ae5);
             }
         }
         get ae8() {
@@ -294,92 +274,102 @@ export let CategoryChart = /*@__PURE__*/ (() => {
             let b = this.ae8;
             if (a != b) {
                 this.ael = a;
-                this.sw("XAxisOverlap", b, this.ae8);
+                this.sy("XAxisMinimumGapSize", b, this.ae8);
             }
         }
-        get afg() {
-            return this.aer;
+        get ae7() {
+            return this.aek;
         }
-        set afg(a) {
-            let b = this.afg;
+        set ae7(a) {
+            let b = this.ae7;
             if (a != b) {
-                this.aer = a;
-                this.sw("YAxisInterval", b, this.afg);
+                this.aek = a;
+                this.sy("XAxisMaximumGap", b, this.ae7);
             }
         }
-        get ac6() {
-            return this.ac5;
+        get afa() {
+            return this.aen;
         }
-        set ac6(a) {
-            let b = this.ac6;
+        set afa(a) {
+            let b = this.afa;
             if (a != b) {
-                this.ac5 = a;
-                this.sw("AutoMarginAndAngleUpdateMode", enumGetBox(AutoMarginsAndAngleUpdateMode_$type, b), enumGetBox(AutoMarginsAndAngleUpdateMode_$type, this.ac6));
+                this.aen = a;
+                this.sy("XAxisOverlap", b, this.afa);
             }
         }
-        agw() {
-            if (this.dataChart != null) {
-                this.dataChart.xb();
+        get afi() {
+            return this.aet;
+        }
+        set afi(a) {
+            let b = this.afi;
+            if (a != b) {
+                this.aet = a;
+                this.sy("YAxisInterval", b, this.afi);
             }
         }
-        get ad6() {
-            return this.adv;
+        get ac8() {
+            return this.ac7;
         }
-        set ad6(a) {
-            let b = this.ad6;
+        set ac8(a) {
+            let b = this.ac8;
             if (a != b) {
-                this.adv = a;
-                this.sw("ShouldAutoExpandMarginForInitialLabels", b, this.ad6);
+                this.ac7 = a;
+                this.sy("AutoMarginAndAngleUpdateMode", enumGetBox(AutoMarginsAndAngleUpdateMode_$type, b), enumGetBox(AutoMarginsAndAngleUpdateMode_$type, this.ac8));
             }
         }
-        get ad7() {
-            return this.adw;
+        agy() {
+            if (this.dataChart != null) {
+                this.dataChart.xc();
+            }
         }
-        set ad7(a) {
-            let b = this.ad7;
+        get ad8() {
+            return this.adx;
+        }
+        set ad8(a) {
+            let b = this.ad8;
             if (a != b) {
-                this.adw = a;
-                this.sw(CategoryChart.af1, b, this.ad7);
+                this.adx = a;
+                this.sy("ShouldAutoExpandMarginForInitialLabels", b, this.ad8);
             }
         }
-        get aev() {
-            return this.aee;
+        get ad9() {
+            return this.ady;
         }
-        set aev(a) {
-            let b = this.aev;
+        set ad9(a) {
+            let b = this.ad9;
             if (a != b) {
-                this.aee = a;
-                this.sw("AutoExpandMarginExtraPadding", b, this.aev);
+                this.ady = a;
+                this.sy(CategoryChart.af3, b, this.ad9);
             }
         }
-        get aew() {
-            return this.aef;
+        get aex() {
+            return this.aeg;
         }
-        set aew(a) {
-            let b = this.aew;
+        set aex(a) {
+            let b = this.aex;
             if (a != b) {
-                this.aef = a;
-                this.sw("AutoExpandMarginMaximumValue", b, this.aew);
+                this.aeg = a;
+                this.sy("AutoExpandMarginExtraPadding", b, this.aex);
             }
         }
-        get aeb() {
-            return this.ad0;
+        get aey() {
+            return this.aeh;
         }
-        set aeb(a) {
-            let b = this.aeb;
+        set aey(a) {
+            let b = this.aey;
             if (a != b) {
-                this.ad0 = a;
-                this.sw("YAxisFavorLabellingScaleEnd", b, this.aeb);
+                this.aeh = a;
+                this.sy("AutoExpandMarginMaximumValue", b, this.aey);
             }
         }
-        get ad8() {
-            return this.adx;
+        get aed() {
+            return this.ad2;
         }
-        set ad8(a) {
-            let b = this.ad8;
+        set aed(a) {
+            let b = this.aed;
             if (a != b) {
-                this.adx = a;
-                this.sw(CategoryChart.af6, b, this.ad8);
+                this.ad2 = a;
+                this.sy("YAxisFavorLabellingScaleEnd", b, this.aed);
             }
         }
         get aea() {
@@ -389,17 +379,7 @@ export let CategoryChart = /*@__PURE__*/ (() => {
             let b = this.aea;
             if (a != b) {
                 this.adz = a;
-                this.sw(CategoryChart.agk, b, this.aea);
-            }
-        }
-        get ac8() {
-            return this.ac7;
-        }
-        set ac8(a) {
-            let b = this.ac8;
-            if (a != b) {
-                this.ac7 = a;
-                this.sw("YAxisAutoRangeBufferMode", enumGetBox(AxisRangeBufferMode_$type, b), enumGetBox(AxisRangeBufferMode_$type, this.ac8));
+                this.sy(CategoryChart.af8, b, this.aea);
             }
         }
         get aec() {
@@ -409,37 +389,47 @@ export let CategoryChart = /*@__PURE__*/ (() => {
             let b = this.aec;
             if (a != b) {
                 this.ad1 = a;
-                this.sw("YAxisIsLogarithmic", b, this.aec);
+                this.sy(CategoryChart.agm, b, this.aec);
             }
         }
-        get afn() {
-            return this.afl;
+        get ada() {
+            return this.ac9;
         }
-        set afn(a) {
-            let b = this.afn;
+        set ada(a) {
+            let b = this.ada;
             if (a != b) {
-                this.afl = a;
-                this.sw("YAxisLogarithmBase", b, this.afn);
+                this.ac9 = a;
+                this.sy("YAxisAutoRangeBufferMode", enumGetBox(AxisRangeBufferMode_$type, b), enumGetBox(AxisRangeBufferMode_$type, this.ada));
             }
         }
-        get afi() {
-            return this.aet;
+        get aee() {
+            return this.ad3;
         }
-        set afi(a) {
-            let b = this.afi;
+        set aee(a) {
+            let b = this.aee;
             if (a != b) {
-                this.aet = a;
-                this.sw("YAxisMinimumValue", b, this.afi);
+                this.ad3 = a;
+                this.sy("YAxisIsLogarithmic", b, this.aee);
             }
         }
-        get afh() {
-            return this.aes;
+        get afp() {
+            return this.afn;
         }
-        set afh(a) {
-            let b = this.afh;
+        set afp(a) {
+            let b = this.afp;
             if (a != b) {
-                this.aes = a;
-                this.sw("YAxisMaximumValue", b, this.afh);
+                this.afn = a;
+                this.sy("YAxisLogarithmBase", b, this.afp);
+            }
+        }
+        get afk() {
+            return this.aev;
+        }
+        set afk(a) {
+            let b = this.afk;
+            if (a != b) {
+                this.aev = a;
+                this.sy("YAxisMinimumValue", b, this.afk);
             }
         }
         get afj() {
@@ -449,81 +439,71 @@ export let CategoryChart = /*@__PURE__*/ (() => {
             let b = this.afj;
             if (a != b) {
                 this.aeu = a;
-                this.sw("YAxisMinorInterval", b, this.afj);
+                this.sy("YAxisMaximumValue", b, this.afj);
+            }
+        }
+        get afl() {
+            return this.aew;
+        }
+        set afl(a) {
+            let b = this.afl;
+            if (a != b) {
+                this.aew = a;
+                this.sy("YAxisMinorInterval", b, this.afl);
             }
         }
-        get ae2() {
+        get ae4() {
             return this.xAxis.mw;
         }
-        get ae1() {
+        get ae3() {
             return this.xAxis.mv;
         }
-        aey() {
-            return this.ae2;
-        }
         ae0() {
-            return this.aff;
+            return this.ae4;
         }
-        aex() {
-            return this.ae1;
+        ae2() {
+            return this.afh;
         }
         aez() {
-            return this.afe;
+            return this.ae3;
         }
-        get aff() {
+        ae1() {
+            return this.afg;
+        }
+        get afh() {
             return this.yAxis.lx;
         }
-        get afe() {
+        get afg() {
             return this.yAxis.lw;
         }
-        get ac3() {
-            return this.ac1;
-        }
-        set ac3(a) {
-            let b = this.ac3;
-            if (a != b) {
-                this.ac1 = a;
-                this.sw("NegativeBrushes", b, this.ac3);
-            }
-        }
-        get ac4() {
-            return this.ac2;
+        get ac5() {
+            return this.ac3;
         }
-        set ac4(a) {
-            let b = this.ac4;
+        set ac5(a) {
+            let b = this.ac5;
             if (a != b) {
-                this.ac2 = a;
-                this.sw("NegativeOutlines", b, this.ac4);
-            }
-        }
-        get ad9() {
-            return this.ady;
-        }
-        set ad9(a) {
-            let b = this.ad9;
-            if (a != b) {
-                this.ady = a;
-                this.sw("YAxisAbbreviateLargeNumbers", b, this.ad9);
+                this.ac3 = a;
+                this.sy("NegativeBrushes", b, this.ac5);
             }
         }
-        get ae9() {
-            return this.aem;
+        get ac6() {
+            return this.ac4;
         }
-        set ae9(a) {
-            let b = this.ae9;
+        set ac6(a) {
+            let b = this.ac6;
             if (a != b) {
-                this.aem = a;
-                this.sw("XAxisZoomMaximumCategoryRange", b, this.ae9);
+                this.ac4 = a;
+                this.sy("NegativeOutlines", b, this.ac6);
             }
         }
-        get afa() {
-            return this.aen;
+        get aeb() {
+            return this.ad0;
         }
-        set afa(a) {
-            let b = this.afa;
+        set aeb(a) {
+            let b = this.aeb;
             if (a != b) {
-                this.aen = a;
-                this.sw("XAxisZoomMaximumItemSpan", b, this.afa);
+                this.ad0 = a;
+                this.sy("YAxisAbbreviateLargeNumbers", b, this.aeb);
             }
         }
         get afb() {
@@ -533,7 +513,7 @@ export let CategoryChart = /*@__PURE__*/ (() => {
             let b = this.afb;
             if (a != b) {
                 this.aeo = a;
-                this.sw("XAxisZoomToCategoryRange", b, this.afb);
+                this.sy("XAxisZoomMaximumCategoryRange", b, this.afb);
             }
         }
         get afc() {
@@ -543,7 +523,7 @@ export let CategoryChart = /*@__PURE__*/ (() => {
             let b = this.afc;
             if (a != b) {
                 this.aep = a;
-                this.sw("XAxisZoomToCategoryStart", b, this.afc);
+                this.sy("XAxisZoomMaximumItemSpan", b, this.afc);
             }
         }
         get afd() {
@@ -553,75 +533,95 @@ export let CategoryChart = /*@__PURE__*/ (() => {
             let b = this.afd;
             if (a != b) {
                 this.aeq = a;
-                this.sw("XAxisZoomToItemSpan", b, this.afd);
+                this.sy("XAxisZoomToCategoryRange", b, this.afd);
             }
         }
-        get ad2() {
-            return this.adr;
+        get afe() {
+            return this.aer;
         }
-        set ad2(a) {
-            let b = this.ad2;
+        set afe(a) {
+            let b = this.afe;
             if (a != b) {
-                this.adr = a;
-                this.sw("IsCategoryHighlightingEnabled", b, this.ad2);
+                this.aer = a;
+                this.sy("XAxisZoomToCategoryStart", b, this.afe);
+            }
+        }
+        get aff() {
+            return this.aes;
+        }
+        set aff(a) {
+            let b = this.aff;
+            if (a != b) {
+                this.aes = a;
+                this.sy("XAxisZoomToItemSpan", b, this.aff);
+            }
+        }
+        get ad4() {
+            return this.adt;
+        }
+        set ad4(a) {
+            let b = this.ad4;
+            if (a != b) {
+                this.adt = a;
+                this.sy("IsCategoryHighlightingEnabled", b, this.ad4);
             }
         }
-        get ad3() {
-            return this.ads;
+        get ad5() {
+            return this.adu;
         }
-        set ad3(a) {
-            let b = this.ad3;
+        set ad5(a) {
+            let b = this.ad5;
             if (a != b) {
-                this.ads = a;
-                this.sw("IsItemHighlightingEnabled", b, this.ad3);
+                this.adu = a;
+                this.sy("IsItemHighlightingEnabled", b, this.ad5);
             }
         }
         constructor() {
             super();
-            this.afk = 1000;
-            this.adp = null;
-            this.ac9 = 9;
-            this.adb = 1;
-            this.adt = false;
-            this.adu = true;
-            this.add = 0;
-            this.adn = 0;
-            this.aeh = 0;
-            this.aek = 0;
-            this.aeg = 0;
+            this.afm = 1000;
+            this.adr = null;
+            this.adb = 9;
+            this.add = 1;
+            this.adv = false;
+            this.adw = true;
+            this.adf = 0;
+            this.adp = 0;
             this.aej = 0;
-            this.aei = 1;
+            this.aem = 0;
+            this.aei = 0;
             this.ael = 0;
-            this.aer = NaN;
-            this.ac5 = 1;
-            this.adv = true;
-            this.adw = true;
-            this.aee = DeviceUtils.g(2);
-            this.aef = DeviceUtils.g(60);
-            this.ad0 = true;
-            this.adx = true;
-            this.adz = false;
-            this.ac7 = 0;
-            this.ad1 = false;
-            this.afl = 10;
+            this.aek = 1;
+            this.aen = 0;
             this.aet = NaN;
-            this.aes = NaN;
-            this.aeu = 0;
-            this.ac1 = null;
-            this.ac2 = null;
+            this.ac7 = 1;
+            this.adx = true;
             this.ady = true;
-            this.aem = 3;
-            this.aen = NaN;
-            this.aeo = NaN;
+            this.aeg = DeviceUtils.g(2);
+            this.aeh = DeviceUtils.g(60);
+            this.ad2 = true;
+            this.adz = true;
+            this.ad1 = false;
+            this.ac9 = 0;
+            this.ad3 = false;
+            this.afn = 10;
+            this.aev = NaN;
+            this.aeu = NaN;
+            this.aew = 0;
+            this.ac3 = null;
+            this.ac4 = null;
+            this.ad0 = true;
+            this.aeo = 3;
             this.aep = NaN;
             this.aeq = NaN;
-            this.adr = false;
-            this.ads = false;
-            this.aed = null;
+            this.aer = NaN;
+            this.aes = NaN;
+            this.adt = false;
+            this.adu = false;
+            this.aef = null;
             DVContainer.instance.registerIfLoaded("CategoryChartToolbarFactoryManager");
-            this.rr();
+            this.rt();
         }
-        get_gr() {
+        get_gt() {
             let a = new List$1(DataSeriesType_$type, 0);
             if (TypeRegistrar.isRegistered("AreaSeries")) {
                 a.add(2);
@@ -652,20 +652,20 @@ export let CategoryChart = /*@__PURE__*/ (() => {
             }
             return a;
         }
-        get gr() {
-            return this.get_gr();
+        get gt() {
+            return this.get_gt();
         }
-        gv() {
-            if (this.aed == null) {
-                this.aed = CategoryChartMockDataGenerator.a();
+        gx() {
+            if (this.aef == null) {
+                this.aef = CategoryChartMockDataGenerator.a();
             }
-            return this.aed;
+            return this.aef;
         }
         cq(a) {
             if (a != null) {
                 let b = super.cq(a);
                 if (b == 2) {
-                    if (a.d5 && this.fx) {
+                    if (a.d5 && this.fz) {
                         return 13;
                     }
                 }
@@ -676,42 +676,42 @@ export let CategoryChart = /*@__PURE__*/ (() => {
             if (a != null) {
                 let b = super.cq(a);
                 if (b == 2) {
-                    if (a.d5 && this.fx) {
+                    if (a.d5 && this.fz) {
                         return 13;
                     }
                 }
             }
             return super.cs(a);
         }
-        get_ge() {
+        get_gg() {
             return this.xAxis != null && this.xAxis.categoryMode != 0;
         }
-        agu(a, b) {
+        agw(a, b) {
             switch (b.propertyName) {
                 case "ActualMinimum":
-                    this.s6("XAxisActualMinimum");
+                    this.s8("XAxisActualMinimum");
                     break;
                 case "ActualMaximum":
-                    this.s6("XAxisActualMaximum");
+                    this.s8("XAxisActualMaximum");
                     break;
             }
         }
-        agv(a, b) {
+        agx(a, b) {
             switch (b.propertyName) {
                 case "ActualMinimumValue":
-                    this.s6("YAxisActualMinimum");
+                    this.s8("YAxisActualMinimum");
                     break;
                 case "ActualMaximumValue":
-                    this.s6("YAxisActualMaximum");
+                    this.s8("YAxisActualMaximum");
                     break;
             }
         }
-        ti() {
-            super.ti();
-            this.xAxis.f0 = this.ym == null ? XYChart.yy(this.xAxis, this.bd.dataSeries) : this.ym;
+        tk() {
+            super.tk();
+            this.xAxis.f0 = this.yo == null ? XYChart.y0(this.xAxis, this.bd.dataSeries) : this.yo;
             this.xAxis.itemsSource = this.dataChart != null && this.dataChart.series.count > 0 ? this.dataChart.series._inner[0].itemsSource : null;
-            if (this.ad6) {
-                this.so((a) => a.xb());
+            if (this.ad8) {
+                this.sq((a) => a.xc());
             }
         }
         get xAxis() {
@@ -726,7 +726,7 @@ export let CategoryChart = /*@__PURE__*/ (() => {
         set yAxis(a) {
             this._yAxis = a;
         }
-        adi(a, b) {
+        adk(a, b) {
             switch (a) {
                 case 2: return this.c3(1);
                 case 3: return this.c3(10);
@@ -737,15 +737,15 @@ export let CategoryChart = /*@__PURE__*/ (() => {
                 case 4: return this.c3(4);
                 case 5: return this.c3(5);
                 case 8: return this.c3(8);
-                case 9: return this.adh(b);
+                case 9: return this.adj(b);
                 default: return this.c3(1);
             }
         }
-        adh(a) {
+        adj(a) {
             return this.c3(a);
         }
         bc(a) {
-            switch (this.ada) {
+            switch (this.adc) {
                 case 1: return 2;
                 case 0: return 0;
                 case 3: return 10;
@@ -760,23 +760,23 @@ export let CategoryChart = /*@__PURE__*/ (() => {
             }
         }
         c1(a, b) {
-            let c = this.adi(this.ada, a.suggestedSeries);
+            let c = this.adk(this.adc, a.suggestedSeries);
             c.uc = a.findMatchingHint(0).path;
             c.xAxis = this.xAxis;
             c.yAxis = this.yAxis;
             return c;
         }
-        tg(a) {
+        ti(a) {
             if (a.suggestedSecondaryAxis == 2) {
                 this.yAxis.li = true;
                 this.yAxis.l9 = 10;
             }
         }
-        tj() {
-            this.yAxis.li = this.aec;
-            this.yAxis.l9 = this.afn;
+        tl() {
+            this.yAxis.li = this.aee;
+            this.yAxis.l9 = this.afp;
         }
-        get_gq() {
+        get_gs() {
             return ((() => {
                 let $ret = new List$1(IDataSeriesAdapterRule_$type, 0);
                 $ret.add(new SimpleCategorySeriesRule());
@@ -784,20 +784,20 @@ export let CategoryChart = /*@__PURE__*/ (() => {
                 return $ret;
             })());
         }
-        get gq() {
-            return this.get_gq();
+        get gs() {
+            return this.get_gs();
         }
-        rj(a, b) {
+        rl(a, b) {
             let c = typeCast(HorizontalAnchoredCategorySeries.$, a);
             if (c != null) {
-                c.tr = this.adc;
+                c.tr = this.ade;
                 c.ql = this.cr(a, b);
             }
         }
-        ags(a) {
-            this.agt((b, c) => a(b));
+        agu(a) {
+            this.agv((b, c) => a(b));
         }
-        agt(a) {
+        agv(a) {
             if (this.dataChart == null) {
                 return;
             }
@@ -809,27 +809,27 @@ export let CategoryChart = /*@__PURE__*/ (() => {
                 a(c, b);
             }
         }
-        v4() {
+        v6() {
             return this.xAxis;
         }
-        v5() {
+        v7() {
             return this.yAxis;
         }
-        adl() {
+        adn() {
             return this.c3(30);
         }
-        adm() {
+        ado() {
             return this.c3(31);
         }
-        gn(a, b) {
-            let c = super.gn(a, b);
+        gp(a, b) {
+            let c = super.gp(a, b);
             if (c != null) {
                 let d = new List$1(Series.$, 0);
-                if (this.adr) {
-                    d.add(this.adl());
+                if (this.adt) {
+                    d.add(this.adn());
                 }
-                if (this.ads) {
-                    d.add(this.adm());
+                if (this.adu) {
+                    d.add(this.ado());
                 }
                 for (let e = 0; e < d.count; e++) {
                     let f = d._inner[e];
@@ -847,32 +847,32 @@ export let CategoryChart = /*@__PURE__*/ (() => {
                 return this.a6;
             }
         }
-        to(a, b, c) {
-            super.to(a, b, c);
+        tq(a, b, c) {
+            super.tq(a, b, c);
             if (this.bd.dataSeries.count > 0) {
-                if (stringIsNullOrEmpty(this.lm)) {
+                if (stringIsNullOrEmpty(this.lo)) {
                     this.b3.setXMemberPath(a, c.getMemberPathFor(16));
                 }
-                if (stringIsNullOrEmpty(this.lo)) {
+                if (stringIsNullOrEmpty(this.lq)) {
                     this.b3.setYMemberPath(a, c.getMemberPathFor(0));
                 }
-                if (stringIsNullOrEmpty(this.li)) {
+                if (stringIsNullOrEmpty(this.lk)) {
                     this.b3.setLabelMemberPath(a, c.getMemberPathFor(0));
                 }
-                if (stringIsNullOrEmpty(this.lf)) {
+                if (stringIsNullOrEmpty(this.lh)) {
                     this.b3.setContentMemberPath(a, c.getMemberPathFor(0));
                 }
             }
         }
-        f0() {
+        f2() {
             if (this.a9 == 4 || this.a9 == 3) {
                 return true;
             }
             else if (this.a9 == 0) {
-                if (this.ada == 2 || this.ada == 8) {
+                if (this.adc == 2 || this.adc == 8) {
                     return false;
                 }
-                else if (this.ada == 9 && this.bd != null && this.bd.dataSeries != null && this.bd.dataSeries.count > 0) {
+                else if (this.adc == 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;
@@ -882,133 +882,133 @@ export let CategoryChart = /*@__PURE__*/ (() => {
             }
             return false;
         }
-        get_f6() {
+        get_f8() {
             return DVContainer.instance.checkLoaded("CategoryChartToolbarFactoryManager");
         }
-        sw(a, b, c) {
-            super.sw(a, b, c);
+        sy(a, b, c) {
+            super.sy(a, b, c);
             switch (a) {
                 case "ChartType":
-                    this.ti();
+                    this.tk();
                     break;
                 case "MarkerCollisionAvoidance":
-                    this.ags((d) => d.tr = this.adc);
+                    this.agu((d) => d.tr = this.ade);
                     break;
                 case "IsTransitionInEnabled":
-                    this.ags((d) => d.so = this.ad5);
+                    this.agu((d) => d.so = this.ad7);
                     break;
                 case "IsSplineShapePartOfRange":
-                    this.ags((d) => {
+                    this.agu((d) => {
                         if (d.ej) {
-                            d.mt(this.ad4);
+                            d.mt(this.ad6);
                         }
                     });
                     break;
                 case "TransitionInMode":
-                    this.ags((d) => d.r8 = this.ade);
+                    this.agu((d) => d.r8 = this.adg);
                     break;
                 case "TransitionInSpeedType":
-                    this.ags((d) => d.cb = this.ado);
+                    this.agu((d) => d.cb = this.adq);
                     break;
                 case "XAxisInterval":
-                    this.xAxis.mr = this.ae4;
+                    this.xAxis.mr = this.ae6;
                     break;
                 case "XAxisMinorInterval":
-                    this.xAxis.ms = this.ae7;
+                    this.xAxis.ms = this.ae9;
                     break;
                 case "XAxisGap":
-                    this.xAxis.k1 = this.ae3;
+                    this.xAxis.k1 = this.ae5;
                     break;
                 case "XAxisOverlap":
-                    this.xAxis.la = this.ae8;
+                    this.xAxis.la = this.afa;
                     break;
                 case "XAxisMinimumGapSize":
-                    this.xAxis.k9 = this.ae6;
+                    this.xAxis.k9 = this.ae8;
                     break;
                 case "XAxisMaximumGap":
-                    this.xAxis.k8 = this.ae5;
+                    this.xAxis.k8 = this.ae7;
                     break;
                 case "XAxisZoomMaximumCategoryRange":
-                    this.xAxis.zoomMaximumCategoryRange = this.ae9;
+                    this.xAxis.zoomMaximumCategoryRange = this.afb;
                     break;
                 case "XAxisZoomMaximumItemSpan":
-                    this.xAxis.zoomMaximumItemSpan = this.afa;
+                    this.xAxis.zoomMaximumItemSpan = this.afc;
                     break;
                 case "XAxisZoomToCategoryRange":
-                    this.xAxis.zoomToCategoryRange = this.afb;
+                    this.xAxis.zoomToCategoryRange = this.afd;
                     break;
                 case "XAxisZoomToCategoryStart":
-                    this.xAxis.zoomToCategoryStart = this.afc;
+                    this.xAxis.zoomToCategoryStart = this.afe;
                     break;
                 case "XAxisZoomToItemSpan":
-                    this.xAxis.zoomToItemSpan = this.afd;
+                    this.xAxis.zoomToItemSpan = this.aff;
                     break;
                 case "YAxisInterval":
-                    this.yAxis.l1 = this.afg;
+                    this.yAxis.l1 = this.afi;
                     break;
                 case "YAxisFavorLabellingScaleEnd":
-                    this.yAxis.ld = this.aeb;
+                    this.yAxis.ld = this.aed;
                     break;
                 case "YAxisAutoRangeBufferMode":
-                    this.yAxis.ku = this.ac8;
+                    this.yAxis.ku = this.ada;
                     break;
                 case "YAxisIsLogarithmic":
-                    this.yAxis.li = this.aec;
+                    this.yAxis.li = this.aee;
                     break;
                 case "YAxisLogarithmBase":
-                    this.yAxis.l9 = this.afn;
+                    this.yAxis.l9 = this.afp;
                     break;
                 case "YAxisMinimumValue":
-                    this.yAxis.l5 = this.afi;
+                    this.yAxis.l5 = this.afk;
                     break;
                 case "YAxisMaximumValue":
-                    this.yAxis.l4 = this.afh;
+                    this.yAxis.l4 = this.afj;
                     break;
                 case "YAxisMinorInterval":
-                    this.yAxis.l6 = this.afj;
+                    this.yAxis.l6 = this.afl;
                     break;
                 case "NegativeBrushes":
                 case "NegativeOutlines":
-                    this.agt((d, e) => {
+                    this.agv((d, e) => {
                         if (d.d6) {
-                            d.ms(ArrayExtension.getModulus$1(Brush.$, this.ac3, e), ArrayExtension.getModulus$1(Brush.$, this.ac4, e));
+                            d.ms(ArrayExtension.getModulus$1(Brush.$, this.ac5, e), ArrayExtension.getModulus$1(Brush.$, this.ac6, e));
                         }
                     });
                     break;
                 case "YAxisAbbreviateLargeNumbers":
-                    this.abk((d) => d.la = this.ad9);
+                    this.abm((d) => d.la = this.aeb);
                     break;
                 case "IsCategoryHighlightingEnabled":
                 case "IsItemHighlightingEnabled":
-                    this.ti();
+                    this.tk();
                     break;
                 case "AutoMarginAndAngleUpdateMode":
-                    this.so((d) => d.t5 = this.ac6);
+                    this.sq((d) => d.t6 = this.ac8);
                     break;
                 case "ShouldAutoExpandMarginForInitialLabels":
-                    this.so((d) => d.u0 = this.ad6);
+                    this.sq((d) => d.u1 = this.ad8);
                     break;
-                case CategoryChart.af1:
-                    this.so((d) => d.u3 = this.ad7);
+                case CategoryChart.af3:
+                    this.sq((d) => d.u4 = this.ad9);
                     break;
                 case "AutoExpandMarginExtraPadding":
-                    this.so((d) => d.vq = this.aev);
+                    this.sq((d) => d.vr = this.aex);
                     break;
                 case "AutoExpandMarginMaximumValue":
-                    this.so((d) => d.vr = this.aew);
+                    this.sq((d) => d.vs = this.aey);
                     break;
-                case CategoryChart.af6:
-                    this.abg((d) => d.b1 = this.ad8, a);
+                case CategoryChart.af8:
+                    this.abi((d) => d.b1 = this.aea, a);
                     break;
-                case CategoryChart.agk:
-                    this.abk((d) => d.b1 = this.aea);
+                case CategoryChart.agm:
+                    this.abm((d) => d.b1 = this.aec);
                     break;
             }
         }
     }
     CategoryChart.$t = /*@__PURE__*/ markType(CategoryChart, 'CategoryChart', XYChart.$);
-    CategoryChart.af1 = "ShouldConsiderAutoRotationForInitialLabels";
-    CategoryChart.af6 = "XAxisEnhancedIntervalPreferMoreCategoryLabels";
-    CategoryChart.agk = "YAxisEnhancedIntervalPreferMoreCategoryLabels";
+    CategoryChart.af3 = "ShouldConsiderAutoRotationForInitialLabels";
+    CategoryChart.af8 = "XAxisEnhancedIntervalPreferMoreCategoryLabels";
+    CategoryChart.agm = "YAxisEnhancedIntervalPreferMoreCategoryLabels";
     return CategoryChart;
 })();