igniteui-webcomponents-charts 6.0.0 → 6.0.1

package/esm2015/lib/CategoryChart.js

@@ -35,148 +35,148 @@ import { stringIsNullOrEmpty } from "igniteui-webcomponents-core";
  */
 export let CategoryChart = /*@__PURE__*/ (() => {
     class CategoryChart extends XYChart {
-        vm() {
-            super.vm();
+        vs() {
+            super.vs();
             if (this.dataChart == null) {
                 return;
             }
-            let a = this.dataChart.c9.j.e();
-            this.ahn = a.d;
-            this.aho = a.e;
-            if (this.agx == null) {
-                this.agx = a.k;
-            }
-            if (this.ag4 == null) {
-                this.ag4 = a.k;
-            }
-            this.acw = 0;
-            this.ag5 = AxisDefaults.axis_MajorBrush;
-            this.ag8 = null;
-            this.ag1 = AxisDefaults.axis_LineBrush;
-            this.agy = null;
-            this.acf = AxisDefaults.categoryAxis_TickLength;
-            this.ag2 = AxisDefaults.axis_TickBrush;
-            this.acg = AxisDefaults.axis_TickStroke;
+            let a = this.dataChart.dc.j.e();
+            this.ah5 = a.d;
+            this.ah6 = a.e;
+            if (this.ahf == null) {
+                this.ahf = a.k;
+            }
+            if (this.ahm == null) {
+                this.ahm = a.k;
+            }
+            this.ada = 0;
+            this.ahn = AxisDefaults.axis_MajorBrush;
+            this.ahq = null;
+            this.ahj = AxisDefaults.axis_LineBrush;
+            this.ahg = null;
+            this.acr = AxisDefaults.categoryAxis_TickLength;
+            this.ahk = AxisDefaults.axis_TickBrush;
+            this.acs = AxisDefaults.axis_TickStroke;
             this.crosshairsAnnotationEnabled = true;
-            this.gq = true;
+            this.gu = true;
             this.crosshairsDisplayMode = 0;
-            this.jq = Defaults.crosshairLineThickness;
-            this.yy = Defaults.crosshairLineBrush;
-            this.yt = Defaults.crosshairXAxisAnnotationBackground;
-            this.yu = Defaults.crosshairXAxisAnnotationTextColor;
-            this.air = true;
-        }
-        vo(a, b) {
-            super.vo(a, b);
-            a.kf = this.aj9;
-            a.kg = this.aka;
-            a.df = this.aib;
-            a.dg = this.aic;
-        }
-        wh(a, b, c) {
-            super.wh(a, b, c);
+            this.ju = Defaults.crosshairLineThickness;
+            this.y4 = Defaults.crosshairLineBrush;
+            this.yz = Defaults.crosshairXAxisAnnotationBackground;
+            this.y0 = Defaults.crosshairXAxisAnnotationTextColor;
+            this.ai9 = true;
+        }
+        vu(a, b) {
+            super.vu(a, b);
+            a.kf = this.akr;
+            a.kg = this.aks;
+            a.df = this.ait;
+            a.dg = this.aiu;
+        }
+        wn(a, b, c) {
+            super.wn(a, b, c);
             switch (a) {
                 case "TransitionInDuration":
-                    this.vb((d) => d.kf = this.aj9);
+                    this.vh((d) => d.kf = this.akr);
                     break;
                 case "TransitionOutDuration":
-                    this.vb((d) => d.kg = this.aka);
+                    this.vh((d) => d.kg = this.aks);
                     break;
                 case "TransitionInEasingFunction":
-                    this.vb((d) => d.df = this.aib);
+                    this.vh((d) => d.df = this.ait);
                     break;
                 case "TransitionOutEasingFunction":
-                    this.vb((d) => d.dg = this.aic);
+                    this.vh((d) => d.dg = this.aiu);
                     break;
             }
         }
-        get aj9() {
-            return this.aj6;
+        get akr() {
+            return this.ako;
         }
-        set aj9(a) {
-            let b = this.aj9;
+        set akr(a) {
+            let b = this.akr;
             if (a != b) {
-                this.aj6 = a;
-                this.wd("TransitionInDuration", b, this.aj9);
+                this.ako = a;
+                this.wj("TransitionInDuration", b, this.akr);
             }
         }
-        get aka() {
-            return this.aj7;
+        get aks() {
+            return this.akp;
         }
-        set aka(a) {
-            let b = this.aka;
+        set aks(a) {
+            let b = this.aks;
             if (a != b) {
-                this.aj7 = a;
-                this.wd("TransitionOutDuration", b, this.aka);
+                this.akp = a;
+                this.wj("TransitionOutDuration", b, this.aks);
             }
         }
-        get aib() {
-            return this.ah9;
+        get ait() {
+            return this.air;
         }
-        set aib(a) {
-            let b = this.aib;
+        set ait(a) {
+            let b = this.ait;
             if (a != b) {
-                this.ah9 = a;
-                this.wd("TransitionInEasingFunction", b, this.aib);
+                this.air = a;
+                this.wj("TransitionInEasingFunction", b, this.ait);
             }
         }
-        get aic() {
-            return this.aia;
+        get aiu() {
+            return this.ais;
         }
-        set aic(a) {
-            let b = this.aic;
+        set aiu(a) {
+            let b = this.aiu;
             if (a != b) {
-                this.aia = a;
-                this.wd("TransitionOutEasingFunction", b, this.aic);
+                this.ais = a;
+                this.wj("TransitionOutEasingFunction", b, this.aiu);
             }
         }
-        akg() {
-            let cvd_ = this.l5();
+        aky() {
+            let cvd_ = this.l9();
             cvd_.scaleByViewport();
             return (cvd_.serialize());
         }
-        vh(a, b) {
-            super.vh(a, b);
-            a.ej = this.gj;
-            a.x1 = this.ais;
-            a.x4 = this.ait;
-            a.yr = this.ajh;
-            a.ys = this.aji;
-            a.w6 = this.ahq;
-        }
         vn(a, b) {
             super.vn(a, b);
+            a.en = this.gl;
+            a.yd = this.aja;
+            a.yg = this.ajb;
+            a.y3 = this.ajz;
+            a.y4 = this.aj0;
+            a.xi = this.ah8;
+        }
+        vt(a, b) {
+            super.vt(a, b);
             let c = typeCast(HorizontalAnchoredCategorySeries.$, a);
             if (c == null) {
                 return;
             }
-            c.aa1 = this.ahw;
-            c.zq = this.air;
-            c.za = this.ahy;
-            c.c6 = this.ah8;
+            c.aa4 = this.aie;
+            c.zq = this.ai9;
+            c.za = this.aig;
+            c.c6 = this.aiq;
             c.trendLineBrush = ArrayExtension.getModulus$1(Brush.$, this.af, b);
             c.trendLineType = this.ec;
-            c.trendLineThickness = this.km;
+            c.trendLineThickness = this.kq;
             c.xf = this.c2(a, b);
             if (a.fn) {
-                a.r7(ArrayExtension.getModulus$1(Brush.$, this.ahn, b), ArrayExtension.getModulus$1(Brush.$, this.aho, b));
+                a.r7(ArrayExtension.getModulus$1(Brush.$, this.ah5, b), ArrayExtension.getModulus$1(Brush.$, this.ah6, b));
             }
         }
-        ahz() {
+        aih() {
             return new CategoryXAxis();
         }
-        ah3() {
+        ail() {
             return new NumericYAxis();
         }
-        ux() {
-            this.xAxis = this.ahz();
+        u3() {
+            this.xAxis = this.aih();
             this.xAxis.name = "xAxis";
             let a = this.xAxis;
-            a.propertyChanged = delegateCombine(a.propertyChanged, runOn(this, this.alk));
-            this.yAxis = this.ah3();
+            a.propertyChanged = delegateCombine(a.propertyChanged, runOn(this, this.al2));
+            this.yAxis = this.ail();
             this.yAxis.name = "yAxis";
             let b = this.yAxis;
-            b.propertyChanged = delegateCombine(b.propertyChanged, runOn(this, this.all));
+            b.propertyChanged = delegateCombine(b.propertyChanged, runOn(this, this.al3));
             if (this.xAxis.az == null) {
                 this.xAxis.az = new AxisLabelSettings();
             }
@@ -184,20 +184,20 @@ export let CategoryChart = /*@__PURE__*/ (() => {
                 this.yAxis.az = new AxisLabelSettings();
             }
         }
-        afx(a) {
-            super.afx(a);
-            a.lf = this.aiv;
-            a.lj = this.aix;
-            a.b1 = this.aiw;
+        agf(a) {
+            super.agf(a);
+            a.lf = this.ajd;
+            a.lj = this.ajf;
+            a.b1 = this.aje;
         }
-        afv(a) {
-            super.afv(a);
-            a.b1 = this.aiu;
-            a.zoomMaximumCategoryRange = this.ajv;
-            a.zoomToCategoryRange = this.ajx;
-            a.zoomToCategoryStart = this.ajy;
-            a.zoomMaximumItemSpan = this.ajw;
-            a.zoomToItemSpan = this.ajz;
+        agd(a) {
+            super.agd(a);
+            a.b1 = this.ajc;
+            a.zoomMaximumCategoryRange = this.akd;
+            a.zoomToCategoryRange = this.akf;
+            a.zoomToCategoryStart = this.akg;
+            a.zoomMaximumItemSpan = this.ake;
+            a.zoomToItemSpan = this.akh;
         }
         get_cb() {
             return 0;
@@ -205,453 +205,453 @@ export let CategoryChart = /*@__PURE__*/ (() => {
         get cb() {
             return this.get_cb();
         }
-        get ahu() {
-            return this.aht;
+        get aic() {
+            return this.aib;
         }
-        set ahu(a) {
-            if (a != this.aht) {
-                let b = this.ahu;
-                this.aht = a;
-                this.wd("ChartType", enumGetBox(CategoryChartType_$type, b), enumGetBox(CategoryChartType_$type, this.ahu));
+        set aic(a) {
+            if (a != this.aib) {
+                let b = this.aic;
+                this.aib = a;
+                this.wj("ChartType", enumGetBox(CategoryChartType_$type, b), enumGetBox(CategoryChartType_$type, this.aic));
             }
         }
-        get ahw() {
-            return this.ahv;
+        get aie() {
+            return this.aid;
         }
-        set ahw(a) {
-            let b = this.ahw;
+        set aie(a) {
+            let b = this.aie;
             if (a != b) {
-                this.ahv = a;
-                this.wd("MarkerCollisionAvoidance", enumGetBox(CategorySeriesMarkerCollisionAvoidance_$type, b), enumGetBox(CategorySeriesMarkerCollisionAvoidance_$type, this.ahw));
+                this.aid = a;
+                this.wj("MarkerCollisionAvoidance", enumGetBox(CategorySeriesMarkerCollisionAvoidance_$type, b), enumGetBox(CategorySeriesMarkerCollisionAvoidance_$type, this.aie));
             }
         }
-        get aiq() {
-            return this.aif;
+        get ai8() {
+            return this.aix;
         }
-        set aiq(a) {
-            let b = this.aiq;
+        set ai8(a) {
+            let b = this.ai8;
             if (a != b) {
-                this.aif = a;
-                this.wd("IsSplineShapePartOfRange", b, this.aiq);
+                this.aix = a;
+                this.wj("IsSplineShapePartOfRange", b, this.ai8);
             }
         }
-        get air() {
-            return this.aig;
+        get ai9() {
+            return this.aiy;
         }
-        set air(a) {
-            let b = this.air;
+        set ai9(a) {
+            let b = this.ai9;
             if (a != b) {
-                this.aig = a;
-                this.wd("IsTransitionInEnabled", b, this.air);
+                this.aiy = a;
+                this.wj("IsTransitionInEnabled", b, this.ai9);
             }
         }
-        get ahy() {
-            return this.ahx;
+        get aig() {
+            return this.aif;
         }
-        set ahy(a) {
-            let b = this.ahy;
+        set aig(a) {
+            let b = this.aig;
             if (a != b) {
-                this.ahx = a;
-                this.wd("TransitionInMode", enumGetBox(CategoryTransitionInMode_$type, b), enumGetBox(CategoryTransitionInMode_$type, this.ahy));
+                this.aif = a;
+                this.wj("TransitionInMode", enumGetBox(CategoryTransitionInMode_$type, b), enumGetBox(CategoryTransitionInMode_$type, this.aig));
             }
         }
-        get ah8() {
-            return this.ah7;
+        get aiq() {
+            return this.aip;
         }
-        set ah8(a) {
-            let b = this.ah8;
+        set aiq(a) {
+            let b = this.aiq;
             if (a != b) {
-                this.ah7 = a;
-                this.wd("TransitionInSpeedType", enumGetBox(TransitionInSpeedType_$type, b), enumGetBox(TransitionInSpeedType_$type, this.ah8));
+                this.aip = a;
+                this.wj("TransitionInSpeedType", enumGetBox(TransitionInSpeedType_$type, b), enumGetBox(TransitionInSpeedType_$type, this.aiq));
             }
         }
-        get ajq() {
-            return this.ai3;
+        get aj8() {
+            return this.ajl;
         }
-        set ajq(a) {
-            let b = this.ajq;
+        set aj8(a) {
+            let b = this.aj8;
             if (a != b) {
-                this.ai3 = a;
-                this.wd("XAxisInterval", b, this.ajq);
+                this.ajl = a;
+                this.wj("XAxisInterval", b, this.aj8);
             }
         }
-        get ajt() {
-            return this.ai6;
+        get akb() {
+            return this.ajo;
         }
-        set ajt(a) {
-            let b = this.ajt;
+        set akb(a) {
+            let b = this.akb;
             if (a != b) {
-                this.ai6 = a;
-                this.wd("XAxisMinorInterval", b, this.ajt);
+                this.ajo = a;
+                this.wj("XAxisMinorInterval", b, this.akb);
             }
         }
-        get ajp() {
-            return this.ai2;
+        get aj7() {
+            return this.ajk;
         }
-        set ajp(a) {
-            let b = this.ajp;
+        set aj7(a) {
+            let b = this.aj7;
             if (a != b) {
-                this.ai2 = a;
-                this.wd("XAxisGap", b, this.ajp);
+                this.ajk = a;
+                this.wj("XAxisGap", b, this.aj7);
             }
         }
-        get ajs() {
-            return this.ai5;
+        get aka() {
+            return this.ajn;
         }
-        set ajs(a) {
-            let b = this.ajs;
+        set aka(a) {
+            let b = this.aka;
             if (a != b) {
-                this.ai5 = a;
-                this.wd("XAxisMinimumGapSize", b, this.ajs);
+                this.ajn = a;
+                this.wj("XAxisMinimumGapSize", b, this.aka);
             }
         }
-        get ajr() {
-            return this.ai4;
+        get aj9() {
+            return this.ajm;
         }
-        set ajr(a) {
-            let b = this.ajr;
+        set aj9(a) {
+            let b = this.aj9;
             if (a != b) {
-                this.ai4 = a;
-                this.wd("XAxisMaximumGap", b, this.ajr);
+                this.ajm = a;
+                this.wj("XAxisMaximumGap", b, this.aj9);
             }
         }
-        get aju() {
-            return this.ai7;
+        get akc() {
+            return this.ajp;
         }
-        set aju(a) {
-            let b = this.aju;
+        set akc(a) {
+            let b = this.akc;
             if (a != b) {
-                this.ai7 = a;
-                this.wd("XAxisOverlap", b, this.aju);
+                this.ajp = a;
+                this.wj("XAxisOverlap", b, this.akc);
             }
         }
-        get aj2() {
-            return this.ajd;
+        get akk() {
+            return this.ajv;
         }
-        set aj2(a) {
-            let b = this.aj2;
+        set akk(a) {
+            let b = this.akk;
             if (a != b) {
-                this.ajd = a;
-                this.wd("YAxisInterval", b, this.aj2);
+                this.ajv = a;
+                this.wj("YAxisInterval", b, this.akk);
             }
         }
-        get ahq() {
-            return this.ahp;
+        get ah8() {
+            return this.ah7;
         }
-        set ahq(a) {
-            let b = this.ahq;
+        set ah8(a) {
+            let b = this.ah8;
             if (a != b) {
-                this.ahp = a;
-                this.wd("AutoMarginAndAngleUpdateMode", enumGetBox(AutoMarginsAndAngleUpdateMode_$type, b), enumGetBox(AutoMarginsAndAngleUpdateMode_$type, this.ahq));
+                this.ah7 = a;
+                this.wj("AutoMarginAndAngleUpdateMode", enumGetBox(AutoMarginsAndAngleUpdateMode_$type, b), enumGetBox(AutoMarginsAndAngleUpdateMode_$type, this.ah8));
             }
         }
-        alm() {
+        al4() {
             if (this.dataChart != null) {
-                this.dataChart.aac();
+                this.dataChart.aao();
             }
         }
-        get ais() {
-            return this.aih;
+        get aja() {
+            return this.aiz;
         }
-        set ais(a) {
-            let b = this.ais;
+        set aja(a) {
+            let b = this.aja;
             if (a != b) {
-                this.aih = a;
-                this.wd("ShouldAutoExpandMarginForInitialLabels", b, this.ais);
+                this.aiz = a;
+                this.wj("ShouldAutoExpandMarginForInitialLabels", b, this.aja);
             }
         }
-        get ait() {
-            return this.aii;
+        get ajb() {
+            return this.ai0;
         }
-        set ait(a) {
-            let b = this.ait;
+        set ajb(a) {
+            let b = this.ajb;
             if (a != b) {
-                this.aii = a;
-                this.wd(CategoryChart.akp, b, this.ait);
+                this.ai0 = a;
+                this.wj(CategoryChart.ak7, b, this.ajb);
             }
         }
-        get ajh() {
-            return this.ai0;
+        get ajz() {
+            return this.aji;
         }
-        set ajh(a) {
-            let b = this.ajh;
+        set ajz(a) {
+            let b = this.ajz;
             if (a != b) {
-                this.ai0 = a;
-                this.wd("AutoExpandMarginExtraPadding", b, this.ajh);
+                this.aji = a;
+                this.wj("AutoExpandMarginExtraPadding", b, this.ajz);
             }
         }
-        get aji() {
-            return this.ai1;
+        get aj0() {
+            return this.ajj;
         }
-        set aji(a) {
-            let b = this.aji;
+        set aj0(a) {
+            let b = this.aj0;
             if (a != b) {
-                this.ai1 = a;
-                this.wd("AutoExpandMarginMaximumValue", b, this.aji);
+                this.ajj = a;
+                this.wj("AutoExpandMarginMaximumValue", b, this.aj0);
             }
         }
-        get aix() {
-            return this.aim;
+        get ajf() {
+            return this.ai4;
         }
-        set aix(a) {
-            let b = this.aix;
+        set ajf(a) {
+            let b = this.ajf;
             if (a != b) {
-                this.aim = a;
-                this.wd("YAxisFavorLabellingScaleEnd", b, this.aix);
+                this.ai4 = a;
+                this.wj("YAxisFavorLabellingScaleEnd", b, this.ajf);
             }
         }
-        get aiu() {
-            return this.aij;
+        get ajc() {
+            return this.ai1;
         }
-        set aiu(a) {
-            let b = this.aiu;
+        set ajc(a) {
+            let b = this.ajc;
             if (a != b) {
-                this.aij = a;
-                this.wd(CategoryChart.akw, b, this.aiu);
+                this.ai1 = a;
+                this.wj(CategoryChart.ale, b, this.ajc);
             }
         }
-        get aiw() {
-            return this.ail;
+        get aje() {
+            return this.ai3;
         }
-        set aiw(a) {
-            let b = this.aiw;
+        set aje(a) {
+            let b = this.aje;
             if (a != b) {
-                this.ail = a;
-                this.wd(CategoryChart.ala, b, this.aiw);
+                this.ai3 = a;
+                this.wj(CategoryChart.als, b, this.aje);
             }
         }
-        get ahs() {
-            return this.ahr;
+        get aia() {
+            return this.ah9;
         }
-        set ahs(a) {
-            let b = this.ahs;
+        set aia(a) {
+            let b = this.aia;
             if (a != b) {
-                this.ahr = a;
-                this.wd("YAxisAutoRangeBufferMode", enumGetBox(AxisRangeBufferMode_$type, b), enumGetBox(AxisRangeBufferMode_$type, this.ahs));
+                this.ah9 = a;
+                this.wj("YAxisAutoRangeBufferMode", enumGetBox(AxisRangeBufferMode_$type, b), enumGetBox(AxisRangeBufferMode_$type, this.aia));
             }
         }
-        get aiy() {
-            return this.ain;
+        get ajg() {
+            return this.ai5;
         }
-        set aiy(a) {
-            let b = this.aiy;
+        set ajg(a) {
+            let b = this.ajg;
             if (a != b) {
-                this.ain = a;
-                this.wd("YAxisIsLogarithmic", b, this.aiy);
+                this.ai5 = a;
+                this.wj("YAxisIsLogarithmic", b, this.ajg);
             }
         }
-        get akb() {
-            return this.aj8;
+        get akt() {
+            return this.akq;
         }
-        set akb(a) {
-            let b = this.akb;
+        set akt(a) {
+            let b = this.akt;
             if (a != b) {
-                this.aj8 = a;
-                this.wd("YAxisLogarithmBase", b, this.akb);
+                this.akq = a;
+                this.wj("YAxisLogarithmBase", b, this.akt);
             }
         }
-        get aj4() {
-            return this.ajf;
+        get akm() {
+            return this.ajx;
         }
-        set aj4(a) {
-            let b = this.aj4;
+        set akm(a) {
+            let b = this.akm;
             if (a != b) {
-                this.ajf = a;
-                this.wd("YAxisMinimumValue", b, this.aj4);
+                this.ajx = a;
+                this.wj("YAxisMinimumValue", b, this.akm);
             }
         }
-        get aj3() {
-            return this.aje;
+        get akl() {
+            return this.ajw;
         }
-        set aj3(a) {
-            let b = this.aj3;
+        set akl(a) {
+            let b = this.akl;
             if (a != b) {
-                this.aje = a;
-                this.wd("YAxisMaximumValue", b, this.aj3);
+                this.ajw = a;
+                this.wj("YAxisMaximumValue", b, this.akl);
             }
         }
-        get aj5() {
-            return this.ajg;
+        get akn() {
+            return this.ajy;
         }
-        set aj5(a) {
-            let b = this.aj5;
+        set akn(a) {
+            let b = this.akn;
             if (a != b) {
-                this.ajg = a;
-                this.wd("YAxisMinorInterval", b, this.aj5);
+                this.ajy = a;
+                this.wj("YAxisMinorInterval", b, this.akn);
             }
         }
-        get ajo() {
+        get aj6() {
             return this.xAxis.m1;
         }
-        get ajn() {
+        get aj5() {
             return this.xAxis.m0;
         }
-        ajk() {
-            return this.ajo;
+        aj2() {
+            return this.aj6;
         }
-        ajm() {
-            return this.aj1;
+        aj4() {
+            return this.akj;
         }
-        ajj() {
-            return this.ajn;
+        aj1() {
+            return this.aj5;
         }
-        ajl() {
-            return this.aj0;
+        aj3() {
+            return this.aki;
         }
-        get aj1() {
+        get akj() {
             return this.yAxis.l4;
         }
-        get aj0() {
+        get aki() {
             return this.yAxis.l3;
         }
-        get ahn() {
-            return this.ahl;
+        get ah5() {
+            return this.ah3;
         }
-        set ahn(a) {
-            let b = this.ahn;
+        set ah5(a) {
+            let b = this.ah5;
             if (a != b) {
-                this.ahl = a;
-                this.wd("NegativeBrushes", b, this.ahn);
+                this.ah3 = a;
+                this.wj("NegativeBrushes", b, this.ah5);
             }
         }
-        get aho() {
-            return this.ahm;
+        get ah6() {
+            return this.ah4;
         }
-        set aho(a) {
-            let b = this.aho;
+        set ah6(a) {
+            let b = this.ah6;
             if (a != b) {
-                this.ahm = a;
-                this.wd("NegativeOutlines", b, this.aho);
+                this.ah4 = a;
+                this.wj("NegativeOutlines", b, this.ah6);
             }
         }
-        get aiv() {
-            return this.aik;
+        get ajd() {
+            return this.ai2;
         }
-        set aiv(a) {
-            let b = this.aiv;
+        set ajd(a) {
+            let b = this.ajd;
             if (a != b) {
-                this.aik = a;
-                this.wd("YAxisAbbreviateLargeNumbers", b, this.aiv);
+                this.ai2 = a;
+                this.wj("YAxisAbbreviateLargeNumbers", b, this.ajd);
             }
         }
-        get ajv() {
-            return this.ai8;
+        get akd() {
+            return this.ajq;
         }
-        set ajv(a) {
-            let b = this.ajv;
+        set akd(a) {
+            let b = this.akd;
             if (a != b) {
-                this.ai8 = a;
-                this.wd("XAxisZoomMaximumCategoryRange", b, this.ajv);
+                this.ajq = a;
+                this.wj("XAxisZoomMaximumCategoryRange", b, this.akd);
             }
         }
-        get ajw() {
-            return this.ai9;
+        get ake() {
+            return this.ajr;
         }
-        set ajw(a) {
-            let b = this.ajw;
+        set ake(a) {
+            let b = this.ake;
             if (a != b) {
-                this.ai9 = a;
-                this.wd("XAxisZoomMaximumItemSpan", b, this.ajw);
+                this.ajr = a;
+                this.wj("XAxisZoomMaximumItemSpan", b, this.ake);
             }
         }
-        get ajx() {
-            return this.aja;
+        get akf() {
+            return this.ajs;
         }
-        set ajx(a) {
-            let b = this.ajx;
+        set akf(a) {
+            let b = this.akf;
             if (a != b) {
-                this.aja = a;
-                this.wd("XAxisZoomToCategoryRange", b, this.ajx);
+                this.ajs = a;
+                this.wj("XAxisZoomToCategoryRange", b, this.akf);
             }
         }
-        get ajy() {
-            return this.ajb;
+        get akg() {
+            return this.ajt;
         }
-        set ajy(a) {
-            let b = this.ajy;
+        set akg(a) {
+            let b = this.akg;
             if (a != b) {
-                this.ajb = a;
-                this.wd("XAxisZoomToCategoryStart", b, this.ajy);
+                this.ajt = a;
+                this.wj("XAxisZoomToCategoryStart", b, this.akg);
             }
         }
-        get ajz() {
-            return this.ajc;
+        get akh() {
+            return this.aju;
         }
-        set ajz(a) {
-            let b = this.ajz;
+        set akh(a) {
+            let b = this.akh;
             if (a != b) {
-                this.ajc = a;
-                this.wd("XAxisZoomToItemSpan", b, this.ajz);
+                this.aju = a;
+                this.wj("XAxisZoomToItemSpan", b, this.akh);
             }
         }
-        get aio() {
-            return this.aid;
+        get ai6() {
+            return this.aiv;
         }
-        set aio(a) {
-            let b = this.aio;
+        set ai6(a) {
+            let b = this.ai6;
             if (a != b) {
-                this.aid = a;
-                this.wd("IsCategoryHighlightingEnabled", b, this.aio);
+                this.aiv = a;
+                this.wj("IsCategoryHighlightingEnabled", b, this.ai6);
             }
         }
-        get aip() {
-            return this.aie;
+        get ai7() {
+            return this.aiw;
         }
-        set aip(a) {
-            let b = this.aip;
+        set ai7(a) {
+            let b = this.ai7;
             if (a != b) {
-                this.aie = a;
-                this.wd("IsItemHighlightingEnabled", b, this.aip);
+                this.aiw = a;
+                this.wj("IsItemHighlightingEnabled", b, this.ai7);
             }
         }
         constructor() {
             super();
-            this.aj6 = 1000;
-            this.aj7 = 1000;
-            this.ah9 = null;
-            this.aia = null;
-            this.aht = 9;
-            this.ahv = 1;
-            this.aif = false;
-            this.aig = true;
-            this.ahx = 0;
-            this.ah7 = 0;
-            this.ai3 = 0;
-            this.ai6 = 0;
-            this.ai2 = 0;
-            this.ai5 = 0;
-            this.ai4 = 1;
-            this.ai7 = 0;
-            this.ajd = NaN;
-            this.ahp = 1;
-            this.aih = true;
-            this.aii = true;
-            this.ai0 = DeviceUtils.g(2);
-            this.ai1 = DeviceUtils.g(60);
-            this.aim = true;
-            this.aij = true;
-            this.ail = false;
-            this.ahr = 0;
-            this.ain = false;
-            this.aj8 = 10;
-            this.ajf = NaN;
-            this.aje = NaN;
-            this.ajg = 0;
-            this.ahl = null;
-            this.ahm = null;
-            this.aik = true;
-            this.ai8 = 3;
-            this.ai9 = NaN;
-            this.aja = NaN;
-            this.ajb = NaN;
-            this.ajc = NaN;
-            this.aid = false;
-            this.aie = false;
-            this.aiz = null;
+            this.ako = 1000;
+            this.akp = 1000;
+            this.air = null;
+            this.ais = null;
+            this.aib = 9;
+            this.aid = 1;
+            this.aix = false;
+            this.aiy = true;
+            this.aif = 0;
+            this.aip = 0;
+            this.ajl = 0;
+            this.ajo = 0;
+            this.ajk = 0;
+            this.ajn = 0;
+            this.ajm = 1;
+            this.ajp = 0;
+            this.ajv = NaN;
+            this.ah7 = 1;
+            this.aiz = true;
+            this.ai0 = true;
+            this.aji = DeviceUtils.g(2);
+            this.ajj = DeviceUtils.g(60);
+            this.ai4 = true;
+            this.ai1 = true;
+            this.ai3 = false;
+            this.ah9 = 0;
+            this.ai5 = false;
+            this.akq = 10;
+            this.ajx = NaN;
+            this.ajw = NaN;
+            this.ajy = 0;
+            this.ah3 = null;
+            this.ah4 = null;
+            this.ai2 = true;
+            this.ajq = 3;
+            this.ajr = NaN;
+            this.ajs = NaN;
+            this.ajt = NaN;
+            this.aju = NaN;
+            this.aiv = false;
+            this.aiw = false;
+            this.ajh = null;
             DVContainer.instance.registerIfLoaded("CategoryChartToolbarFactoryManager");
-            this.u2();
+            this.u8();
         }
-        get_h2() {
+        get_h6() {
             let a = new List$1(DataSeriesType_$type, 0);
             if (TypeRegistrar.isRegistered("AreaSeries")) {
                 a.add(2);
@@ -682,20 +682,20 @@ export let CategoryChart = /*@__PURE__*/ (() => {
             }
             return a;
         }
-        get h2() {
-            return this.get_h2();
+        get h6() {
+            return this.get_h6();
         }
-        h8() {
-            if (this.aiz == null) {
-                this.aiz = CategoryChartMockDataGenerator.a();
+        ic() {
+            if (this.ajh == null) {
+                this.ajh = CategoryChartMockDataGenerator.a();
             }
-            return this.aiz;
+            return this.ajh;
         }
         c1(a) {
             if (a != null) {
                 let b = super.c1(a);
                 if (b == 2) {
-                    if (a.fm && this.g1) {
+                    if (a.fm && this.g5) {
                         return 13;
                     }
                 }
@@ -706,42 +706,42 @@ export let CategoryChart = /*@__PURE__*/ (() => {
             if (a != null) {
                 let b = super.c1(a);
                 if (b == 2) {
-                    if (a.fm && this.g1) {
+                    if (a.fm && this.g5) {
                         return 13;
                     }
                 }
             }
             return super.c3(a);
         }
-        get_hk() {
+        get_ho() {
             return true;
         }
-        alk(a, b) {
+        al2(a, b) {
             switch (b.propertyName) {
                 case "ActualMinimum":
-                    this.wv("XAxisActualMinimum");
+                    this.w1("XAxisActualMinimum");
                     break;
                 case "ActualMaximum":
-                    this.wv("XAxisActualMaximum");
+                    this.w1("XAxisActualMaximum");
                     break;
             }
         }
-        all(a, b) {
+        al3(a, b) {
             switch (b.propertyName) {
                 case "ActualMinimumValue":
-                    this.wv("YAxisActualMinimum");
+                    this.w1("YAxisActualMinimum");
                     break;
                 case "ActualMaximumValue":
-                    this.wv("YAxisActualMaximum");
+                    this.w1("YAxisActualMaximum");
                     break;
             }
         }
-        xa() {
-            super.xa();
-            this.xAxis.f2 = this.ac6 == null ? XYChart.adi(this.xAxis, this.bf.dataSeries) : this.ac6;
+        xg() {
+            super.xg();
+            this.xAxis.f2 = this.adk == null ? XYChart.adw(this.xAxis, this.bf.dataSeries) : this.adk;
             this.xAxis.itemsSource = this.dataChart != null && this.dataChart.series.count > 0 ? this.dataChart.series._inner[0].itemsSource : null;
-            if (this.ais) {
-                this.v1((a) => a.aac());
+            if (this.aja) {
+                this.v7((a) => a.aao());
             }
         }
         get xAxis() {
@@ -756,7 +756,7 @@ export let CategoryChart = /*@__PURE__*/ (() => {
         set yAxis(a) {
             this._yAxis = a;
         }
-        ah2(a, b) {
+        aik(a, b) {
             switch (a) {
                 case 2: return this.df(1);
                 case 3: return this.df(10);
@@ -767,15 +767,15 @@ export let CategoryChart = /*@__PURE__*/ (() => {
                 case 4: return this.df(4);
                 case 5: return this.df(5);
                 case 8: return this.df(8);
-                case 9: return this.ah1(b);
+                case 9: return this.aij(b);
                 default: return this.df(1);
             }
         }
-        ah1(a) {
+        aij(a) {
             return this.df(a);
         }
         be(a) {
-            switch (this.ahu) {
+            switch (this.aic) {
                 case 1: return 2;
                 case 0: return 0;
                 case 3: return 10;
@@ -790,23 +790,23 @@ export let CategoryChart = /*@__PURE__*/ (() => {
             }
         }
         dc(a, b) {
-            let c = this.ah2(this.ahu, a.suggestedSeries);
-            c.abr = a.findMatchingHint(0).path;
+            let c = this.aik(this.aic, a.suggestedSeries);
+            c.abu = a.findMatchingHint(0).path;
             c.xAxis = this.xAxis;
             c.yAxis = this.yAxis;
             return c;
         }
-        w8(a) {
+        xe(a) {
             if (a.suggestedSecondaryAxis == 2) {
                 this.yAxis.lo = true;
                 this.yAxis.mm = 10;
             }
         }
-        xb() {
-            this.yAxis.lo = this.aiy;
-            this.yAxis.mm = this.akb;
+        xh() {
+            this.yAxis.lo = this.ajg;
+            this.yAxis.mm = this.akt;
         }
-        get_h1() {
+        get_h5() {
             return ((() => {
                 let $ret = new List$1(IDataSeriesAdapterRule_$type, 0);
                 $ret.add(new SimpleCategorySeriesRule());
@@ -814,20 +814,20 @@ export let CategoryChart = /*@__PURE__*/ (() => {
                 return $ret;
             })());
         }
-        get h1() {
-            return this.get_h1();
+        get h5() {
+            return this.get_h5();
         }
-        ur(a, b) {
+        ux(a, b) {
             let c = typeCast(HorizontalAnchoredCategorySeries.$, a);
             if (c != null) {
-                c.aa1 = this.ahw;
+                c.aa4 = this.aie;
                 c.xf = this.c2(a, b);
             }
         }
-        ali(a) {
-            this.alj((b, c) => a(b));
+        al0(a) {
+            this.al1((b, c) => a(b));
         }
-        alj(a) {
+        al1(a) {
             if (this.dataChart == null) {
                 return;
             }
@@ -839,27 +839,27 @@ export let CategoryChart = /*@__PURE__*/ (() => {
                 a(c, b);
             }
         }
-        aao() {
+        aau() {
             return this.xAxis;
         }
-        aap() {
+        aav() {
             return this.yAxis;
         }
-        ah5() {
+        ain() {
             return this.df(30);
         }
-        ah6() {
+        aio() {
             return this.df(31);
         }
-        hy(a, b) {
-            let c = super.hy(a, b);
+        h2(a, b) {
+            let c = super.h2(a, b);
             if (c != null) {
                 let d = new List$1(Series.$, 0);
-                if (this.aid) {
-                    d.add(this.ah5());
+                if (this.aiv) {
+                    d.add(this.ain());
                 }
-                if (this.aie) {
-                    d.add(this.ah6());
+                if (this.aiw) {
+                    d.add(this.aio());
                 }
                 for (let e = 0; e < d.count; e++) {
                     let f = d._inner[e];
@@ -877,32 +877,32 @@ export let CategoryChart = /*@__PURE__*/ (() => {
                 return this.a9;
             }
         }
-        xf(a, b, c) {
-            super.xf(a, b, c);
+        xl(a, b, c) {
+            super.xl(a, b, c);
             if (this.bf.dataSeries.count > 0) {
-                if (stringIsNullOrEmpty(this.nz)) {
+                if (stringIsNullOrEmpty(this.n3)) {
                     this.ce.setXMemberPath(a, c.getMemberPathFor(16));
                 }
-                if (stringIsNullOrEmpty(this.n1)) {
+                if (stringIsNullOrEmpty(this.n5)) {
                     this.ce.setYMemberPath(a, c.getMemberPathFor(0));
                 }
-                if (stringIsNullOrEmpty(this.nm)) {
+                if (stringIsNullOrEmpty(this.nq)) {
                     this.ce.setLabelMemberPath(a, c.getMemberPathFor(0));
                 }
-                if (stringIsNullOrEmpty(this.ni)) {
+                if (stringIsNullOrEmpty(this.nm)) {
                     this.ce.setContentMemberPath(a, c.getMemberPathFor(0));
                 }
             }
         }
-        g4() {
+        g8() {
             if (this.crosshairsDisplayMode == 4 || this.crosshairsDisplayMode == 3) {
                 return true;
             }
             else if (this.crosshairsDisplayMode == 0) {
-                if (this.ahu == 2 || this.ahu == 8) {
+                if (this.aic == 2 || this.aic == 8) {
                     return false;
                 }
-                else if (this.ahu == 9 && this.bf != null && this.bf.dataSeries != null && this.bf.dataSeries.count > 0) {
+                else if (this.aic == 9 && this.bf != null && this.bf.dataSeries != null && this.bf.dataSeries.count > 0) {
                     let a = this.bf.dataSeries._inner[0].suggestedSeries;
                     if (a == 1 || a == 8) {
                         return false;
@@ -912,133 +912,133 @@ export let CategoryChart = /*@__PURE__*/ (() => {
             }
             return false;
         }
-        get_hb() {
+        get_hf() {
             return DVContainer.instance.checkLoaded("CategoryChartToolbarFactoryManager");
         }
-        wd(a, b, c) {
-            super.wd(a, b, c);
+        wj(a, b, c) {
+            super.wj(a, b, c);
             switch (a) {
                 case "ChartType":
-                    this.u8();
+                    this.ve();
                     break;
                 case "MarkerCollisionAvoidance":
-                    this.ali((d) => d.aa1 = this.ahw);
+                    this.al0((d) => d.aa4 = this.aie);
                     break;
                 case "IsTransitionInEnabled":
-                    this.ali((d) => d.zq = this.air);
+                    this.al0((d) => d.zq = this.ai9);
                     break;
                 case "IsSplineShapePartOfRange":
-                    this.ali((d) => {
+                    this.al0((d) => {
                         if (d.f1) {
-                            d.r8(this.aiq);
+                            d.r8(this.ai8);
                         }
                     });
                     break;
                 case "TransitionInMode":
-                    this.ali((d) => d.za = this.ahy);
+                    this.al0((d) => d.za = this.aig);
                     break;
                 case "TransitionInSpeedType":
-                    this.ali((d) => d.c6 = this.ah8);
+                    this.al0((d) => d.c6 = this.aiq);
                     break;
                 case "XAxisInterval":
-                    this.xAxis.mw = this.ajq;
+                    this.xAxis.mw = this.aj8;
                     break;
                 case "XAxisMinorInterval":
-                    this.xAxis.mx = this.ajt;
+                    this.xAxis.mx = this.akb;
                     break;
                 case "XAxisGap":
-                    this.xAxis.k5 = this.ajp;
+                    this.xAxis.k5 = this.aj7;
                     break;
                 case "XAxisOverlap":
-                    this.xAxis.le = this.aju;
+                    this.xAxis.le = this.akc;
                     break;
                 case "XAxisMinimumGapSize":
-                    this.xAxis.ld = this.ajs;
+                    this.xAxis.ld = this.aka;
                     break;
                 case "XAxisMaximumGap":
-                    this.xAxis.lc = this.ajr;
+                    this.xAxis.lc = this.aj9;
                     break;
                 case "XAxisZoomMaximumCategoryRange":
-                    this.xAxis.zoomMaximumCategoryRange = this.ajv;
+                    this.xAxis.zoomMaximumCategoryRange = this.akd;
                     break;
                 case "XAxisZoomMaximumItemSpan":
-                    this.xAxis.zoomMaximumItemSpan = this.ajw;
+                    this.xAxis.zoomMaximumItemSpan = this.ake;
                     break;
                 case "XAxisZoomToCategoryRange":
-                    this.xAxis.zoomToCategoryRange = this.ajx;
+                    this.xAxis.zoomToCategoryRange = this.akf;
                     break;
                 case "XAxisZoomToCategoryStart":
-                    this.xAxis.zoomToCategoryStart = this.ajy;
+                    this.xAxis.zoomToCategoryStart = this.akg;
                     break;
                 case "XAxisZoomToItemSpan":
-                    this.xAxis.zoomToItemSpan = this.ajz;
+                    this.xAxis.zoomToItemSpan = this.akh;
                     break;
                 case "YAxisInterval":
-                    this.yAxis.l8 = this.aj2;
+                    this.yAxis.l8 = this.akk;
                     break;
                 case "YAxisFavorLabellingScaleEnd":
-                    this.yAxis.lj = this.aix;
+                    this.yAxis.lj = this.ajf;
                     break;
                 case "YAxisAutoRangeBufferMode":
-                    this.yAxis.ky = this.ahs;
+                    this.yAxis.ky = this.aia;
                     break;
                 case "YAxisIsLogarithmic":
-                    this.yAxis.lo = this.aiy;
+                    this.yAxis.lo = this.ajg;
                     break;
                 case "YAxisLogarithmBase":
-                    this.yAxis.mm = this.akb;
+                    this.yAxis.mm = this.akt;
                     break;
                 case "YAxisMinimumValue":
-                    this.yAxis.mc = this.aj4;
+                    this.yAxis.mc = this.akm;
                     break;
                 case "YAxisMaximumValue":
-                    this.yAxis.mb = this.aj3;
+                    this.yAxis.mb = this.akl;
                     break;
                 case "YAxisMinorInterval":
-                    this.yAxis.md = this.aj5;
+                    this.yAxis.md = this.akn;
                     break;
                 case "NegativeBrushes":
                 case "NegativeOutlines":
-                    this.alj((d, e) => {
+                    this.al1((d, e) => {
                         if (d.fn) {
-                            d.r7(ArrayExtension.getModulus$1(Brush.$, this.ahn, e), ArrayExtension.getModulus$1(Brush.$, this.aho, e));
+                            d.r7(ArrayExtension.getModulus$1(Brush.$, this.ah5, e), ArrayExtension.getModulus$1(Brush.$, this.ah6, e));
                         }
                     });
                     break;
                 case "YAxisAbbreviateLargeNumbers":
-                    this.af4((d) => d.lf = this.aiv);
+                    this.agm((d) => d.lf = this.ajd);
                     break;
                 case "IsCategoryHighlightingEnabled":
                 case "IsItemHighlightingEnabled":
-                    this.u8();
+                    this.ve();
                     break;
                 case "AutoMarginAndAngleUpdateMode":
-                    this.v1((d) => d.w6 = this.ahq);
+                    this.v7((d) => d.xi = this.ah8);
                     break;
                 case "ShouldAutoExpandMarginForInitialLabels":
-                    this.v1((d) => d.x1 = this.ais);
+                    this.v7((d) => d.yd = this.aja);
                     break;
-                case CategoryChart.akp:
-                    this.v1((d) => d.x4 = this.ait);
+                case CategoryChart.ak7:
+                    this.v7((d) => d.yg = this.ajb);
                     break;
                 case "AutoExpandMarginExtraPadding":
-                    this.v1((d) => d.yr = this.ajh);
+                    this.v7((d) => d.y3 = this.ajz);
                     break;
                 case "AutoExpandMarginMaximumValue":
-                    this.v1((d) => d.ys = this.aji);
+                    this.v7((d) => d.y4 = this.aj0);
                     break;
-                case CategoryChart.akw:
-                    this.af0((d) => d.b1 = this.aiu, a);
+                case CategoryChart.ale:
+                    this.agi((d) => d.b1 = this.ajc, a);
                     break;
-                case CategoryChart.ala:
-                    this.af4((d) => d.b1 = this.aiw);
+                case CategoryChart.als:
+                    this.agm((d) => d.b1 = this.aje);
                     break;
             }
         }
     }
     CategoryChart.$t = /*@__PURE__*/ markType(CategoryChart, 'CategoryChart', XYChart.$);
-    CategoryChart.akp = "ShouldConsiderAutoRotationForInitialLabels";
-    CategoryChart.akw = "XAxisEnhancedIntervalPreferMoreCategoryLabels";
-    CategoryChart.ala = "YAxisEnhancedIntervalPreferMoreCategoryLabels";
+    CategoryChart.ak7 = "ShouldConsiderAutoRotationForInitialLabels";
+    CategoryChart.ale = "XAxisEnhancedIntervalPreferMoreCategoryLabels";
+    CategoryChart.als = "YAxisEnhancedIntervalPreferMoreCategoryLabels";
     return CategoryChart;
 })();