igniteui-webcomponents-charts 5.0.0-beta.2 → 5.0.0

package/esm5/lib/CategoryChart.js

@@ -38,211 +38,211 @@ var CategoryChart = /** @class */ /*@__PURE__*/ (function (_super) {
     __extends(CategoryChart, _super);
     function CategoryChart() {
         var _this = _super.call(this) || this;
-        _this.aiq = 1000;
-        _this.air = 1000;
-        _this.agt = null;
-        _this.agu = null;
-        _this.agd = 9;
-        _this.agf = 1;
-        _this.agz = false;
-        _this.ag0 = true;
-        _this.agh = 0;
-        _this.agr = 0;
-        _this.ahn = 0;
-        _this.ahq = 0;
-        _this.ahm = 0;
-        _this.ahp = 0;
-        _this.aho = 1;
-        _this.ahr = 0;
-        _this.ahx = NaN;
-        _this.af9 = 1;
-        _this.ag1 = true;
-        _this.ag2 = true;
-        _this.ahk = DeviceUtils.g(2);
-        _this.ahl = DeviceUtils.g(60);
-        _this.ag6 = true;
-        _this.ag3 = true;
-        _this.ag5 = false;
-        _this.agb = 0;
-        _this.ag7 = false;
-        _this.ais = 10;
-        _this.ahz = NaN;
-        _this.ahy = NaN;
-        _this.ah0 = 0;
-        _this.af5 = null;
-        _this.af6 = null;
-        _this.ag4 = true;
-        _this.ahs = 3;
-        _this.aht = NaN;
-        _this.ahu = NaN;
-        _this.ahv = NaN;
-        _this.ahw = NaN;
-        _this.agx = false;
-        _this.agy = false;
-        _this.ahj = null;
+        _this.ai2 = 1000;
+        _this.ai3 = 1000;
+        _this.ag5 = null;
+        _this.ag6 = null;
+        _this.agp = 9;
+        _this.agr = 1;
+        _this.ahb = false;
+        _this.ahc = true;
+        _this.agt = 0;
+        _this.ag3 = 0;
+        _this.ahz = 0;
+        _this.ah2 = 0;
+        _this.ahy = 0;
+        _this.ah1 = 0;
+        _this.ah0 = 1;
+        _this.ah3 = 0;
+        _this.ah9 = NaN;
+        _this.agl = 1;
+        _this.ahd = true;
+        _this.ahe = true;
+        _this.ahw = DeviceUtils.g(2);
+        _this.ahx = DeviceUtils.g(60);
+        _this.ahi = true;
+        _this.ahf = true;
+        _this.ahh = false;
+        _this.agn = 0;
+        _this.ahj = false;
+        _this.ai4 = 10;
+        _this.aib = NaN;
+        _this.aia = NaN;
+        _this.aic = 0;
+        _this.agh = null;
+        _this.agi = null;
+        _this.ahg = true;
+        _this.ah4 = 3;
+        _this.ah5 = NaN;
+        _this.ah6 = NaN;
+        _this.ah7 = NaN;
+        _this.ah8 = NaN;
+        _this.ag9 = false;
+        _this.aha = false;
+        _this.ahv = null;
         DVContainer.instance.registerIfLoaded("CategoryChartToolbarFactoryManager");
-        _this.t8();
+        _this.ue();
         return _this;
     }
-    CategoryChart.prototype.ur = function () {
-        _super.prototype.ur.call(this);
+    CategoryChart.prototype.ux = function () {
+        _super.prototype.ux.call(this);
         if (this.dataChart == null) {
             return;
         }
         var a = this.dataChart.c8.j.e();
-        this.af7 = a.d;
-        this.af8 = a.e;
-        if (this.afh == null) {
-            this.afh = a.k;
+        this.agj = a.d;
+        this.agk = a.e;
+        if (this.aft == null) {
+            this.aft = a.k;
         }
-        if (this.afo == null) {
-            this.afo = a.k;
+        if (this.af0 == null) {
+            this.af0 = a.k;
         }
-        this.abg = 0;
-        this.afp = AxisDefaults.h;
-        this.afs = null;
-        this.afl = AxisDefaults.g;
-        this.afi = null;
-        this.aaz = AxisDefaults.f;
-        this.afm = AxisDefaults.j;
-        this.aa0 = AxisDefaults.e;
-        this.gi = true;
-        this.gj = true;
+        this.abs = 0;
+        this.af1 = AxisDefaults.h;
+        this.af4 = null;
+        this.afx = AxisDefaults.g;
+        this.afu = null;
+        this.abb = AxisDefaults.f;
+        this.afy = AxisDefaults.j;
+        this.abc = AxisDefaults.e;
+        this.go = true;
+        this.gp = true;
         this.bf = 0;
-        this.jg = Defaults.j;
-        this.xk = Defaults.ae;
-        this.xf = Defaults.af;
-        this.xg = Defaults.ag;
-        this.ahb = true;
+        this.jm = Defaults.j;
+        this.xw = Defaults.ae;
+        this.xr = Defaults.af;
+        this.xs = Defaults.ag;
+        this.ahn = true;
     };
-    CategoryChart.prototype.ut = function (a, b) {
-        _super.prototype.ut.call(this, a, b);
-        a.kc = this.ait;
-        a.kd = this.aiu;
-        a.dc = this.agv;
-        a.dd = this.agw;
+    CategoryChart.prototype.uz = function (a, b) {
+        _super.prototype.uz.call(this, a, b);
+        a.kc = this.ai5;
+        a.kd = this.ai6;
+        a.dc = this.ag7;
+        a.dd = this.ag8;
     };
-    CategoryChart.prototype.vi = function (a, b, c) {
+    CategoryChart.prototype.vo = function (a, b, c) {
         var _this = this;
-        _super.prototype.vi.call(this, a, b, c);
+        _super.prototype.vo.call(this, a, b, c);
         switch (a) {
             case "TransitionInDuration":
-                this.ug(function (d) { return d.kc = _this.ait; });
+                this.um(function (d) { return d.kc = _this.ai5; });
                 break;
             case "TransitionOutDuration":
-                this.ug(function (d) { return d.kd = _this.aiu; });
+                this.um(function (d) { return d.kd = _this.ai6; });
                 break;
             case "TransitionInEasingFunction":
-                this.ug(function (d) { return d.dc = _this.agv; });
+                this.um(function (d) { return d.dc = _this.ag7; });
                 break;
             case "TransitionOutEasingFunction":
-                this.ug(function (d) { return d.dd = _this.agw; });
+                this.um(function (d) { return d.dd = _this.ag8; });
                 break;
         }
     };
-    Object.defineProperty(CategoryChart.prototype, "ait", {
+    Object.defineProperty(CategoryChart.prototype, "ai5", {
         get: function () {
-            return this.aiq;
+            return this.ai2;
         },
         set: function (a) {
-            var b = this.ait;
+            var b = this.ai5;
             if (a != b) {
-                this.aiq = a;
-                this.vf("TransitionInDuration", b, this.ait);
+                this.ai2 = a;
+                this.vl("TransitionInDuration", b, this.ai5);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aiu", {
+    Object.defineProperty(CategoryChart.prototype, "ai6", {
         get: function () {
-            return this.air;
+            return this.ai3;
         },
         set: function (a) {
-            var b = this.aiu;
+            var b = this.ai6;
             if (a != b) {
-                this.air = a;
-                this.vf("TransitionOutDuration", b, this.aiu);
+                this.ai3 = a;
+                this.vl("TransitionOutDuration", b, this.ai6);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "agv", {
+    Object.defineProperty(CategoryChart.prototype, "ag7", {
         get: function () {
-            return this.agt;
+            return this.ag5;
         },
         set: function (a) {
-            var b = this.agv;
+            var b = this.ag7;
             if (a != b) {
-                this.agt = a;
-                this.vf("TransitionInEasingFunction", b, this.agv);
+                this.ag5 = a;
+                this.vl("TransitionInEasingFunction", b, this.ag7);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "agw", {
+    Object.defineProperty(CategoryChart.prototype, "ag8", {
         get: function () {
-            return this.agu;
+            return this.ag6;
         },
         set: function (a) {
-            var b = this.agw;
+            var b = this.ag8;
             if (a != b) {
-                this.agu = a;
-                this.vf("TransitionOutEasingFunction", b, this.agw);
+                this.ag6 = a;
+                this.vl("TransitionOutEasingFunction", b, this.ag8);
             }
         },
         enumerable: false,
         configurable: true
     });
-    CategoryChart.prototype.ai0 = function () {
-        var cvd_ = this.lp();
+    CategoryChart.prototype.ajc = function () {
+        var cvd_ = this.lv();
         cvd_.scaleByViewport();
         return (cvd_.serialize());
     };
-    CategoryChart.prototype.um = function (a, b) {
-        _super.prototype.um.call(this, a, b);
-        a.eh = this.ga;
-        a.w2 = this.ahc;
-        a.w5 = this.ahd;
-        a.xs = this.ah1;
-        a.xt = this.ah2;
-        a.v7 = this.aga;
-    };
     CategoryChart.prototype.us = function (a, b) {
         _super.prototype.us.call(this, a, b);
+        a.eh = this.gg;
+        a.w2 = this.aho;
+        a.w5 = this.ahp;
+        a.xs = this.aid;
+        a.xt = this.aie;
+        a.v7 = this.agm;
+    };
+    CategoryChart.prototype.uy = function (a, b) {
+        _super.prototype.uy.call(this, a, b);
         var c = typeCast(HorizontalAnchoredCategorySeries.$, a);
         if (c == null) {
             return;
         }
-        c.aaf = this.agg;
-        c.zb = this.ahb;
-        c.yv = this.agi;
-        c.c3 = this.ags;
+        c.aag = this.ags;
+        c.zc = this.ahn;
+        c.yw = this.agu;
+        c.c3 = this.ag4;
         c.trendLineBrush = ArrayExtension.getModulus$1(Brush.$, this.ah, b);
-        c.trendLineType = this.d9;
-        c.trendLineThickness = this.kc;
-        c.w1 = this.c0(a, b);
+        c.trendLineType = this.ef;
+        c.trendLineThickness = this.ki;
+        c.w2 = this.c6(a, b);
         if (a.fk) {
-            a.rw(ArrayExtension.getModulus$1(Brush.$, this.af7, b), ArrayExtension.getModulus$1(Brush.$, this.af8, b));
+            a.rx(ArrayExtension.getModulus$1(Brush.$, this.agj, b), ArrayExtension.getModulus$1(Brush.$, this.agk, b));
         }
     };
-    CategoryChart.prototype.agj = function () {
+    CategoryChart.prototype.agv = function () {
         return new CategoryXAxis();
     };
-    CategoryChart.prototype.agn = function () {
+    CategoryChart.prototype.agz = function () {
         return new NumericYAxis();
     };
-    CategoryChart.prototype.t3 = function () {
-        this.xAxis = this.agj();
+    CategoryChart.prototype.t9 = function () {
+        this.xAxis = this.agv();
         this.xAxis.name = "xAxis";
         var a = this.xAxis;
-        a.propertyChanged = delegateCombine(a.propertyChanged, runOn(this, this.aj4));
-        this.yAxis = this.agn();
+        a.propertyChanged = delegateCombine(a.propertyChanged, runOn(this, this.akg));
+        this.yAxis = this.agz();
         this.yAxis.name = "yAxis";
         var b = this.yAxis;
-        b.propertyChanged = delegateCombine(b.propertyChanged, runOn(this, this.aj5));
+        b.propertyChanged = delegateCombine(b.propertyChanged, runOn(this, this.akh));
         if (this.xAxis.az == null) {
             this.xAxis.az = new AxisLabelSettings();
         }
@@ -250,595 +250,595 @@ var CategoryChart = /** @class */ /*@__PURE__*/ (function (_super) {
             this.yAxis.az = new AxisLabelSettings();
         }
     };
-    CategoryChart.prototype.aeh = function (a) {
-        _super.prototype.aeh.call(this, a);
-        a.lb = this.ahf;
-        a.le = this.ahh;
-        a.b1 = this.ahg;
+    CategoryChart.prototype.aet = function (a) {
+        _super.prototype.aet.call(this, a);
+        a.lb = this.ahr;
+        a.le = this.aht;
+        a.b1 = this.ahs;
     };
-    CategoryChart.prototype.aef = function (a) {
-        _super.prototype.aef.call(this, a);
-        a.b1 = this.ahe;
-        a.zoomMaximumCategoryRange = this.aif;
-        a.zoomToCategoryRange = this.aih;
-        a.zoomToCategoryStart = this.aii;
-        a.zoomMaximumItemSpan = this.aig;
-        a.zoomToItemSpan = this.aij;
+    CategoryChart.prototype.aer = function (a) {
+        _super.prototype.aer.call(this, a);
+        a.b1 = this.ahq;
+        a.zoomMaximumCategoryRange = this.air;
+        a.zoomToCategoryRange = this.ait;
+        a.zoomToCategoryStart = this.aiu;
+        a.zoomMaximumItemSpan = this.ais;
+        a.zoomToItemSpan = this.aiv;
     };
-    CategoryChart.prototype.get_b9 = function () {
+    CategoryChart.prototype.get_cf = function () {
         return 0;
     };
-    Object.defineProperty(CategoryChart.prototype, "b9", {
+    Object.defineProperty(CategoryChart.prototype, "cf", {
         get: function () {
-            return this.get_b9();
+            return this.get_cf();
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "age", {
+    Object.defineProperty(CategoryChart.prototype, "agq", {
         get: function () {
-            return this.agd;
+            return this.agp;
         },
         set: function (a) {
-            if (a != this.agd) {
-                var b = this.age;
-                this.agd = a;
-                this.vf("ChartType", enumGetBox(CategoryChartType_$type, b), enumGetBox(CategoryChartType_$type, this.age));
+            if (a != this.agp) {
+                var b = this.agq;
+                this.agp = a;
+                this.vl("ChartType", enumGetBox(CategoryChartType_$type, b), enumGetBox(CategoryChartType_$type, this.agq));
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "agg", {
+    Object.defineProperty(CategoryChart.prototype, "ags", {
         get: function () {
-            return this.agf;
+            return this.agr;
         },
         set: function (a) {
-            var b = this.agg;
+            var b = this.ags;
             if (a != b) {
-                this.agf = a;
-                this.vf("MarkerCollisionAvoidance", enumGetBox(CategorySeriesMarkerCollisionAvoidance_$type, b), enumGetBox(CategorySeriesMarkerCollisionAvoidance_$type, this.agg));
+                this.agr = a;
+                this.vl("MarkerCollisionAvoidance", enumGetBox(CategorySeriesMarkerCollisionAvoidance_$type, b), enumGetBox(CategorySeriesMarkerCollisionAvoidance_$type, this.ags));
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aha", {
+    Object.defineProperty(CategoryChart.prototype, "ahm", {
         get: function () {
-            return this.agz;
+            return this.ahb;
         },
         set: function (a) {
-            var b = this.aha;
+            var b = this.ahm;
             if (a != b) {
-                this.agz = a;
-                this.vf("IsSplineShapePartOfRange", b, this.aha);
+                this.ahb = a;
+                this.vl("IsSplineShapePartOfRange", b, this.ahm);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ahb", {
+    Object.defineProperty(CategoryChart.prototype, "ahn", {
         get: function () {
-            return this.ag0;
+            return this.ahc;
         },
         set: function (a) {
-            var b = this.ahb;
+            var b = this.ahn;
             if (a != b) {
-                this.ag0 = a;
-                this.vf("IsTransitionInEnabled", b, this.ahb);
+                this.ahc = a;
+                this.vl("IsTransitionInEnabled", b, this.ahn);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "agi", {
+    Object.defineProperty(CategoryChart.prototype, "agu", {
         get: function () {
-            return this.agh;
+            return this.agt;
         },
         set: function (a) {
-            var b = this.agi;
+            var b = this.agu;
             if (a != b) {
-                this.agh = a;
-                this.vf("TransitionInMode", enumGetBox(CategoryTransitionInMode_$type, b), enumGetBox(CategoryTransitionInMode_$type, this.agi));
+                this.agt = a;
+                this.vl("TransitionInMode", enumGetBox(CategoryTransitionInMode_$type, b), enumGetBox(CategoryTransitionInMode_$type, this.agu));
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ags", {
+    Object.defineProperty(CategoryChart.prototype, "ag4", {
         get: function () {
-            return this.agr;
+            return this.ag3;
         },
         set: function (a) {
-            var b = this.ags;
+            var b = this.ag4;
             if (a != b) {
-                this.agr = a;
-                this.vf("TransitionInSpeedType", enumGetBox(TransitionInSpeedType_$type, b), enumGetBox(TransitionInSpeedType_$type, this.ags));
+                this.ag3 = a;
+                this.vl("TransitionInSpeedType", enumGetBox(TransitionInSpeedType_$type, b), enumGetBox(TransitionInSpeedType_$type, this.ag4));
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aia", {
+    Object.defineProperty(CategoryChart.prototype, "aim", {
         get: function () {
-            return this.ahn;
+            return this.ahz;
         },
         set: function (a) {
-            var b = this.aia;
+            var b = this.aim;
             if (a != b) {
-                this.ahn = a;
-                this.vf("XAxisInterval", b, this.aia);
+                this.ahz = a;
+                this.vl("XAxisInterval", b, this.aim);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aid", {
+    Object.defineProperty(CategoryChart.prototype, "aip", {
         get: function () {
-            return this.ahq;
+            return this.ah2;
         },
         set: function (a) {
-            var b = this.aid;
+            var b = this.aip;
             if (a != b) {
-                this.ahq = a;
-                this.vf("XAxisMinorInterval", b, this.aid);
+                this.ah2 = a;
+                this.vl("XAxisMinorInterval", b, this.aip);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ah9", {
+    Object.defineProperty(CategoryChart.prototype, "ail", {
         get: function () {
-            return this.ahm;
+            return this.ahy;
         },
         set: function (a) {
-            var b = this.ah9;
+            var b = this.ail;
             if (a != b) {
-                this.ahm = a;
-                this.vf("XAxisGap", b, this.ah9);
+                this.ahy = a;
+                this.vl("XAxisGap", b, this.ail);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aic", {
+    Object.defineProperty(CategoryChart.prototype, "aio", {
         get: function () {
-            return this.ahp;
+            return this.ah1;
         },
         set: function (a) {
-            var b = this.aic;
+            var b = this.aio;
             if (a != b) {
-                this.ahp = a;
-                this.vf("XAxisMinimumGapSize", b, this.aic);
+                this.ah1 = a;
+                this.vl("XAxisMinimumGapSize", b, this.aio);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aib", {
+    Object.defineProperty(CategoryChart.prototype, "ain", {
         get: function () {
-            return this.aho;
+            return this.ah0;
         },
         set: function (a) {
-            var b = this.aib;
+            var b = this.ain;
             if (a != b) {
-                this.aho = a;
-                this.vf("XAxisMaximumGap", b, this.aib);
+                this.ah0 = a;
+                this.vl("XAxisMaximumGap", b, this.ain);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aie", {
+    Object.defineProperty(CategoryChart.prototype, "aiq", {
         get: function () {
-            return this.ahr;
+            return this.ah3;
         },
         set: function (a) {
-            var b = this.aie;
+            var b = this.aiq;
             if (a != b) {
-                this.ahr = a;
-                this.vf("XAxisOverlap", b, this.aie);
+                this.ah3 = a;
+                this.vl("XAxisOverlap", b, this.aiq);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aim", {
+    Object.defineProperty(CategoryChart.prototype, "aiy", {
         get: function () {
-            return this.ahx;
+            return this.ah9;
         },
         set: function (a) {
-            var b = this.aim;
+            var b = this.aiy;
             if (a != b) {
-                this.ahx = a;
-                this.vf("YAxisInterval", b, this.aim);
+                this.ah9 = a;
+                this.vl("YAxisInterval", b, this.aiy);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aga", {
+    Object.defineProperty(CategoryChart.prototype, "agm", {
         get: function () {
-            return this.af9;
+            return this.agl;
         },
         set: function (a) {
-            var b = this.aga;
+            var b = this.agm;
             if (a != b) {
-                this.af9 = a;
-                this.vf("AutoMarginAndAngleUpdateMode", enumGetBox(AutoMarginsAndAngleUpdateMode_$type, b), enumGetBox(AutoMarginsAndAngleUpdateMode_$type, this.aga));
+                this.agl = a;
+                this.vl("AutoMarginAndAngleUpdateMode", enumGetBox(AutoMarginsAndAngleUpdateMode_$type, b), enumGetBox(AutoMarginsAndAngleUpdateMode_$type, this.agm));
             }
         },
         enumerable: false,
         configurable: true
     });
-    CategoryChart.prototype.aj6 = function () {
+    CategoryChart.prototype.aki = function () {
         if (this.dataChart != null) {
             this.dataChart.zd();
         }
     };
-    Object.defineProperty(CategoryChart.prototype, "ahc", {
+    Object.defineProperty(CategoryChart.prototype, "aho", {
         get: function () {
-            return this.ag1;
+            return this.ahd;
         },
         set: function (a) {
-            var b = this.ahc;
+            var b = this.aho;
             if (a != b) {
-                this.ag1 = a;
-                this.vf("ShouldAutoExpandMarginForInitialLabels", b, this.ahc);
+                this.ahd = a;
+                this.vl("ShouldAutoExpandMarginForInitialLabels", b, this.aho);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ahd", {
+    Object.defineProperty(CategoryChart.prototype, "ahp", {
         get: function () {
-            return this.ag2;
+            return this.ahe;
         },
         set: function (a) {
-            var b = this.ahd;
+            var b = this.ahp;
             if (a != b) {
-                this.ag2 = a;
-                this.vf(CategoryChart.ai9, b, this.ahd);
+                this.ahe = a;
+                this.vl(CategoryChart.ajl, b, this.ahp);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ah1", {
+    Object.defineProperty(CategoryChart.prototype, "aid", {
         get: function () {
-            return this.ahk;
+            return this.ahw;
         },
         set: function (a) {
-            var b = this.ah1;
+            var b = this.aid;
             if (a != b) {
-                this.ahk = a;
-                this.vf("AutoExpandMarginExtraPadding", b, this.ah1);
+                this.ahw = a;
+                this.vl("AutoExpandMarginExtraPadding", b, this.aid);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ah2", {
+    Object.defineProperty(CategoryChart.prototype, "aie", {
         get: function () {
-            return this.ahl;
+            return this.ahx;
         },
         set: function (a) {
-            var b = this.ah2;
+            var b = this.aie;
             if (a != b) {
-                this.ahl = a;
-                this.vf("AutoExpandMarginMaximumValue", b, this.ah2);
+                this.ahx = a;
+                this.vl("AutoExpandMarginMaximumValue", b, this.aie);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ahh", {
+    Object.defineProperty(CategoryChart.prototype, "aht", {
         get: function () {
-            return this.ag6;
+            return this.ahi;
         },
         set: function (a) {
-            var b = this.ahh;
+            var b = this.aht;
             if (a != b) {
-                this.ag6 = a;
-                this.vf("YAxisFavorLabellingScaleEnd", b, this.ahh);
+                this.ahi = a;
+                this.vl("YAxisFavorLabellingScaleEnd", b, this.aht);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ahe", {
+    Object.defineProperty(CategoryChart.prototype, "ahq", {
         get: function () {
-            return this.ag3;
+            return this.ahf;
         },
         set: function (a) {
-            var b = this.ahe;
+            var b = this.ahq;
             if (a != b) {
-                this.ag3 = a;
-                this.vf(CategoryChart.ajg, b, this.ahe);
+                this.ahf = a;
+                this.vl(CategoryChart.ajs, b, this.ahq);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ahg", {
+    Object.defineProperty(CategoryChart.prototype, "ahs", {
         get: function () {
-            return this.ag5;
+            return this.ahh;
         },
         set: function (a) {
-            var b = this.ahg;
+            var b = this.ahs;
             if (a != b) {
-                this.ag5 = a;
-                this.vf(CategoryChart.aju, b, this.ahg);
+                this.ahh = a;
+                this.vl(CategoryChart.aj6, b, this.ahs);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "agc", {
+    Object.defineProperty(CategoryChart.prototype, "ago", {
         get: function () {
-            return this.agb;
+            return this.agn;
         },
         set: function (a) {
-            var b = this.agc;
+            var b = this.ago;
             if (a != b) {
-                this.agb = a;
-                this.vf("YAxisAutoRangeBufferMode", enumGetBox(AxisRangeBufferMode_$type, b), enumGetBox(AxisRangeBufferMode_$type, this.agc));
+                this.agn = a;
+                this.vl("YAxisAutoRangeBufferMode", enumGetBox(AxisRangeBufferMode_$type, b), enumGetBox(AxisRangeBufferMode_$type, this.ago));
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ahi", {
+    Object.defineProperty(CategoryChart.prototype, "ahu", {
         get: function () {
-            return this.ag7;
+            return this.ahj;
         },
         set: function (a) {
-            var b = this.ahi;
+            var b = this.ahu;
             if (a != b) {
-                this.ag7 = a;
-                this.vf("YAxisIsLogarithmic", b, this.ahi);
+                this.ahj = a;
+                this.vl("YAxisIsLogarithmic", b, this.ahu);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aiv", {
+    Object.defineProperty(CategoryChart.prototype, "ai7", {
         get: function () {
-            return this.ais;
+            return this.ai4;
         },
         set: function (a) {
-            var b = this.aiv;
+            var b = this.ai7;
             if (a != b) {
-                this.ais = a;
-                this.vf("YAxisLogarithmBase", b, this.aiv);
+                this.ai4 = a;
+                this.vl("YAxisLogarithmBase", b, this.ai7);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aio", {
+    Object.defineProperty(CategoryChart.prototype, "ai0", {
         get: function () {
-            return this.ahz;
+            return this.aib;
         },
         set: function (a) {
-            var b = this.aio;
+            var b = this.ai0;
             if (a != b) {
-                this.ahz = a;
-                this.vf("YAxisMinimumValue", b, this.aio);
+                this.aib = a;
+                this.vl("YAxisMinimumValue", b, this.ai0);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ain", {
+    Object.defineProperty(CategoryChart.prototype, "aiz", {
         get: function () {
-            return this.ahy;
+            return this.aia;
         },
         set: function (a) {
-            var b = this.ain;
+            var b = this.aiz;
             if (a != b) {
-                this.ahy = a;
-                this.vf("YAxisMaximumValue", b, this.ain);
+                this.aia = a;
+                this.vl("YAxisMaximumValue", b, this.aiz);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aip", {
+    Object.defineProperty(CategoryChart.prototype, "ai1", {
         get: function () {
-            return this.ah0;
+            return this.aic;
         },
         set: function (a) {
-            var b = this.aip;
+            var b = this.ai1;
             if (a != b) {
-                this.ah0 = a;
-                this.vf("YAxisMinorInterval", b, this.aip);
+                this.aic = a;
+                this.vl("YAxisMinorInterval", b, this.ai1);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ah8", {
+    Object.defineProperty(CategoryChart.prototype, "aik", {
         get: function () {
             return this.xAxis.my;
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ah7", {
+    Object.defineProperty(CategoryChart.prototype, "aij", {
         get: function () {
             return this.xAxis.mx;
         },
         enumerable: false,
         configurable: true
     });
-    CategoryChart.prototype.ah4 = function () {
-        return this.ah8;
+    CategoryChart.prototype.aig = function () {
+        return this.aik;
     };
-    CategoryChart.prototype.ah6 = function () {
-        return this.ail;
+    CategoryChart.prototype.aii = function () {
+        return this.aix;
     };
-    CategoryChart.prototype.ah3 = function () {
-        return this.ah7;
+    CategoryChart.prototype.aif = function () {
+        return this.aij;
     };
-    CategoryChart.prototype.ah5 = function () {
-        return this.aik;
+    CategoryChart.prototype.aih = function () {
+        return this.aiw;
     };
-    Object.defineProperty(CategoryChart.prototype, "ail", {
+    Object.defineProperty(CategoryChart.prototype, "aix", {
         get: function () {
             return this.yAxis.ly;
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aik", {
+    Object.defineProperty(CategoryChart.prototype, "aiw", {
         get: function () {
             return this.yAxis.lx;
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "af7", {
+    Object.defineProperty(CategoryChart.prototype, "agj", {
         get: function () {
-            return this.af5;
+            return this.agh;
         },
         set: function (a) {
-            var b = this.af7;
+            var b = this.agj;
             if (a != b) {
-                this.af5 = a;
-                this.vf("NegativeBrushes", b, this.af7);
+                this.agh = a;
+                this.vl("NegativeBrushes", b, this.agj);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "af8", {
+    Object.defineProperty(CategoryChart.prototype, "agk", {
         get: function () {
-            return this.af6;
+            return this.agi;
         },
         set: function (a) {
-            var b = this.af8;
+            var b = this.agk;
             if (a != b) {
-                this.af6 = a;
-                this.vf("NegativeOutlines", b, this.af8);
+                this.agi = a;
+                this.vl("NegativeOutlines", b, this.agk);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ahf", {
+    Object.defineProperty(CategoryChart.prototype, "ahr", {
         get: function () {
-            return this.ag4;
+            return this.ahg;
         },
         set: function (a) {
-            var b = this.ahf;
+            var b = this.ahr;
             if (a != b) {
-                this.ag4 = a;
-                this.vf("YAxisAbbreviateLargeNumbers", b, this.ahf);
+                this.ahg = a;
+                this.vl("YAxisAbbreviateLargeNumbers", b, this.ahr);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aif", {
+    Object.defineProperty(CategoryChart.prototype, "air", {
         get: function () {
-            return this.ahs;
+            return this.ah4;
         },
         set: function (a) {
-            var b = this.aif;
+            var b = this.air;
             if (a != b) {
-                this.ahs = a;
-                this.vf("XAxisZoomMaximumCategoryRange", b, this.aif);
+                this.ah4 = a;
+                this.vl("XAxisZoomMaximumCategoryRange", b, this.air);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aig", {
+    Object.defineProperty(CategoryChart.prototype, "ais", {
         get: function () {
-            return this.aht;
+            return this.ah5;
         },
         set: function (a) {
-            var b = this.aig;
+            var b = this.ais;
             if (a != b) {
-                this.aht = a;
-                this.vf("XAxisZoomMaximumItemSpan", b, this.aig);
+                this.ah5 = a;
+                this.vl("XAxisZoomMaximumItemSpan", b, this.ais);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aih", {
+    Object.defineProperty(CategoryChart.prototype, "ait", {
         get: function () {
-            return this.ahu;
+            return this.ah6;
         },
         set: function (a) {
-            var b = this.aih;
+            var b = this.ait;
             if (a != b) {
-                this.ahu = a;
-                this.vf("XAxisZoomToCategoryRange", b, this.aih);
+                this.ah6 = a;
+                this.vl("XAxisZoomToCategoryRange", b, this.ait);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aii", {
+    Object.defineProperty(CategoryChart.prototype, "aiu", {
         get: function () {
-            return this.ahv;
+            return this.ah7;
         },
         set: function (a) {
-            var b = this.aii;
+            var b = this.aiu;
             if (a != b) {
-                this.ahv = a;
-                this.vf("XAxisZoomToCategoryStart", b, this.aii);
+                this.ah7 = a;
+                this.vl("XAxisZoomToCategoryStart", b, this.aiu);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aij", {
+    Object.defineProperty(CategoryChart.prototype, "aiv", {
         get: function () {
-            return this.ahw;
+            return this.ah8;
         },
         set: function (a) {
-            var b = this.aij;
+            var b = this.aiv;
             if (a != b) {
-                this.ahw = a;
-                this.vf("XAxisZoomToItemSpan", b, this.aij);
+                this.ah8 = a;
+                this.vl("XAxisZoomToItemSpan", b, this.aiv);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ag8", {
+    Object.defineProperty(CategoryChart.prototype, "ahk", {
         get: function () {
-            return this.agx;
+            return this.ag9;
         },
         set: function (a) {
-            var b = this.ag8;
+            var b = this.ahk;
             if (a != b) {
-                this.agx = a;
-                this.vf("IsCategoryHighlightingEnabled", b, this.ag8);
+                this.ag9 = a;
+                this.vl("IsCategoryHighlightingEnabled", b, this.ahk);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ag9", {
+    Object.defineProperty(CategoryChart.prototype, "ahl", {
         get: function () {
-            return this.agy;
+            return this.aha;
         },
         set: function (a) {
-            var b = this.ag9;
+            var b = this.ahl;
             if (a != b) {
-                this.agy = a;
-                this.vf("IsItemHighlightingEnabled", b, this.ag9);
+                this.aha = a;
+                this.vl("IsItemHighlightingEnabled", b, this.ahl);
             }
         },
         enumerable: false,
         configurable: true
     });
-    CategoryChart.prototype.get_hs = function () {
+    CategoryChart.prototype.get_hy = function () {
         var a = new List$1(DataSeriesType_$type, 0);
         if (TypeRegistrar.isRegistered("AreaSeries")) {
             a.add(2);
@@ -869,70 +869,70 @@ var CategoryChart = /** @class */ /*@__PURE__*/ (function (_super) {
         }
         return a;
     };
-    Object.defineProperty(CategoryChart.prototype, "hs", {
+    Object.defineProperty(CategoryChart.prototype, "hy", {
         get: function () {
-            return this.get_hs();
+            return this.get_hy();
         },
         enumerable: false,
         configurable: true
     });
-    CategoryChart.prototype.hy = function () {
-        if (this.ahj == null) {
-            this.ahj = CategoryChartMockDataGenerator.a();
+    CategoryChart.prototype.h4 = function () {
+        if (this.ahv == null) {
+            this.ahv = CategoryChartMockDataGenerator.a();
         }
-        return this.ahj;
+        return this.ahv;
     };
-    CategoryChart.prototype.cz = function (a) {
+    CategoryChart.prototype.c5 = function (a) {
         if (a != null) {
-            var b = _super.prototype.cz.call(this, a);
+            var b = _super.prototype.c5.call(this, a);
             if (b == 2) {
-                if (a.fj && this.gv) {
+                if (a.fj && this.g1) {
                     return 13;
                 }
             }
         }
-        return _super.prototype.cz.call(this, a);
+        return _super.prototype.c5.call(this, a);
     };
-    CategoryChart.prototype.c1 = function (a) {
+    CategoryChart.prototype.c7 = function (a) {
         if (a != null) {
-            var b = _super.prototype.cz.call(this, a);
+            var b = _super.prototype.c5.call(this, a);
             if (b == 2) {
-                if (a.fj && this.gv) {
+                if (a.fj && this.g1) {
                     return 13;
                 }
             }
         }
-        return _super.prototype.c1.call(this, a);
+        return _super.prototype.c7.call(this, a);
     };
-    CategoryChart.prototype.get_hd = function () {
+    CategoryChart.prototype.get_hj = function () {
         return this.xAxis != null && this.xAxis.categoryMode != 0;
     };
-    CategoryChart.prototype.aj4 = function (a, b) {
+    CategoryChart.prototype.akg = function (a, b) {
         switch (b.propertyName) {
             case "ActualMinimum":
-                this.vr("XAxisActualMinimum");
+                this.v2("XAxisActualMinimum");
                 break;
             case "ActualMaximum":
-                this.vr("XAxisActualMaximum");
+                this.v2("XAxisActualMaximum");
                 break;
         }
     };
-    CategoryChart.prototype.aj5 = function (a, b) {
+    CategoryChart.prototype.akh = function (a, b) {
         switch (b.propertyName) {
             case "ActualMinimumValue":
-                this.vr("YAxisActualMinimum");
+                this.v2("YAxisActualMinimum");
                 break;
             case "ActualMaximumValue":
-                this.vr("YAxisActualMaximum");
+                this.v2("YAxisActualMaximum");
                 break;
         }
     };
-    CategoryChart.prototype.v4 = function () {
-        _super.prototype.v4.call(this);
-        this.xAxis.f1 = this.abq == null ? XYChart.ab2(this.xAxis, this.bj.dataSeries) : this.abq;
+    CategoryChart.prototype.wg = function () {
+        _super.prototype.wg.call(this);
+        this.xAxis.f1 = this.ab2 == null ? XYChart.ace(this.xAxis, this.bj.dataSeries) : this.ab2;
         this.xAxis.itemsSource = this.dataChart != null && this.dataChart.series.count > 0 ? this.dataChart.series._inner[0].itemsSource : null;
-        if (this.ahc) {
-            this.u6(function (a) { return a.zd(); });
+        if (this.aho) {
+            this.vc(function (a) { return a.zd(); });
         }
     };
     Object.defineProperty(CategoryChart.prototype, "xAxis", {
@@ -955,26 +955,26 @@ var CategoryChart = /** @class */ /*@__PURE__*/ (function (_super) {
         enumerable: false,
         configurable: true
     });
-    CategoryChart.prototype.agm = function (a, b) {
+    CategoryChart.prototype.agy = function (a, b) {
         switch (a) {
-            case 2: return this.dc(1);
-            case 3: return this.dc(10);
-            case 0: return this.dc(0);
-            case 1: return this.dc(2);
-            case 6: return this.dc(6);
-            case 7: return this.dc(7);
-            case 4: return this.dc(4);
-            case 5: return this.dc(5);
-            case 8: return this.dc(8);
-            case 9: return this.agl(b);
-            default: return this.dc(1);
+            case 2: return this.di(1);
+            case 3: return this.di(10);
+            case 0: return this.di(0);
+            case 1: return this.di(2);
+            case 6: return this.di(6);
+            case 7: return this.di(7);
+            case 4: return this.di(4);
+            case 5: return this.di(5);
+            case 8: return this.di(8);
+            case 9: return this.agx(b);
+            default: return this.di(1);
         }
     };
-    CategoryChart.prototype.agl = function (a) {
-        return this.dc(a);
+    CategoryChart.prototype.agx = function (a) {
+        return this.di(a);
     };
     CategoryChart.prototype.bi = function (a) {
-        switch (this.age) {
+        switch (this.agq) {
             case 1: return 2;
             case 0: return 0;
             case 3: return 10;
@@ -988,24 +988,24 @@ var CategoryChart = /** @class */ /*@__PURE__*/ (function (_super) {
             case 2: return 1;
         }
     };
-    CategoryChart.prototype.da = function (a, b) {
-        var c = this.agm(this.age, a.suggestedSeries);
-        c.aa3 = a.findMatchingHint(0).path;
+    CategoryChart.prototype.dg = function (a, b) {
+        var c = this.agy(this.agq, a.suggestedSeries);
+        c.aa4 = a.findMatchingHint(0).path;
         c.xAxis = this.xAxis;
         c.yAxis = this.yAxis;
         return c;
     };
-    CategoryChart.prototype.v2 = function (a) {
+    CategoryChart.prototype.we = function (a) {
         if (a.suggestedSecondaryAxis == 2) {
             this.yAxis.lj = true;
             this.yAxis.ma = 10;
         }
     };
-    CategoryChart.prototype.v5 = function () {
-        this.yAxis.lj = this.ahi;
-        this.yAxis.ma = this.aiv;
+    CategoryChart.prototype.wh = function () {
+        this.yAxis.lj = this.ahu;
+        this.yAxis.ma = this.ai7;
     };
-    CategoryChart.prototype.get_hr = function () {
+    CategoryChart.prototype.get_hx = function () {
         return ((function () {
             var $ret = new List$1(IDataSeriesAdapterRule_$type, 0);
             $ret.add(new SimpleCategorySeriesRule());
@@ -1013,24 +1013,24 @@ var CategoryChart = /** @class */ /*@__PURE__*/ (function (_super) {
             return $ret;
         })());
     };
-    Object.defineProperty(CategoryChart.prototype, "hr", {
+    Object.defineProperty(CategoryChart.prototype, "hx", {
         get: function () {
-            return this.get_hr();
+            return this.get_hx();
         },
         enumerable: false,
         configurable: true
     });
-    CategoryChart.prototype.tx = function (a, b) {
+    CategoryChart.prototype.t3 = function (a, b) {
         var c = typeCast(HorizontalAnchoredCategorySeries.$, a);
         if (c != null) {
-            c.aaf = this.agg;
-            c.w1 = this.c0(a, b);
+            c.aag = this.ags;
+            c.w2 = this.c6(a, b);
         }
     };
-    CategoryChart.prototype.aj2 = function (a) {
-        this.aj3(function (b, c) { return a(b); });
+    CategoryChart.prototype.ake = function (a) {
+        this.akf(function (b, c) { return a(b); });
     };
-    CategoryChart.prototype.aj3 = function (a) {
+    CategoryChart.prototype.akf = function (a) {
         if (this.dataChart == null) {
             return;
         }
@@ -1042,27 +1042,27 @@ var CategoryChart = /** @class */ /*@__PURE__*/ (function (_super) {
             a(c, b);
         }
     };
-    CategoryChart.prototype.y8 = function () {
+    CategoryChart.prototype.zk = function () {
         return this.xAxis;
     };
-    CategoryChart.prototype.y9 = function () {
+    CategoryChart.prototype.zl = function () {
         return this.yAxis;
     };
-    CategoryChart.prototype.agp = function () {
-        return this.dc(30);
+    CategoryChart.prototype.ag1 = function () {
+        return this.di(30);
     };
-    CategoryChart.prototype.agq = function () {
-        return this.dc(31);
+    CategoryChart.prototype.ag2 = function () {
+        return this.di(31);
     };
-    CategoryChart.prototype.ho = function (a, b) {
-        var c = _super.prototype.ho.call(this, a, b);
+    CategoryChart.prototype.hu = function (a, b) {
+        var c = _super.prototype.hu.call(this, a, b);
         if (c != null) {
             var d = new List$1(Series.$, 0);
-            if (this.agx) {
-                d.add(this.agp());
+            if (this.ag9) {
+                d.add(this.ag1());
             }
-            if (this.agy) {
-                d.add(this.agq());
+            if (this.aha) {
+                d.add(this.ag2());
             }
             for (var e = 0; e < d.count; e++) {
                 var f = d._inner[e];
@@ -1080,32 +1080,32 @@ var CategoryChart = /** @class */ /*@__PURE__*/ (function (_super) {
             return this.bc;
         }
     };
-    CategoryChart.prototype.wa = function (a, b, c) {
-        _super.prototype.wa.call(this, a, b, c);
+    CategoryChart.prototype.wm = function (a, b, c) {
+        _super.prototype.wm.call(this, a, b, c);
         if (this.bj.dataSeries.count > 0) {
-            if (stringIsNullOrEmpty(this.ne)) {
-                this.cc.setXMemberPath(a, c.getMemberPathFor(16));
+            if (stringIsNullOrEmpty(this.nk)) {
+                this.ci.setXMemberPath(a, c.getMemberPathFor(16));
             }
-            if (stringIsNullOrEmpty(this.ng)) {
-                this.cc.setYMemberPath(a, c.getMemberPathFor(0));
+            if (stringIsNullOrEmpty(this.nm)) {
+                this.ci.setYMemberPath(a, c.getMemberPathFor(0));
             }
-            if (stringIsNullOrEmpty(this.m6)) {
-                this.cc.setLabelMemberPath(a, c.getMemberPathFor(0));
+            if (stringIsNullOrEmpty(this.nc)) {
+                this.ci.setLabelMemberPath(a, c.getMemberPathFor(0));
             }
-            if (stringIsNullOrEmpty(this.m3)) {
-                this.cc.setContentMemberPath(a, c.getMemberPathFor(0));
+            if (stringIsNullOrEmpty(this.m9)) {
+                this.ci.setContentMemberPath(a, c.getMemberPathFor(0));
             }
         }
     };
-    CategoryChart.prototype.gy = function () {
+    CategoryChart.prototype.g4 = function () {
         if (this.bf == 4 || this.bf == 3) {
             return true;
         }
         else if (this.bf == 0) {
-            if (this.age == 2 || this.age == 8) {
+            if (this.agq == 2 || this.agq == 8) {
                 return false;
             }
-            else if (this.age == 9 && this.bj != null && this.bj.dataSeries != null && this.bj.dataSeries.count > 0) {
+            else if (this.agq == 9 && this.bj != null && this.bj.dataSeries != null && this.bj.dataSeries.count > 0) {
                 var a = this.bj.dataSeries._inner[0].suggestedSeries;
                 if (a == 1 || a == 8) {
                     return false;
@@ -1115,134 +1115,134 @@ var CategoryChart = /** @class */ /*@__PURE__*/ (function (_super) {
         }
         return false;
     };
-    CategoryChart.prototype.get_g5 = function () {
+    CategoryChart.prototype.get_hb = function () {
         return DVContainer.instance.checkLoaded("CategoryChartToolbarFactoryManager");
     };
-    CategoryChart.prototype.vf = function (a, b, c) {
+    CategoryChart.prototype.vl = function (a, b, c) {
         var _this = this;
-        _super.prototype.vf.call(this, a, b, c);
+        _super.prototype.vl.call(this, a, b, c);
         switch (a) {
             case "ChartType":
-                this.t7();
+                this.ud();
                 break;
             case "MarkerCollisionAvoidance":
-                this.aj2(function (d) { return d.aaf = _this.agg; });
+                this.ake(function (d) { return d.aag = _this.ags; });
                 break;
             case "IsTransitionInEnabled":
-                this.aj2(function (d) { return d.zb = _this.ahb; });
+                this.ake(function (d) { return d.zc = _this.ahn; });
                 break;
             case "IsSplineShapePartOfRange":
-                this.aj2(function (d) {
+                this.ake(function (d) {
                     if (d.fy) {
-                        d.rx(_this.aha);
+                        d.ry(_this.ahm);
                     }
                 });
                 break;
             case "TransitionInMode":
-                this.aj2(function (d) { return d.yv = _this.agi; });
+                this.ake(function (d) { return d.yw = _this.agu; });
                 break;
             case "TransitionInSpeedType":
-                this.aj2(function (d) { return d.c3 = _this.ags; });
+                this.ake(function (d) { return d.c3 = _this.ag4; });
                 break;
             case "XAxisInterval":
-                this.xAxis.mt = this.aia;
+                this.xAxis.mt = this.aim;
                 break;
             case "XAxisMinorInterval":
-                this.xAxis.mu = this.aid;
+                this.xAxis.mu = this.aip;
                 break;
             case "XAxisGap":
-                this.xAxis.k2 = this.ah9;
+                this.xAxis.k2 = this.ail;
                 break;
             case "XAxisOverlap":
-                this.xAxis.lb = this.aie;
+                this.xAxis.lb = this.aiq;
                 break;
             case "XAxisMinimumGapSize":
-                this.xAxis.la = this.aic;
+                this.xAxis.la = this.aio;
                 break;
             case "XAxisMaximumGap":
-                this.xAxis.k9 = this.aib;
+                this.xAxis.k9 = this.ain;
                 break;
             case "XAxisZoomMaximumCategoryRange":
-                this.xAxis.zoomMaximumCategoryRange = this.aif;
+                this.xAxis.zoomMaximumCategoryRange = this.air;
                 break;
             case "XAxisZoomMaximumItemSpan":
-                this.xAxis.zoomMaximumItemSpan = this.aig;
+                this.xAxis.zoomMaximumItemSpan = this.ais;
                 break;
             case "XAxisZoomToCategoryRange":
-                this.xAxis.zoomToCategoryRange = this.aih;
+                this.xAxis.zoomToCategoryRange = this.ait;
                 break;
             case "XAxisZoomToCategoryStart":
-                this.xAxis.zoomToCategoryStart = this.aii;
+                this.xAxis.zoomToCategoryStart = this.aiu;
                 break;
             case "XAxisZoomToItemSpan":
-                this.xAxis.zoomToItemSpan = this.aij;
+                this.xAxis.zoomToItemSpan = this.aiv;
                 break;
             case "YAxisInterval":
-                this.yAxis.l2 = this.aim;
+                this.yAxis.l2 = this.aiy;
                 break;
             case "YAxisFavorLabellingScaleEnd":
-                this.yAxis.le = this.ahh;
+                this.yAxis.le = this.aht;
                 break;
             case "YAxisAutoRangeBufferMode":
-                this.yAxis.kv = this.agc;
+                this.yAxis.kv = this.ago;
                 break;
             case "YAxisIsLogarithmic":
-                this.yAxis.lj = this.ahi;
+                this.yAxis.lj = this.ahu;
                 break;
             case "YAxisLogarithmBase":
-                this.yAxis.ma = this.aiv;
+                this.yAxis.ma = this.ai7;
                 break;
             case "YAxisMinimumValue":
-                this.yAxis.l6 = this.aio;
+                this.yAxis.l6 = this.ai0;
                 break;
             case "YAxisMaximumValue":
-                this.yAxis.l5 = this.ain;
+                this.yAxis.l5 = this.aiz;
                 break;
             case "YAxisMinorInterval":
-                this.yAxis.l7 = this.aip;
+                this.yAxis.l7 = this.ai1;
                 break;
             case "NegativeBrushes":
             case "NegativeOutlines":
-                this.aj3(function (d, e) {
+                this.akf(function (d, e) {
                     if (d.fk) {
-                        d.rw(ArrayExtension.getModulus$1(Brush.$, _this.af7, e), ArrayExtension.getModulus$1(Brush.$, _this.af8, e));
+                        d.rx(ArrayExtension.getModulus$1(Brush.$, _this.agj, e), ArrayExtension.getModulus$1(Brush.$, _this.agk, e));
                     }
                 });
                 break;
             case "YAxisAbbreviateLargeNumbers":
-                this.aeo(function (d) { return d.lb = _this.ahf; });
+                this.ae0(function (d) { return d.lb = _this.ahr; });
                 break;
             case "IsCategoryHighlightingEnabled":
             case "IsItemHighlightingEnabled":
-                this.t7();
+                this.ud();
                 break;
             case "AutoMarginAndAngleUpdateMode":
-                this.u6(function (d) { return d.v7 = _this.aga; });
+                this.vc(function (d) { return d.v7 = _this.agm; });
                 break;
             case "ShouldAutoExpandMarginForInitialLabels":
-                this.u6(function (d) { return d.w2 = _this.ahc; });
+                this.vc(function (d) { return d.w2 = _this.aho; });
                 break;
-            case CategoryChart.ai9:
-                this.u6(function (d) { return d.w5 = _this.ahd; });
+            case CategoryChart.ajl:
+                this.vc(function (d) { return d.w5 = _this.ahp; });
                 break;
             case "AutoExpandMarginExtraPadding":
-                this.u6(function (d) { return d.xs = _this.ah1; });
+                this.vc(function (d) { return d.xs = _this.aid; });
                 break;
             case "AutoExpandMarginMaximumValue":
-                this.u6(function (d) { return d.xt = _this.ah2; });
+                this.vc(function (d) { return d.xt = _this.aie; });
                 break;
-            case CategoryChart.ajg:
-                this.aek(function (d) { return d.b1 = _this.ahe; }, a);
+            case CategoryChart.ajs:
+                this.aew(function (d) { return d.b1 = _this.ahq; }, a);
                 break;
-            case CategoryChart.aju:
-                this.aeo(function (d) { return d.b1 = _this.ahg; });
+            case CategoryChart.aj6:
+                this.ae0(function (d) { return d.b1 = _this.ahs; });
                 break;
         }
     };
     CategoryChart.$t = markType(CategoryChart, 'CategoryChart', XYChart.$);
-    CategoryChart.ai9 = "ShouldConsiderAutoRotationForInitialLabels";
-    CategoryChart.ajg = "XAxisEnhancedIntervalPreferMoreCategoryLabels";
-    CategoryChart.aju = "YAxisEnhancedIntervalPreferMoreCategoryLabels";
+    CategoryChart.ajl = "ShouldConsiderAutoRotationForInitialLabels";
+    CategoryChart.ajs = "XAxisEnhancedIntervalPreferMoreCategoryLabels";
+    CategoryChart.aj6 = "YAxisEnhancedIntervalPreferMoreCategoryLabels";
     return CategoryChart;
 }(XYChart));
 export { CategoryChart };