igniteui-webcomponents-charts 4.3.3-beta.0 → 4.3.3-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.afk = 1000;
-        _this.adp = null;
-        _this.ac9 = 9;
-        _this.adb = 1;
-        _this.adt = false;
-        _this.adu = true;
-        _this.add = 0;
-        _this.adn = 0;
-        _this.aeh = 0;
-        _this.aek = 0;
-        _this.aeg = 0;
+        _this.afm = 1000;
+        _this.adr = null;
+        _this.adb = 9;
+        _this.add = 1;
+        _this.adv = false;
+        _this.adw = true;
+        _this.adf = 0;
+        _this.adp = 0;
         _this.aej = 0;
-        _this.aei = 1;
+        _this.aem = 0;
+        _this.aei = 0;
         _this.ael = 0;
-        _this.aer = NaN;
-        _this.ac5 = 1;
-        _this.adv = true;
-        _this.adw = true;
-        _this.aee = DeviceUtils.g(2);
-        _this.aef = DeviceUtils.g(60);
-        _this.ad0 = true;
-        _this.adx = true;
-        _this.adz = false;
-        _this.ac7 = 0;
-        _this.ad1 = false;
-        _this.afl = 10;
+        _this.aek = 1;
+        _this.aen = 0;
         _this.aet = NaN;
-        _this.aes = NaN;
-        _this.aeu = 0;
-        _this.ac1 = null;
-        _this.ac2 = null;
+        _this.ac7 = 1;
+        _this.adx = true;
         _this.ady = true;
-        _this.aem = 3;
-        _this.aen = NaN;
-        _this.aeo = NaN;
+        _this.aeg = DeviceUtils.g(2);
+        _this.aeh = DeviceUtils.g(60);
+        _this.ad2 = true;
+        _this.adz = true;
+        _this.ad1 = false;
+        _this.ac9 = 0;
+        _this.ad3 = false;
+        _this.afn = 10;
+        _this.aev = NaN;
+        _this.aeu = NaN;
+        _this.aew = 0;
+        _this.ac3 = null;
+        _this.ac4 = null;
+        _this.ad0 = true;
+        _this.aeo = 3;
         _this.aep = NaN;
         _this.aeq = NaN;
-        _this.adr = false;
-        _this.ads = false;
-        _this.aed = null;
+        _this.aer = NaN;
+        _this.aes = NaN;
+        _this.adt = false;
+        _this.adu = false;
+        _this.aef = null;
         DVContainer.instance.registerIfLoaded("CategoryChartToolbarFactoryManager");
-        _this.rr();
+        _this.rt();
         return _this;
     }
