igniteui-webcomponents-charts 4.7.2 → 4.8.1-alpha.0

package/esm2015/lib/CategoryChart.js

@@ -35,148 +35,148 @@ import { stringIsNullOrEmpty } from "igniteui-webcomponents-core";
  */
 export let CategoryChart = /*@__PURE__*/ (() => {
     class CategoryChart extends XYChart {
-        sr() {
-            super.sr();
+        ti() {
+            super.ti();
             if (this.dataChart == null) {
                 return;
             }
-            let a = this.dataChart.cu.j.e();
-            this.adl = a.d;
-            this.adm = a.e;
-            if (this.acv == null) {
-                this.acv = a.k;
-            }
-            if (this.ac2 == null) {
-                this.ac2 = a.k;
-            }
-            this.yu = 0;
-            this.ac3 = AxisDefaults.h;
-            this.ac6 = null;
-            this.acz = AxisDefaults.g;
-            this.acw = null;
-            this.yd = AxisDefaults.f;
-            this.ac0 = AxisDefaults.j;
-            this.ye = AxisDefaults.e;
-            this.fx = true;
-            this.fy = true;
-            this.a9 = 0;
-            this.il = Defaults.j;
-            this.u7 = Defaults.ae;
-            this.u2 = Defaults.af;
-            this.u3 = Defaults.ag;
-            this.aep = true;
-        }
-        st(a, b) {
-            super.st(a, b);
-            a.jk = this.af7;
-            a.jl = this.af8;
-            a.cy = this.ad9;
-            a.cz = this.aea;
-        }
-        th(a, b, c) {
-            super.th(a, b, c);
+            let a = this.dataChart.c8.j.e();
+            this.aeo = a.d;
+            this.aep = a.e;
+            if (this.ady == null) {
+                this.ady = a.k;
+            }
+            if (this.ad5 == null) {
+                this.ad5 = a.k;
+            }
+            this.zx = 0;
+            this.ad6 = AxisDefaults.h;
+            this.ad9 = null;
+            this.ad2 = AxisDefaults.g;
+            this.adz = null;
+            this.zg = AxisDefaults.f;
+            this.ad3 = AxisDefaults.j;
+            this.zh = AxisDefaults.e;
+            this.gc = true;
+            this.gd = true;
+            this.bd = 0;
+            this.i2 = Defaults.j;
+            this.v3 = Defaults.ae;
+            this.vy = Defaults.af;
+            this.vz = Defaults.ag;
+            this.afs = true;
+        }
+        tk(a, b) {
+            super.tk(a, b);
+            a.ju = this.aha;
+            a.jv = this.ahb;
+            a.c4 = this.afc;
+            a.c5 = this.afd;
+        }
+        t8(a, b, c) {
+            super.t8(a, b, c);
             switch (a) {
                 case "TransitionInDuration":
-                    this.sg((d) => d.jk = this.af7);
+                    this.s7((d) => d.ju = this.aha);
                     break;
                 case "TransitionOutDuration":
-                    this.sg((d) => d.jl = this.af8);
+                    this.s7((d) => d.jv = this.ahb);
                     break;
                 case "TransitionInEasingFunction":
-                    this.sg((d) => d.cy = this.ad9);
+                    this.s7((d) => d.c4 = this.afc);
                     break;
                 case "TransitionOutEasingFunction":
-                    this.sg((d) => d.cz = this.aea);
+                    this.s7((d) => d.c5 = this.afd);
                     break;
             }
         }
-        get af7() {
-            return this.af4;
+        get aha() {
+            return this.ag7;
         }
-        set af7(a) {
-            let b = this.af7;
+        set aha(a) {
+            let b = this.aha;
             if (a != b) {
-                this.af4 = a;
-                this.te("TransitionInDuration", b, this.af7);
+                this.ag7 = a;
+                this.t5("TransitionInDuration", b, this.aha);
             }
         }
-        get af8() {
-            return this.af5;
+        get ahb() {
+            return this.ag8;
         }
-        set af8(a) {
-            let b = this.af8;
+        set ahb(a) {
+            let b = this.ahb;
             if (a != b) {
-                this.af5 = a;
-                this.te("TransitionOutDuration", b, this.af8);
+                this.ag8 = a;
+                this.t5("TransitionOutDuration", b, this.ahb);
             }
         }
-        get ad9() {
-            return this.ad7;
+        get afc() {
+            return this.afa;
         }
-        set ad9(a) {
-            let b = this.ad9;
+        set afc(a) {
+            let b = this.afc;
             if (a != b) {
-                this.ad7 = a;
-                this.te("TransitionInEasingFunction", b, this.ad9);
+                this.afa = a;
+                this.t5("TransitionInEasingFunction", b, this.afc);
             }
         }
-        get aea() {
-            return this.ad8;
+        get afd() {
+            return this.afb;
         }
-        set aea(a) {
-            let b = this.aea;
+        set afd(a) {
+            let b = this.afd;
             if (a != b) {
-                this.ad8 = a;
-                this.te("TransitionOutEasingFunction", b, this.aea);
+                this.afb = a;
+                this.t5("TransitionOutEasingFunction", b, this.afd);
             }
         }
-        age() {
-            let cvd_ = this.kk();
+        ahh() {
+            let cvd_ = this.k0();
             cvd_.scaleByViewport();
             return (cvd_.serialize());
         }
-        sm(a) {
-            super.sm(a);
-            a.dw = this.fs;
-            a.u8 = this.aeq;
-            a.vb = this.aer;
-            a.vy = this.aff;
-            a.vz = this.afg;
-            a.ud = this.ado;
-        }
-        ss(a, b) {
-            super.ss(a, b);
+        td(a) {
+            super.td(a);
+            a.eg = this.f7;
+            a.wy = this.aft;
+            a.w1 = this.afu;
+            a.xo = this.agi;
+            a.xp = this.agj;
+            a.v3 = this.aer;
+        }
+        tj(a, b) {
+            super.tj(a, b);
             let c = typeCast(HorizontalAnchoredCategorySeries.$, a);
             if (c == null) {
                 return;
             }
-            c.xj = this.adu;
-            c.wf = this.aep;
-            c.vz = this.adw;
-            c.cq = this.ad6;
+            c.yx = this.aex;
+            c.xt = this.afs;
+            c.xd = this.aez;
+            c.cv = this.ae9;
             c.trendLineBrush = ArrayExtension.getModulus$1(Brush.$, this.ah, b);
-            c.trendLineType = this.dt;
-            c.trendLineThickness = this.ji;
-            c.uc = this.cs(a, b);
-            if (a.e0) {
-                a.p1(ArrayExtension.getModulus$1(Brush.$, this.adl, b), ArrayExtension.getModulus$1(Brush.$, this.adm, b));
+            c.trendLineType = this.d5;
+            c.trendLineThickness = this.jy;
+            c.vp = this.cw(a, b);
+            if (a.e7) {
+                a.qw(ArrayExtension.getModulus$1(Brush.$, this.aeo, b), ArrayExtension.getModulus$1(Brush.$, this.aep, b));
             }
         }
-        adx() {
+        ae0() {
             return new CategoryXAxis();
         }
-        ad1() {
+        ae4() {
             return new NumericYAxis();
         }
-        r5() {
-            this.xAxis = this.adx();
+        sw() {
+            this.xAxis = this.ae0();
             this.xAxis.name = "xAxis";
             let a = this.xAxis;
-            a.propertyChanged = delegateCombine(a.propertyChanged, runOn(this, this.ahi));
-            this.yAxis = this.ad1();
+            a.propertyChanged = delegateCombine(a.propertyChanged, runOn(this, this.ail));
+            this.yAxis = this.ae4();
             this.yAxis.name = "yAxis";
             let b = this.yAxis;
-            b.propertyChanged = delegateCombine(b.propertyChanged, runOn(this, this.ahj));
+            b.propertyChanged = delegateCombine(b.propertyChanged, runOn(this, this.aim));
             if (this.xAxis.az == null) {
                 this.xAxis.az = new AxisLabelSettings();
             }
@@ -184,474 +184,474 @@ export let CategoryChart = /*@__PURE__*/ (() => {
                 this.yAxis.az = new AxisLabelSettings();
             }
         }
-        abv(a) {
-            super.abv(a);
-            a.la = this.aet;
-            a.ld = this.aev;
-            a.b1 = this.aeu;
+        acy(a) {
+            super.acy(a);
+            a.la = this.afw;
+            a.ld = this.afy;
+            a.b1 = this.afx;
         }
-        abt(a) {
-            super.abt(a);
-            a.b1 = this.aes;
-            a.zoomMaximumCategoryRange = this.aft;
-            a.zoomToCategoryRange = this.afv;
-            a.zoomToCategoryStart = this.afw;
-            a.zoomMaximumItemSpan = this.afu;
-            a.zoomToItemSpan = this.afx;
+        acw(a) {
+            super.acw(a);
+            a.b1 = this.afv;
+            a.zoomMaximumCategoryRange = this.agw;
+            a.zoomToCategoryRange = this.agy;
+            a.zoomToCategoryStart = this.agz;
+            a.zoomMaximumItemSpan = this.agx;
+            a.zoomToItemSpan = this.ag0;
         }
-        get_b1() {
+        get_b5() {
             return 0;
         }
-        get b1() {
-            return this.get_b1();
+        get b5() {
+            return this.get_b5();
         }
-        get ads() {
-            return this.adr;
+        get aev() {
+            return this.aeu;
         }
-        set ads(a) {
-            if (a != this.adr) {
-                let b = this.ads;
-                this.adr = a;
-                this.te("ChartType", enumGetBox(CategoryChartType_$type, b), enumGetBox(CategoryChartType_$type, this.ads));
+        set aev(a) {
+            if (a != this.aeu) {
+                let b = this.aev;
+                this.aeu = a;
+                this.t5("ChartType", enumGetBox(CategoryChartType_$type, b), enumGetBox(CategoryChartType_$type, this.aev));
             }
         }
-        get adu() {
-            return this.adt;
+        get aex() {
+            return this.aew;
         }
-        set adu(a) {
-            let b = this.adu;
+        set aex(a) {
+            let b = this.aex;
             if (a != b) {
-                this.adt = a;
-                this.te("MarkerCollisionAvoidance", enumGetBox(CategorySeriesMarkerCollisionAvoidance_$type, b), enumGetBox(CategorySeriesMarkerCollisionAvoidance_$type, this.adu));
+                this.aew = a;
+                this.t5("MarkerCollisionAvoidance", enumGetBox(CategorySeriesMarkerCollisionAvoidance_$type, b), enumGetBox(CategorySeriesMarkerCollisionAvoidance_$type, this.aex));
             }
         }
-        get aeo() {
-            return this.aed;
+        get afr() {
+            return this.afg;
         }
-        set aeo(a) {
-            let b = this.aeo;
+        set afr(a) {
+            let b = this.afr;
             if (a != b) {
-                this.aed = a;
-                this.te("IsSplineShapePartOfRange", b, this.aeo);
+                this.afg = a;
+                this.t5("IsSplineShapePartOfRange", b, this.afr);
             }
         }
-        get aep() {
-            return this.aee;
+        get afs() {
+            return this.afh;
         }
-        set aep(a) {
-            let b = this.aep;
+        set afs(a) {
+            let b = this.afs;
             if (a != b) {
-                this.aee = a;
-                this.te("IsTransitionInEnabled", b, this.aep);
+                this.afh = a;
+                this.t5("IsTransitionInEnabled", b, this.afs);
             }
         }
-        get adw() {
-            return this.adv;
+        get aez() {
+            return this.aey;
         }
-        set adw(a) {
-            let b = this.adw;
+        set aez(a) {
+            let b = this.aez;
             if (a != b) {
-                this.adv = a;
-                this.te("TransitionInMode", enumGetBox(CategoryTransitionInMode_$type, b), enumGetBox(CategoryTransitionInMode_$type, this.adw));
+                this.aey = a;
+                this.t5("TransitionInMode", enumGetBox(CategoryTransitionInMode_$type, b), enumGetBox(CategoryTransitionInMode_$type, this.aez));
             }
         }
-        get ad6() {
-            return this.ad5;
+        get ae9() {
+            return this.ae8;
         }
-        set ad6(a) {
-            let b = this.ad6;
+        set ae9(a) {
+            let b = this.ae9;
             if (a != b) {
-                this.ad5 = a;
-                this.te("TransitionInSpeedType", enumGetBox(TransitionInSpeedType_$type, b), enumGetBox(TransitionInSpeedType_$type, this.ad6));
+                this.ae8 = a;
+                this.t5("TransitionInSpeedType", enumGetBox(TransitionInSpeedType_$type, b), enumGetBox(TransitionInSpeedType_$type, this.ae9));
             }
         }
-        get afo() {
-            return this.ae1;
+        get agr() {
+            return this.af4;
         }
-        set afo(a) {
-            let b = this.afo;
+        set agr(a) {
+            let b = this.agr;
             if (a != b) {
-                this.ae1 = a;
-                this.te("XAxisInterval", b, this.afo);
+                this.af4 = a;
+                this.t5("XAxisInterval", b, this.agr);
             }
         }
-        get afr() {
-            return this.ae4;
+        get agu() {
+            return this.af7;
         }
-        set afr(a) {
-            let b = this.afr;
+        set agu(a) {
+            let b = this.agu;
             if (a != b) {
-                this.ae4 = a;
-                this.te("XAxisMinorInterval", b, this.afr);
+                this.af7 = a;
+                this.t5("XAxisMinorInterval", b, this.agu);
             }
         }
-        get afn() {
-            return this.ae0;
+        get agq() {
+            return this.af3;
         }
-        set afn(a) {
-            let b = this.afn;
+        set agq(a) {
+            let b = this.agq;
             if (a != b) {
-                this.ae0 = a;
-                this.te("XAxisGap", b, this.afn);
+                this.af3 = a;
+                this.t5("XAxisGap", b, this.agq);
             }
         }
-        get afq() {
-            return this.ae3;
+        get agt() {
+            return this.af6;
         }
-        set afq(a) {
-            let b = this.afq;
+        set agt(a) {
+            let b = this.agt;
             if (a != b) {
-                this.ae3 = a;
-                this.te("XAxisMinimumGapSize", b, this.afq);
+                this.af6 = a;
+                this.t5("XAxisMinimumGapSize", b, this.agt);
             }
         }
-        get afp() {
-            return this.ae2;
+        get ags() {
+            return this.af5;
         }
-        set afp(a) {
-            let b = this.afp;
+        set ags(a) {
+            let b = this.ags;
             if (a != b) {
-                this.ae2 = a;
-                this.te("XAxisMaximumGap", b, this.afp);
+                this.af5 = a;
+                this.t5("XAxisMaximumGap", b, this.ags);
             }
         }
-        get afs() {
-            return this.ae5;
+        get agv() {
+            return this.af8;
         }
-        set afs(a) {
-            let b = this.afs;
+        set agv(a) {
+            let b = this.agv;
             if (a != b) {
-                this.ae5 = a;
-                this.te("XAxisOverlap", b, this.afs);
+                this.af8 = a;
+                this.t5("XAxisOverlap", b, this.agv);
             }
         }
-        get af0() {
-            return this.afb;
+        get ag3() {
+            return this.age;
         }
-        set af0(a) {
-            let b = this.af0;
+        set ag3(a) {
+            let b = this.ag3;
             if (a != b) {
-                this.afb = a;
-                this.te("YAxisInterval", b, this.af0);
+                this.age = a;
+                this.t5("YAxisInterval", b, this.ag3);
             }
         }
-        get ado() {
-            return this.adn;
+        get aer() {
+            return this.aeq;
         }
-        set ado(a) {
-            let b = this.ado;
+        set aer(a) {
+            let b = this.aer;
             if (a != b) {
-                this.adn = a;
-                this.te("AutoMarginAndAngleUpdateMode", enumGetBox(AutoMarginsAndAngleUpdateMode_$type, b), enumGetBox(AutoMarginsAndAngleUpdateMode_$type, this.ado));
+                this.aeq = a;
+                this.t5("AutoMarginAndAngleUpdateMode", enumGetBox(AutoMarginsAndAngleUpdateMode_$type, b), enumGetBox(AutoMarginsAndAngleUpdateMode_$type, this.aer));
             }
         }
-        ahk() {
+        ain() {
             if (this.dataChart != null) {
-                this.dataChart.xj();
+                this.dataChart.y9();
             }
         }
-        get aeq() {
-            return this.aef;
+        get aft() {
+            return this.afi;
         }
-        set aeq(a) {
-            let b = this.aeq;
+        set aft(a) {
+            let b = this.aft;
             if (a != b) {
-                this.aef = a;
-                this.te("ShouldAutoExpandMarginForInitialLabels", b, this.aeq);
+                this.afi = a;
+                this.t5("ShouldAutoExpandMarginForInitialLabels", b, this.aft);
             }
         }
-        get aer() {
-            return this.aeg;
+        get afu() {
+            return this.afj;
         }
-        set aer(a) {
-            let b = this.aer;
+        set afu(a) {
+            let b = this.afu;
             if (a != b) {
-                this.aeg = a;
-                this.te(CategoryChart.agn, b, this.aer);
+                this.afj = a;
+                this.t5(CategoryChart.ahq, b, this.afu);
             }
         }
-        get aff() {
-            return this.aey;
+        get agi() {
+            return this.af1;
         }
-        set aff(a) {
-            let b = this.aff;
+        set agi(a) {
+            let b = this.agi;
             if (a != b) {
-                this.aey = a;
-                this.te("AutoExpandMarginExtraPadding", b, this.aff);
+                this.af1 = a;
+                this.t5("AutoExpandMarginExtraPadding", b, this.agi);
             }
         }
-        get afg() {
-            return this.aez;
+        get agj() {
+            return this.af2;
         }
-        set afg(a) {
-            let b = this.afg;
+        set agj(a) {
+            let b = this.agj;
             if (a != b) {
-                this.aez = a;
-                this.te("AutoExpandMarginMaximumValue", b, this.afg);
+                this.af2 = a;
+                this.t5("AutoExpandMarginMaximumValue", b, this.agj);
             }
         }
-        get aev() {
-            return this.aek;
+        get afy() {
+            return this.afn;
         }
-        set aev(a) {
-            let b = this.aev;
+        set afy(a) {
+            let b = this.afy;
             if (a != b) {
-                this.aek = a;
-                this.te("YAxisFavorLabellingScaleEnd", b, this.aev);
+                this.afn = a;
+                this.t5("YAxisFavorLabellingScaleEnd", b, this.afy);
             }
         }
-        get aes() {
-            return this.aeh;
+        get afv() {
+            return this.afk;
         }
-        set aes(a) {
-            let b = this.aes;
+        set afv(a) {
+            let b = this.afv;
             if (a != b) {
-                this.aeh = a;
-                this.te(CategoryChart.agu, b, this.aes);
+                this.afk = a;
+                this.t5(CategoryChart.ahx, b, this.afv);
             }
         }
-        get aeu() {
-            return this.aej;
+        get afx() {
+            return this.afm;
         }
-        set aeu(a) {
-            let b = this.aeu;
+        set afx(a) {
+            let b = this.afx;
             if (a != b) {
-                this.aej = a;
-                this.te(CategoryChart.ag8, b, this.aeu);
+                this.afm = a;
+                this.t5(CategoryChart.aib, b, this.afx);
             }
         }
-        get adq() {
-            return this.adp;
+        get aet() {
+            return this.aes;
         }
-        set adq(a) {
-            let b = this.adq;
+        set aet(a) {
+            let b = this.aet;
             if (a != b) {
-                this.adp = a;
-                this.te("YAxisAutoRangeBufferMode", enumGetBox(AxisRangeBufferMode_$type, b), enumGetBox(AxisRangeBufferMode_$type, this.adq));
+                this.aes = a;
+                this.t5("YAxisAutoRangeBufferMode", enumGetBox(AxisRangeBufferMode_$type, b), enumGetBox(AxisRangeBufferMode_$type, this.aet));
             }
         }
-        get aew() {
-            return this.ael;
+        get afz() {
+            return this.afo;
         }
-        set aew(a) {
-            let b = this.aew;
+        set afz(a) {
+            let b = this.afz;
             if (a != b) {
-                this.ael = a;
-                this.te("YAxisIsLogarithmic", b, this.aew);
+                this.afo = a;
+                this.t5("YAxisIsLogarithmic", b, this.afz);
             }
         }
-        get af9() {
-            return this.af6;
+        get ahc() {
+            return this.ag9;
         }
-        set af9(a) {
-            let b = this.af9;
+        set ahc(a) {
+            let b = this.ahc;
             if (a != b) {
-                this.af6 = a;
-                this.te("YAxisLogarithmBase", b, this.af9);
+                this.ag9 = a;
+                this.t5("YAxisLogarithmBase", b, this.ahc);
             }
         }
-        get af2() {
-            return this.afd;
+        get ag5() {
+            return this.agg;
         }
-        set af2(a) {
-            let b = this.af2;
+        set ag5(a) {
+            let b = this.ag5;
             if (a != b) {
-                this.afd = a;
-                this.te("YAxisMinimumValue", b, this.af2);
+                this.agg = a;
+                this.t5("YAxisMinimumValue", b, this.ag5);
             }
         }
-        get af1() {
-            return this.afc;
+        get ag4() {
+            return this.agf;
         }
-        set af1(a) {
-            let b = this.af1;
+        set ag4(a) {
+            let b = this.ag4;
             if (a != b) {
-                this.afc = a;
-                this.te("YAxisMaximumValue", b, this.af1);
+                this.agf = a;
+                this.t5("YAxisMaximumValue", b, this.ag4);
             }
         }
-        get af3() {
-            return this.afe;
+        get ag6() {
+            return this.agh;
         }
-        set af3(a) {
-            let b = this.af3;
+        set ag6(a) {
+            let b = this.ag6;
             if (a != b) {
-                this.afe = a;
-                this.te("YAxisMinorInterval", b, this.af3);
+                this.agh = a;
+                this.t5("YAxisMinorInterval", b, this.ag6);
             }
         }
-        get afm() {
+        get agp() {
             return this.xAxis.mw;
         }
-        get afl() {
+        get ago() {
             return this.xAxis.mv;
         }
-        afi() {
-            return this.afm;
+        agl() {
+            return this.agp;
         }
-        afk() {
-            return this.afz;
+        agn() {
+            return this.ag2;
         }
-        afh() {
-            return this.afl;
+        agk() {
+            return this.ago;
         }
-        afj() {
-            return this.afy;
+        agm() {
+            return this.ag1;
         }
-        get afz() {
+        get ag2() {
             return this.yAxis.lx;
         }
-        get afy() {
+        get ag1() {
             return this.yAxis.lw;
         }
-        get adl() {
-            return this.adj;
+        get aeo() {
+            return this.aem;
         }
-        set adl(a) {
-            let b = this.adl;
+        set aeo(a) {
+            let b = this.aeo;
             if (a != b) {
-                this.adj = a;
-                this.te("NegativeBrushes", b, this.adl);
+                this.aem = a;
+                this.t5("NegativeBrushes", b, this.aeo);
             }
         }
-        get adm() {
-            return this.adk;
+        get aep() {
+            return this.aen;
         }
-        set adm(a) {
-            let b = this.adm;
+        set aep(a) {
+            let b = this.aep;
             if (a != b) {
-                this.adk = a;
-                this.te("NegativeOutlines", b, this.adm);
+                this.aen = a;
+                this.t5("NegativeOutlines", b, this.aep);
             }
         }
-        get aet() {
-            return this.aei;
+        get afw() {
+            return this.afl;
         }
-        set aet(a) {
-            let b = this.aet;
+        set afw(a) {
+            let b = this.afw;
             if (a != b) {
-                this.aei = a;
-                this.te("YAxisAbbreviateLargeNumbers", b, this.aet);
+                this.afl = a;
+                this.t5("YAxisAbbreviateLargeNumbers", b, this.afw);
             }
         }
-        get aft() {
-            return this.ae6;
+        get agw() {
+            return this.af9;
         }
-        set aft(a) {
-            let b = this.aft;
+        set agw(a) {
+            let b = this.agw;
             if (a != b) {
-                this.ae6 = a;
-                this.te("XAxisZoomMaximumCategoryRange", b, this.aft);
+                this.af9 = a;
+                this.t5("XAxisZoomMaximumCategoryRange", b, this.agw);
             }
         }
-        get afu() {
-            return this.ae7;
+        get agx() {
+            return this.aga;
         }
-        set afu(a) {
-            let b = this.afu;
+        set agx(a) {
+            let b = this.agx;
             if (a != b) {
-                this.ae7 = a;
-                this.te("XAxisZoomMaximumItemSpan", b, this.afu);
+                this.aga = a;
+                this.t5("XAxisZoomMaximumItemSpan", b, this.agx);
             }
         }
-        get afv() {
-            return this.ae8;
+        get agy() {
+            return this.agb;
         }
-        set afv(a) {
-            let b = this.afv;
+        set agy(a) {
+            let b = this.agy;
             if (a != b) {
-                this.ae8 = a;
-                this.te("XAxisZoomToCategoryRange", b, this.afv);
+                this.agb = a;
+                this.t5("XAxisZoomToCategoryRange", b, this.agy);
             }
         }
-        get afw() {
-            return this.ae9;
+        get agz() {
+            return this.agc;
         }
-        set afw(a) {
-            let b = this.afw;
+        set agz(a) {
+            let b = this.agz;
             if (a != b) {
-                this.ae9 = a;
-                this.te("XAxisZoomToCategoryStart", b, this.afw);
+                this.agc = a;
+                this.t5("XAxisZoomToCategoryStart", b, this.agz);
             }
         }
-        get afx() {
-            return this.afa;
+        get ag0() {
+            return this.agd;
         }
-        set afx(a) {
-            let b = this.afx;
+        set ag0(a) {
+            let b = this.ag0;
             if (a != b) {
-                this.afa = a;
-                this.te("XAxisZoomToItemSpan", b, this.afx);
+                this.agd = a;
+                this.t5("XAxisZoomToItemSpan", b, this.ag0);
             }
         }
-        get aem() {
-            return this.aeb;
+        get afp() {
+            return this.afe;
         }
-        set aem(a) {
-            let b = this.aem;
+        set afp(a) {
+            let b = this.afp;
             if (a != b) {
-                this.aeb = a;
-                this.te("IsCategoryHighlightingEnabled", b, this.aem);
+                this.afe = a;
+                this.t5("IsCategoryHighlightingEnabled", b, this.afp);
             }
         }
-        get aen() {
-            return this.aec;
+        get afq() {
+            return this.aff;
         }
-        set aen(a) {
-            let b = this.aen;
+        set afq(a) {
+            let b = this.afq;
             if (a != b) {
-                this.aec = a;
-                this.te("IsItemHighlightingEnabled", b, this.aen);
+                this.aff = a;
+                this.t5("IsItemHighlightingEnabled", b, this.afq);
             }
         }
         constructor() {
             super();
-            this.af4 = 1000;
-            this.af5 = 1000;
-            this.ad7 = null;
-            this.ad8 = null;
-            this.adr = 9;
-            this.adt = 1;
-            this.aed = false;
-            this.aee = true;
-            this.adv = 0;
-            this.ad5 = 0;
-            this.ae1 = 0;
-            this.ae4 = 0;
-            this.ae0 = 0;
-            this.ae3 = 0;
-            this.ae2 = 1;
-            this.ae5 = 0;
-            this.afb = NaN;
-            this.adn = 1;
-            this.aef = true;
-            this.aeg = true;
-            this.aey = DeviceUtils.g(2);
-            this.aez = DeviceUtils.g(60);
-            this.aek = true;
-            this.aeh = true;
-            this.aej = false;
-            this.adp = 0;
-            this.ael = false;
-            this.af6 = 10;
-            this.afd = NaN;
-            this.afc = NaN;
-            this.afe = 0;
-            this.adj = null;
-            this.adk = null;
-            this.aei = true;
-            this.ae6 = 3;
-            this.ae7 = NaN;
-            this.ae8 = NaN;
-            this.ae9 = NaN;
-            this.afa = NaN;
-            this.aeb = false;
-            this.aec = false;
-            this.aex = null;
+            this.ag7 = 1000;
+            this.ag8 = 1000;
+            this.afa = null;
+            this.afb = null;
+            this.aeu = 9;
+            this.aew = 1;
+            this.afg = false;
+            this.afh = true;
+            this.aey = 0;
+            this.ae8 = 0;
+            this.af4 = 0;
+            this.af7 = 0;
+            this.af3 = 0;
+            this.af6 = 0;
+            this.af5 = 1;
+            this.af8 = 0;
+            this.age = NaN;
+            this.aeq = 1;
+            this.afi = true;
+            this.afj = true;
+            this.af1 = DeviceUtils.g(2);
+            this.af2 = DeviceUtils.g(60);
+            this.afn = true;
+            this.afk = true;
+            this.afm = false;
+            this.aes = 0;
+            this.afo = false;
+            this.ag9 = 10;
+            this.agg = NaN;
+            this.agf = NaN;
+            this.agh = 0;
+            this.aem = null;
+            this.aen = null;
+            this.afl = true;
+            this.af9 = 3;
+            this.aga = NaN;
+            this.agb = NaN;
+            this.agc = NaN;
+            this.agd = NaN;
+            this.afe = false;
+            this.aff = false;
+            this.af0 = null;
             DVContainer.instance.registerIfLoaded("CategoryChartToolbarFactoryManager");
-            this.r9();
+            this.s0();
         }
-        get_g2() {
+        get_hi() {
             let a = new List$1(DataSeriesType_$type, 0);
             if (TypeRegistrar.isRegistered("AreaSeries")) {
                 a.add(2);
@@ -682,66 +682,66 @@ export let CategoryChart = /*@__PURE__*/ (() => {
             }
             return a;
         }
-        get g2() {
-            return this.get_g2();
+        get hi() {
+            return this.get_hi();
         }
-        g6() {
-            if (this.aex == null) {
-                this.aex = CategoryChartMockDataGenerator.a();
+        hm() {
+            if (this.af0 == null) {
+                this.af0 = CategoryChartMockDataGenerator.a();
             }
-            return this.aex;
+            return this.af0;
         }
-        cr(a) {
+        cv(a) {
             if (a != null) {
-                let b = super.cr(a);
+                let b = super.cv(a);
                 if (b == 2) {
-                    if (a.ez && this.f8) {
+                    if (a.e6 && this.go) {
                         return 13;
                     }
                 }
             }
-            return super.cr(a);
+            return super.cv(a);
         }
-        ct(a) {
+        cx(a) {
             if (a != null) {
-                let b = super.cr(a);
+                let b = super.cv(a);
                 if (b == 2) {
-                    if (a.ez && this.f8) {
+                    if (a.e6 && this.go) {
                         return 13;
                     }
                 }
             }
-            return super.ct(a);
+            return super.cx(a);
         }
-        get_gp() {
+        get_g5() {
             return this.xAxis != null && this.xAxis.categoryMode != 0;
         }
-        ahi(a, b) {
+        ail(a, b) {
             switch (b.propertyName) {
                 case "ActualMinimum":
-                    this.to("XAxisActualMinimum");
+                    this.ug("XAxisActualMinimum");
                     break;
                 case "ActualMaximum":
-                    this.to("XAxisActualMaximum");
+                    this.ug("XAxisActualMaximum");
                     break;
             }
         }
-        ahj(a, b) {
+        aim(a, b) {
             switch (b.propertyName) {
                 case "ActualMinimumValue":
-                    this.to("YAxisActualMinimum");
+                    this.ug("YAxisActualMinimum");
                     break;
                 case "ActualMaximumValue":
-                    this.to("YAxisActualMaximum");
+                    this.ug("YAxisActualMaximum");
                     break;
             }
         }
-        t0() {
-            super.t0();
-            this.xAxis.f0 = this.y4 == null ? XYChart.zg(this.xAxis, this.bd.dataSeries) : this.y4;
+        ut() {
+            super.ut();
+            this.xAxis.f0 = this.z7 == null ? XYChart.aaj(this.xAxis, this.bh.dataSeries) : this.z7;
             this.xAxis.itemsSource = this.dataChart != null && this.dataChart.series.count > 0 ? this.dataChart.series._inner[0].itemsSource : null;
-            if (this.aeq) {
-                this.s6((a) => a.xj());
+            if (this.aft) {
+                this.tx((a) => a.y9());
             }
         }
         get xAxis() {
@@ -756,26 +756,26 @@ export let CategoryChart = /*@__PURE__*/ (() => {
         set yAxis(a) {
             this._yAxis = a;
         }
-        ad0(a, b) {
+        ae3(a, b) {
             switch (a) {
-                case 2: return this.c4(1);
-                case 3: return this.c4(10);
-                case 0: return this.c4(0);
-                case 1: return this.c4(2);
-                case 6: return this.c4(6);
-                case 7: return this.c4(7);
-                case 4: return this.c4(4);
-                case 5: return this.c4(5);
-                case 8: return this.c4(8);
-                case 9: return this.adz(b);
-                default: return this.c4(1);
-            }
-        }
-        adz(a) {
-            return this.c4(a);
-        }
-        bc(a) {
-            switch (this.ads) {
+                case 2: return this.c8(1);
+                case 3: return this.c8(10);
+                case 0: return this.c8(0);
+                case 1: return this.c8(2);
+                case 6: return this.c8(6);
+                case 7: return this.c8(7);
+                case 4: return this.c8(4);
+                case 5: return this.c8(5);
+                case 8: return this.c8(8);
+                case 9: return this.ae2(b);
+                default: return this.c8(1);
+            }
+        }
+        ae2(a) {
+            return this.c8(a);
+        }
+        bg(a) {
+            switch (this.aev) {
                 case 1: return 2;
                 case 0: return 0;
                 case 3: return 10;
@@ -789,24 +789,24 @@ export let CategoryChart = /*@__PURE__*/ (() => {
                 case 2: return 1;
             }
         }
-        c2(a, b) {
-            let c = this.ad0(this.ads, a.suggestedSeries);
-            c.x7 = a.findMatchingHint(0).path;
+        c6(a, b) {
+            let c = this.ae3(this.aev, a.suggestedSeries);
+            c.zl = a.findMatchingHint(0).path;
             c.xAxis = this.xAxis;
             c.yAxis = this.yAxis;
             return c;
         }
-        ty(a) {
+        ur(a) {
             if (a.suggestedSecondaryAxis == 2) {
                 this.yAxis.li = true;
                 this.yAxis.l9 = 10;
             }
         }
-        t1() {
-            this.yAxis.li = this.aew;
-            this.yAxis.l9 = this.af9;
+        uu() {
+            this.yAxis.li = this.afz;
+            this.yAxis.l9 = this.ahc;
         }
-        get_g1() {
+        get_hh() {
             return ((() => {
                 let $ret = new List$1(IDataSeriesAdapterRule_$type, 0);
                 $ret.add(new SimpleCategorySeriesRule());
@@ -814,20 +814,20 @@ export let CategoryChart = /*@__PURE__*/ (() => {
                 return $ret;
             })());
         }
-        get g1() {
-            return this.get_g1();
+        get hh() {
+            return this.get_hh();
         }
-        r1(a, b) {
+        ss(a, b) {
             let c = typeCast(HorizontalAnchoredCategorySeries.$, a);
             if (c != null) {
-                c.xj = this.adu;
-                c.uc = this.cs(a, b);
+                c.yx = this.aex;
+                c.vp = this.cw(a, b);
             }
         }
-        ahg(a) {
-            this.ahh((b, c) => a(b));
+        aij(a) {
+            this.aik((b, c) => a(b));
         }
-        ahh(a) {
+        aik(a) {
             if (this.dataChart == null) {
                 return;
             }
@@ -839,27 +839,27 @@ export let CategoryChart = /*@__PURE__*/ (() => {
                 a(c, b);
             }
         }
-        wm() {
+        xp() {
             return this.xAxis;
         }
-        wn() {
+        xq() {
             return this.yAxis;
         }
-        ad3() {
-            return this.c4(30);
+        ae6() {
+            return this.c8(30);
         }
-        ad4() {
-            return this.c4(31);
+        ae7() {
+            return this.c8(31);
         }
-        gy(a, b) {
-            let c = super.gy(a, b);
+        he(a, b) {
+            let c = super.he(a, b);
             if (c != null) {
                 let d = new List$1(Series.$, 0);
-                if (this.aeb) {
-                    d.add(this.ad3());
+                if (this.afe) {
+                    d.add(this.ae6());
                 }
-                if (this.aec) {
-                    d.add(this.ad4());
+                if (this.aff) {
+                    d.add(this.ae7());
                 }
                 for (let e = 0; e < d.count; e++) {
                     let f = d._inner[e];
@@ -869,41 +869,41 @@ export let CategoryChart = /*@__PURE__*/ (() => {
             }
             return c;
         }
-        a7() {
-            if (this.a6 == 0) {
+        bb() {
+            if (this.ba == 0) {
                 return 1;
             }
             else {
-                return this.a6;
+                return this.ba;
             }
         }
-        t6(a, b, c) {
-            super.t6(a, b, c);
-            if (this.bd.dataSeries.count > 0) {
-                if (stringIsNullOrEmpty(this.lz)) {
-                    this.b4.setXMemberPath(a, c.getMemberPathFor(16));
+        uz(a, b, c) {
+            super.uz(a, b, c);
+            if (this.bh.dataSeries.count > 0) {
+                if (stringIsNullOrEmpty(this.mf)) {
+                    this.b8.setXMemberPath(a, c.getMemberPathFor(16));
                 }
-                if (stringIsNullOrEmpty(this.l1)) {
-                    this.b4.setYMemberPath(a, c.getMemberPathFor(0));
+                if (stringIsNullOrEmpty(this.mh)) {
+                    this.b8.setYMemberPath(a, c.getMemberPathFor(0));
                 }
-                if (stringIsNullOrEmpty(this.lv)) {
-                    this.b4.setLabelMemberPath(a, c.getMemberPathFor(0));
+                if (stringIsNullOrEmpty(this.mb)) {
+                    this.b8.setLabelMemberPath(a, c.getMemberPathFor(0));
                 }
-                if (stringIsNullOrEmpty(this.ls)) {
-                    this.b4.setContentMemberPath(a, c.getMemberPathFor(0));
+                if (stringIsNullOrEmpty(this.l8)) {
+                    this.b8.setContentMemberPath(a, c.getMemberPathFor(0));
                 }
             }
         }
-        gb() {
-            if (this.a9 == 4 || this.a9 == 3) {
+        gr() {
+            if (this.bd == 4 || this.bd == 3) {
                 return true;
             }
-            else if (this.a9 == 0) {
-                if (this.ads == 2 || this.ads == 8) {
+            else if (this.bd == 0) {
+                if (this.aev == 2 || this.aev == 8) {
                     return false;
                 }
-                else if (this.ads == 9 && this.bd != null && this.bd.dataSeries != null && this.bd.dataSeries.count > 0) {
-                    let a = this.bd.dataSeries._inner[0].suggestedSeries;
+                else if (this.aev == 9 && this.bh != null && this.bh.dataSeries != null && this.bh.dataSeries.count > 0) {
+                    let a = this.bh.dataSeries._inner[0].suggestedSeries;
                     if (a == 1 || a == 8) {
                         return false;
                     }
@@ -912,133 +912,133 @@ export let CategoryChart = /*@__PURE__*/ (() => {
             }
             return false;
         }
-        get_gh() {
+        get_gx() {
             return DVContainer.instance.checkLoaded("CategoryChartToolbarFactoryManager");
         }
-        te(a, b, c) {
-            super.te(a, b, c);
+        t5(a, b, c) {
+            super.t5(a, b, c);
             switch (a) {
                 case "ChartType":
-                    this.t0();
+                    this.ut();
                     break;
                 case "MarkerCollisionAvoidance":
-                    this.ahg((d) => d.xj = this.adu);
+                    this.aij((d) => d.yx = this.aex);
                     break;
                 case "IsTransitionInEnabled":
-                    this.ahg((d) => d.wf = this.aep);
+                    this.aij((d) => d.xt = this.afs);
                     break;
                 case "IsSplineShapePartOfRange":
-                    this.ahg((d) => {
-                        if (d.fe) {
-                            d.p2(this.aeo);
+                    this.aij((d) => {
+                        if (d.fl) {
+                            d.qx(this.afr);
                         }
                     });
                     break;
                 case "TransitionInMode":
-                    this.ahg((d) => d.vz = this.adw);
+                    this.aij((d) => d.xd = this.aez);
                     break;
                 case "TransitionInSpeedType":
-                    this.ahg((d) => d.cq = this.ad6);
+                    this.aij((d) => d.cv = this.ae9);
                     break;
                 case "XAxisInterval":
-                    this.xAxis.mr = this.afo;
+                    this.xAxis.mr = this.agr;
                     break;
                 case "XAxisMinorInterval":
-                    this.xAxis.ms = this.afr;
+                    this.xAxis.ms = this.agu;
                     break;
                 case "XAxisGap":
-                    this.xAxis.k1 = this.afn;
+                    this.xAxis.k1 = this.agq;
                     break;
                 case "XAxisOverlap":
-                    this.xAxis.la = this.afs;
+                    this.xAxis.la = this.agv;
                     break;
                 case "XAxisMinimumGapSize":
-                    this.xAxis.k9 = this.afq;
+                    this.xAxis.k9 = this.agt;
                     break;
                 case "XAxisMaximumGap":
-                    this.xAxis.k8 = this.afp;
+                    this.xAxis.k8 = this.ags;
                     break;
                 case "XAxisZoomMaximumCategoryRange":
-                    this.xAxis.zoomMaximumCategoryRange = this.aft;
+                    this.xAxis.zoomMaximumCategoryRange = this.agw;
                     break;
                 case "XAxisZoomMaximumItemSpan":
-                    this.xAxis.zoomMaximumItemSpan = this.afu;
+                    this.xAxis.zoomMaximumItemSpan = this.agx;
                     break;
                 case "XAxisZoomToCategoryRange":
-                    this.xAxis.zoomToCategoryRange = this.afv;
+                    this.xAxis.zoomToCategoryRange = this.agy;
                     break;
                 case "XAxisZoomToCategoryStart":
-                    this.xAxis.zoomToCategoryStart = this.afw;
+                    this.xAxis.zoomToCategoryStart = this.agz;
                     break;
                 case "XAxisZoomToItemSpan":
-                    this.xAxis.zoomToItemSpan = this.afx;
+                    this.xAxis.zoomToItemSpan = this.ag0;
                     break;
                 case "YAxisInterval":
-                    this.yAxis.l1 = this.af0;
+                    this.yAxis.l1 = this.ag3;
                     break;
                 case "YAxisFavorLabellingScaleEnd":
-                    this.yAxis.ld = this.aev;
+                    this.yAxis.ld = this.afy;
                     break;
                 case "YAxisAutoRangeBufferMode":
-                    this.yAxis.ku = this.adq;
+                    this.yAxis.ku = this.aet;
                     break;
                 case "YAxisIsLogarithmic":
-                    this.yAxis.li = this.aew;
+                    this.yAxis.li = this.afz;
                     break;
                 case "YAxisLogarithmBase":
-                    this.yAxis.l9 = this.af9;
+                    this.yAxis.l9 = this.ahc;
                     break;
                 case "YAxisMinimumValue":
-                    this.yAxis.l5 = this.af2;
+                    this.yAxis.l5 = this.ag5;
                     break;
                 case "YAxisMaximumValue":
-                    this.yAxis.l4 = this.af1;
+                    this.yAxis.l4 = this.ag4;
                     break;
                 case "YAxisMinorInterval":
-                    this.yAxis.l6 = this.af3;
+                    this.yAxis.l6 = this.ag6;
                     break;
                 case "NegativeBrushes":
                 case "NegativeOutlines":
-                    this.ahh((d, e) => {
-                        if (d.e0) {
-                            d.p1(ArrayExtension.getModulus$1(Brush.$, this.adl, e), ArrayExtension.getModulus$1(Brush.$, this.adm, e));
+                    this.aik((d, e) => {
+                        if (d.e7) {
+                            d.qw(ArrayExtension.getModulus$1(Brush.$, this.aeo, e), ArrayExtension.getModulus$1(Brush.$, this.aep, e));
                         }
                     });
                     break;
                 case "YAxisAbbreviateLargeNumbers":
-                    this.ab2((d) => d.la = this.aet);
+                    this.ac5((d) => d.la = this.afw);
                     break;
                 case "IsCategoryHighlightingEnabled":
                 case "IsItemHighlightingEnabled":
-                    this.t0();
+                    this.ut();
                     break;
                 case "AutoMarginAndAngleUpdateMode":
-                    this.s6((d) => d.ud = this.ado);
+                    this.tx((d) => d.v3 = this.aer);
                     break;
                 case "ShouldAutoExpandMarginForInitialLabels":
-                    this.s6((d) => d.u8 = this.aeq);
+                    this.tx((d) => d.wy = this.aft);
                     break;
-                case CategoryChart.agn:
-                    this.s6((d) => d.vb = this.aer);
+                case CategoryChart.ahq:
+                    this.tx((d) => d.w1 = this.afu);
                     break;
                 case "AutoExpandMarginExtraPadding":
-                    this.s6((d) => d.vy = this.aff);
+                    this.tx((d) => d.xo = this.agi);
                     break;
                 case "AutoExpandMarginMaximumValue":
-                    this.s6((d) => d.vz = this.afg);
+                    this.tx((d) => d.xp = this.agj);
                     break;
-                case CategoryChart.agu:
-                    this.aby((d) => d.b1 = this.aes, a);
+                case CategoryChart.ahx:
+                    this.ac1((d) => d.b1 = this.afv, a);
                     break;
-                case CategoryChart.ag8:
-                    this.ab2((d) => d.b1 = this.aeu);
+                case CategoryChart.aib:
+                    this.ac5((d) => d.b1 = this.afx);
                     break;
             }
         }
     }
     CategoryChart.$t = /*@__PURE__*/ markType(CategoryChart, 'CategoryChart', XYChart.$);
-    CategoryChart.agn = "ShouldConsiderAutoRotationForInitialLabels";
-    CategoryChart.agu = "XAxisEnhancedIntervalPreferMoreCategoryLabels";
-    CategoryChart.ag8 = "YAxisEnhancedIntervalPreferMoreCategoryLabels";
+    CategoryChart.ahq = "ShouldConsiderAutoRotationForInitialLabels";
+    CategoryChart.ahx = "XAxisEnhancedIntervalPreferMoreCategoryLabels";
+    CategoryChart.aib = "YAxisEnhancedIntervalPreferMoreCategoryLabels";
     return CategoryChart;
 })();