igniteui-webcomponents-charts 5.4.0 → 5.5.0-beta.0

package/esm2015/lib/CategoryChart.js

@@ -35,148 +35,148 @@ import { stringIsNullOrEmpty } from "igniteui-webcomponents-core";
  */
 export let CategoryChart = /*@__PURE__*/ (() => {
     class CategoryChart extends XYChart {
-        vd() {
-            super.vd();
+        vm() {
+            super.vm();
             if (this.dataChart == null) {
                 return;
             }
             let a = this.dataChart.c9.j.e();
-            this.ahd = a.d;
-            this.ahe = a.e;
-            if (this.agn == null) {
-                this.agn = a.k;
-            }
-            if (this.agu == null) {
-                this.agu = a.k;
-            }
-            this.acm = 0;
-            this.agv = AxisDefaults.h;
+            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.h;
+            this.ag8 = null;
+            this.ag1 = AxisDefaults.g;
             this.agy = null;
-            this.agr = AxisDefaults.g;
-            this.ago = null;
-            this.ab5 = AxisDefaults.f;
-            this.ags = AxisDefaults.j;
-            this.ab6 = AxisDefaults.e;
+            this.acf = AxisDefaults.f;
+            this.ag2 = AxisDefaults.j;
+            this.acg = AxisDefaults.e;
             this.crosshairsAnnotationEnabled = true;
             this.gq = true;
             this.crosshairsDisplayMode = 0;
-            this.jq = Defaults.j;
-            this.yo = Defaults.ae;
-            this.yj = Defaults.af;
-            this.yk = Defaults.ag;
-            this.aih = true;
-        }
-        vf(a, b) {
-            super.vf(a, b);
-            a.ke = this.ajz;
-            a.kf = this.aj0;
-            a.df = this.ah1;
-            a.dg = this.ah2;
-        }
-        v7(a, b, c) {
-            super.v7(a, b, c);
+            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);
             switch (a) {
                 case "TransitionInDuration":
-                    this.u2((d) => d.ke = this.ajz);
+                    this.vb((d) => d.kf = this.aj9);
                     break;
                 case "TransitionOutDuration":
-                    this.u2((d) => d.kf = this.aj0);
+                    this.vb((d) => d.kg = this.aka);
                     break;
                 case "TransitionInEasingFunction":
-                    this.u2((d) => d.df = this.ah1);
+                    this.vb((d) => d.df = this.aib);
                     break;
                 case "TransitionOutEasingFunction":
-                    this.u2((d) => d.dg = this.ah2);
+                    this.vb((d) => d.dg = this.aic);
                     break;
             }
         }
-        get ajz() {
-            return this.ajw;
+        get aj9() {
+            return this.aj6;
         }
-        set ajz(a) {
-            let b = this.ajz;
+        set aj9(a) {
+            let b = this.aj9;
             if (a != b) {
-                this.ajw = a;
-                this.v3("TransitionInDuration", b, this.ajz);
+                this.aj6 = a;
+                this.wd("TransitionInDuration", b, this.aj9);
             }
         }
-        get aj0() {
-            return this.ajx;
+        get aka() {
+            return this.aj7;
         }
-        set aj0(a) {
-            let b = this.aj0;
+        set aka(a) {
+            let b = this.aka;
             if (a != b) {
-                this.ajx = a;
-                this.v3("TransitionOutDuration", b, this.aj0);
+                this.aj7 = a;
+                this.wd("TransitionOutDuration", b, this.aka);
             }
         }
-        get ah1() {
-            return this.ahz;
+        get aib() {
+            return this.ah9;
         }
-        set ah1(a) {
-            let b = this.ah1;
+        set aib(a) {
+            let b = this.aib;
             if (a != b) {
-                this.ahz = a;
-                this.v3("TransitionInEasingFunction", b, this.ah1);
+                this.ah9 = a;
+                this.wd("TransitionInEasingFunction", b, this.aib);
             }
         }
-        get ah2() {
-            return this.ah0;
+        get aic() {
+            return this.aia;
         }
-        set ah2(a) {
-            let b = this.ah2;
+        set aic(a) {
+            let b = this.aic;
             if (a != b) {
-                this.ah0 = a;
-                this.v3("TransitionOutEasingFunction", b, this.ah2);
+                this.aia = a;
+                this.wd("TransitionOutEasingFunction", b, this.aic);
             }
         }
-        aj6() {
-            let cvd_ = this.lz();
+        akg() {
+            let cvd_ = this.l5();
             cvd_.scaleByViewport();
             return (cvd_.serialize());
         }
-        u8(a, b) {
-            super.u8(a, b);
+        vh(a, b) {
+            super.vh(a, b);
             a.ej = this.gj;
-            a.xp = this.aii;
-            a.xs = this.aij;
-            a.yf = this.ai7;
-            a.yg = this.ai8;
-            a.wu = this.ahg;
-        }
-        ve(a, b) {
-            super.ve(a, b);
+            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);
             let c = typeCast(HorizontalAnchoredCategorySeries.$, a);
             if (c == null) {
                 return;
             }
-            c.aay = this.ahm;
-            c.zn = this.aih;
-            c.y7 = this.aho;
-            c.c6 = this.ahy;
+            c.aa1 = this.ahw;
+            c.zq = this.air;
+            c.za = this.ahy;
+            c.c6 = this.ah8;
             c.trendLineBrush = ArrayExtension.getModulus$1(Brush.$, this.af, b);
             c.trendLineType = this.ec;
             c.trendLineThickness = this.km;
-            c.xc = this.c2(a, b);
-            if (a.fm) {
-                a.r5(ArrayExtension.getModulus$1(Brush.$, this.ahd, b), ArrayExtension.getModulus$1(Brush.$, this.ahe, b));
+            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));
             }
         }
-        ahp() {
+        ahz() {
             return new CategoryXAxis();
         }
-        aht() {
+        ah3() {
             return new NumericYAxis();
         }
-        uo() {
-            this.xAxis = this.ahp();
+        ux() {
+            this.xAxis = this.ahz();
             this.xAxis.name = "xAxis";
             let a = this.xAxis;
-            a.propertyChanged = delegateCombine(a.propertyChanged, runOn(this, this.ala));
-            this.yAxis = this.aht();
+            a.propertyChanged = delegateCombine(a.propertyChanged, runOn(this, this.alk));
+            this.yAxis = this.ah3();
             this.yAxis.name = "yAxis";
             let b = this.yAxis;
-            b.propertyChanged = delegateCombine(b.propertyChanged, runOn(this, this.alb));
+            b.propertyChanged = delegateCombine(b.propertyChanged, runOn(this, this.all));
             if (this.xAxis.az == null) {
                 this.xAxis.az = new AxisLabelSettings();
             }
@@ -184,20 +184,20 @@ export let CategoryChart = /*@__PURE__*/ (() => {
                 this.yAxis.az = new AxisLabelSettings();
             }
         }
-        afn(a) {
-            super.afn(a);
-            a.lf = this.ail;
-            a.lj = this.ain;
-            a.b1 = this.aim;
+        afx(a) {
+            super.afx(a);
+            a.lf = this.aiv;
+            a.lj = this.aix;
+            a.b1 = this.aiw;
         }
-        afl(a) {
-            super.afl(a);
-            a.b1 = this.aik;
-            a.zoomMaximumCategoryRange = this.ajl;
-            a.zoomToCategoryRange = this.ajn;
-            a.zoomToCategoryStart = this.ajo;
-            a.zoomMaximumItemSpan = this.ajm;
-            a.zoomToItemSpan = this.ajp;
+        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;
         }
         get_cb() {
             return 0;
@@ -205,54 +205,44 @@ export let CategoryChart = /*@__PURE__*/ (() => {
         get cb() {
             return this.get_cb();
         }
-        get ahk() {
-            return this.ahj;
+        get ahu() {
+            return this.aht;
         }
-        set ahk(a) {
-            if (a != this.ahj) {
-                let b = this.ahk;
-                this.ahj = a;
-                this.v3("ChartType", enumGetBox(CategoryChartType_$type, b), enumGetBox(CategoryChartType_$type, this.ahk));
-            }
-        }
-        get ahm() {
-            return this.ahl;
-        }
-        set ahm(a) {
-            let b = this.ahm;
-            if (a != b) {
-                this.ahl = a;
-                this.v3("MarkerCollisionAvoidance", enumGetBox(CategorySeriesMarkerCollisionAvoidance_$type, b), enumGetBox(CategorySeriesMarkerCollisionAvoidance_$type, this.ahm));
+        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));
             }
         }
-        get aig() {
-            return this.ah5;
+        get ahw() {
+            return this.ahv;
         }
-        set aig(a) {
-            let b = this.aig;
+        set ahw(a) {
+            let b = this.ahw;
             if (a != b) {
-                this.ah5 = a;
-                this.v3("IsSplineShapePartOfRange", b, this.aig);
+                this.ahv = a;
+                this.wd("MarkerCollisionAvoidance", enumGetBox(CategorySeriesMarkerCollisionAvoidance_$type, b), enumGetBox(CategorySeriesMarkerCollisionAvoidance_$type, this.ahw));
             }
         }
-        get aih() {
-            return this.ah6;
+        get aiq() {
+            return this.aif;
         }
-        set aih(a) {
-            let b = this.aih;
+        set aiq(a) {
+            let b = this.aiq;
             if (a != b) {
-                this.ah6 = a;
-                this.v3("IsTransitionInEnabled", b, this.aih);
+                this.aif = a;
+                this.wd("IsSplineShapePartOfRange", b, this.aiq);
             }
         }
-        get aho() {
-            return this.ahn;
+        get air() {
+            return this.aig;
         }
-        set aho(a) {
-            let b = this.aho;
+        set air(a) {
+            let b = this.air;
             if (a != b) {
-                this.ahn = a;
-                this.v3("TransitionInMode", enumGetBox(CategoryTransitionInMode_$type, b), enumGetBox(CategoryTransitionInMode_$type, this.aho));
+                this.aig = a;
+                this.wd("IsTransitionInEnabled", b, this.air);
             }
         }
         get ahy() {
@@ -262,394 +252,404 @@ export let CategoryChart = /*@__PURE__*/ (() => {
             let b = this.ahy;
             if (a != b) {
                 this.ahx = a;
-                this.v3("TransitionInSpeedType", enumGetBox(TransitionInSpeedType_$type, b), enumGetBox(TransitionInSpeedType_$type, this.ahy));
+                this.wd("TransitionInMode", enumGetBox(CategoryTransitionInMode_$type, b), enumGetBox(CategoryTransitionInMode_$type, this.ahy));
             }
         }
-        get ajg() {
-            return this.ait;
+        get ah8() {
+            return this.ah7;
         }
-        set ajg(a) {
-            let b = this.ajg;
+        set ah8(a) {
+            let b = this.ah8;
             if (a != b) {
-                this.ait = a;
-                this.v3("XAxisInterval", b, this.ajg);
+                this.ah7 = a;
+                this.wd("TransitionInSpeedType", enumGetBox(TransitionInSpeedType_$type, b), enumGetBox(TransitionInSpeedType_$type, this.ah8));
             }
         }
-        get ajj() {
-            return this.aiw;
+        get ajq() {
+            return this.ai3;
         }
-        set ajj(a) {
-            let b = this.ajj;
+        set ajq(a) {
+            let b = this.ajq;
             if (a != b) {
-                this.aiw = a;
-                this.v3("XAxisMinorInterval", b, this.ajj);
+                this.ai3 = a;
+                this.wd("XAxisInterval", b, this.ajq);
             }
         }
-        get ajf() {
-            return this.ais;
+        get ajt() {
+            return this.ai6;
         }
-        set ajf(a) {
-            let b = this.ajf;
+        set ajt(a) {
+            let b = this.ajt;
             if (a != b) {
-                this.ais = a;
-                this.v3("XAxisGap", b, this.ajf);
+                this.ai6 = a;
+                this.wd("XAxisMinorInterval", b, this.ajt);
             }
         }
-        get aji() {
-            return this.aiv;
+        get ajp() {
+            return this.ai2;
         }
-        set aji(a) {
-            let b = this.aji;
+        set ajp(a) {
+            let b = this.ajp;
             if (a != b) {
-                this.aiv = a;
-                this.v3("XAxisMinimumGapSize", b, this.aji);
+                this.ai2 = a;
+                this.wd("XAxisGap", b, this.ajp);
             }
         }
-        get ajh() {
-            return this.aiu;
+        get ajs() {
+            return this.ai5;
         }
-        set ajh(a) {
-            let b = this.ajh;
+        set ajs(a) {
+            let b = this.ajs;
             if (a != b) {
-                this.aiu = a;
-                this.v3("XAxisMaximumGap", b, this.ajh);
+                this.ai5 = a;
+                this.wd("XAxisMinimumGapSize", b, this.ajs);
             }
         }
-        get ajk() {
-            return this.aix;
+        get ajr() {
+            return this.ai4;
         }
-        set ajk(a) {
-            let b = this.ajk;
+        set ajr(a) {
+            let b = this.ajr;
             if (a != b) {
-                this.aix = a;
-                this.v3("XAxisOverlap", b, this.ajk);
+                this.ai4 = a;
+                this.wd("XAxisMaximumGap", b, this.ajr);
             }
         }
-        get ajs() {
-            return this.ai3;
+        get aju() {
+            return this.ai7;
         }
-        set ajs(a) {
-            let b = this.ajs;
+        set aju(a) {
+            let b = this.aju;
             if (a != b) {
-                this.ai3 = a;
-                this.v3("YAxisInterval", b, this.ajs);
+                this.ai7 = a;
+                this.wd("XAxisOverlap", b, this.aju);
             }
         }
-        get ahg() {
-            return this.ahf;
+        get aj2() {
+            return this.ajd;
         }
-        set ahg(a) {
-            let b = this.ahg;
+        set aj2(a) {
+            let b = this.aj2;
             if (a != b) {
-                this.ahf = a;
-                this.v3("AutoMarginAndAngleUpdateMode", enumGetBox(AutoMarginsAndAngleUpdateMode_$type, b), enumGetBox(AutoMarginsAndAngleUpdateMode_$type, this.ahg));
+                this.ajd = a;
+                this.wd("YAxisInterval", b, this.aj2);
             }
         }
-        alc() {
+        get ahq() {
+            return this.ahp;
+        }
+        set ahq(a) {
+            let b = this.ahq;
+            if (a != b) {
+                this.ahp = a;
+                this.wd("AutoMarginAndAngleUpdateMode", enumGetBox(AutoMarginsAndAngleUpdateMode_$type, b), enumGetBox(AutoMarginsAndAngleUpdateMode_$type, this.ahq));
+            }
+        }
+        alm() {
             if (this.dataChart != null) {
-                this.dataChart.z0();
+                this.dataChart.aac();
             }
         }
-        get aii() {
-            return this.ah7;
+        get ais() {
+            return this.aih;
         }
-        set aii(a) {
-            let b = this.aii;
+        set ais(a) {
+            let b = this.ais;
             if (a != b) {
-                this.ah7 = a;
-                this.v3("ShouldAutoExpandMarginForInitialLabels", b, this.aii);
+                this.aih = a;
+                this.wd("ShouldAutoExpandMarginForInitialLabels", b, this.ais);
             }
         }
-        get aij() {
-            return this.ah8;
+        get ait() {
+            return this.aii;
         }
-        set aij(a) {
-            let b = this.aij;
+        set ait(a) {
+            let b = this.ait;
             if (a != b) {
-                this.ah8 = a;
-                this.v3(CategoryChart.akf, b, this.aij);
+                this.aii = a;
+                this.wd(CategoryChart.akp, b, this.ait);
             }
         }
-        get ai7() {
-            return this.aiq;
+        get ajh() {
+            return this.ai0;
         }
-        set ai7(a) {
-            let b = this.ai7;
+        set ajh(a) {
+            let b = this.ajh;
             if (a != b) {
-                this.aiq = a;
-                this.v3("AutoExpandMarginExtraPadding", b, this.ai7);
+                this.ai0 = a;
+                this.wd("AutoExpandMarginExtraPadding", b, this.ajh);
             }
         }
-        get ai8() {
-            return this.air;
+        get aji() {
+            return this.ai1;
         }
-        set ai8(a) {
-            let b = this.ai8;
+        set aji(a) {
+            let b = this.aji;
             if (a != b) {
-                this.air = a;
-                this.v3("AutoExpandMarginMaximumValue", b, this.ai8);
+                this.ai1 = a;
+                this.wd("AutoExpandMarginMaximumValue", b, this.aji);
             }
         }
-        get ain() {
-            return this.aic;
+        get aix() {
+            return this.aim;
         }
-        set ain(a) {
-            let b = this.ain;
+        set aix(a) {
+            let b = this.aix;
             if (a != b) {
-                this.aic = a;
-                this.v3("YAxisFavorLabellingScaleEnd", b, this.ain);
+                this.aim = a;
+                this.wd("YAxisFavorLabellingScaleEnd", b, this.aix);
             }
         }
-        get aik() {
-            return this.ah9;
+        get aiu() {
+            return this.aij;
         }
-        set aik(a) {
-            let b = this.aik;
+        set aiu(a) {
+            let b = this.aiu;
             if (a != b) {
-                this.ah9 = a;
-                this.v3(CategoryChart.akm, b, this.aik);
+                this.aij = a;
+                this.wd(CategoryChart.akw, b, this.aiu);
             }
         }
-        get aim() {
-            return this.aib;
+        get aiw() {
+            return this.ail;
         }
-        set aim(a) {
-            let b = this.aim;
+        set aiw(a) {
+            let b = this.aiw;
             if (a != b) {
-                this.aib = a;
-                this.v3(CategoryChart.ak0, b, this.aim);
+                this.ail = a;
+                this.wd(CategoryChart.ala, b, this.aiw);
             }
         }
-        get ahi() {
-            return this.ahh;
+        get ahs() {
+            return this.ahr;
         }
-        set ahi(a) {
-            let b = this.ahi;
+        set ahs(a) {
+            let b = this.ahs;
             if (a != b) {
-                this.ahh = a;
-                this.v3("YAxisAutoRangeBufferMode", enumGetBox(AxisRangeBufferMode_$type, b), enumGetBox(AxisRangeBufferMode_$type, this.ahi));
+                this.ahr = a;
+                this.wd("YAxisAutoRangeBufferMode", enumGetBox(AxisRangeBufferMode_$type, b), enumGetBox(AxisRangeBufferMode_$type, this.ahs));
             }
         }
-        get aio() {
-            return this.aid;
+        get aiy() {
+            return this.ain;
         }
-        set aio(a) {
-            let b = this.aio;
+        set aiy(a) {
+            let b = this.aiy;
             if (a != b) {
-                this.aid = a;
-                this.v3("YAxisIsLogarithmic", b, this.aio);
+                this.ain = a;
+                this.wd("YAxisIsLogarithmic", b, this.aiy);
             }
         }
-        get aj1() {
-            return this.ajy;
+        get akb() {
+            return this.aj8;
         }
-        set aj1(a) {
-            let b = this.aj1;
+        set akb(a) {
+            let b = this.akb;
             if (a != b) {
-                this.ajy = a;
-                this.v3("YAxisLogarithmBase", b, this.aj1);
+                this.aj8 = a;
+                this.wd("YAxisLogarithmBase", b, this.akb);
             }
         }
-        get aju() {
-            return this.ai5;
+        get aj4() {
+            return this.ajf;
         }
-        set aju(a) {
-            let b = this.aju;
+        set aj4(a) {
+            let b = this.aj4;
             if (a != b) {
-                this.ai5 = a;
-                this.v3("YAxisMinimumValue", b, this.aju);
+                this.ajf = a;
+                this.wd("YAxisMinimumValue", b, this.aj4);
             }
         }
-        get ajt() {
-            return this.ai4;
+        get aj3() {
+            return this.aje;
         }
-        set ajt(a) {
-            let b = this.ajt;
+        set aj3(a) {
+            let b = this.aj3;
             if (a != b) {
-                this.ai4 = a;
-                this.v3("YAxisMaximumValue", b, this.ajt);
+                this.aje = a;
+                this.wd("YAxisMaximumValue", b, this.aj3);
             }
         }
-        get ajv() {
-            return this.ai6;
+        get aj5() {
+            return this.ajg;
         }
-        set ajv(a) {
-            let b = this.ajv;
+        set aj5(a) {
+            let b = this.aj5;
             if (a != b) {
-                this.ai6 = a;
-                this.v3("YAxisMinorInterval", b, this.ajv);
+                this.ajg = a;
+                this.wd("YAxisMinorInterval", b, this.aj5);
             }
         }
-        get aje() {
+        get ajo() {
             return this.xAxis.m1;
         }
-        get ajd() {
+        get ajn() {
             return this.xAxis.m0;
         }
-        aja() {
-            return this.aje;
+        ajk() {
+            return this.ajo;
         }
-        ajc() {
-            return this.ajr;
+        ajm() {
+            return this.aj1;
         }
-        ai9() {
-            return this.ajd;
+        ajj() {
+            return this.ajn;
         }
-        ajb() {
-            return this.ajq;
+        ajl() {
+            return this.aj0;
         }
-        get ajr() {
+        get aj1() {
             return this.yAxis.l4;
         }
-        get ajq() {
+        get aj0() {
             return this.yAxis.l3;
         }
-        get ahd() {
-            return this.ahb;
+        get ahn() {
+            return this.ahl;
         }
-        set ahd(a) {
-            let b = this.ahd;
+        set ahn(a) {
+            let b = this.ahn;
             if (a != b) {
-                this.ahb = a;
-                this.v3("NegativeBrushes", b, this.ahd);
+                this.ahl = a;
+                this.wd("NegativeBrushes", b, this.ahn);
             }
         }
-        get ahe() {
-            return this.ahc;
+        get aho() {
+            return this.ahm;
         }
-        set ahe(a) {
-            let b = this.ahe;
+        set aho(a) {
+            let b = this.aho;
             if (a != b) {
-                this.ahc = a;
-                this.v3("NegativeOutlines", b, this.ahe);
+                this.ahm = a;
+                this.wd("NegativeOutlines", b, this.aho);
             }
         }
-        get ail() {
-            return this.aia;
+        get aiv() {
+            return this.aik;
         }
-        set ail(a) {
-            let b = this.ail;
+        set aiv(a) {
+            let b = this.aiv;
             if (a != b) {
-                this.aia = a;
-                this.v3("YAxisAbbreviateLargeNumbers", b, this.ail);
+                this.aik = a;
+                this.wd("YAxisAbbreviateLargeNumbers", b, this.aiv);
             }
         }
-        get ajl() {
-            return this.aiy;
+        get ajv() {
+            return this.ai8;
         }
-        set ajl(a) {
-            let b = this.ajl;
+        set ajv(a) {
+            let b = this.ajv;
             if (a != b) {
-                this.aiy = a;
-                this.v3("XAxisZoomMaximumCategoryRange", b, this.ajl);
+                this.ai8 = a;
+                this.wd("XAxisZoomMaximumCategoryRange", b, this.ajv);
             }
         }
-        get ajm() {
-            return this.aiz;
+        get ajw() {
+            return this.ai9;
         }
-        set ajm(a) {
-            let b = this.ajm;
+        set ajw(a) {
+            let b = this.ajw;
             if (a != b) {
-                this.aiz = a;
-                this.v3("XAxisZoomMaximumItemSpan", b, this.ajm);
+                this.ai9 = a;
+                this.wd("XAxisZoomMaximumItemSpan", b, this.ajw);
             }
         }
-        get ajn() {
-            return this.ai0;
+        get ajx() {
+            return this.aja;
         }
-        set ajn(a) {
-            let b = this.ajn;
+        set ajx(a) {
+            let b = this.ajx;
             if (a != b) {
-                this.ai0 = a;
-                this.v3("XAxisZoomToCategoryRange", b, this.ajn);
+                this.aja = a;
+                this.wd("XAxisZoomToCategoryRange", b, this.ajx);
             }
         }
-        get ajo() {
-            return this.ai1;
+        get ajy() {
+            return this.ajb;
         }
-        set ajo(a) {
-            let b = this.ajo;
+        set ajy(a) {
+            let b = this.ajy;
             if (a != b) {
-                this.ai1 = a;
-                this.v3("XAxisZoomToCategoryStart", b, this.ajo);
+                this.ajb = a;
+                this.wd("XAxisZoomToCategoryStart", b, this.ajy);
             }
         }
-        get ajp() {
-            return this.ai2;
+        get ajz() {
+            return this.ajc;
         }
-        set ajp(a) {
-            let b = this.ajp;
+        set ajz(a) {
+            let b = this.ajz;
             if (a != b) {
-                this.ai2 = a;
-                this.v3("XAxisZoomToItemSpan", b, this.ajp);
+                this.ajc = a;
+                this.wd("XAxisZoomToItemSpan", b, this.ajz);
             }
         }
-        get aie() {
-            return this.ah3;
+        get aio() {
+            return this.aid;
         }
-        set aie(a) {
-            let b = this.aie;
+        set aio(a) {
+            let b = this.aio;
             if (a != b) {
-                this.ah3 = a;
-                this.v3("IsCategoryHighlightingEnabled", b, this.aie);
+                this.aid = a;
+                this.wd("IsCategoryHighlightingEnabled", b, this.aio);
             }
         }
-        get aif() {
-            return this.ah4;
+        get aip() {
+            return this.aie;
         }
-        set aif(a) {
-            let b = this.aif;
+        set aip(a) {
+            let b = this.aip;
             if (a != b) {
-                this.ah4 = a;
-                this.v3("IsItemHighlightingEnabled", b, this.aif);
+                this.aie = a;
+                this.wd("IsItemHighlightingEnabled", b, this.aip);
             }
         }
         constructor() {
             super();
-            this.ajw = 1000;
-            this.ajx = 1000;
-            this.ahz = null;
-            this.ah0 = null;
-            this.ahj = 9;
-            this.ahl = 1;
-            this.ah5 = false;
-            this.ah6 = true;
-            this.ahn = 0;
+            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.ait = 0;
-            this.aiw = 0;
-            this.ais = 0;
-            this.aiv = 0;
-            this.aiu = 1;
-            this.aix = 0;
-            this.ai3 = NaN;
-            this.ahf = 1;
-            this.ah7 = true;
-            this.ah8 = true;
-            this.aiq = DeviceUtils.g(2);
-            this.air = DeviceUtils.g(60);
-            this.aic = true;
-            this.ah9 = true;
-            this.aib = false;
-            this.ahh = 0;
-            this.aid = false;
-            this.ajy = 10;
-            this.ai5 = NaN;
-            this.ai4 = NaN;
+            this.ah7 = 0;
+            this.ai3 = 0;
             this.ai6 = 0;
-            this.ahb = null;
-            this.ahc = null;
-            this.aia = true;
-            this.aiy = 3;
-            this.aiz = NaN;
-            this.ai0 = NaN;
-            this.ai1 = NaN;
-            this.ai2 = NaN;
-            this.ah3 = false;
-            this.ah4 = false;
-            this.aip = null;
+            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;
             DVContainer.instance.registerIfLoaded("CategoryChartToolbarFactoryManager");
-            this.ut();
+            this.u2();
         }
         get_h2() {
             let a = new List$1(DataSeriesType_$type, 0);
@@ -686,16 +686,16 @@ export let CategoryChart = /*@__PURE__*/ (() => {
             return this.get_h2();
         }
         h8() {
-            if (this.aip == null) {
-                this.aip = CategoryChartMockDataGenerator.a();
+            if (this.aiz == null) {
+                this.aiz = CategoryChartMockDataGenerator.a();
             }
-            return this.aip;
+            return this.aiz;
         }
         c1(a) {
             if (a != null) {
                 let b = super.c1(a);
                 if (b == 2) {
-                    if (a.fl && this.g1) {
+                    if (a.fm && this.g1) {
                         return 13;
                     }
                 }
@@ -706,7 +706,7 @@ export let CategoryChart = /*@__PURE__*/ (() => {
             if (a != null) {
                 let b = super.c1(a);
                 if (b == 2) {
-                    if (a.fl && this.g1) {
+                    if (a.fm && this.g1) {
                         return 13;
                     }
                 }
@@ -716,32 +716,32 @@ export let CategoryChart = /*@__PURE__*/ (() => {
         get_hk() {
             return true;
         }
-        ala(a, b) {
+        alk(a, b) {
             switch (b.propertyName) {
                 case "ActualMinimum":
-                    this.wl("XAxisActualMinimum");
+                    this.wv("XAxisActualMinimum");
                     break;
                 case "ActualMaximum":
-                    this.wl("XAxisActualMaximum");
+                    this.wv("XAxisActualMaximum");
                     break;
             }
         }
-        alb(a, b) {
+        all(a, b) {
             switch (b.propertyName) {
                 case "ActualMinimumValue":
-                    this.wl("YAxisActualMinimum");
+                    this.wv("YAxisActualMinimum");
                     break;
                 case "ActualMaximumValue":
-                    this.wl("YAxisActualMaximum");
+                    this.wv("YAxisActualMaximum");
                     break;
             }
         }
-        w0() {
-            super.w0();
-            this.xAxis.f2 = this.acw == null ? XYChart.ac8(this.xAxis, this.bf.dataSeries) : this.acw;
+        xa() {
+            super.xa();
+            this.xAxis.f2 = this.ac6 == null ? XYChart.adi(this.xAxis, this.bf.dataSeries) : this.ac6;
             this.xAxis.itemsSource = this.dataChart != null && this.dataChart.series.count > 0 ? this.dataChart.series._inner[0].itemsSource : null;
-            if (this.aii) {
-                this.vs((a) => a.z0());
+            if (this.ais) {
+                this.v1((a) => a.aac());
             }
         }
         get xAxis() {
@@ -756,7 +756,7 @@ export let CategoryChart = /*@__PURE__*/ (() => {
         set yAxis(a) {
             this._yAxis = a;
         }
-        ahs(a, b) {
+        ah2(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.ahr(b);
+                case 9: return this.ah1(b);
                 default: return this.df(1);
             }
         }
-        ahr(a) {
+        ah1(a) {
             return this.df(a);
         }
         be(a) {
-            switch (this.ahk) {
+            switch (this.ahu) {
                 case 1: return 2;
                 case 0: return 0;
                 case 3: return 10;
@@ -790,21 +790,21 @@ export let CategoryChart = /*@__PURE__*/ (() => {
             }
         }
         dc(a, b) {
-            let c = this.ahs(this.ahk, a.suggestedSeries);
-            c.abo = a.findMatchingHint(0).path;
+            let c = this.ah2(this.ahu, a.suggestedSeries);
+            c.abr = a.findMatchingHint(0).path;
             c.xAxis = this.xAxis;
             c.yAxis = this.yAxis;
             return c;
         }
-        wy(a) {
+        w8(a) {
             if (a.suggestedSecondaryAxis == 2) {
                 this.yAxis.lo = true;
                 this.yAxis.mm = 10;
             }
         }
-        w1() {
-            this.yAxis.lo = this.aio;
-            this.yAxis.mm = this.aj1;
+        xb() {
+            this.yAxis.lo = this.aiy;
+            this.yAxis.mm = this.akb;
         }
         get_h1() {
             return ((() => {
@@ -817,17 +817,17 @@ export let CategoryChart = /*@__PURE__*/ (() => {
         get h1() {
             return this.get_h1();
         }
-        ui(a, b) {
+        ur(a, b) {
             let c = typeCast(HorizontalAnchoredCategorySeries.$, a);
             if (c != null) {
-                c.aay = this.ahm;
-                c.xc = this.c2(a, b);
+                c.aa1 = this.ahw;
+                c.xf = this.c2(a, b);
             }
         }
-        ak8(a) {
-            this.ak9((b, c) => a(b));
+        ali(a) {
+            this.alj((b, c) => a(b));
         }
-        ak9(a) {
+        alj(a) {
             if (this.dataChart == null) {
                 return;
             }
@@ -839,27 +839,27 @@ export let CategoryChart = /*@__PURE__*/ (() => {
                 a(c, b);
             }
         }
-        aae() {
+        aao() {
             return this.xAxis;
         }
-        aaf() {
+        aap() {
             return this.yAxis;
         }
-        ahv() {
+        ah5() {
             return this.df(30);
         }
-        ahw() {
+        ah6() {
             return this.df(31);
         }
         hy(a, b) {
             let c = super.hy(a, b);
             if (c != null) {
                 let d = new List$1(Series.$, 0);
-                if (this.ah3) {
-                    d.add(this.ahv());
+                if (this.aid) {
+                    d.add(this.ah5());
                 }
-                if (this.ah4) {
-                    d.add(this.ahw());
+                if (this.aie) {
+                    d.add(this.ah6());
                 }
                 for (let e = 0; e < d.count; e++) {
                     let f = d._inner[e];
@@ -877,19 +877,19 @@ export let CategoryChart = /*@__PURE__*/ (() => {
                 return this.a9;
             }
         }
-        w5(a, b, c) {
-            super.w5(a, b, c);
+        xf(a, b, c) {
+            super.xf(a, b, c);
             if (this.bf.dataSeries.count > 0) {
-                if (stringIsNullOrEmpty(this.nt)) {
+                if (stringIsNullOrEmpty(this.nz)) {
                     this.ce.setXMemberPath(a, c.getMemberPathFor(16));
                 }
-                if (stringIsNullOrEmpty(this.nv)) {
+                if (stringIsNullOrEmpty(this.n1)) {
                     this.ce.setYMemberPath(a, c.getMemberPathFor(0));
                 }
-                if (stringIsNullOrEmpty(this.ng)) {
+                if (stringIsNullOrEmpty(this.nm)) {
                     this.ce.setLabelMemberPath(a, c.getMemberPathFor(0));
                 }
-                if (stringIsNullOrEmpty(this.nc)) {
+                if (stringIsNullOrEmpty(this.ni)) {
                     this.ce.setContentMemberPath(a, c.getMemberPathFor(0));
                 }
             }
@@ -899,10 +899,10 @@ export let CategoryChart = /*@__PURE__*/ (() => {
                 return true;
             }
             else if (this.crosshairsDisplayMode == 0) {
-                if (this.ahk == 2 || this.ahk == 8) {
+                if (this.ahu == 2 || this.ahu == 8) {
                     return false;
                 }
-                else if (this.ahk == 9 && this.bf != null && this.bf.dataSeries != null && this.bf.dataSeries.count > 0) {
+                else if (this.ahu == 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;
@@ -915,130 +915,130 @@ export let CategoryChart = /*@__PURE__*/ (() => {
         get_hb() {
             return DVContainer.instance.checkLoaded("CategoryChartToolbarFactoryManager");
         }
-        v3(a, b, c) {
-            super.v3(a, b, c);
+        wd(a, b, c) {
+            super.wd(a, b, c);
             switch (a) {
                 case "ChartType":
-                    this.uz();
+                    this.u8();
                     break;
                 case "MarkerCollisionAvoidance":
-                    this.ak8((d) => d.aay = this.ahm);
+                    this.ali((d) => d.aa1 = this.ahw);
                     break;
                 case "IsTransitionInEnabled":
-                    this.ak8((d) => d.zn = this.aih);
+                    this.ali((d) => d.zq = this.air);
                     break;
                 case "IsSplineShapePartOfRange":
-                    this.ak8((d) => {
-                        if (d.f0) {
-                            d.r6(this.aig);
+                    this.ali((d) => {
+                        if (d.f1) {
+                            d.r8(this.aiq);
                         }
                     });
                     break;
                 case "TransitionInMode":
-                    this.ak8((d) => d.y7 = this.aho);
+                    this.ali((d) => d.za = this.ahy);
                     break;
                 case "TransitionInSpeedType":
-                    this.ak8((d) => d.c6 = this.ahy);
+                    this.ali((d) => d.c6 = this.ah8);
                     break;
                 case "XAxisInterval":
-                    this.xAxis.mw = this.ajg;
+                    this.xAxis.mw = this.ajq;
                     break;
                 case "XAxisMinorInterval":
-                    this.xAxis.mx = this.ajj;
+                    this.xAxis.mx = this.ajt;
                     break;
                 case "XAxisGap":
-                    this.xAxis.k5 = this.ajf;
+                    this.xAxis.k5 = this.ajp;
                     break;
                 case "XAxisOverlap":
-                    this.xAxis.le = this.ajk;
+                    this.xAxis.le = this.aju;
                     break;
                 case "XAxisMinimumGapSize":
-                    this.xAxis.ld = this.aji;
+                    this.xAxis.ld = this.ajs;
                     break;
                 case "XAxisMaximumGap":
-                    this.xAxis.lc = this.ajh;
+                    this.xAxis.lc = this.ajr;
                     break;
                 case "XAxisZoomMaximumCategoryRange":
-                    this.xAxis.zoomMaximumCategoryRange = this.ajl;
+                    this.xAxis.zoomMaximumCategoryRange = this.ajv;
                     break;
                 case "XAxisZoomMaximumItemSpan":
-                    this.xAxis.zoomMaximumItemSpan = this.ajm;
+                    this.xAxis.zoomMaximumItemSpan = this.ajw;
                     break;
                 case "XAxisZoomToCategoryRange":
-                    this.xAxis.zoomToCategoryRange = this.ajn;
+                    this.xAxis.zoomToCategoryRange = this.ajx;
                     break;
                 case "XAxisZoomToCategoryStart":
-                    this.xAxis.zoomToCategoryStart = this.ajo;
+                    this.xAxis.zoomToCategoryStart = this.ajy;
                     break;
                 case "XAxisZoomToItemSpan":
-                    this.xAxis.zoomToItemSpan = this.ajp;
+                    this.xAxis.zoomToItemSpan = this.ajz;
                     break;
                 case "YAxisInterval":
-                    this.yAxis.l8 = this.ajs;
+                    this.yAxis.l8 = this.aj2;
                     break;
                 case "YAxisFavorLabellingScaleEnd":
-                    this.yAxis.lj = this.ain;
+                    this.yAxis.lj = this.aix;
                     break;
                 case "YAxisAutoRangeBufferMode":
-                    this.yAxis.ky = this.ahi;
+                    this.yAxis.ky = this.ahs;
                     break;
                 case "YAxisIsLogarithmic":
-                    this.yAxis.lo = this.aio;
+                    this.yAxis.lo = this.aiy;
                     break;
                 case "YAxisLogarithmBase":
-                    this.yAxis.mm = this.aj1;
+                    this.yAxis.mm = this.akb;
                     break;
                 case "YAxisMinimumValue":
-                    this.yAxis.mc = this.aju;
+                    this.yAxis.mc = this.aj4;
                     break;
                 case "YAxisMaximumValue":
-                    this.yAxis.mb = this.ajt;
+                    this.yAxis.mb = this.aj3;
                     break;
                 case "YAxisMinorInterval":
-                    this.yAxis.md = this.ajv;
+                    this.yAxis.md = this.aj5;
                     break;
                 case "NegativeBrushes":
                 case "NegativeOutlines":
-                    this.ak9((d, e) => {
-                        if (d.fm) {
-                            d.r5(ArrayExtension.getModulus$1(Brush.$, this.ahd, e), ArrayExtension.getModulus$1(Brush.$, this.ahe, e));
+                    this.alj((d, e) => {
+                        if (d.fn) {
+                            d.r7(ArrayExtension.getModulus$1(Brush.$, this.ahn, e), ArrayExtension.getModulus$1(Brush.$, this.aho, e));
                         }
                     });
                     break;
                 case "YAxisAbbreviateLargeNumbers":
-                    this.afu((d) => d.lf = this.ail);
+                    this.af4((d) => d.lf = this.aiv);
                     break;
                 case "IsCategoryHighlightingEnabled":
                 case "IsItemHighlightingEnabled":
-                    this.uz();
+                    this.u8();
                     break;
                 case "AutoMarginAndAngleUpdateMode":
-                    this.vs((d) => d.wu = this.ahg);
+                    this.v1((d) => d.w6 = this.ahq);
                     break;
                 case "ShouldAutoExpandMarginForInitialLabels":
-                    this.vs((d) => d.xp = this.aii);
+                    this.v1((d) => d.x1 = this.ais);
                     break;
-                case CategoryChart.akf:
-                    this.vs((d) => d.xs = this.aij);
+                case CategoryChart.akp:
+                    this.v1((d) => d.x4 = this.ait);
                     break;
                 case "AutoExpandMarginExtraPadding":
-                    this.vs((d) => d.yf = this.ai7);
+                    this.v1((d) => d.yr = this.ajh);
                     break;
                 case "AutoExpandMarginMaximumValue":
-                    this.vs((d) => d.yg = this.ai8);
+                    this.v1((d) => d.ys = this.aji);
                     break;
-                case CategoryChart.akm:
-                    this.afq((d) => d.b1 = this.aik, a);
+                case CategoryChart.akw:
+                    this.af0((d) => d.b1 = this.aiu, a);
                     break;
-                case CategoryChart.ak0:
-                    this.afu((d) => d.b1 = this.aim);
+                case CategoryChart.ala:
+                    this.af4((d) => d.b1 = this.aiw);
                     break;
             }
         }
     }
     CategoryChart.$t = /*@__PURE__*/ markType(CategoryChart, 'CategoryChart', XYChart.$);
-    CategoryChart.akf = "ShouldConsiderAutoRotationForInitialLabels";
-    CategoryChart.akm = "XAxisEnhancedIntervalPreferMoreCategoryLabels";
-    CategoryChart.ak0 = "YAxisEnhancedIntervalPreferMoreCategoryLabels";
+    CategoryChart.akp = "ShouldConsiderAutoRotationForInitialLabels";
+    CategoryChart.akw = "XAxisEnhancedIntervalPreferMoreCategoryLabels";
+    CategoryChart.ala = "YAxisEnhancedIntervalPreferMoreCategoryLabels";
     return CategoryChart;
 })();