-    CategoryChart.prototype.r9 = function () {
-        _super.prototype.r9.call(this);
+    CategoryChart.prototype.sb = function () {
+        _super.prototype.sb.call(this);
         if (this.dataChart == null) {
             return;
         }
         var a = this.dataChart.cu.j.e();
-        this.ac3 = a.d;
-        this.ac4 = a.e;
-        if (this.acd == null) {
-            this.acd = a.k;
+        this.ac5 = a.d;
+        this.ac6 = a.e;
+        if (this.acf == null) {
+            this.acf = a.k;
         }
-        if (this.ack == null) {
-            this.ack = a.k;
+        if (this.acm == null) {
+            this.acm = a.k;
         }
-        this.yc = 0;
-        this.acl = AxisDefaults.h;
-        this.aco = null;
-        this.ach = AxisDefaults.g;
-        this.ace = null;
-        this.xv = AxisDefaults.f;
-        this.aci = AxisDefaults.j;
-        this.xw = AxisDefaults.e;
-        this.fm = true;
-        this.fn = true;
+        this.ye = 0;
+        this.acn = AxisDefaults.h;
+        this.acq = null;
+        this.acj = AxisDefaults.g;
+        this.acg = null;
+        this.xx = AxisDefaults.f;
+        this.ack = AxisDefaults.j;
+        this.xy = AxisDefaults.e;
+        this.fo = true;
+        this.fp = true;
         this.a9 = 0;
-        this.h9 = Defaults.j;
-        this.up = Defaults.ae;
-        this.uk = Defaults.af;
-        this.ul = Defaults.ag;
-        this.ad5 = true;
+        this.ib = Defaults.j;
+        this.ur = Defaults.ae;
+        this.um = Defaults.af;
+        this.un = Defaults.ag;
+        this.ad7 = true;
     };
-    CategoryChart.prototype.sb = function (a, b) {
-        _super.prototype.sb.call(this, a, b);
-        a.hs = this.afm;
-        a.ch = this.adq;
+    CategoryChart.prototype.sd = function (a, b) {
+        _super.prototype.sd.call(this, a, b);
+        a.hs = this.afo;
+        a.ch = this.ads;
     };
-    CategoryChart.prototype.sz = function (a, b, c) {
+    CategoryChart.prototype.s1 = function (a, b, c) {
         var _this = this;
-        _super.prototype.sz.call(this, a, b, c);
+        _super.prototype.s1.call(this, a, b, c);
         switch (a) {
             case "TransitionInDuration":
-                this.ry(function (d) { return d.hs = _this.afm; });
+                this.r0(function (d) { return d.hs = _this.afo; });
                 break;
             case "TransitionInEasingFunction":
-                this.ry(function (d) { return d.ch = _this.adq; });
+                this.r0(function (d) { return d.ch = _this.ads; });
                 break;
         }
     };
-    Object.defineProperty(CategoryChart.prototype, "afm", {
+    Object.defineProperty(CategoryChart.prototype, "afo", {
         get: function () {
-            return this.afk;
+            return this.afm;
         },
         set: function (a) {
-            var b = this.afm;
+            var b = this.afo;
             if (a != b) {
-                this.afk = a;
-                this.sw("TransitionInDuration", b, this.afm);
+                this.afm = a;
+                this.sy("TransitionInDuration", b, this.afo);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "adq", {
+    Object.defineProperty(CategoryChart.prototype, "ads", {
         get: function () {
-            return this.adp;
+            return this.adr;
         },
         set: function (a) {
-            var b = this.adq;
+            var b = this.ads;
             if (a != b) {
-                this.adp = a;
-                this.sw("TransitionInEasingFunction", b, this.adq);
+                this.adr = a;
+                this.sy("TransitionInEasingFunction", b, this.ads);
             }
         },
         enumerable: false,
         configurable: true
     });
-    CategoryChart.prototype.afs = function () {
-        var cvd_ = this.j9();
+    CategoryChart.prototype.afu = function () {
+        var cvd_ = this.kb();
         cvd_.scaleByViewport();
         return (cvd_.serialize());
     };
-    CategoryChart.prototype.r4 = function (a) {
-        _super.prototype.r4.call(this, a);
-        a.dt = this.fh;
-        a.u0 = this.ad6;
-        a.u3 = this.ad7;
-        a.vq = this.aev;
-        a.vr = this.aew;
-        a.t5 = this.ac6;
+    CategoryChart.prototype.r6 = function (a) {
+        _super.prototype.r6.call(this, a);
+        a.du = this.fj;
+        a.u1 = this.ad8;
+        a.u4 = this.ad9;
+        a.vr = this.aex;
+        a.vs = this.aey;
+        a.t6 = this.ac8;
     };
-    CategoryChart.prototype.sa = function (a, b) {
-        _super.prototype.sa.call(this, a, b);
+    CategoryChart.prototype.sc = function (a, b) {
+        _super.prototype.sc.call(this, a, b);
         var c = typeCast(HorizontalAnchoredCategorySeries.$, a);
         if (c == null) {
             return;
         }
-        c.tr = this.adc;
-        c.so = this.ad5;
-        c.r8 = this.ade;
-        c.cb = this.ado;
+        c.tr = this.ade;
+        c.so = this.ad7;
+        c.r8 = this.adg;
+        c.cb = this.adq;
         c.trendLineBrush = ArrayExtension.getModulus$1(Brush.$, this.ah, b);
         c.trendLineType = this.dq;
-        c.trendLineThickness = this.i7;
+        c.trendLineThickness = this.i9;
         c.ql = this.cr(a, b);
         if (a.d6) {
-            a.ms(ArrayExtension.getModulus$1(Brush.$, this.ac3, b), ArrayExtension.getModulus$1(Brush.$, this.ac4, b));
+            a.ms(ArrayExtension.getModulus$1(Brush.$, this.ac5, b), ArrayExtension.getModulus$1(Brush.$, this.ac6, b));
         }
     };
-    CategoryChart.prototype.adf = function () {
+    CategoryChart.prototype.adh = function () {
         return new CategoryXAxis();
     };
-    CategoryChart.prototype.adj = function () {
+    CategoryChart.prototype.adl = function () {
         return new NumericYAxis();
     };
-    CategoryChart.prototype.rn = function () {
-        this.xAxis = this.adf();
+    CategoryChart.prototype.rp = function () {
+        this.xAxis = this.adh();
         this.xAxis.name = "xAxis";
         var a = this.xAxis;
-        a.propertyChanged = delegateCombine(a.propertyChanged, runOn(this, this.agu));
-        this.yAxis = this.adj();
+        a.propertyChanged = delegateCombine(a.propertyChanged, runOn(this, this.agw));
+        this.yAxis = this.adl();
         this.yAxis.name = "yAxis";
         var b = this.yAxis;
-        b.propertyChanged = delegateCombine(b.propertyChanged, runOn(this, this.agv));
+        b.propertyChanged = delegateCombine(b.propertyChanged, runOn(this, this.agx));
         if (this.xAxis.az == null) {
             this.xAxis.az = new AxisLabelSettings();
         }
@@ -212,20 +212,20 @@ var CategoryChart = /** @class */ /*@__PURE__*/ (function (_super) {
             this.yAxis.az = new AxisLabelSettings();
         }
     };
+    CategoryChart.prototype.abf = function (a) {
+        _super.prototype.abf.call(this, a);
+        a.la = this.aeb;
+        a.ld = this.aed;
+        a.b1 = this.aec;
+    };
     CategoryChart.prototype.abd = function (a) {
         _super.prototype.abd.call(this, a);
-        a.la = this.ad9;
-        a.ld = this.aeb;
         a.b1 = this.aea;
-    };
-    CategoryChart.prototype.abb = function (a) {
-        _super.prototype.abb.call(this, a);
-        a.b1 = this.ad8;
-        a.zoomMaximumCategoryRange = this.ae9;
-        a.zoomToCategoryRange = this.afb;
-        a.zoomToCategoryStart = this.afc;
-        a.zoomMaximumItemSpan = this.afa;
-        a.zoomToItemSpan = this.afd;
+        a.zoomMaximumCategoryRange = this.afb;
+        a.zoomToCategoryRange = this.afd;
+        a.zoomToCategoryStart = this.afe;
+        a.zoomMaximumItemSpan = this.afc;
+        a.zoomToItemSpan = this.aff;
     };
     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, "ada", {
+    Object.defineProperty(CategoryChart.prototype, "adc", {
         get: function () {
-            return this.ac9;
+            return this.adb;
         },
         set: function (a) {
-            if (a != this.ac9) {
-                var b = this.ada;
-                this.ac9 = a;
-                this.sw("ChartType", enumGetBox(CategoryChartType_$type, b), enumGetBox(CategoryChartType_$type, this.ada));
+            if (a != this.adb) {
+                var b = this.adc;
+                this.adb = a;
+                this.sy("ChartType", enumGetBox(CategoryChartType_$type, b), enumGetBox(CategoryChartType_$type, this.adc));
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "adc", {
+    Object.defineProperty(CategoryChart.prototype, "ade", {
         get: function () {
-            return this.adb;
+            return this.add;
         },
         set: function (a) {
-            var b = this.adc;
+            var b = this.ade;
             if (a != b) {
-                this.adb = a;
-                this.sw("MarkerCollisionAvoidance", enumGetBox(CategorySeriesMarkerCollisionAvoidance_$type, b), enumGetBox(CategorySeriesMarkerCollisionAvoidance_$type, this.adc));
+                this.add = a;
+                this.sy("MarkerCollisionAvoidance", enumGetBox(CategorySeriesMarkerCollisionAvoidance_$type, b), enumGetBox(CategorySeriesMarkerCollisionAvoidance_$type, this.ade));
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ad4", {
+    Object.defineProperty(CategoryChart.prototype, "ad6", {
         get: function () {
-            return this.adt;
+            return this.adv;
         },
         set: function (a) {
-            var b = this.ad4;
+            var b = this.ad6;
             if (a != b) {
-                this.adt = a;
-                this.sw("IsSplineShapePartOfRange", b, this.ad4);
+                this.adv = a;
+                this.sy("IsSplineShapePartOfRange", b, this.ad6);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ad5", {
+    Object.defineProperty(CategoryChart.prototype, "ad7", {
         get: function () {
-            return this.adu;
+            return this.adw;
         },
         set: function (a) {
-            var b = this.ad5;
+            var b = this.ad7;
             if (a != b) {
-                this.adu = a;
-                this.sw("IsTransitionInEnabled", b, this.ad5);
+                this.adw = a;
+                this.sy("IsTransitionInEnabled", b, this.ad7);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ade", {
+    Object.defineProperty(CategoryChart.prototype, "adg", {
         get: function () {
-            return this.add;
+            return this.adf;
         },
         set: function (a) {
-            var b = this.ade;
+            var b = this.adg;
             if (a != b) {
-                this.add = a;
-                this.sw("TransitionInMode", enumGetBox(CategoryTransitionInMode_$type, b), enumGetBox(CategoryTransitionInMode_$type, this.ade));
+                this.adf = a;
+                this.sy("TransitionInMode", enumGetBox(CategoryTransitionInMode_$type, b), enumGetBox(CategoryTransitionInMode_$type, this.adg));
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ado", {
+    Object.defineProperty(CategoryChart.prototype, "adq", {
         get: function () {
-            return this.adn;
+            return this.adp;
         },
         set: function (a) {
-            var b = this.ado;
+            var b = this.adq;
             if (a != b) {
-                this.adn = a;
-                this.sw("TransitionInSpeedType", enumGetBox(TransitionInSpeedType_$type, b), enumGetBox(TransitionInSpeedType_$type, this.ado));
+                this.adp = a;
+                this.sy("TransitionInSpeedType", enumGetBox(TransitionInSpeedType_$type, b), enumGetBox(TransitionInSpeedType_$type, this.adq));
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ae4", {
+    Object.defineProperty(CategoryChart.prototype, "ae6", {
         get: function () {
-            return this.aeh;
+            return this.aej;
         },
         set: function (a) {
-            var b = this.ae4;
+            var b = this.ae6;
             if (a != b) {
-                this.aeh = a;
-                this.sw("XAxisInterval", b, this.ae4);
+                this.aej = a;
+                this.sy("XAxisInterval", b, this.ae6);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ae7", {
+    Object.defineProperty(CategoryChart.prototype, "ae9", {
         get: function () {
-            return this.aek;
+            return this.aem;
         },
         set: function (a) {
-            var b = this.ae7;
+            var b = this.ae9;
             if (a != b) {
-                this.aek = a;
-                this.sw("XAxisMinorInterval", b, this.ae7);
+                this.aem = a;
+                this.sy("XAxisMinorInterval", b, this.ae9);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ae3", {
+    Object.defineProperty(CategoryChart.prototype, "ae5", {
         get: function () {
-            return this.aeg;
+            return this.aei;
         },
         set: function (a) {
-            var b = this.ae3;
+            var b = this.ae5;
             if (a != b) {
-                this.aeg = a;
-                this.sw("XAxisGap", b, this.ae3);
+                this.aei = a;
+                this.sy("XAxisGap", b, this.ae5);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ae6", {
+    Object.defineProperty(CategoryChart.prototype, "ae8", {
         get: function () {
-            return this.aej;
+            return this.ael;
         },
         set: function (a) {
-            var b = this.ae6;
+            var b = this.ae8;
             if (a != b) {
-                this.aej = a;
-                this.sw("XAxisMinimumGapSize", b, this.ae6);
+                this.ael = a;
+                this.sy("XAxisMinimumGapSize", b, this.ae8);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ae5", {
+    Object.defineProperty(CategoryChart.prototype, "ae7", {
         get: function () {
-            return this.aei;
+            return this.aek;
         },
         set: function (a) {
-            var b = this.ae5;
+            var b = this.ae7;
             if (a != b) {
-                this.aei = a;
-                this.sw("XAxisMaximumGap", b, this.ae5);
+                this.aek = a;
+                this.sy("XAxisMaximumGap", b, this.ae7);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ae8", {
+    Object.defineProperty(CategoryChart.prototype, "afa", {
         get: function () {
-            return this.ael;
+            return this.aen;
         },
         set: function (a) {
-            var b = this.ae8;
+            var b = this.afa;
             if (a != b) {
-                this.ael = a;
-                this.sw("XAxisOverlap", b, this.ae8);
+                this.aen = a;
+                this.sy("XAxisOverlap", b, this.afa);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "afg", {
+    Object.defineProperty(CategoryChart.prototype, "afi", {
         get: function () {
-            return this.aer;
+            return this.aet;
         },
         set: function (a) {
-            var b = this.afg;
+            var b = this.afi;
             if (a != b) {
-                this.aer = a;
-                this.sw("YAxisInterval", b, this.afg);
+                this.aet = a;
+                this.sy("YAxisInterval", b, this.afi);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ac6", {
+    Object.defineProperty(CategoryChart.prototype, "ac8", {
         get: function () {
-            return this.ac5;
+            return this.ac7;
         },
         set: function (a) {
-            var b = this.ac6;
+            var b = this.ac8;
             if (a != b) {
-                this.ac5 = a;
-                this.sw("AutoMarginAndAngleUpdateMode", enumGetBox(AutoMarginsAndAngleUpdateMode_$type, b), enumGetBox(AutoMarginsAndAngleUpdateMode_$type, this.ac6));
+                this.ac7 = a;
+                this.sy("AutoMarginAndAngleUpdateMode", enumGetBox(AutoMarginsAndAngleUpdateMode_$type, b), enumGetBox(AutoMarginsAndAngleUpdateMode_$type, this.ac8));
             }
         },
         enumerable: false,
         configurable: true
     });
-    CategoryChart.prototype.agw = function () {
+    CategoryChart.prototype.agy = function () {
         if (this.dataChart != null) {
-            this.dataChart.xb();
+            this.dataChart.xc();
         }
     };
-    Object.defineProperty(CategoryChart.prototype, "ad6", {
+    Object.defineProperty(CategoryChart.prototype, "ad8", {
         get: function () {
-            return this.adv;
+            return this.adx;
         },
         set: function (a) {
-            var b = this.ad6;
+            var b = this.ad8;
             if (a != b) {
-                this.adv = a;
-                this.sw("ShouldAutoExpandMarginForInitialLabels", b, this.ad6);
+                this.adx = a;
+                this.sy("ShouldAutoExpandMarginForInitialLabels", b, this.ad8);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ad7", {
+    Object.defineProperty(CategoryChart.prototype, "ad9", {
         get: function () {
-            return this.adw;
+            return this.ady;
         },
         set: function (a) {
-            var b = this.ad7;
+            var b = this.ad9;
             if (a != b) {
-                this.adw = a;
-                this.sw(CategoryChart.af1, b, this.ad7);
+                this.ady = a;
+                this.sy(CategoryChart.af3, b, this.ad9);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aev", {
+    Object.defineProperty(CategoryChart.prototype, "aex", {
         get: function () {
-            return this.aee;
+            return this.aeg;
         },
         set: function (a) {
-            var b = this.aev;
+            var b = this.aex;
             if (a != b) {
-                this.aee = a;
-                this.sw("AutoExpandMarginExtraPadding", b, this.aev);
+                this.aeg = a;
+                this.sy("AutoExpandMarginExtraPadding", b, this.aex);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aew", {
+    Object.defineProperty(CategoryChart.prototype, "aey", {
         get: function () {
-            return this.aef;
+            return this.aeh;
         },
         set: function (a) {
-            var b = this.aew;
+            var b = this.aey;
             if (a != b) {
-                this.aef = a;
-                this.sw("AutoExpandMarginMaximumValue", b, this.aew);
+                this.aeh = a;
+                this.sy("AutoExpandMarginMaximumValue", b, this.aey);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aeb", {
+    Object.defineProperty(CategoryChart.prototype, "aed", {
         get: function () {
-            return this.ad0;
+            return this.ad2;
         },
         set: function (a) {
-            var b = this.aeb;
+            var b = this.aed;
             if (a != b) {
-                this.ad0 = a;
-                this.sw("YAxisFavorLabellingScaleEnd", b, this.aeb);
+                this.ad2 = a;
+                this.sy("YAxisFavorLabellingScaleEnd", b, this.aed);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ad8", {
+    Object.defineProperty(CategoryChart.prototype, "aea", {
         get: function () {
-            return this.adx;
+            return this.adz;
         },
         set: function (a) {
-            var b = this.ad8;
+            var b = this.aea;
             if (a != b) {
-                this.adx = a;
-                this.sw(CategoryChart.af6, b, this.ad8);
+                this.adz = a;
+                this.sy(CategoryChart.af8, b, this.aea);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aea", {
+    Object.defineProperty(CategoryChart.prototype, "aec", {
         get: function () {
-            return this.adz;
+            return this.ad1;
         },
         set: function (a) {
-            var b = this.aea;
+            var b = this.aec;
             if (a != b) {
-                this.adz = a;
-                this.sw(CategoryChart.agk, b, this.aea);
+                this.ad1 = a;
+                this.sy(CategoryChart.agm, b, this.aec);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ac8", {
+    Object.defineProperty(CategoryChart.prototype, "ada", {
         get: function () {
-            return this.ac7;
+            return this.ac9;
         },
         set: function (a) {
-            var b = this.ac8;
+            var b = this.ada;
             if (a != b) {
-                this.ac7 = a;
-                this.sw("YAxisAutoRangeBufferMode", enumGetBox(AxisRangeBufferMode_$type, b), enumGetBox(AxisRangeBufferMode_$type, this.ac8));
+                this.ac9 = a;
+                this.sy("YAxisAutoRangeBufferMode", enumGetBox(AxisRangeBufferMode_$type, b), enumGetBox(AxisRangeBufferMode_$type, this.ada));
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aec", {
+    Object.defineProperty(CategoryChart.prototype, "aee", {
         get: function () {
-            return this.ad1;
+            return this.ad3;
         },
         set: function (a) {
-            var b = this.aec;
+            var b = this.aee;
             if (a != b) {
-                this.ad1 = a;
-                this.sw("YAxisIsLogarithmic", b, this.aec);
+                this.ad3 = a;
+                this.sy("YAxisIsLogarithmic", b, this.aee);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "afn", {
+    Object.defineProperty(CategoryChart.prototype, "afp", {
         get: function () {
-            return this.afl;
+            return this.afn;
         },
         set: function (a) {
-            var b = this.afn;
+            var b = this.afp;
             if (a != b) {
-                this.afl = a;
-                this.sw("YAxisLogarithmBase", b, this.afn);
+                this.afn = a;
+                this.sy("YAxisLogarithmBase", b, this.afp);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "afi", {
+    Object.defineProperty(CategoryChart.prototype, "afk", {
         get: function () {
-            return this.aet;
+            return this.aev;
         },
         set: function (a) {
-            var b = this.afi;
+            var b = this.afk;
             if (a != b) {
-                this.aet = a;
-                this.sw("YAxisMinimumValue", b, this.afi);
+                this.aev = a;
+                this.sy("YAxisMinimumValue", b, this.afk);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "afh", {
+    Object.defineProperty(CategoryChart.prototype, "afj", {
         get: function () {
-            return this.aes;
+            return this.aeu;
         },
         set: function (a) {
-            var b = this.afh;
+            var b = this.afj;
             if (a != b) {
-                this.aes = a;
-                this.sw("YAxisMaximumValue", b, this.afh);
+                this.aeu = a;
+                this.sy("YAxisMaximumValue", b, this.afj);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "afj", {
+    Object.defineProperty(CategoryChart.prototype, "afl", {
         get: function () {
-            return this.aeu;
+            return this.aew;
         },
         set: function (a) {
-            var b = this.afj;
+            var b = this.afl;
             if (a != b) {
-                this.aeu = a;
-                this.sw("YAxisMinorInterval", b, this.afj);
+                this.aew = a;
+                this.sy("YAxisMinorInterval", b, this.afl);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ae2", {
+    Object.defineProperty(CategoryChart.prototype, "ae4", {
         get: function () {
             return this.xAxis.mw;
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ae1", {
+    Object.defineProperty(CategoryChart.prototype, "ae3", {
         get: function () {
             return this.xAxis.mv;
         },
         enumerable: false,
         configurable: true
     });
-    CategoryChart.prototype.aey = function () {
-        return this.ae2;
-    };
     CategoryChart.prototype.ae0 = function () {
-        return this.aff;
+        return this.ae4;
     };
-    CategoryChart.prototype.aex = function () {
-        return this.ae1;
+    CategoryChart.prototype.ae2 = function () {
+        return this.afh;
     };
     CategoryChart.prototype.aez = function () {
-        return this.afe;
+        return this.ae3;
     };
-    Object.defineProperty(CategoryChart.prototype, "aff", {
+    CategoryChart.prototype.ae1 = function () {
+        return this.afg;
+    };
+    Object.defineProperty(CategoryChart.prototype, "afh", {
         get: function () {
             return this.yAxis.lx;
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "afe", {
+    Object.defineProperty(CategoryChart.prototype, "afg", {
         get: function () {
             return this.yAxis.lw;
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ac3", {
+    Object.defineProperty(CategoryChart.prototype, "ac5", {
         get: function () {
-            return this.ac1;
+            return this.ac3;
         },
         set: function (a) {
-            var b = this.ac3;
+            var b = this.ac5;
             if (a != b) {
-                this.ac1 = a;
-                this.sw("NegativeBrushes", b, this.ac3);
+                this.ac3 = a;
+                this.sy("NegativeBrushes", b, this.ac5);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ac4", {
+    Object.defineProperty(CategoryChart.prototype, "ac6", {
         get: function () {
-            return this.ac2;
+            return this.ac4;
         },
         set: function (a) {
-            var b = this.ac4;
+            var b = this.ac6;
             if (a != b) {
-                this.ac2 = a;
-                this.sw("NegativeOutlines", b, this.ac4);
+                this.ac4 = a;
+                this.sy("NegativeOutlines", b, this.ac6);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ad9", {
+    Object.defineProperty(CategoryChart.prototype, "aeb", {
         get: function () {
-            return this.ady;
+            return this.ad0;
         },
         set: function (a) {
-            var b = this.ad9;
+            var b = this.aeb;
             if (a != b) {
-                this.ady = a;
-                this.sw("YAxisAbbreviateLargeNumbers", b, this.ad9);
+                this.ad0 = a;
+                this.sy("YAxisAbbreviateLargeNumbers", b, this.aeb);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ae9", {
+    Object.defineProperty(CategoryChart.prototype, "afb", {
         get: function () {
-            return this.aem;
+            return this.aeo;
         },
         set: function (a) {
-            var b = this.ae9;
+            var b = this.afb;
             if (a != b) {
-                this.aem = a;
-                this.sw("XAxisZoomMaximumCategoryRange", b, this.ae9);
+                this.aeo = a;
+                this.sy("XAxisZoomMaximumCategoryRange", b, this.afb);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "afa", {
+    Object.defineProperty(CategoryChart.prototype, "afc", {
         get: function () {
-            return this.aen;
+            return this.aep;
         },
         set: function (a) {
-            var b = this.afa;
+            var b = this.afc;
             if (a != b) {
-                this.aen = a;
-                this.sw("XAxisZoomMaximumItemSpan", b, this.afa);
+                this.aep = a;
+                this.sy("XAxisZoomMaximumItemSpan", b, this.afc);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "afb", {
+    Object.defineProperty(CategoryChart.prototype, "afd", {
         get: function () {
-            return this.aeo;
+            return this.aeq;
         },
         set: function (a) {
-            var b = this.afb;
+            var b = this.afd;
             if (a != b) {
-                this.aeo = a;
-                this.sw("XAxisZoomToCategoryRange", b, this.afb);
+                this.aeq = a;
+                this.sy("XAxisZoomToCategoryRange", b, this.afd);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "afc", {
+    Object.defineProperty(CategoryChart.prototype, "afe", {
         get: function () {
-            return this.aep;
+            return this.aer;
         },
         set: function (a) {
-            var b = this.afc;
+            var b = this.afe;
             if (a != b) {
-                this.aep = a;
-                this.sw("XAxisZoomToCategoryStart", b, this.afc);
+                this.aer = a;
+                this.sy("XAxisZoomToCategoryStart", b, this.afe);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "afd", {
+    Object.defineProperty(CategoryChart.prototype, "aff", {
         get: function () {
-            return this.aeq;
+            return this.aes;
         },
         set: function (a) {
-            var b = this.afd;
+            var b = this.aff;
             if (a != b) {
-                this.aeq = a;
-                this.sw("XAxisZoomToItemSpan", b, this.afd);
+                this.aes = a;
+                this.sy("XAxisZoomToItemSpan", b, this.aff);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ad2", {
+    Object.defineProperty(CategoryChart.prototype, "ad4", {
         get: function () {
-            return this.adr;
+            return this.adt;
         },
         set: function (a) {
-            var b = this.ad2;
+            var b = this.ad4;
             if (a != b) {
-                this.adr = a;
-                this.sw("IsCategoryHighlightingEnabled", b, this.ad2);
+                this.adt = a;
+                this.sy("IsCategoryHighlightingEnabled", b, this.ad4);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ad3", {
+    Object.defineProperty(CategoryChart.prototype, "ad5", {
         get: function () {
-            return this.ads;
+            return this.adu;
         },
         set: function (a) {
-            var b = this.ad3;
+            var b = this.ad5;
             if (a != b) {
-                this.ads = a;
-                this.sw("IsItemHighlightingEnabled", b, this.ad3);
+                this.adu = a;
+                this.sy("IsItemHighlightingEnabled", b, this.ad5);
             }
         },
         enumerable: false,
         configurable: true
     });
-    CategoryChart.prototype.get_gr = function () {
+    CategoryChart.prototype.get_gt = function () {
         var a = new List$1(DataSeriesType_$type, 0);
         if (TypeRegistrar.isRegistered("AreaSeries")) {
             a.add(2);
@@ -831,24 +831,24 @@ var CategoryChart = /** @class */ /*@__PURE__*/ (function (_super) {
         }
         return a;
     };
-    Object.defineProperty(CategoryChart.prototype, "gr", {
+    Object.defineProperty(CategoryChart.prototype, "gt", {
         get: function () {
-            return this.get_gr();
+            return this.get_gt();
         },
         enumerable: false,
         configurable: true
     });
-    CategoryChart.prototype.gv = function () {
-        if (this.aed == null) {
-            this.aed = CategoryChartMockDataGenerator.a();
+    CategoryChart.prototype.gx = function () {
+        if (this.aef == null) {
+            this.aef = CategoryChartMockDataGenerator.a();
         }
-        return this.aed;
+        return this.aef;
     };
     CategoryChart.prototype.cq = function (a) {
         if (a != null) {
             var b = _super.prototype.cq.call(this, a);
             if (b == 2) {
-                if (a.d5 && this.fx) {
+                if (a.d5 && this.fz) {
                     return 13;
                 }
             }
@@ -859,42 +859,42 @@ var CategoryChart = /** @class */ /*@__PURE__*/ (function (_super) {
         if (a != null) {
             var b = _super.prototype.cq.call(this, a);
             if (b == 2) {
-                if (a.d5 && this.fx) {
+                if (a.d5 && this.fz) {
                     return 13;
                 }
             }
         }
         return _super.prototype.cs.call(this, a);
     };
-    CategoryChart.prototype.get_ge = function () {
+    CategoryChart.prototype.get_gg = function () {
         return this.xAxis != null && this.xAxis.categoryMode != 0;
     };
-    CategoryChart.prototype.agu = function (a, b) {
+    CategoryChart.prototype.agw = function (a, b) {
         switch (b.propertyName) {
             case "ActualMinimum":
-                this.s6("XAxisActualMinimum");
+                this.s8("XAxisActualMinimum");
                 break;
             case "ActualMaximum":
-                this.s6("XAxisActualMaximum");
+                this.s8("XAxisActualMaximum");
                 break;
         }
     };
-    CategoryChart.prototype.agv = function (a, b) {
+    CategoryChart.prototype.agx = function (a, b) {
         switch (b.propertyName) {
             case "ActualMinimumValue":
-                this.s6("YAxisActualMinimum");
+                this.s8("YAxisActualMinimum");
                 break;
             case "ActualMaximumValue":
-                this.s6("YAxisActualMaximum");
+                this.s8("YAxisActualMaximum");
                 break;
         }
     };
-    CategoryChart.prototype.ti = function () {
-        _super.prototype.ti.call(this);
-        this.xAxis.f0 = this.ym == null ? XYChart.yy(this.xAxis, this.bd.dataSeries) : this.ym;
+    CategoryChart.prototype.tk = function () {
+        _super.prototype.tk.call(this);
+        this.xAxis.f0 = this.yo == null ? XYChart.y0(this.xAxis, this.bd.dataSeries) : this.yo;
         this.xAxis.itemsSource = this.dataChart != null && this.dataChart.series.count > 0 ? this.dataChart.series._inner[0].itemsSource : null;
-        if (this.ad6) {
-            this.so(function (a) { return a.xb(); });
+        if (this.ad8) {
+            this.sq(function (a) { return a.xc(); });
         }
     };
     Object.defineProperty(CategoryChart.prototype, "xAxis", {
@@ -917,7 +917,7 @@ var CategoryChart = /** @class */ /*@__PURE__*/ (function (_super) {
         enumerable: false,
         configurable: true
     });
-    CategoryChart.prototype.adi = function (a, b) {
+    CategoryChart.prototype.adk = function (a, b) {
         switch (a) {
             case 2: return this.c3(1);
             case 3: return this.c3(10);
@@ -928,15 +928,15 @@ var CategoryChart = /** @class */ /*@__PURE__*/ (function (_super) {
             case 4: return this.c3(4);
             case 5: return this.c3(5);
             case 8: return this.c3(8);
-            case 9: return this.adh(b);
+            case 9: return this.adj(b);
             default: return this.c3(1);
         }
     };
-    CategoryChart.prototype.adh = function (a) {
+    CategoryChart.prototype.adj = function (a) {
         return this.c3(a);
     };
     CategoryChart.prototype.bc = function (a) {
-        switch (this.ada) {
+        switch (this.adc) {
             case 1: return 2;
             case 0: return 0;
             case 3: return 10;
@@ -951,23 +951,23 @@ var CategoryChart = /** @class */ /*@__PURE__*/ (function (_super) {
         }
     };
     CategoryChart.prototype.c1 = function (a, b) {
-        var c = this.adi(this.ada, a.suggestedSeries);
+        var c = this.adk(this.adc, a.suggestedSeries);
         c.uc = a.findMatchingHint(0).path;
         c.xAxis = this.xAxis;
         c.yAxis = this.yAxis;
         return c;
     };
-    CategoryChart.prototype.tg = function (a) {
+    CategoryChart.prototype.ti = function (a) {
         if (a.suggestedSecondaryAxis == 2) {
             this.yAxis.li = true;
             this.yAxis.l9 = 10;
         }
     };
-    CategoryChart.prototype.tj = function () {
-        this.yAxis.li = this.aec;
-        this.yAxis.l9 = this.afn;
+    CategoryChart.prototype.tl = function () {
+        this.yAxis.li = this.aee;
+        this.yAxis.l9 = this.afp;
     };
-    CategoryChart.prototype.get_gq = function () {
+    CategoryChart.prototype.get_gs = function () {
         return ((function () {
             var $ret = new List$1(IDataSeriesAdapterRule_$type, 0);
             $ret.add(new SimpleCategorySeriesRule());
@@ -975,24 +975,24 @@ var CategoryChart = /** @class */ /*@__PURE__*/ (function (_super) {
             return $ret;
         })());
     };
-    Object.defineProperty(CategoryChart.prototype, "gq", {
+    Object.defineProperty(CategoryChart.prototype, "gs", {
         get: function () {
-            return this.get_gq();
+            return this.get_gs();
         },
         enumerable: false,
         configurable: true
     });
-    CategoryChart.prototype.rj = function (a, b) {
+    CategoryChart.prototype.rl = function (a, b) {
         var c = typeCast(HorizontalAnchoredCategorySeries.$, a);
         if (c != null) {
-            c.tr = this.adc;
+            c.tr = this.ade;
             c.ql = this.cr(a, b);
         }
     };
-    CategoryChart.prototype.ags = function (a) {
-        this.agt(function (b, c) { return a(b); });
+    CategoryChart.prototype.agu = function (a) {
+        this.agv(function (b, c) { return a(b); });
     };
-    CategoryChart.prototype.agt = function (a) {
+    CategoryChart.prototype.agv = function (a) {
         if (this.dataChart == null) {
             return;
         }
@@ -1004,27 +1004,27 @@ var CategoryChart = /** @class */ /*@__PURE__*/ (function (_super) {
             a(c, b);
         }
     };
-    CategoryChart.prototype.v4 = function () {
+    CategoryChart.prototype.v6 = function () {
         return this.xAxis;
     };
-    CategoryChart.prototype.v5 = function () {
+    CategoryChart.prototype.v7 = function () {
         return this.yAxis;
     };
-    CategoryChart.prototype.adl = function () {
+    CategoryChart.prototype.adn = function () {
         return this.c3(30);
     };
-    CategoryChart.prototype.adm = function () {
+    CategoryChart.prototype.ado = function () {
         return this.c3(31);
     };
-    CategoryChart.prototype.gn = function (a, b) {
-        var c = _super.prototype.gn.call(this, a, b);
+    CategoryChart.prototype.gp = function (a, b) {
+        var c = _super.prototype.gp.call(this, a, b);
         if (c != null) {
             var d = new List$1(Series.$, 0);
-            if (this.adr) {
-                d.add(this.adl());
+            if (this.adt) {
+                d.add(this.adn());
             }
-            if (this.ads) {
-                d.add(this.adm());
+            if (this.adu) {
+                d.add(this.ado());
             }
             for (var e = 0; e < d.count; e++) {
                 var f = d._inner[e];
@@ -1042,32 +1042,32 @@ var CategoryChart = /** @class */ /*@__PURE__*/ (function (_super) {
             return this.a6;
         }
     };
-    CategoryChart.prototype.to = function (a, b, c) {
-        _super.prototype.to.call(this, a, b, c);
+    CategoryChart.prototype.tq = function (a, b, c) {
+        _super.prototype.tq.call(this, a, b, c);
         if (this.bd.dataSeries.count > 0) {
-            if (stringIsNullOrEmpty(this.lm)) {
+            if (stringIsNullOrEmpty(this.lo)) {
                 this.b3.setXMemberPath(a, c.getMemberPathFor(16));
             }
-            if (stringIsNullOrEmpty(this.lo)) {
+            if (stringIsNullOrEmpty(this.lq)) {
                 this.b3.setYMemberPath(a, c.getMemberPathFor(0));
             }
-            if (stringIsNullOrEmpty(this.li)) {
+            if (stringIsNullOrEmpty(this.lk)) {
                 this.b3.setLabelMemberPath(a, c.getMemberPathFor(0));
             }
-            if (stringIsNullOrEmpty(this.lf)) {
+            if (stringIsNullOrEmpty(this.lh)) {
                 this.b3.setContentMemberPath(a, c.getMemberPathFor(0));
             }
         }
     };
-    CategoryChart.prototype.f0 = function () {
+    CategoryChart.prototype.f2 = function () {
         if (this.a9 == 4 || this.a9 == 3) {
             return true;
         }
         else if (this.a9 == 0) {
-            if (this.ada == 2 || this.ada == 8) {
+            if (this.adc == 2 || this.adc == 8) {
                 return false;
             }
-            else if (this.ada == 9 && this.bd != null && this.bd.dataSeries != null && this.bd.dataSeries.count > 0) {
+            else if (this.adc == 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;
@@ -1077,134 +1077,134 @@ var CategoryChart = /** @class */ /*@__PURE__*/ (function (_super) {
         }
         return false;
     };
-    CategoryChart.prototype.get_f6 = function () {
+    CategoryChart.prototype.get_f8 = function () {
         return DVContainer.instance.checkLoaded("CategoryChartToolbarFactoryManager");
     };
-    CategoryChart.prototype.sw = function (a, b, c) {
+    CategoryChart.prototype.sy = function (a, b, c) {
         var _this = this;
-        _super.prototype.sw.call(this, a, b, c);
+        _super.prototype.sy.call(this, a, b, c);
         switch (a) {
             case "ChartType":
-                this.ti();
+                this.tk();
                 break;
             case "MarkerCollisionAvoidance":
-                this.ags(function (d) { return d.tr = _this.adc; });
+                this.agu(function (d) { return d.tr = _this.ade; });
                 break;
             case "IsTransitionInEnabled":
-                this.ags(function (d) { return d.so = _this.ad5; });
+                this.agu(function (d) { return d.so = _this.ad7; });
                 break;
             case "IsSplineShapePartOfRange":
-                this.ags(function (d) {
+                this.agu(function (d) {
                     if (d.ej) {
-                        d.mt(_this.ad4);
+                        d.mt(_this.ad6);
                     }
                 });
                 break;
             case "TransitionInMode":
-                this.ags(function (d) { return d.r8 = _this.ade; });
+                this.agu(function (d) { return d.r8 = _this.adg; });
                 break;
             case "TransitionInSpeedType":
-                this.ags(function (d) { return d.cb = _this.ado; });
+                this.agu(function (d) { return d.cb = _this.adq; });
                 break;
             case "XAxisInterval":
-                this.xAxis.mr = this.ae4;
+                this.xAxis.mr = this.ae6;
                 break;
             case "XAxisMinorInterval":
-                this.xAxis.ms = this.ae7;
+                this.xAxis.ms = this.ae9;
                 break;
             case "XAxisGap":
-                this.xAxis.k1 = this.ae3;
+                this.xAxis.k1 = this.ae5;
                 break;
             case "XAxisOverlap":
-                this.xAxis.la = this.ae8;
+                this.xAxis.la = this.afa;
                 break;
             case "XAxisMinimumGapSize":
-                this.xAxis.k9 = this.ae6;
+                this.xAxis.k9 = this.ae8;
                 break;
             case "XAxisMaximumGap":
-                this.xAxis.k8 = this.ae5;
+                this.xAxis.k8 = this.ae7;
                 break;
             case "XAxisZoomMaximumCategoryRange":
-                this.xAxis.zoomMaximumCategoryRange = this.ae9;
+                this.xAxis.zoomMaximumCategoryRange = this.afb;
                 break;
             case "XAxisZoomMaximumItemSpan":
-                this.xAxis.zoomMaximumItemSpan = this.afa;
+                this.xAxis.zoomMaximumItemSpan = this.afc;
                 break;
             case "XAxisZoomToCategoryRange":
-                this.xAxis.zoomToCategoryRange = this.afb;
+                this.xAxis.zoomToCategoryRange = this.afd;
                 break;
             case "XAxisZoomToCategoryStart":
-                this.xAxis.zoomToCategoryStart = this.afc;
+                this.xAxis.zoomToCategoryStart = this.afe;
                 break;
             case "XAxisZoomToItemSpan":
-                this.xAxis.zoomToItemSpan = this.afd;
+                this.xAxis.zoomToItemSpan = this.aff;
                 break;
             case "YAxisInterval":
-                this.yAxis.l1 = this.afg;
+                this.yAxis.l1 = this.afi;
                 break;
             case "YAxisFavorLabellingScaleEnd":
-                this.yAxis.ld = this.aeb;
+                this.yAxis.ld = this.aed;
                 break;
             case "YAxisAutoRangeBufferMode":
-                this.yAxis.ku = this.ac8;
+                this.yAxis.ku = this.ada;
                 break;
             case "YAxisIsLogarithmic":
-                this.yAxis.li = this.aec;
+                this.yAxis.li = this.aee;
                 break;
             case "YAxisLogarithmBase":
-                this.yAxis.l9 = this.afn;
+                this.yAxis.l9 = this.afp;
                 break;
             case "YAxisMinimumValue":
-                this.yAxis.l5 = this.afi;
+                this.yAxis.l5 = this.afk;
                 break;
             case "YAxisMaximumValue":
-                this.yAxis.l4 = this.afh;
+                this.yAxis.l4 = this.afj;
                 break;
             case "YAxisMinorInterval":
-                this.yAxis.l6 = this.afj;
+                this.yAxis.l6 = this.afl;
                 break;
             case "NegativeBrushes":
             case "NegativeOutlines":
-                this.agt(function (d, e) {
+                this.agv(function (d, e) {
                     if (d.d6) {
-                        d.ms(ArrayExtension.getModulus$1(Brush.$, _this.ac3, e), ArrayExtension.getModulus$1(Brush.$, _this.ac4, e));
+                        d.ms(ArrayExtension.getModulus$1(Brush.$, _this.ac5, e), ArrayExtension.getModulus$1(Brush.$, _this.ac6, e));
                     }
                 });
                 break;
             case "YAxisAbbreviateLargeNumbers":
-                this.abk(function (d) { return d.la = _this.ad9; });
+                this.abm(function (d) { return d.la = _this.aeb; });
                 break;
             case "IsCategoryHighlightingEnabled":
             case "IsItemHighlightingEnabled":
-                this.ti();
+                this.tk();
                 break;
             case "AutoMarginAndAngleUpdateMode":
-                this.so(function (d) { return d.t5 = _this.ac6; });
+                this.sq(function (d) { return d.t6 = _this.ac8; });
                 break;
             case "ShouldAutoExpandMarginForInitialLabels":
-                this.so(function (d) { return d.u0 = _this.ad6; });
+                this.sq(function (d) { return d.u1 = _this.ad8; });
                 break;
-            case CategoryChart.af1:
-                this.so(function (d) { return d.u3 = _this.ad7; });
+            case CategoryChart.af3:
+                this.sq(function (d) { return d.u4 = _this.ad9; });
                 break;
             case "AutoExpandMarginExtraPadding":
-                this.so(function (d) { return d.vq = _this.aev; });
+                this.sq(function (d) { return d.vr = _this.aex; });
                 break;
             case "AutoExpandMarginMaximumValue":
-                this.so(function (d) { return d.vr = _this.aew; });
+                this.sq(function (d) { return d.vs = _this.aey; });
                 break;
-            case CategoryChart.af6:
-                this.abg(function (d) { return d.b1 = _this.ad8; }, a);
+            case CategoryChart.af8:
+                this.abi(function (d) { return d.b1 = _this.aea; }, a);
                 break;
-            case CategoryChart.agk:
-                this.abk(function (d) { return d.b1 = _this.aea; });
+            case CategoryChart.agm:
+                this.abm(function (d) { return d.b1 = _this.aec; });
                 break;
         }
     };
     CategoryChart.$t = markType(CategoryChart, 'CategoryChart', XYChart.$);
-    CategoryChart.af1 = "ShouldConsiderAutoRotationForInitialLabels";
-    CategoryChart.af6 = "XAxisEnhancedIntervalPreferMoreCategoryLabels";
-    CategoryChart.agk = "YAxisEnhancedIntervalPreferMoreCategoryLabels";
+    CategoryChart.af3 = "ShouldConsiderAutoRotationForInitialLabels";
+    CategoryChart.af8 = "XAxisEnhancedIntervalPreferMoreCategoryLabels";
+    CategoryChart.agm = "YAxisEnhancedIntervalPreferMoreCategoryLabels";
     return CategoryChart;
 }(XYChart));
 export { CategoryChart };