igniteui-webcomponents-charts 4.3.0-beta.0 → 4.3.0-beta.2

package/esm5/lib/CategoryChart.js

@@ -38,173 +38,173 @@ var CategoryChart = /** @class */ /*@__PURE__*/ (function (_super) {
     __extends(CategoryChart, _super);
     function CategoryChart() {
         var _this = _super.call(this) || this;
-        _this.aff = 1000;
-        _this.adk = null;
-        _this.ac4 = 9;
-        _this.ac6 = 1;
-        _this.ado = false;
-        _this.adp = true;
-        _this.ac8 = 0;
-        _this.adi = 0;
-        _this.aec = 0;
-        _this.aef = 0;
-        _this.aeb = 0;
-        _this.aee = 0;
-        _this.aed = 1;
+        _this.afj = 1000;
+        _this.ado = null;
+        _this.ac8 = 9;
+        _this.ada = 1;
+        _this.ads = false;
+        _this.adt = true;
+        _this.adc = 0;
+        _this.adm = 0;
         _this.aeg = 0;
-        _this.aem = NaN;
-        _this.ac0 = 1;
-        _this.adq = true;
-        _this.adr = true;
-        _this.ad9 = DeviceUtils.g(2);
-        _this.aea = DeviceUtils.g(60);
+        _this.aej = 0;
+        _this.aef = 0;
+        _this.aei = 0;
+        _this.aeh = 1;
+        _this.aek = 0;
+        _this.aeq = NaN;
+        _this.ac4 = 1;
+        _this.adu = true;
         _this.adv = true;
-        _this.ads = true;
-        _this.adu = false;
-        _this.ac2 = 0;
-        _this.adw = false;
-        _this.afg = 10;
-        _this.aeo = NaN;
+        _this.aed = DeviceUtils.g(2);
+        _this.aee = DeviceUtils.g(60);
+        _this.adz = true;
+        _this.adw = true;
+        _this.ady = false;
+        _this.ac6 = 0;
+        _this.ad0 = false;
+        _this.afk = 10;
+        _this.aes = NaN;
+        _this.aer = NaN;
+        _this.aet = 0;
+        _this.ac0 = null;
+        _this.ac1 = null;
+        _this.adx = true;
+        _this.ael = 3;
+        _this.aem = NaN;
         _this.aen = NaN;
-        _this.aep = 0;
-        _this.acw = null;
-        _this.acx = null;
-        _this.adt = true;
-        _this.aeh = 3;
-        _this.aei = NaN;
-        _this.aej = NaN;
-        _this.aek = NaN;
-        _this.ael = NaN;
-        _this.adm = false;
-        _this.adn = false;
-        _this.ad8 = null;
+        _this.aeo = NaN;
+        _this.aep = NaN;
+        _this.adq = false;
+        _this.adr = false;
+        _this.aec = null;
         DVContainer.instance.registerIfLoaded("CategoryChartToolbarFactoryManager");
-        _this.rn();
+        _this.rr();
         return _this;
     }
-    CategoryChart.prototype.r5 = function () {
-        _super.prototype.r5.call(this);
+    CategoryChart.prototype.r9 = function () {
+        _super.prototype.r9.call(this);
         if (this.dataChart == null) {
             return;
         }
         var a = this.dataChart.cu.j.e();
-        this.acy = a.d;
-        this.acz = a.e;
-        if (this.ab8 == null) {
-            this.ab8 = a.k;
+        this.ac2 = a.d;
+        this.ac3 = a.e;
+        if (this.acc == null) {
+            this.acc = a.k;
         }
-        if (this.acf == null) {
-            this.acf = a.k;
+        if (this.acj == null) {
+            this.acj = a.k;
         }
-        this.x7 = 0;
-        this.acg = AxisDefaults.h;
-        this.acj = null;
-        this.acc = AxisDefaults.g;
-        this.ab9 = null;
-        this.xq = AxisDefaults.f;
-        this.acd = AxisDefaults.j;
-        this.xr = AxisDefaults.e;
-        this.fj = true;
-        this.fk = true;
+        this.yb = 0;
+        this.ack = AxisDefaults.h;
+        this.acn = null;
+        this.acg = AxisDefaults.g;
+        this.acd = null;
+        this.xu = AxisDefaults.f;
+        this.ach = AxisDefaults.j;
+        this.xv = AxisDefaults.e;
+        this.fm = true;
+        this.fn = true;
         this.a9 = 0;
-        this.h6 = Defaults.j;
-        this.uk = Defaults.ae;
-        this.uf = Defaults.af;
-        this.ug = Defaults.ag;
-        this.ad0 = true;
+        this.h9 = Defaults.j;
+        this.uo = Defaults.ae;
+        this.uj = Defaults.af;
+        this.uk = Defaults.ag;
+        this.ad4 = true;
     };
-    CategoryChart.prototype.r7 = function (a, b) {
-        _super.prototype.r7.call(this, a, b);
-        a.hs = this.afh;
-        a.ch = this.adl;
+    CategoryChart.prototype.sb = function (a, b) {
+        _super.prototype.sb.call(this, a, b);
+        a.hs = this.afl;
+        a.ch = this.adp;
     };
-    CategoryChart.prototype.su = function (a, b, c) {
+    CategoryChart.prototype.sy = function (a, b, c) {
         var _this = this;
-        _super.prototype.su.call(this, a, b, c);
+        _super.prototype.sy.call(this, a, b, c);
         switch (a) {
             case "TransitionInDuration":
-                this.ru(function (d) { return d.hs = _this.afh; });
+                this.ry(function (d) { return d.hs = _this.afl; });
                 break;
             case "TransitionInEasingFunction":
-                this.ru(function (d) { return d.ch = _this.adl; });
+                this.ry(function (d) { return d.ch = _this.adp; });
                 break;
         }
     };
-    Object.defineProperty(CategoryChart.prototype, "afh", {
+    Object.defineProperty(CategoryChart.prototype, "afl", {
         get: function () {
-            return this.aff;
+            return this.afj;
         },
         set: function (a) {
-            var b = this.afh;
+            var b = this.afl;
             if (a != b) {
-                this.aff = a;
-                this.sr("TransitionInDuration", b, this.afh);
+                this.afj = a;
+                this.sv("TransitionInDuration", b, this.afl);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "adl", {
+    Object.defineProperty(CategoryChart.prototype, "adp", {
         get: function () {
-            return this.adk;
+            return this.ado;
         },
         set: function (a) {
-            var b = this.adl;
+            var b = this.adp;
             if (a != b) {
-                this.adk = a;
-                this.sr("TransitionInEasingFunction", b, this.adl);
+                this.ado = a;
+                this.sv("TransitionInEasingFunction", b, this.adp);
             }
         },
         enumerable: false,
         configurable: true
     });
-    CategoryChart.prototype.afn = function () {
-        var cvd_ = this.j6();
+    CategoryChart.prototype.afr = function () {
+        var cvd_ = this.j9();
         cvd_.scaleByViewport();
         return (cvd_.serialize());
     };
-    CategoryChart.prototype.r0 = function (a) {
-        _super.prototype.r0.call(this, a);
-        a.ds = this.ff;
-        a.ur = this.ad1;
-        a.uu = this.ad2;
-        a.vh = this.aeq;
-        a.vi = this.aer;
-        a.tw = this.ac1;
+    CategoryChart.prototype.r4 = function (a) {
+        _super.prototype.r4.call(this, a);
+        a.ds = this.fh;
+        a.ur = this.ad5;
+        a.uu = this.ad6;
+        a.vh = this.aeu;
+        a.vi = this.aev;
+        a.tw = this.ac5;
     };
-    CategoryChart.prototype.r6 = function (a, b) {
-        _super.prototype.r6.call(this, a, b);
+    CategoryChart.prototype.sa = function (a, b) {
+        _super.prototype.sa.call(this, a, b);
         var c = typeCast(HorizontalAnchoredCategorySeries.$, a);
         if (c == null) {
             return;
         }
-        c.tr = this.ac7;
-        c.so = this.ad0;
-        c.r8 = this.ac9;
-        c.cb = this.adj;
+        c.tr = this.adb;
+        c.so = this.ad4;
+        c.r8 = this.add;
+        c.cb = this.adn;
         c.trendLineBrush = ArrayExtension.getModulus$1(Brush.$, this.ah, b);
-        c.trendLineType = this.dp;
-        c.trendLineThickness = this.i4;
+        c.trendLineType = this.dq;
+        c.trendLineThickness = this.i7;
         c.ql = this.cr(a, b);
         if (a.d6) {
-            a.ms(ArrayExtension.getModulus$1(Brush.$, this.acy, b), ArrayExtension.getModulus$1(Brush.$, this.acz, b));
+            a.ms(ArrayExtension.getModulus$1(Brush.$, this.ac2, b), ArrayExtension.getModulus$1(Brush.$, this.ac3, b));
         }
     };
-    CategoryChart.prototype.ada = function () {
+    CategoryChart.prototype.ade = function () {
         return new CategoryXAxis();
     };
-    CategoryChart.prototype.ade = function () {
+    CategoryChart.prototype.adi = function () {
         return new NumericYAxis();
     };
-    CategoryChart.prototype.rj = function () {
-        this.xAxis = this.ada();
+    CategoryChart.prototype.rn = function () {
+        this.xAxis = this.ade();
         this.xAxis.name = "xAxis";
         var a = this.xAxis;
-        a.propertyChanged = delegateCombine(a.propertyChanged, runOn(this, this.agp));
-        this.yAxis = this.ade();
+        a.propertyChanged = delegateCombine(a.propertyChanged, runOn(this, this.agt));
+        this.yAxis = this.adi();
         this.yAxis.name = "yAxis";
         var b = this.yAxis;
-        b.propertyChanged = delegateCombine(b.propertyChanged, runOn(this, this.agq));
+        b.propertyChanged = delegateCombine(b.propertyChanged, runOn(this, this.agu));
         if (this.xAxis.ay == null) {
             this.xAxis.ay = new AxisLabelSettings();
         }
@@ -212,20 +212,20 @@ var CategoryChart = /** @class */ /*@__PURE__*/ (function (_super) {
             this.yAxis.ay = new AxisLabelSettings();
         }
     };
-    CategoryChart.prototype.aa8 = function (a) {
-        _super.prototype.aa8.call(this, a);
-        a.k9 = this.ad4;
-        a.lc = this.ad6;
-        a.b0 = this.ad5;
+    CategoryChart.prototype.abc = function (a) {
+        _super.prototype.abc.call(this, a);
+        a.k9 = this.ad8;
+        a.lc = this.aea;
+        a.b0 = this.ad9;
     };
-    CategoryChart.prototype.aa6 = function (a) {
-        _super.prototype.aa6.call(this, a);
-        a.b0 = this.ad3;
-        a.zoomMaximumCategoryRange = this.ae4;
-        a.zoomToCategoryRange = this.ae6;
-        a.zoomToCategoryStart = this.ae7;
-        a.zoomMaximumItemSpan = this.ae5;
-        a.zoomToItemSpan = this.ae8;
+    CategoryChart.prototype.aba = function (a) {
+        _super.prototype.aba.call(this, a);
+        a.b0 = this.ad7;
+        a.zoomMaximumCategoryRange = this.ae8;
+        a.zoomToCategoryRange = this.afa;
+        a.zoomToCategoryStart = this.afb;
+        a.zoomMaximumItemSpan = this.ae9;
+        a.zoomToItemSpan = this.afc;
     };
     CategoryChart.prototype.get_b1 = function () {
         return 0;
@@ -237,570 +237,570 @@ var CategoryChart = /** @class */ /*@__PURE__*/ (function (_super) {
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ac5", {
+    Object.defineProperty(CategoryChart.prototype, "ac9", {
         get: function () {
-            return this.ac4;
+            return this.ac8;
         },
         set: function (a) {
-            if (a != this.ac4) {
-                var b = this.ac5;
-                this.ac4 = a;
-                this.sr("ChartType", enumGetBox(CategoryChartType_$type, b), enumGetBox(CategoryChartType_$type, this.ac5));
+            if (a != this.ac8) {
+                var b = this.ac9;
+                this.ac8 = a;
+                this.sv("ChartType", enumGetBox(CategoryChartType_$type, b), enumGetBox(CategoryChartType_$type, this.ac9));
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ac7", {
+    Object.defineProperty(CategoryChart.prototype, "adb", {
         get: function () {
-            return this.ac6;
+            return this.ada;
         },
         set: function (a) {
-            var b = this.ac7;
+            var b = this.adb;
             if (a != b) {
-                this.ac6 = a;
-                this.sr("MarkerCollisionAvoidance", enumGetBox(CategorySeriesMarkerCollisionAvoidance_$type, b), enumGetBox(CategorySeriesMarkerCollisionAvoidance_$type, this.ac7));
+                this.ada = a;
+                this.sv("MarkerCollisionAvoidance", enumGetBox(CategorySeriesMarkerCollisionAvoidance_$type, b), enumGetBox(CategorySeriesMarkerCollisionAvoidance_$type, this.adb));
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "adz", {
+    Object.defineProperty(CategoryChart.prototype, "ad3", {
         get: function () {
-            return this.ado;
+            return this.ads;
         },
         set: function (a) {
-            var b = this.adz;
+            var b = this.ad3;
             if (a != b) {
-                this.ado = a;
-                this.sr("IsSplineShapePartOfRange", b, this.adz);
+                this.ads = a;
+                this.sv("IsSplineShapePartOfRange", b, this.ad3);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ad0", {
+    Object.defineProperty(CategoryChart.prototype, "ad4", {
         get: function () {
-            return this.adp;
+            return this.adt;
         },
         set: function (a) {
-            var b = this.ad0;
+            var b = this.ad4;
             if (a != b) {
-                this.adp = a;
-                this.sr("IsTransitionInEnabled", b, this.ad0);
+                this.adt = a;
+                this.sv("IsTransitionInEnabled", b, this.ad4);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ac9", {
+    Object.defineProperty(CategoryChart.prototype, "add", {
         get: function () {
-            return this.ac8;
+            return this.adc;
         },
         set: function (a) {
-            var b = this.ac9;
+            var b = this.add;
             if (a != b) {
-                this.ac8 = a;
-                this.sr("TransitionInMode", enumGetBox(CategoryTransitionInMode_$type, b), enumGetBox(CategoryTransitionInMode_$type, this.ac9));
+                this.adc = a;
+                this.sv("TransitionInMode", enumGetBox(CategoryTransitionInMode_$type, b), enumGetBox(CategoryTransitionInMode_$type, this.add));
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "adj", {
+    Object.defineProperty(CategoryChart.prototype, "adn", {
         get: function () {
-            return this.adi;
+            return this.adm;
         },
         set: function (a) {
-            var b = this.adj;
+            var b = this.adn;
             if (a != b) {
-                this.adi = a;
-                this.sr("TransitionInSpeedType", enumGetBox(TransitionInSpeedType_$type, b), enumGetBox(TransitionInSpeedType_$type, this.adj));
+                this.adm = a;
+                this.sv("TransitionInSpeedType", enumGetBox(TransitionInSpeedType_$type, b), enumGetBox(TransitionInSpeedType_$type, this.adn));
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aez", {
+    Object.defineProperty(CategoryChart.prototype, "ae3", {
         get: function () {
-            return this.aec;
+            return this.aeg;
         },
         set: function (a) {
-            var b = this.aez;
+            var b = this.ae3;
             if (a != b) {
-                this.aec = a;
-                this.sr("XAxisInterval", b, this.aez);
+                this.aeg = a;
+                this.sv("XAxisInterval", b, this.ae3);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ae2", {
+    Object.defineProperty(CategoryChart.prototype, "ae6", {
         get: function () {
-            return this.aef;
+            return this.aej;
         },
         set: function (a) {
-            var b = this.ae2;
+            var b = this.ae6;
             if (a != b) {
-                this.aef = a;
-                this.sr("XAxisMinorInterval", b, this.ae2);
+                this.aej = a;
+                this.sv("XAxisMinorInterval", b, this.ae6);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aey", {
+    Object.defineProperty(CategoryChart.prototype, "ae2", {
         get: function () {
-            return this.aeb;
+            return this.aef;
         },
         set: function (a) {
-            var b = this.aey;
+            var b = this.ae2;
             if (a != b) {
-                this.aeb = a;
-                this.sr("XAxisGap", b, this.aey);
+                this.aef = a;
+                this.sv("XAxisGap", b, this.ae2);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ae1", {
+    Object.defineProperty(CategoryChart.prototype, "ae5", {
         get: function () {
-            return this.aee;
+            return this.aei;
         },
         set: function (a) {
-            var b = this.ae1;
+            var b = this.ae5;
             if (a != b) {
-                this.aee = a;
-                this.sr("XAxisMinimumGapSize", b, this.ae1);
+                this.aei = a;
+                this.sv("XAxisMinimumGapSize", b, this.ae5);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ae0", {
+    Object.defineProperty(CategoryChart.prototype, "ae4", {
         get: function () {
-            return this.aed;
+            return this.aeh;
         },
         set: function (a) {
-            var b = this.ae0;
+            var b = this.ae4;
             if (a != b) {
-                this.aed = a;
-                this.sr("XAxisMaximumGap", b, this.ae0);
+                this.aeh = a;
+                this.sv("XAxisMaximumGap", b, this.ae4);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ae3", {
+    Object.defineProperty(CategoryChart.prototype, "ae7", {
         get: function () {
-            return this.aeg;
+            return this.aek;
         },
         set: function (a) {
-            var b = this.ae3;
+            var b = this.ae7;
             if (a != b) {
-                this.aeg = a;
-                this.sr("XAxisOverlap", b, this.ae3);
+                this.aek = a;
+                this.sv("XAxisOverlap", b, this.ae7);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "afb", {
+    Object.defineProperty(CategoryChart.prototype, "aff", {
         get: function () {
-            return this.aem;
+            return this.aeq;
         },
         set: function (a) {
-            var b = this.afb;
+            var b = this.aff;
             if (a != b) {
-                this.aem = a;
-                this.sr("YAxisInterval", b, this.afb);
+                this.aeq = a;
+                this.sv("YAxisInterval", b, this.aff);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ac1", {
+    Object.defineProperty(CategoryChart.prototype, "ac5", {
         get: function () {
-            return this.ac0;
+            return this.ac4;
         },
         set: function (a) {
-            var b = this.ac1;
+            var b = this.ac5;
             if (a != b) {
-                this.ac0 = a;
-                this.sr("AutoMarginAndAngleUpdateMode", enumGetBox(AutoMarginsAndAngleUpdateMode_$type, b), enumGetBox(AutoMarginsAndAngleUpdateMode_$type, this.ac1));
+                this.ac4 = a;
+                this.sv("AutoMarginAndAngleUpdateMode", enumGetBox(AutoMarginsAndAngleUpdateMode_$type, b), enumGetBox(AutoMarginsAndAngleUpdateMode_$type, this.ac5));
             }
         },
         enumerable: false,
         configurable: true
     });
-    CategoryChart.prototype.agr = function () {
+    CategoryChart.prototype.agv = function () {
         if (this.dataChart != null) {
             this.dataChart.w2();
         }
     };
-    Object.defineProperty(CategoryChart.prototype, "ad1", {
+    Object.defineProperty(CategoryChart.prototype, "ad5", {
         get: function () {
-            return this.adq;
+            return this.adu;
         },
         set: function (a) {
-            var b = this.ad1;
+            var b = this.ad5;
             if (a != b) {
-                this.adq = a;
-                this.sr("ShouldAutoExpandMarginForInitialLabels", b, this.ad1);
+                this.adu = a;
+                this.sv("ShouldAutoExpandMarginForInitialLabels", b, this.ad5);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ad2", {
+    Object.defineProperty(CategoryChart.prototype, "ad6", {
         get: function () {
-            return this.adr;
+            return this.adv;
         },
         set: function (a) {
-            var b = this.ad2;
+            var b = this.ad6;
             if (a != b) {
-                this.adr = a;
-                this.sr(CategoryChart.afw, b, this.ad2);
+                this.adv = a;
+                this.sv(CategoryChart.af0, b, this.ad6);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aeq", {
+    Object.defineProperty(CategoryChart.prototype, "aeu", {
         get: function () {
-            return this.ad9;
+            return this.aed;
         },
         set: function (a) {
-            var b = this.aeq;
+            var b = this.aeu;
             if (a != b) {
-                this.ad9 = a;
-                this.sr("AutoExpandMarginExtraPadding", b, this.aeq);
+                this.aed = a;
+                this.sv("AutoExpandMarginExtraPadding", b, this.aeu);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aer", {
+    Object.defineProperty(CategoryChart.prototype, "aev", {
         get: function () {
-            return this.aea;
+            return this.aee;
         },
         set: function (a) {
-            var b = this.aer;
+            var b = this.aev;
             if (a != b) {
-                this.aea = a;
-                this.sr("AutoExpandMarginMaximumValue", b, this.aer);
+                this.aee = a;
+                this.sv("AutoExpandMarginMaximumValue", b, this.aev);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ad6", {
+    Object.defineProperty(CategoryChart.prototype, "aea", {
         get: function () {
-            return this.adv;
+            return this.adz;
         },
         set: function (a) {
-            var b = this.ad6;
+            var b = this.aea;
             if (a != b) {
-                this.adv = a;
-                this.sr("YAxisFavorLabellingScaleEnd", b, this.ad6);
+                this.adz = a;
+                this.sv("YAxisFavorLabellingScaleEnd", b, this.aea);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ad3", {
+    Object.defineProperty(CategoryChart.prototype, "ad7", {
         get: function () {
-            return this.ads;
+            return this.adw;
         },
         set: function (a) {
-            var b = this.ad3;
+            var b = this.ad7;
             if (a != b) {
-                this.ads = a;
-                this.sr(CategoryChart.af1, b, this.ad3);
+                this.adw = a;
+                this.sv(CategoryChart.af5, b, this.ad7);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ad5", {
+    Object.defineProperty(CategoryChart.prototype, "ad9", {
         get: function () {
-            return this.adu;
+            return this.ady;
         },
         set: function (a) {
-            var b = this.ad5;
+            var b = this.ad9;
             if (a != b) {
-                this.adu = a;
-                this.sr(CategoryChart.agf, b, this.ad5);
+                this.ady = a;
+                this.sv(CategoryChart.agj, b, this.ad9);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ac3", {
+    Object.defineProperty(CategoryChart.prototype, "ac7", {
         get: function () {
-            return this.ac2;
+            return this.ac6;
         },
         set: function (a) {
-            var b = this.ac3;
+            var b = this.ac7;
             if (a != b) {
-                this.ac2 = a;
-                this.sr("YAxisAutoRangeBufferMode", enumGetBox(AxisRangeBufferMode_$type, b), enumGetBox(AxisRangeBufferMode_$type, this.ac3));
+                this.ac6 = a;
+                this.sv("YAxisAutoRangeBufferMode", enumGetBox(AxisRangeBufferMode_$type, b), enumGetBox(AxisRangeBufferMode_$type, this.ac7));
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ad7", {
+    Object.defineProperty(CategoryChart.prototype, "aeb", {
         get: function () {
-            return this.adw;
+            return this.ad0;
         },
         set: function (a) {
-            var b = this.ad7;
+            var b = this.aeb;
             if (a != b) {
-                this.adw = a;
-                this.sr("YAxisIsLogarithmic", b, this.ad7);
+                this.ad0 = a;
+                this.sv("YAxisIsLogarithmic", b, this.aeb);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "afi", {
+    Object.defineProperty(CategoryChart.prototype, "afm", {
         get: function () {
-            return this.afg;
+            return this.afk;
         },
         set: function (a) {
-            var b = this.afi;
+            var b = this.afm;
             if (a != b) {
-                this.afg = a;
-                this.sr("YAxisLogarithmBase", b, this.afi);
+                this.afk = a;
+                this.sv("YAxisLogarithmBase", b, this.afm);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "afd", {
+    Object.defineProperty(CategoryChart.prototype, "afh", {
         get: function () {
-            return this.aeo;
+            return this.aes;
         },
         set: function (a) {
-            var b = this.afd;
+            var b = this.afh;
             if (a != b) {
-                this.aeo = a;
-                this.sr("YAxisMinimumValue", b, this.afd);
+                this.aes = a;
+                this.sv("YAxisMinimumValue", b, this.afh);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "afc", {
+    Object.defineProperty(CategoryChart.prototype, "afg", {
         get: function () {
-            return this.aen;
+            return this.aer;
         },
         set: function (a) {
-            var b = this.afc;
+            var b = this.afg;
             if (a != b) {
-                this.aen = a;
-                this.sr("YAxisMaximumValue", b, this.afc);
+                this.aer = a;
+                this.sv("YAxisMaximumValue", b, this.afg);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "afe", {
+    Object.defineProperty(CategoryChart.prototype, "afi", {
         get: function () {
-            return this.aep;
+            return this.aet;
         },
         set: function (a) {
-            var b = this.afe;
+            var b = this.afi;
             if (a != b) {
-                this.aep = a;
-                this.sr("YAxisMinorInterval", b, this.afe);
+                this.aet = a;
+                this.sv("YAxisMinorInterval", b, this.afi);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aex", {
+    Object.defineProperty(CategoryChart.prototype, "ae1", {
         get: function () {
             return this.xAxis.mv;
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aew", {
+    Object.defineProperty(CategoryChart.prototype, "ae0", {
         get: function () {
             return this.xAxis.mu;
         },
         enumerable: false,
         configurable: true
     });
-    CategoryChart.prototype.aet = function () {
-        return this.aex;
+    CategoryChart.prototype.aex = function () {
+        return this.ae1;
     };
-    CategoryChart.prototype.aev = function () {
-        return this.afa;
+    CategoryChart.prototype.aez = function () {
+        return this.afe;
     };
-    CategoryChart.prototype.aes = function () {
-        return this.aew;
+    CategoryChart.prototype.aew = function () {
+        return this.ae0;
     };
-    CategoryChart.prototype.aeu = function () {
-        return this.ae9;
+    CategoryChart.prototype.aey = function () {
+        return this.afd;
     };
-    Object.defineProperty(CategoryChart.prototype, "afa", {
+    Object.defineProperty(CategoryChart.prototype, "afe", {
         get: function () {
             return this.yAxis.lw;
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ae9", {
+    Object.defineProperty(CategoryChart.prototype, "afd", {
         get: function () {
             return this.yAxis.lv;
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "acy", {
+    Object.defineProperty(CategoryChart.prototype, "ac2", {
         get: function () {
-            return this.acw;
+            return this.ac0;
         },
         set: function (a) {
-            var b = this.acy;
+            var b = this.ac2;
             if (a != b) {
-                this.acw = a;
-                this.sr("NegativeBrushes", b, this.acy);
+                this.ac0 = a;
+                this.sv("NegativeBrushes", b, this.ac2);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "acz", {
+    Object.defineProperty(CategoryChart.prototype, "ac3", {
         get: function () {
-            return this.acx;
+            return this.ac1;
         },
         set: function (a) {
-            var b = this.acz;
+            var b = this.ac3;
             if (a != b) {
-                this.acx = a;
-                this.sr("NegativeOutlines", b, this.acz);
+                this.ac1 = a;
+                this.sv("NegativeOutlines", b, this.ac3);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ad4", {
+    Object.defineProperty(CategoryChart.prototype, "ad8", {
         get: function () {
-            return this.adt;
+            return this.adx;
         },
         set: function (a) {
-            var b = this.ad4;
+            var b = this.ad8;
             if (a != b) {
-                this.adt = a;
-                this.sr("YAxisAbbreviateLargeNumbers", b, this.ad4);
+                this.adx = a;
+                this.sv("YAxisAbbreviateLargeNumbers", b, this.ad8);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ae4", {
+    Object.defineProperty(CategoryChart.prototype, "ae8", {
         get: function () {
-            return this.aeh;
+            return this.ael;
         },
         set: function (a) {
-            var b = this.ae4;
+            var b = this.ae8;
             if (a != b) {
-                this.aeh = a;
-                this.sr("XAxisZoomMaximumCategoryRange", b, this.ae4);
+                this.ael = a;
+                this.sv("XAxisZoomMaximumCategoryRange", b, this.ae8);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ae5", {
+    Object.defineProperty(CategoryChart.prototype, "ae9", {
         get: function () {
-            return this.aei;
+            return this.aem;
         },
         set: function (a) {
-            var b = this.ae5;
+            var b = this.ae9;
             if (a != b) {
-                this.aei = a;
-                this.sr("XAxisZoomMaximumItemSpan", b, this.ae5);
+                this.aem = a;
+                this.sv("XAxisZoomMaximumItemSpan", b, this.ae9);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ae6", {
+    Object.defineProperty(CategoryChart.prototype, "afa", {
         get: function () {
-            return this.aej;
+            return this.aen;
         },
         set: function (a) {
-            var b = this.ae6;
+            var b = this.afa;
             if (a != b) {
-                this.aej = a;
-                this.sr("XAxisZoomToCategoryRange", b, this.ae6);
+                this.aen = a;
+                this.sv("XAxisZoomToCategoryRange", b, this.afa);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ae7", {
+    Object.defineProperty(CategoryChart.prototype, "afb", {
         get: function () {
-            return this.aek;
+            return this.aeo;
         },
         set: function (a) {
-            var b = this.ae7;
+            var b = this.afb;
             if (a != b) {
-                this.aek = a;
-                this.sr("XAxisZoomToCategoryStart", b, this.ae7);
+                this.aeo = a;
+                this.sv("XAxisZoomToCategoryStart", b, this.afb);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ae8", {
+    Object.defineProperty(CategoryChart.prototype, "afc", {
         get: function () {
-            return this.ael;
+            return this.aep;
         },
         set: function (a) {
-            var b = this.ae8;
+            var b = this.afc;
             if (a != b) {
-                this.ael = a;
-                this.sr("XAxisZoomToItemSpan", b, this.ae8);
+                this.aep = a;
+                this.sv("XAxisZoomToItemSpan", b, this.afc);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "adx", {
+    Object.defineProperty(CategoryChart.prototype, "ad1", {
         get: function () {
-            return this.adm;
+            return this.adq;
         },
         set: function (a) {
-            var b = this.adx;
+            var b = this.ad1;
             if (a != b) {
-                this.adm = a;
-                this.sr("IsCategoryHighlightingEnabled", b, this.adx);
+                this.adq = a;
+                this.sv("IsCategoryHighlightingEnabled", b, this.ad1);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ady", {
+    Object.defineProperty(CategoryChart.prototype, "ad2", {
         get: function () {
-            return this.adn;
+            return this.adr;
         },
         set: function (a) {
-            var b = this.ady;
+            var b = this.ad2;
             if (a != b) {
-                this.adn = a;
-                this.sr("IsItemHighlightingEnabled", b, this.ady);
+                this.adr = a;
+                this.sv("IsItemHighlightingEnabled", b, this.ad2);
             }
         },
         enumerable: false,
         configurable: true
     });
-    CategoryChart.prototype.get_go = function () {
+    CategoryChart.prototype.get_gr = function () {
         var a = new List$1(DataSeriesType_$type, 0);
         if (TypeRegistrar.isRegistered("AreaSeries")) {
             a.add(2);
@@ -831,59 +831,70 @@ var CategoryChart = /** @class */ /*@__PURE__*/ (function (_super) {
         }
         return a;
     };
-    Object.defineProperty(CategoryChart.prototype, "go", {
+    Object.defineProperty(CategoryChart.prototype, "gr", {
         get: function () {
-            return this.get_go();
+            return this.get_gr();
         },
         enumerable: false,
         configurable: true
     });
-    CategoryChart.prototype.gs = function () {
-        if (this.ad8 == null) {
-            this.ad8 = CategoryChartMockDataGenerator.a();
+    CategoryChart.prototype.gv = function () {
+        if (this.aec == null) {
+            this.aec = CategoryChartMockDataGenerator.a();
         }
-        return this.ad8;
+        return this.aec;
     };
     CategoryChart.prototype.cq = function (a) {
         if (a != null) {
             var b = _super.prototype.cq.call(this, a);
             if (b == 2) {
-                if (a.d5 && this.fu) {
+                if (a.d5 && this.fx) {
                     return 13;
                 }
             }
         }
         return _super.prototype.cq.call(this, a);
     };
-    CategoryChart.prototype.get_gb = function () {
+    CategoryChart.prototype.cs = function (a) {
+        if (a != null) {
+            var b = _super.prototype.cq.call(this, a);
+            if (b == 2) {
+                if (a.d5 && this.fx) {
+                    return 13;
+                }
+            }
+        }
+        return _super.prototype.cs.call(this, a);
+    };
+    CategoryChart.prototype.get_ge = function () {
         return this.xAxis != null && this.xAxis.categoryMode != 0;
     };
-    CategoryChart.prototype.agp = function (a, b) {
+    CategoryChart.prototype.agt = function (a, b) {
         switch (b.propertyName) {
             case "ActualMinimum":
-                this.s1("XAxisActualMinimum");
+                this.s5("XAxisActualMinimum");
                 break;
             case "ActualMaximum":
-                this.s1("XAxisActualMaximum");
+                this.s5("XAxisActualMaximum");
                 break;
         }
     };
-    CategoryChart.prototype.agq = function (a, b) {
+    CategoryChart.prototype.agu = function (a, b) {
         switch (b.propertyName) {
             case "ActualMinimumValue":
-                this.s1("YAxisActualMinimum");
+                this.s5("YAxisActualMinimum");
                 break;
             case "ActualMaximumValue":
-                this.s1("YAxisActualMaximum");
+                this.s5("YAxisActualMaximum");
                 break;
         }
     };
-    CategoryChart.prototype.td = function () {
-        _super.prototype.td.call(this);
-        this.xAxis.fz = this.yh == null ? XYChart.yt(this.xAxis, this.bd.dataSeries) : this.yh;
+    CategoryChart.prototype.th = function () {
+        _super.prototype.th.call(this);
+        this.xAxis.fz = this.yl == null ? XYChart.yx(this.xAxis, this.bd.dataSeries) : this.yl;
         this.xAxis.itemsSource = this.dataChart != null && this.dataChart.series.count > 0 ? this.dataChart.series._inner[0].itemsSource : null;
-        if (this.ad1) {
-            this.sj(function (a) { return a.w2(); });
+        if (this.ad5) {
+            this.sn(function (a) { return a.w2(); });
         }
     };
     Object.defineProperty(CategoryChart.prototype, "xAxis", {
@@ -906,26 +917,26 @@ var CategoryChart = /** @class */ /*@__PURE__*/ (function (_super) {
         enumerable: false,
         configurable: true
     });
-    CategoryChart.prototype.add = function (a, b) {
+    CategoryChart.prototype.adh = function (a, b) {
         switch (a) {
-            case 2: return this.c2(1);
-            case 3: return this.c2(10);
-            case 0: return this.c2(0);
-            case 1: return this.c2(2);
-            case 6: return this.c2(6);
-            case 7: return this.c2(7);
-            case 4: return this.c2(4);
-            case 5: return this.c2(5);
-            case 8: return this.c2(8);
-            case 9: return this.adc(b);
-            default: return this.c2(1);
+            case 2: return this.c3(1);
+            case 3: return this.c3(10);
+            case 0: return this.c3(0);
+            case 1: return this.c3(2);
+            case 6: return this.c3(6);
+            case 7: return this.c3(7);
+            case 4: return this.c3(4);
+            case 5: return this.c3(5);
+            case 8: return this.c3(8);
+            case 9: return this.adg(b);
+            default: return this.c3(1);
         }
     };
-    CategoryChart.prototype.adc = function (a) {
-        return this.c2(a);
+    CategoryChart.prototype.adg = function (a) {
+        return this.c3(a);
     };
     CategoryChart.prototype.bc = function (a) {
-        switch (this.ac5) {
+        switch (this.ac9) {
             case 1: return 2;
             case 0: return 0;
             case 3: return 10;
@@ -939,24 +950,24 @@ var CategoryChart = /** @class */ /*@__PURE__*/ (function (_super) {
             case 2: return 1;
         }
     };
-    CategoryChart.prototype.c0 = function (a, b) {
-        var c = this.add(this.ac5, a.suggestedSeries);
+    CategoryChart.prototype.c1 = function (a, b) {
+        var c = this.adh(this.ac9, a.suggestedSeries);
         c.uc = a.findMatchingHint(0).path;
         c.xAxis = this.xAxis;
         c.yAxis = this.yAxis;
         return c;
     };
-    CategoryChart.prototype.tb = function (a) {
+    CategoryChart.prototype.tf = function (a) {
         if (a.suggestedSecondaryAxis == 2) {
             this.yAxis.lh = true;
             this.yAxis.l8 = 10;
         }
     };
-    CategoryChart.prototype.te = function () {
-        this.yAxis.lh = this.ad7;
-        this.yAxis.l8 = this.afi;
+    CategoryChart.prototype.ti = function () {
+        this.yAxis.lh = this.aeb;
+        this.yAxis.l8 = this.afm;
     };
-    CategoryChart.prototype.get_gn = function () {
+    CategoryChart.prototype.get_gq = function () {
         return ((function () {
             var $ret = new List$1(IDataSeriesAdapterRule_$type, 0);
             $ret.add(new SimpleCategorySeriesRule());
@@ -964,24 +975,24 @@ var CategoryChart = /** @class */ /*@__PURE__*/ (function (_super) {
             return $ret;
         })());
     };
-    Object.defineProperty(CategoryChart.prototype, "gn", {
+    Object.defineProperty(CategoryChart.prototype, "gq", {
         get: function () {
-            return this.get_gn();
+            return this.get_gq();
         },
         enumerable: false,
         configurable: true
     });
-    CategoryChart.prototype.rf = function (a, b) {
+    CategoryChart.prototype.rj = function (a, b) {
         var c = typeCast(HorizontalAnchoredCategorySeries.$, a);
         if (c != null) {
-            c.tr = this.ac7;
+            c.tr = this.adb;
             c.ql = this.cr(a, b);
         }
     };
-    CategoryChart.prototype.agn = function (a) {
-        this.ago(function (b, c) { return a(b); });
+    CategoryChart.prototype.agr = function (a) {
+        this.ags(function (b, c) { return a(b); });
     };
-    CategoryChart.prototype.ago = function (a) {
+    CategoryChart.prototype.ags = function (a) {
         if (this.dataChart == null) {
             return;
         }
@@ -993,27 +1004,27 @@ var CategoryChart = /** @class */ /*@__PURE__*/ (function (_super) {
             a(c, b);
         }
     };
-    CategoryChart.prototype.vz = function () {
+    CategoryChart.prototype.v3 = function () {
         return this.xAxis;
     };
-    CategoryChart.prototype.v0 = function () {
+    CategoryChart.prototype.v4 = function () {
         return this.yAxis;
     };
-    CategoryChart.prototype.adg = function () {
-        return this.c2(30);
+    CategoryChart.prototype.adk = function () {
+        return this.c3(30);
     };
-    CategoryChart.prototype.adh = function () {
-        return this.c2(31);
+    CategoryChart.prototype.adl = function () {
+        return this.c3(31);
     };
-    CategoryChart.prototype.gk = function (a, b) {
-        var c = _super.prototype.gk.call(this, a, b);
+    CategoryChart.prototype.gn = function (a, b) {
+        var c = _super.prototype.gn.call(this, a, b);
         if (c != null) {
             var d = new List$1(Series.$, 0);
-            if (this.adm) {
-                d.add(this.adg());
+            if (this.adq) {
+                d.add(this.adk());
             }
-            if (this.adn) {
-                d.add(this.adh());
+            if (this.adr) {
+                d.add(this.adl());
             }
             for (var e = 0; e < d.count; e++) {
                 var f = d._inner[e];
@@ -1031,32 +1042,32 @@ var CategoryChart = /** @class */ /*@__PURE__*/ (function (_super) {
             return this.a6;
         }
     };
-    CategoryChart.prototype.tj = function (a, b, c) {
-        _super.prototype.tj.call(this, a, b, c);
+    CategoryChart.prototype.tn = function (a, b, c) {
+        _super.prototype.tn.call(this, a, b, c);
         if (this.bd.dataSeries.count > 0) {
-            if (stringIsNullOrEmpty(this.li)) {
+            if (stringIsNullOrEmpty(this.lm)) {
                 this.b3.setXMemberPath(a, c.getMemberPathFor(16));
             }
-            if (stringIsNullOrEmpty(this.lk)) {
+            if (stringIsNullOrEmpty(this.lo)) {
                 this.b3.setYMemberPath(a, c.getMemberPathFor(0));
             }
-            if (stringIsNullOrEmpty(this.le)) {
+            if (stringIsNullOrEmpty(this.li)) {
                 this.b3.setLabelMemberPath(a, c.getMemberPathFor(0));
             }
-            if (stringIsNullOrEmpty(this.lb)) {
+            if (stringIsNullOrEmpty(this.lf)) {
                 this.b3.setContentMemberPath(a, c.getMemberPathFor(0));
             }
         }
     };
-    CategoryChart.prototype.fx = function () {
+    CategoryChart.prototype.f0 = function () {
         if (this.a9 == 4 || this.a9 == 3) {
             return true;
         }
         else if (this.a9 == 0) {
-            if (this.ac5 == 2 || this.ac5 == 8) {
+            if (this.ac9 == 2 || this.ac9 == 8) {
                 return false;
             }
-            else if (this.ac5 == 9 && this.bd != null && this.bd.dataSeries != null && this.bd.dataSeries.count > 0) {
+            else if (this.ac9 == 9 && this.bd != null && this.bd.dataSeries != null && this.bd.dataSeries.count > 0) {
                 var a = this.bd.dataSeries._inner[0].suggestedSeries;
                 if (a == 1 || a == 8) {
                     return false;
@@ -1066,134 +1077,134 @@ var CategoryChart = /** @class */ /*@__PURE__*/ (function (_super) {
         }
         return false;
     };
-    CategoryChart.prototype.get_f3 = function () {
+    CategoryChart.prototype.get_f6 = function () {
         return DVContainer.instance.checkLoaded("CategoryChartToolbarFactoryManager");
     };
-    CategoryChart.prototype.sr = function (a, b, c) {
+    CategoryChart.prototype.sv = function (a, b, c) {
         var _this = this;
-        _super.prototype.sr.call(this, a, b, c);
+        _super.prototype.sv.call(this, a, b, c);
         switch (a) {
             case "ChartType":
-                this.td();
+                this.th();
                 break;
             case "MarkerCollisionAvoidance":
-                this.agn(function (d) { return d.tr = _this.ac7; });
+                this.agr(function (d) { return d.tr = _this.adb; });
                 break;
             case "IsTransitionInEnabled":
-                this.agn(function (d) { return d.so = _this.ad0; });
+                this.agr(function (d) { return d.so = _this.ad4; });
                 break;
             case "IsSplineShapePartOfRange":
-                this.agn(function (d) {
+                this.agr(function (d) {
                     if (d.ej) {
-                        d.mt(_this.adz);
+                        d.mt(_this.ad3);
                     }
                 });
                 break;
             case "TransitionInMode":
-                this.agn(function (d) { return d.r8 = _this.ac9; });
+                this.agr(function (d) { return d.r8 = _this.add; });
                 break;
             case "TransitionInSpeedType":
-                this.agn(function (d) { return d.cb = _this.adj; });
+                this.agr(function (d) { return d.cb = _this.adn; });
                 break;
             case "XAxisInterval":
-                this.xAxis.mq = this.aez;
+                this.xAxis.mq = this.ae3;
                 break;
             case "XAxisMinorInterval":
-                this.xAxis.mr = this.ae2;
+                this.xAxis.mr = this.ae6;
                 break;
             case "XAxisGap":
-                this.xAxis.k0 = this.aey;
+                this.xAxis.k0 = this.ae2;
                 break;
             case "XAxisOverlap":
-                this.xAxis.k9 = this.ae3;
+                this.xAxis.k9 = this.ae7;
                 break;
             case "XAxisMinimumGapSize":
-                this.xAxis.k8 = this.ae1;
+                this.xAxis.k8 = this.ae5;
                 break;
             case "XAxisMaximumGap":
-                this.xAxis.k7 = this.ae0;
+                this.xAxis.k7 = this.ae4;
                 break;
             case "XAxisZoomMaximumCategoryRange":
-                this.xAxis.zoomMaximumCategoryRange = this.ae4;
+                this.xAxis.zoomMaximumCategoryRange = this.ae8;
                 break;
             case "XAxisZoomMaximumItemSpan":
-                this.xAxis.zoomMaximumItemSpan = this.ae5;
+                this.xAxis.zoomMaximumItemSpan = this.ae9;
                 break;
             case "XAxisZoomToCategoryRange":
-                this.xAxis.zoomToCategoryRange = this.ae6;
+                this.xAxis.zoomToCategoryRange = this.afa;
                 break;
             case "XAxisZoomToCategoryStart":
-                this.xAxis.zoomToCategoryStart = this.ae7;
+                this.xAxis.zoomToCategoryStart = this.afb;
                 break;
             case "XAxisZoomToItemSpan":
-                this.xAxis.zoomToItemSpan = this.ae8;
+                this.xAxis.zoomToItemSpan = this.afc;
                 break;
             case "YAxisInterval":
-                this.yAxis.l0 = this.afb;
+                this.yAxis.l0 = this.aff;
                 break;
             case "YAxisFavorLabellingScaleEnd":
-                this.yAxis.lc = this.ad6;
+                this.yAxis.lc = this.aea;
                 break;
             case "YAxisAutoRangeBufferMode":
-                this.yAxis.kt = this.ac3;
+                this.yAxis.kt = this.ac7;
                 break;
             case "YAxisIsLogarithmic":
-                this.yAxis.lh = this.ad7;
+                this.yAxis.lh = this.aeb;
                 break;
             case "YAxisLogarithmBase":
-                this.yAxis.l8 = this.afi;
+                this.yAxis.l8 = this.afm;
                 break;
             case "YAxisMinimumValue":
-                this.yAxis.l4 = this.afd;
+                this.yAxis.l4 = this.afh;
                 break;
             case "YAxisMaximumValue":
-                this.yAxis.l3 = this.afc;
+                this.yAxis.l3 = this.afg;
                 break;
             case "YAxisMinorInterval":
-                this.yAxis.l5 = this.afe;
+                this.yAxis.l5 = this.afi;
                 break;
             case "NegativeBrushes":
             case "NegativeOutlines":
-                this.ago(function (d, e) {
+                this.ags(function (d, e) {
                     if (d.d6) {
-                        d.ms(ArrayExtension.getModulus$1(Brush.$, _this.acy, e), ArrayExtension.getModulus$1(Brush.$, _this.acz, e));
+                        d.ms(ArrayExtension.getModulus$1(Brush.$, _this.ac2, e), ArrayExtension.getModulus$1(Brush.$, _this.ac3, e));
                     }
                 });
                 break;
             case "YAxisAbbreviateLargeNumbers":
-                this.abf(function (d) { return d.k9 = _this.ad4; });
+                this.abj(function (d) { return d.k9 = _this.ad8; });
                 break;
             case "IsCategoryHighlightingEnabled":
             case "IsItemHighlightingEnabled":
-                this.td();
+                this.th();
                 break;
             case "AutoMarginAndAngleUpdateMode":
-                this.sj(function (d) { return d.tw = _this.ac1; });
+                this.sn(function (d) { return d.tw = _this.ac5; });
                 break;
             case "ShouldAutoExpandMarginForInitialLabels":
-                this.sj(function (d) { return d.ur = _this.ad1; });
+                this.sn(function (d) { return d.ur = _this.ad5; });
                 break;
-            case CategoryChart.afw:
-                this.sj(function (d) { return d.uu = _this.ad2; });
+            case CategoryChart.af0:
+                this.sn(function (d) { return d.uu = _this.ad6; });
                 break;
             case "AutoExpandMarginExtraPadding":
-                this.sj(function (d) { return d.vh = _this.aeq; });
+                this.sn(function (d) { return d.vh = _this.aeu; });
                 break;
             case "AutoExpandMarginMaximumValue":
-                this.sj(function (d) { return d.vi = _this.aer; });
+                this.sn(function (d) { return d.vi = _this.aev; });
                 break;
-            case CategoryChart.af1:
-                this.abb(function (d) { return d.b0 = _this.ad3; }, a);
+            case CategoryChart.af5:
+                this.abf(function (d) { return d.b0 = _this.ad7; }, a);
                 break;
-            case CategoryChart.agf:
-                this.abf(function (d) { return d.b0 = _this.ad5; });
+            case CategoryChart.agj:
+                this.abj(function (d) { return d.b0 = _this.ad9; });
                 break;
         }
     };
     CategoryChart.$t = markType(CategoryChart, 'CategoryChart', XYChart.$);
-    CategoryChart.afw = "ShouldConsiderAutoRotationForInitialLabels";
-    CategoryChart.af1 = "XAxisEnhancedIntervalPreferMoreCategoryLabels";
-    CategoryChart.agf = "YAxisEnhancedIntervalPreferMoreCategoryLabels";
+    CategoryChart.af0 = "ShouldConsiderAutoRotationForInitialLabels";
+    CategoryChart.af5 = "XAxisEnhancedIntervalPreferMoreCategoryLabels";
+    CategoryChart.agj = "YAxisEnhancedIntervalPreferMoreCategoryLabels";
     return CategoryChart;
 }(XYChart));
 export { CategoryChart };