igniteui-webcomponents-charts 4.6.0 → 4.7.0

package/esm5/lib/CategoryChart.js

@@ -38,173 +38,211 @@ var CategoryChart = /** @class */ /*@__PURE__*/ (function (_super) {
     __extends(CategoryChart, _super);
     function CategoryChart() {
         var _this = _super.call(this) || this;
-        _this.afm = 1000;
-        _this.adr = null;
-        _this.adb = 9;
-        _this.add = 1;
-        _this.adv = false;
-        _this.adw = true;
-        _this.adf = 0;
+        _this.af4 = 1000;
+        _this.af5 = 1000;
+        _this.ad7 = null;
+        _this.ad8 = null;
+        _this.adr = 9;
+        _this.adt = 1;
+        _this.aed = false;
+        _this.aee = true;
+        _this.adv = 0;
+        _this.ad5 = 0;
+        _this.ae1 = 0;
+        _this.ae4 = 0;
+        _this.ae0 = 0;
+        _this.ae3 = 0;
+        _this.ae2 = 1;
+        _this.ae5 = 0;
+        _this.afb = NaN;
+        _this.adn = 1;
+        _this.aef = true;
+        _this.aeg = true;
+        _this.aey = DeviceUtils.g(2);
+        _this.aez = DeviceUtils.g(60);
+        _this.aek = true;
+        _this.aeh = true;
+        _this.aej = false;
         _this.adp = 0;
-        _this.aej = 0;
-        _this.aem = 0;
-        _this.aei = 0;
-        _this.ael = 0;
-        _this.aek = 1;
-        _this.aen = 0;
-        _this.aet = NaN;
-        _this.ac7 = 1;
-        _this.adx = true;
-        _this.ady = true;
-        _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.aer = NaN;
-        _this.aes = NaN;
-        _this.adt = false;
-        _this.adu = false;
-        _this.aef = null;
+        _this.ael = false;
+        _this.af6 = 10;
+        _this.afd = NaN;
+        _this.afc = NaN;
+        _this.afe = 0;
+        _this.adj = null;
+        _this.adk = null;
+        _this.aei = true;
+        _this.ae6 = 3;
+        _this.ae7 = NaN;
+        _this.ae8 = NaN;
+        _this.ae9 = NaN;
+        _this.afa = NaN;
+        _this.aeb = false;
+        _this.aec = false;
+        _this.aex = null;
         DVContainer.instance.registerIfLoaded("CategoryChartToolbarFactoryManager");
-        _this.rt();
+        _this.r9();
         return _this;
     }
-    CategoryChart.prototype.sb = function () {
-        _super.prototype.sb.call(this);
+    CategoryChart.prototype.sr = function () {
+        _super.prototype.sr.call(this);
         if (this.dataChart == null) {
             return;
         }
-        var a = this.dataChart.cu.j.e();
-        this.ac5 = a.d;
-        this.ac6 = a.e;
-        if (this.acf == null) {
-            this.acf = a.k;
+        var a = this.dataChart.cv.j.e();
+        this.adl = a.d;
+        this.adm = a.e;
+        if (this.acv == null) {
+            this.acv = a.k;
         }
-        if (this.acm == null) {
-            this.acm = a.k;
+        if (this.ac2 == null) {
+            this.ac2 = a.k;
         }
-        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.yu = 0;
+        this.ac3 = AxisDefaults.h;
+        this.ac6 = null;
+        this.acz = AxisDefaults.g;
+        this.acw = null;
+        this.yd = AxisDefaults.f;
+        this.ac0 = AxisDefaults.j;
+        this.ye = AxisDefaults.e;
+        this.fx = true;
+        this.fy = true;
         this.a9 = 0;
-        this.ib = Defaults.j;
-        this.ur = Defaults.ae;
-        this.um = Defaults.af;
-        this.un = Defaults.ag;
-        this.ad7 = true;
+        this.il = Defaults.j;
+        this.u7 = Defaults.ae;
+        this.u2 = Defaults.af;
+        this.u3 = Defaults.ag;
+        this.aep = true;
     };
-    CategoryChart.prototype.sd = function (a, b) {
-        _super.prototype.sd.call(this, a, b);
-        a.hs = this.afo;
-        a.ch = this.ads;
+    CategoryChart.prototype.st = function (a, b) {
+        _super.prototype.st.call(this, a, b);
+        a.jj = this.af7;
+        a.jk = this.af8;
+        a.c1 = this.ad9;
+        a.c2 = this.aea;
     };
-    CategoryChart.prototype.s1 = function (a, b, c) {
+    CategoryChart.prototype.th = function (a, b, c) {
         var _this = this;
-        _super.prototype.s1.call(this, a, b, c);
+        _super.prototype.th.call(this, a, b, c);
         switch (a) {
             case "TransitionInDuration":
-                this.r0(function (d) { return d.hs = _this.afo; });
+                this.sg(function (d) { return d.jj = _this.af7; });
+                break;
+            case "TransitionOutDuration":
+                this.sg(function (d) { return d.jk = _this.af8; });
                 break;
             case "TransitionInEasingFunction":
-                this.r0(function (d) { return d.ch = _this.ads; });
+                this.sg(function (d) { return d.c1 = _this.ad9; });
+                break;
+            case "TransitionOutEasingFunction":
+                this.sg(function (d) { return d.c2 = _this.aea; });
                 break;
         }
     };
-    Object.defineProperty(CategoryChart.prototype, "afo", {
+    Object.defineProperty(CategoryChart.prototype, "af7", {
         get: function () {
-            return this.afm;
+            return this.af4;
         },
         set: function (a) {
-            var b = this.afo;
+            var b = this.af7;
             if (a != b) {
-                this.afm = a;
-                this.sy("TransitionInDuration", b, this.afo);
+                this.af4 = a;
+                this.te("TransitionInDuration", b, this.af7);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ads", {
+    Object.defineProperty(CategoryChart.prototype, "af8", {
         get: function () {
-            return this.adr;
+            return this.af5;
         },
         set: function (a) {
-            var b = this.ads;
+            var b = this.af8;
             if (a != b) {
-                this.adr = a;
-                this.sy("TransitionInEasingFunction", b, this.ads);
+                this.af5 = a;
+                this.te("TransitionOutDuration", b, this.af8);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(CategoryChart.prototype, "ad9", {
+        get: function () {
+            return this.ad7;
+        },
+        set: function (a) {
+            var b = this.ad9;
+            if (a != b) {
+                this.ad7 = a;
+                this.te("TransitionInEasingFunction", b, this.ad9);
             }
         },
         enumerable: false,
         configurable: true
     });
-    CategoryChart.prototype.afu = function () {
-        var cvd_ = this.kb();
+    Object.defineProperty(CategoryChart.prototype, "aea", {
+        get: function () {
+            return this.ad8;
+        },
+        set: function (a) {
+            var b = this.aea;
+            if (a != b) {
+                this.ad8 = a;
+                this.te("TransitionOutEasingFunction", b, this.aea);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    CategoryChart.prototype.age = function () {
+        var cvd_ = this.kk();
         cvd_.scaleByViewport();
         return (cvd_.serialize());
     };
-    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.sm = function (a) {
+        _super.prototype.sm.call(this, a);
+        a.dv = this.fs;
+        a.u4 = this.aeq;
+        a.u7 = this.aer;
+        a.vu = this.aff;
+        a.vv = this.afg;
+        a.t9 = this.ado;
     };
-    CategoryChart.prototype.sc = function (a, b) {
-        _super.prototype.sc.call(this, a, b);
+    CategoryChart.prototype.ss = function (a, b) {
+        _super.prototype.ss.call(this, a, b);
         var c = typeCast(HorizontalAnchoredCategorySeries.$, a);
         if (c == null) {
             return;
         }
-        c.tr = this.ade;
-        c.so = this.ad7;
-        c.r8 = this.adg;
-        c.cb = this.adq;
+        c.xh = this.adu;
+        c.wd = this.aep;
+        c.vx = this.adw;
+        c.ct = this.ad6;
         c.trendLineBrush = ArrayExtension.getModulus$1(Brush.$, this.ah, b);
-        c.trendLineType = this.dq;
-        c.trendLineThickness = this.i9;
-        c.ql = this.cr(a, b);
-        if (a.d6) {
-            a.ms(ArrayExtension.getModulus$1(Brush.$, this.ac5, b), ArrayExtension.getModulus$1(Brush.$, this.ac6, b));
+        c.trendLineType = this.dt;
+        c.trendLineThickness = this.ji;
+        c.ua = this.cs(a, b);
+        if (a.ez) {
+            a.pz(ArrayExtension.getModulus$1(Brush.$, this.adl, b), ArrayExtension.getModulus$1(Brush.$, this.adm, b));
         }
     };
-    CategoryChart.prototype.adh = function () {
+    CategoryChart.prototype.adx = function () {
         return new CategoryXAxis();
     };
-    CategoryChart.prototype.adl = function () {
+    CategoryChart.prototype.ad1 = function () {
         return new NumericYAxis();
     };
-    CategoryChart.prototype.rp = function () {
-        this.xAxis = this.adh();
+    CategoryChart.prototype.r5 = function () {
+        this.xAxis = this.adx();
         this.xAxis.name = "xAxis";
         var a = this.xAxis;
-        a.propertyChanged = delegateCombine(a.propertyChanged, runOn(this, this.agw));
-        this.yAxis = this.adl();
+        a.propertyChanged = delegateCombine(a.propertyChanged, runOn(this, this.ahi));
+        this.yAxis = this.ad1();
         this.yAxis.name = "yAxis";
         var b = this.yAxis;
-        b.propertyChanged = delegateCombine(b.propertyChanged, runOn(this, this.agx));
+        b.propertyChanged = delegateCombine(b.propertyChanged, runOn(this, this.ahj));
         if (this.xAxis.az == null) {
             this.xAxis.az = new AxisLabelSettings();
         }
@@ -212,20 +250,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.abv = function (a) {
+        _super.prototype.abv.call(this, a);
+        a.la = this.aet;
+        a.ld = this.aev;
+        a.b1 = this.aeu;
     };
-    CategoryChart.prototype.abd = function (a) {
-        _super.prototype.abd.call(this, a);
-        a.b1 = this.aea;
-        a.zoomMaximumCategoryRange = this.afb;
-        a.zoomToCategoryRange = this.afd;
-        a.zoomToCategoryStart = this.afe;
-        a.zoomMaximumItemSpan = this.afc;
-        a.zoomToItemSpan = this.aff;
+    CategoryChart.prototype.abt = function (a) {
+        _super.prototype.abt.call(this, a);
+        a.b1 = this.aes;
+        a.zoomMaximumCategoryRange = this.aft;
+        a.zoomToCategoryRange = this.afv;
+        a.zoomToCategoryStart = this.afw;
+        a.zoomMaximumItemSpan = this.afu;
+        a.zoomToItemSpan = this.afx;
     };
     CategoryChart.prototype.get_b1 = function () {
         return 0;
@@ -237,570 +275,570 @@ var CategoryChart = /** @class */ /*@__PURE__*/ (function (_super) {
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "adc", {
+    Object.defineProperty(CategoryChart.prototype, "ads", {
         get: function () {
-            return this.adb;
+            return this.adr;
         },
         set: function (a) {
-            if (a != this.adb) {
-                var b = this.adc;
-                this.adb = a;
-                this.sy("ChartType", enumGetBox(CategoryChartType_$type, b), enumGetBox(CategoryChartType_$type, this.adc));
+            if (a != this.adr) {
+                var b = this.ads;
+                this.adr = a;
+                this.te("ChartType", enumGetBox(CategoryChartType_$type, b), enumGetBox(CategoryChartType_$type, this.ads));
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ade", {
+    Object.defineProperty(CategoryChart.prototype, "adu", {
         get: function () {
-            return this.add;
+            return this.adt;
         },
         set: function (a) {
-            var b = this.ade;
+            var b = this.adu;
             if (a != b) {
-                this.add = a;
-                this.sy("MarkerCollisionAvoidance", enumGetBox(CategorySeriesMarkerCollisionAvoidance_$type, b), enumGetBox(CategorySeriesMarkerCollisionAvoidance_$type, this.ade));
+                this.adt = a;
+                this.te("MarkerCollisionAvoidance", enumGetBox(CategorySeriesMarkerCollisionAvoidance_$type, b), enumGetBox(CategorySeriesMarkerCollisionAvoidance_$type, this.adu));
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ad6", {
+    Object.defineProperty(CategoryChart.prototype, "aeo", {
         get: function () {
-            return this.adv;
+            return this.aed;
         },
         set: function (a) {
-            var b = this.ad6;
+            var b = this.aeo;
             if (a != b) {
-                this.adv = a;
-                this.sy("IsSplineShapePartOfRange", b, this.ad6);
+                this.aed = a;
+                this.te("IsSplineShapePartOfRange", b, this.aeo);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ad7", {
+    Object.defineProperty(CategoryChart.prototype, "aep", {
         get: function () {
-            return this.adw;
+            return this.aee;
         },
         set: function (a) {
-            var b = this.ad7;
+            var b = this.aep;
             if (a != b) {
-                this.adw = a;
-                this.sy("IsTransitionInEnabled", b, this.ad7);
+                this.aee = a;
+                this.te("IsTransitionInEnabled", b, this.aep);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "adg", {
+    Object.defineProperty(CategoryChart.prototype, "adw", {
         get: function () {
-            return this.adf;
+            return this.adv;
         },
         set: function (a) {
-            var b = this.adg;
+            var b = this.adw;
             if (a != b) {
-                this.adf = a;
-                this.sy("TransitionInMode", enumGetBox(CategoryTransitionInMode_$type, b), enumGetBox(CategoryTransitionInMode_$type, this.adg));
+                this.adv = a;
+                this.te("TransitionInMode", enumGetBox(CategoryTransitionInMode_$type, b), enumGetBox(CategoryTransitionInMode_$type, this.adw));
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "adq", {
+    Object.defineProperty(CategoryChart.prototype, "ad6", {
         get: function () {
-            return this.adp;
+            return this.ad5;
         },
         set: function (a) {
-            var b = this.adq;
+            var b = this.ad6;
             if (a != b) {
-                this.adp = a;
-                this.sy("TransitionInSpeedType", enumGetBox(TransitionInSpeedType_$type, b), enumGetBox(TransitionInSpeedType_$type, this.adq));
+                this.ad5 = a;
+                this.te("TransitionInSpeedType", enumGetBox(TransitionInSpeedType_$type, b), enumGetBox(TransitionInSpeedType_$type, this.ad6));
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ae6", {
+    Object.defineProperty(CategoryChart.prototype, "afo", {
         get: function () {
-            return this.aej;
+            return this.ae1;
         },
         set: function (a) {
-            var b = this.ae6;
+            var b = this.afo;
             if (a != b) {
-                this.aej = a;
-                this.sy("XAxisInterval", b, this.ae6);
+                this.ae1 = a;
+                this.te("XAxisInterval", b, this.afo);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ae9", {
+    Object.defineProperty(CategoryChart.prototype, "afr", {
         get: function () {
-            return this.aem;
+            return this.ae4;
         },
         set: function (a) {
-            var b = this.ae9;
+            var b = this.afr;
             if (a != b) {
-                this.aem = a;
-                this.sy("XAxisMinorInterval", b, this.ae9);
+                this.ae4 = a;
+                this.te("XAxisMinorInterval", b, this.afr);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ae5", {
+    Object.defineProperty(CategoryChart.prototype, "afn", {
         get: function () {
-            return this.aei;
+            return this.ae0;
         },
         set: function (a) {
-            var b = this.ae5;
+            var b = this.afn;
             if (a != b) {
-                this.aei = a;
-                this.sy("XAxisGap", b, this.ae5);
+                this.ae0 = a;
+                this.te("XAxisGap", b, this.afn);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ae8", {
+    Object.defineProperty(CategoryChart.prototype, "afq", {
         get: function () {
-            return this.ael;
+            return this.ae3;
         },
         set: function (a) {
-            var b = this.ae8;
+            var b = this.afq;
             if (a != b) {
-                this.ael = a;
-                this.sy("XAxisMinimumGapSize", b, this.ae8);
+                this.ae3 = a;
+                this.te("XAxisMinimumGapSize", b, this.afq);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ae7", {
+    Object.defineProperty(CategoryChart.prototype, "afp", {
         get: function () {
-            return this.aek;
+            return this.ae2;
         },
         set: function (a) {
-            var b = this.ae7;
+            var b = this.afp;
             if (a != b) {
-                this.aek = a;
-                this.sy("XAxisMaximumGap", b, this.ae7);
+                this.ae2 = a;
+                this.te("XAxisMaximumGap", b, this.afp);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "afa", {
+    Object.defineProperty(CategoryChart.prototype, "afs", {
         get: function () {
-            return this.aen;
+            return this.ae5;
         },
         set: function (a) {
-            var b = this.afa;
+            var b = this.afs;
             if (a != b) {
-                this.aen = a;
-                this.sy("XAxisOverlap", b, this.afa);
+                this.ae5 = a;
+                this.te("XAxisOverlap", b, this.afs);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "afi", {
+    Object.defineProperty(CategoryChart.prototype, "af0", {
         get: function () {
-            return this.aet;
+            return this.afb;
         },
         set: function (a) {
-            var b = this.afi;
+            var b = this.af0;
             if (a != b) {
-                this.aet = a;
-                this.sy("YAxisInterval", b, this.afi);
+                this.afb = a;
+                this.te("YAxisInterval", b, this.af0);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ac8", {
+    Object.defineProperty(CategoryChart.prototype, "ado", {
         get: function () {
-            return this.ac7;
+            return this.adn;
         },
         set: function (a) {
-            var b = this.ac8;
+            var b = this.ado;
             if (a != b) {
-                this.ac7 = a;
-                this.sy("AutoMarginAndAngleUpdateMode", enumGetBox(AutoMarginsAndAngleUpdateMode_$type, b), enumGetBox(AutoMarginsAndAngleUpdateMode_$type, this.ac8));
+                this.adn = a;
+                this.te("AutoMarginAndAngleUpdateMode", enumGetBox(AutoMarginsAndAngleUpdateMode_$type, b), enumGetBox(AutoMarginsAndAngleUpdateMode_$type, this.ado));
             }
         },
         enumerable: false,
         configurable: true
     });
-    CategoryChart.prototype.agy = function () {
+    CategoryChart.prototype.ahk = function () {
         if (this.dataChart != null) {
-            this.dataChart.xc();
+            this.dataChart.xf();
         }
     };
-    Object.defineProperty(CategoryChart.prototype, "ad8", {
+    Object.defineProperty(CategoryChart.prototype, "aeq", {
         get: function () {
-            return this.adx;
+            return this.aef;
         },
         set: function (a) {
-            var b = this.ad8;
+            var b = this.aeq;
             if (a != b) {
-                this.adx = a;
-                this.sy("ShouldAutoExpandMarginForInitialLabels", b, this.ad8);
+                this.aef = a;
+                this.te("ShouldAutoExpandMarginForInitialLabels", b, this.aeq);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ad9", {
+    Object.defineProperty(CategoryChart.prototype, "aer", {
         get: function () {
-            return this.ady;
+            return this.aeg;
         },
         set: function (a) {
-            var b = this.ad9;
+            var b = this.aer;
             if (a != b) {
-                this.ady = a;
-                this.sy(CategoryChart.af3, b, this.ad9);
+                this.aeg = a;
+                this.te(CategoryChart.agn, b, this.aer);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aex", {
+    Object.defineProperty(CategoryChart.prototype, "aff", {
         get: function () {
-            return this.aeg;
+            return this.aey;
         },
         set: function (a) {
-            var b = this.aex;
+            var b = this.aff;
             if (a != b) {
-                this.aeg = a;
-                this.sy("AutoExpandMarginExtraPadding", b, this.aex);
+                this.aey = a;
+                this.te("AutoExpandMarginExtraPadding", b, this.aff);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aey", {
+    Object.defineProperty(CategoryChart.prototype, "afg", {
         get: function () {
-            return this.aeh;
+            return this.aez;
         },
         set: function (a) {
-            var b = this.aey;
+            var b = this.afg;
             if (a != b) {
-                this.aeh = a;
-                this.sy("AutoExpandMarginMaximumValue", b, this.aey);
+                this.aez = a;
+                this.te("AutoExpandMarginMaximumValue", b, this.afg);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aed", {
+    Object.defineProperty(CategoryChart.prototype, "aev", {
         get: function () {
-            return this.ad2;
+            return this.aek;
         },
         set: function (a) {
-            var b = this.aed;
+            var b = this.aev;
             if (a != b) {
-                this.ad2 = a;
-                this.sy("YAxisFavorLabellingScaleEnd", b, this.aed);
+                this.aek = a;
+                this.te("YAxisFavorLabellingScaleEnd", b, this.aev);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aea", {
+    Object.defineProperty(CategoryChart.prototype, "aes", {
         get: function () {
-            return this.adz;
+            return this.aeh;
         },
         set: function (a) {
-            var b = this.aea;
+            var b = this.aes;
             if (a != b) {
-                this.adz = a;
-                this.sy(CategoryChart.af8, b, this.aea);
+                this.aeh = a;
+                this.te(CategoryChart.agu, b, this.aes);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aec", {
+    Object.defineProperty(CategoryChart.prototype, "aeu", {
         get: function () {
-            return this.ad1;
+            return this.aej;
         },
         set: function (a) {
-            var b = this.aec;
+            var b = this.aeu;
             if (a != b) {
-                this.ad1 = a;
-                this.sy(CategoryChart.agm, b, this.aec);
+                this.aej = a;
+                this.te(CategoryChart.ag8, b, this.aeu);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ada", {
+    Object.defineProperty(CategoryChart.prototype, "adq", {
         get: function () {
-            return this.ac9;
+            return this.adp;
         },
         set: function (a) {
-            var b = this.ada;
+            var b = this.adq;
             if (a != b) {
-                this.ac9 = a;
-                this.sy("YAxisAutoRangeBufferMode", enumGetBox(AxisRangeBufferMode_$type, b), enumGetBox(AxisRangeBufferMode_$type, this.ada));
+                this.adp = a;
+                this.te("YAxisAutoRangeBufferMode", enumGetBox(AxisRangeBufferMode_$type, b), enumGetBox(AxisRangeBufferMode_$type, this.adq));
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aee", {
+    Object.defineProperty(CategoryChart.prototype, "aew", {
         get: function () {
-            return this.ad3;
+            return this.ael;
         },
         set: function (a) {
-            var b = this.aee;
+            var b = this.aew;
             if (a != b) {
-                this.ad3 = a;
-                this.sy("YAxisIsLogarithmic", b, this.aee);
+                this.ael = a;
+                this.te("YAxisIsLogarithmic", b, this.aew);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "afp", {
+    Object.defineProperty(CategoryChart.prototype, "af9", {
         get: function () {
-            return this.afn;
+            return this.af6;
         },
         set: function (a) {
-            var b = this.afp;
+            var b = this.af9;
             if (a != b) {
-                this.afn = a;
-                this.sy("YAxisLogarithmBase", b, this.afp);
+                this.af6 = a;
+                this.te("YAxisLogarithmBase", b, this.af9);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "afk", {
+    Object.defineProperty(CategoryChart.prototype, "af2", {
         get: function () {
-            return this.aev;
+            return this.afd;
         },
         set: function (a) {
-            var b = this.afk;
+            var b = this.af2;
             if (a != b) {
-                this.aev = a;
-                this.sy("YAxisMinimumValue", b, this.afk);
+                this.afd = a;
+                this.te("YAxisMinimumValue", b, this.af2);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "afj", {
+    Object.defineProperty(CategoryChart.prototype, "af1", {
         get: function () {
-            return this.aeu;
+            return this.afc;
         },
         set: function (a) {
-            var b = this.afj;
+            var b = this.af1;
             if (a != b) {
-                this.aeu = a;
-                this.sy("YAxisMaximumValue", b, this.afj);
+                this.afc = a;
+                this.te("YAxisMaximumValue", b, this.af1);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "afl", {
+    Object.defineProperty(CategoryChart.prototype, "af3", {
         get: function () {
-            return this.aew;
+            return this.afe;
         },
         set: function (a) {
-            var b = this.afl;
+            var b = this.af3;
             if (a != b) {
-                this.aew = a;
-                this.sy("YAxisMinorInterval", b, this.afl);
+                this.afe = a;
+                this.te("YAxisMinorInterval", b, this.af3);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ae4", {
+    Object.defineProperty(CategoryChart.prototype, "afm", {
         get: function () {
             return this.xAxis.mw;
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ae3", {
+    Object.defineProperty(CategoryChart.prototype, "afl", {
         get: function () {
             return this.xAxis.mv;
         },
         enumerable: false,
         configurable: true
     });
-    CategoryChart.prototype.ae0 = function () {
-        return this.ae4;
+    CategoryChart.prototype.afi = function () {
+        return this.afm;
     };
-    CategoryChart.prototype.ae2 = function () {
-        return this.afh;
+    CategoryChart.prototype.afk = function () {
+        return this.afz;
     };
-    CategoryChart.prototype.aez = function () {
-        return this.ae3;
+    CategoryChart.prototype.afh = function () {
+        return this.afl;
     };
-    CategoryChart.prototype.ae1 = function () {
-        return this.afg;
+    CategoryChart.prototype.afj = function () {
+        return this.afy;
     };
-    Object.defineProperty(CategoryChart.prototype, "afh", {
+    Object.defineProperty(CategoryChart.prototype, "afz", {
         get: function () {
             return this.yAxis.lx;
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "afg", {
+    Object.defineProperty(CategoryChart.prototype, "afy", {
         get: function () {
             return this.yAxis.lw;
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ac5", {
+    Object.defineProperty(CategoryChart.prototype, "adl", {
         get: function () {
-            return this.ac3;
+            return this.adj;
         },
         set: function (a) {
-            var b = this.ac5;
+            var b = this.adl;
             if (a != b) {
-                this.ac3 = a;
-                this.sy("NegativeBrushes", b, this.ac5);
+                this.adj = a;
+                this.te("NegativeBrushes", b, this.adl);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ac6", {
+    Object.defineProperty(CategoryChart.prototype, "adm", {
         get: function () {
-            return this.ac4;
+            return this.adk;
         },
         set: function (a) {
-            var b = this.ac6;
+            var b = this.adm;
             if (a != b) {
-                this.ac4 = a;
-                this.sy("NegativeOutlines", b, this.ac6);
+                this.adk = a;
+                this.te("NegativeOutlines", b, this.adm);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aeb", {
+    Object.defineProperty(CategoryChart.prototype, "aet", {
         get: function () {
-            return this.ad0;
+            return this.aei;
         },
         set: function (a) {
-            var b = this.aeb;
+            var b = this.aet;
             if (a != b) {
-                this.ad0 = a;
-                this.sy("YAxisAbbreviateLargeNumbers", b, this.aeb);
+                this.aei = a;
+                this.te("YAxisAbbreviateLargeNumbers", b, this.aet);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "afb", {
+    Object.defineProperty(CategoryChart.prototype, "aft", {
         get: function () {
-            return this.aeo;
+            return this.ae6;
         },
         set: function (a) {
-            var b = this.afb;
+            var b = this.aft;
             if (a != b) {
-                this.aeo = a;
-                this.sy("XAxisZoomMaximumCategoryRange", b, this.afb);
+                this.ae6 = a;
+                this.te("XAxisZoomMaximumCategoryRange", b, this.aft);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "afc", {
+    Object.defineProperty(CategoryChart.prototype, "afu", {
         get: function () {
-            return this.aep;
+            return this.ae7;
         },
         set: function (a) {
-            var b = this.afc;
+            var b = this.afu;
             if (a != b) {
-                this.aep = a;
-                this.sy("XAxisZoomMaximumItemSpan", b, this.afc);
+                this.ae7 = a;
+                this.te("XAxisZoomMaximumItemSpan", b, this.afu);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "afd", {
+    Object.defineProperty(CategoryChart.prototype, "afv", {
         get: function () {
-            return this.aeq;
+            return this.ae8;
         },
         set: function (a) {
-            var b = this.afd;
+            var b = this.afv;
             if (a != b) {
-                this.aeq = a;
-                this.sy("XAxisZoomToCategoryRange", b, this.afd);
+                this.ae8 = a;
+                this.te("XAxisZoomToCategoryRange", b, this.afv);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "afe", {
+    Object.defineProperty(CategoryChart.prototype, "afw", {
         get: function () {
-            return this.aer;
+            return this.ae9;
         },
         set: function (a) {
-            var b = this.afe;
+            var b = this.afw;
             if (a != b) {
-                this.aer = a;
-                this.sy("XAxisZoomToCategoryStart", b, this.afe);
+                this.ae9 = a;
+                this.te("XAxisZoomToCategoryStart", b, this.afw);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aff", {
+    Object.defineProperty(CategoryChart.prototype, "afx", {
         get: function () {
-            return this.aes;
+            return this.afa;
         },
         set: function (a) {
-            var b = this.aff;
+            var b = this.afx;
             if (a != b) {
-                this.aes = a;
-                this.sy("XAxisZoomToItemSpan", b, this.aff);
+                this.afa = a;
+                this.te("XAxisZoomToItemSpan", b, this.afx);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ad4", {
+    Object.defineProperty(CategoryChart.prototype, "aem", {
         get: function () {
-            return this.adt;
+            return this.aeb;
         },
         set: function (a) {
-            var b = this.ad4;
+            var b = this.aem;
             if (a != b) {
-                this.adt = a;
-                this.sy("IsCategoryHighlightingEnabled", b, this.ad4);
+                this.aeb = a;
+                this.te("IsCategoryHighlightingEnabled", b, this.aem);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ad5", {
+    Object.defineProperty(CategoryChart.prototype, "aen", {
         get: function () {
-            return this.adu;
+            return this.aec;
         },
         set: function (a) {
-            var b = this.ad5;
+            var b = this.aen;
             if (a != b) {
-                this.adu = a;
-                this.sy("IsItemHighlightingEnabled", b, this.ad5);
+                this.aec = a;
+                this.te("IsItemHighlightingEnabled", b, this.aen);
             }
         },
         enumerable: false,
         configurable: true
     });
-    CategoryChart.prototype.get_gt = function () {
+    CategoryChart.prototype.get_g2 = function () {
         var a = new List$1(DataSeriesType_$type, 0);
         if (TypeRegistrar.isRegistered("AreaSeries")) {
             a.add(2);
@@ -831,70 +869,70 @@ var CategoryChart = /** @class */ /*@__PURE__*/ (function (_super) {
         }
         return a;
     };
-    Object.defineProperty(CategoryChart.prototype, "gt", {
+    Object.defineProperty(CategoryChart.prototype, "g2", {
         get: function () {
-            return this.get_gt();
+            return this.get_g2();
         },
         enumerable: false,
         configurable: true
     });
-    CategoryChart.prototype.gx = function () {
-        if (this.aef == null) {
-            this.aef = CategoryChartMockDataGenerator.a();
+    CategoryChart.prototype.g6 = function () {
+        if (this.aex == null) {
+            this.aex = CategoryChartMockDataGenerator.a();
         }
-        return this.aef;
+        return this.aex;
     };
-    CategoryChart.prototype.cq = function (a) {
+    CategoryChart.prototype.cr = function (a) {
         if (a != null) {
-            var b = _super.prototype.cq.call(this, a);
+            var b = _super.prototype.cr.call(this, a);
             if (b == 2) {
-                if (a.d5 && this.fz) {
+                if (a.ey && this.f8) {
                     return 13;
                 }
             }
         }
-        return _super.prototype.cq.call(this, a);
+        return _super.prototype.cr.call(this, a);
     };
-    CategoryChart.prototype.cs = function (a) {
+    CategoryChart.prototype.ct = function (a) {
         if (a != null) {
-            var b = _super.prototype.cq.call(this, a);
+            var b = _super.prototype.cr.call(this, a);
             if (b == 2) {
-                if (a.d5 && this.fz) {
+                if (a.ey && this.f8) {
                     return 13;
                 }
             }
         }
-        return _super.prototype.cs.call(this, a);
+        return _super.prototype.ct.call(this, a);
     };
-    CategoryChart.prototype.get_gg = function () {
+    CategoryChart.prototype.get_gp = function () {
         return this.xAxis != null && this.xAxis.categoryMode != 0;
     };
-    CategoryChart.prototype.agw = function (a, b) {
+    CategoryChart.prototype.ahi = function (a, b) {
         switch (b.propertyName) {
             case "ActualMinimum":
-                this.s8("XAxisActualMinimum");
+                this.to("XAxisActualMinimum");
                 break;
             case "ActualMaximum":
-                this.s8("XAxisActualMaximum");
+                this.to("XAxisActualMaximum");
                 break;
         }
     };
-    CategoryChart.prototype.agx = function (a, b) {
+    CategoryChart.prototype.ahj = function (a, b) {
         switch (b.propertyName) {
             case "ActualMinimumValue":
-                this.s8("YAxisActualMinimum");
+                this.to("YAxisActualMinimum");
                 break;
             case "ActualMaximumValue":
-                this.s8("YAxisActualMaximum");
+                this.to("YAxisActualMaximum");
                 break;
         }
     };
-    CategoryChart.prototype.tk = function () {
-        _super.prototype.tk.call(this);
-        this.xAxis.f0 = this.yo == null ? XYChart.y0(this.xAxis, this.bd.dataSeries) : this.yo;
+    CategoryChart.prototype.t0 = function () {
+        _super.prototype.t0.call(this);
+        this.xAxis.f0 = this.y4 == null ? XYChart.zg(this.xAxis, this.bd.dataSeries) : this.y4;
         this.xAxis.itemsSource = this.dataChart != null && this.dataChart.series.count > 0 ? this.dataChart.series._inner[0].itemsSource : null;
-        if (this.ad8) {
-            this.sq(function (a) { return a.xc(); });
+        if (this.aeq) {
+            this.s6(function (a) { return a.xf(); });
         }
     };
     Object.defineProperty(CategoryChart.prototype, "xAxis", {
@@ -917,26 +955,26 @@ var CategoryChart = /** @class */ /*@__PURE__*/ (function (_super) {
         enumerable: false,
         configurable: true
     });
-    CategoryChart.prototype.adk = function (a, b) {
+    CategoryChart.prototype.ad0 = function (a, b) {
         switch (a) {
-            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.adj(b);
-            default: return this.c3(1);
+            case 2: return this.c4(1);
+            case 3: return this.c4(10);
+            case 0: return this.c4(0);
+            case 1: return this.c4(2);
+            case 6: return this.c4(6);
+            case 7: return this.c4(7);
+            case 4: return this.c4(4);
+            case 5: return this.c4(5);
+            case 8: return this.c4(8);
+            case 9: return this.adz(b);
+            default: return this.c4(1);
         }
     };
-    CategoryChart.prototype.adj = function (a) {
-        return this.c3(a);
+    CategoryChart.prototype.adz = function (a) {
+        return this.c4(a);
     };
     CategoryChart.prototype.bc = function (a) {
-        switch (this.adc) {
+        switch (this.ads) {
             case 1: return 2;
             case 0: return 0;
             case 3: return 10;
@@ -950,24 +988,24 @@ var CategoryChart = /** @class */ /*@__PURE__*/ (function (_super) {
             case 2: return 1;
         }
     };
-    CategoryChart.prototype.c1 = function (a, b) {
-        var c = this.adk(this.adc, a.suggestedSeries);
-        c.uc = a.findMatchingHint(0).path;
+    CategoryChart.prototype.c2 = function (a, b) {
+        var c = this.ad0(this.ads, a.suggestedSeries);
+        c.x5 = a.findMatchingHint(0).path;
         c.xAxis = this.xAxis;
         c.yAxis = this.yAxis;
         return c;
     };
-    CategoryChart.prototype.ti = function (a) {
+    CategoryChart.prototype.ty = function (a) {
         if (a.suggestedSecondaryAxis == 2) {
             this.yAxis.li = true;
             this.yAxis.l9 = 10;
         }
     };
-    CategoryChart.prototype.tl = function () {
-        this.yAxis.li = this.aee;
-        this.yAxis.l9 = this.afp;
+    CategoryChart.prototype.t1 = function () {
+        this.yAxis.li = this.aew;
+        this.yAxis.l9 = this.af9;
     };
-    CategoryChart.prototype.get_gs = function () {
+    CategoryChart.prototype.get_g1 = function () {
         return ((function () {
             var $ret = new List$1(IDataSeriesAdapterRule_$type, 0);
             $ret.add(new SimpleCategorySeriesRule());
@@ -975,24 +1013,24 @@ var CategoryChart = /** @class */ /*@__PURE__*/ (function (_super) {
             return $ret;
         })());
     };
-    Object.defineProperty(CategoryChart.prototype, "gs", {
+    Object.defineProperty(CategoryChart.prototype, "g1", {
         get: function () {
-            return this.get_gs();
+            return this.get_g1();
         },
         enumerable: false,
         configurable: true
     });
-    CategoryChart.prototype.rl = function (a, b) {
+    CategoryChart.prototype.r1 = function (a, b) {
         var c = typeCast(HorizontalAnchoredCategorySeries.$, a);
         if (c != null) {
-            c.tr = this.ade;
-            c.ql = this.cr(a, b);
+            c.xh = this.adu;
+            c.ua = this.cs(a, b);
         }
     };
-    CategoryChart.prototype.agu = function (a) {
-        this.agv(function (b, c) { return a(b); });
+    CategoryChart.prototype.ahg = function (a) {
+        this.ahh(function (b, c) { return a(b); });
     };
-    CategoryChart.prototype.agv = function (a) {
+    CategoryChart.prototype.ahh = function (a) {
         if (this.dataChart == null) {
             return;
         }
@@ -1004,27 +1042,27 @@ var CategoryChart = /** @class */ /*@__PURE__*/ (function (_super) {
             a(c, b);
         }
     };
-    CategoryChart.prototype.v6 = function () {
+    CategoryChart.prototype.wm = function () {
         return this.xAxis;
     };
-    CategoryChart.prototype.v7 = function () {
+    CategoryChart.prototype.wn = function () {
         return this.yAxis;
     };
-    CategoryChart.prototype.adn = function () {
-        return this.c3(30);
+    CategoryChart.prototype.ad3 = function () {
+        return this.c4(30);
     };
-    CategoryChart.prototype.ado = function () {
-        return this.c3(31);
+    CategoryChart.prototype.ad4 = function () {
+        return this.c4(31);
     };
-    CategoryChart.prototype.gp = function (a, b) {
-        var c = _super.prototype.gp.call(this, a, b);
+    CategoryChart.prototype.gy = function (a, b) {
+        var c = _super.prototype.gy.call(this, a, b);
         if (c != null) {
             var d = new List$1(Series.$, 0);
-            if (this.adt) {
-                d.add(this.adn());
+            if (this.aeb) {
+                d.add(this.ad3());
             }
-            if (this.adu) {
-                d.add(this.ado());
+            if (this.aec) {
+                d.add(this.ad4());
             }
             for (var e = 0; e < d.count; e++) {
                 var f = d._inner[e];
@@ -1042,32 +1080,32 @@ var CategoryChart = /** @class */ /*@__PURE__*/ (function (_super) {
             return this.a6;
         }
     };
-    CategoryChart.prototype.tq = function (a, b, c) {
-        _super.prototype.tq.call(this, a, b, c);
+    CategoryChart.prototype.t6 = function (a, b, c) {
+        _super.prototype.t6.call(this, a, b, c);
         if (this.bd.dataSeries.count > 0) {
-            if (stringIsNullOrEmpty(this.lo)) {
-                this.b3.setXMemberPath(a, c.getMemberPathFor(16));
+            if (stringIsNullOrEmpty(this.lz)) {
+                this.b4.setXMemberPath(a, c.getMemberPathFor(16));
             }
-            if (stringIsNullOrEmpty(this.lq)) {
-                this.b3.setYMemberPath(a, c.getMemberPathFor(0));
+            if (stringIsNullOrEmpty(this.l1)) {
+                this.b4.setYMemberPath(a, c.getMemberPathFor(0));
             }
-            if (stringIsNullOrEmpty(this.lk)) {
-                this.b3.setLabelMemberPath(a, c.getMemberPathFor(0));
+            if (stringIsNullOrEmpty(this.lv)) {
+                this.b4.setLabelMemberPath(a, c.getMemberPathFor(0));
             }
-            if (stringIsNullOrEmpty(this.lh)) {
-                this.b3.setContentMemberPath(a, c.getMemberPathFor(0));
+            if (stringIsNullOrEmpty(this.ls)) {
+                this.b4.setContentMemberPath(a, c.getMemberPathFor(0));
             }
         }
     };
-    CategoryChart.prototype.f2 = function () {
+    CategoryChart.prototype.gb = function () {
         if (this.a9 == 4 || this.a9 == 3) {
             return true;
         }
         else if (this.a9 == 0) {
-            if (this.adc == 2 || this.adc == 8) {
+            if (this.ads == 2 || this.ads == 8) {
                 return false;
             }
-            else if (this.adc == 9 && this.bd != null && this.bd.dataSeries != null && this.bd.dataSeries.count > 0) {
+            else if (this.ads == 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 +1115,134 @@ var CategoryChart = /** @class */ /*@__PURE__*/ (function (_super) {
         }
         return false;
     };
-    CategoryChart.prototype.get_f8 = function () {
+    CategoryChart.prototype.get_gh = function () {
         return DVContainer.instance.checkLoaded("CategoryChartToolbarFactoryManager");
     };
-    CategoryChart.prototype.sy = function (a, b, c) {
+    CategoryChart.prototype.te = function (a, b, c) {
         var _this = this;
-        _super.prototype.sy.call(this, a, b, c);
+        _super.prototype.te.call(this, a, b, c);
         switch (a) {
             case "ChartType":
-                this.tk();
+                this.t0();
                 break;
             case "MarkerCollisionAvoidance":
-                this.agu(function (d) { return d.tr = _this.ade; });
+                this.ahg(function (d) { return d.xh = _this.adu; });
                 break;
             case "IsTransitionInEnabled":
-                this.agu(function (d) { return d.so = _this.ad7; });
+                this.ahg(function (d) { return d.wd = _this.aep; });
                 break;
             case "IsSplineShapePartOfRange":
-                this.agu(function (d) {
-                    if (d.ej) {
-                        d.mt(_this.ad6);
+                this.ahg(function (d) {
+                    if (d.fd) {
+                        d.p0(_this.aeo);
                     }
                 });
                 break;
             case "TransitionInMode":
-                this.agu(function (d) { return d.r8 = _this.adg; });
+                this.ahg(function (d) { return d.vx = _this.adw; });
                 break;
             case "TransitionInSpeedType":
-                this.agu(function (d) { return d.cb = _this.adq; });
+                this.ahg(function (d) { return d.ct = _this.ad6; });
                 break;
             case "XAxisInterval":
-                this.xAxis.mr = this.ae6;
+                this.xAxis.mr = this.afo;
                 break;
             case "XAxisMinorInterval":
-                this.xAxis.ms = this.ae9;
+                this.xAxis.ms = this.afr;
                 break;
             case "XAxisGap":
-                this.xAxis.k1 = this.ae5;
+                this.xAxis.k1 = this.afn;
                 break;
             case "XAxisOverlap":
-                this.xAxis.la = this.afa;
+                this.xAxis.la = this.afs;
                 break;
             case "XAxisMinimumGapSize":
-                this.xAxis.k9 = this.ae8;
+                this.xAxis.k9 = this.afq;
                 break;
             case "XAxisMaximumGap":
-                this.xAxis.k8 = this.ae7;
+                this.xAxis.k8 = this.afp;
                 break;
             case "XAxisZoomMaximumCategoryRange":
-                this.xAxis.zoomMaximumCategoryRange = this.afb;
+                this.xAxis.zoomMaximumCategoryRange = this.aft;
                 break;
             case "XAxisZoomMaximumItemSpan":
-                this.xAxis.zoomMaximumItemSpan = this.afc;
+                this.xAxis.zoomMaximumItemSpan = this.afu;
                 break;
             case "XAxisZoomToCategoryRange":
-                this.xAxis.zoomToCategoryRange = this.afd;
+                this.xAxis.zoomToCategoryRange = this.afv;
                 break;
             case "XAxisZoomToCategoryStart":
-                this.xAxis.zoomToCategoryStart = this.afe;
+                this.xAxis.zoomToCategoryStart = this.afw;
                 break;
             case "XAxisZoomToItemSpan":
-                this.xAxis.zoomToItemSpan = this.aff;
+                this.xAxis.zoomToItemSpan = this.afx;
                 break;
             case "YAxisInterval":
-                this.yAxis.l1 = this.afi;
+                this.yAxis.l1 = this.af0;
                 break;
             case "YAxisFavorLabellingScaleEnd":
-                this.yAxis.ld = this.aed;
+                this.yAxis.ld = this.aev;
                 break;
             case "YAxisAutoRangeBufferMode":
-                this.yAxis.ku = this.ada;
+                this.yAxis.ku = this.adq;
                 break;
             case "YAxisIsLogarithmic":
-                this.yAxis.li = this.aee;
+                this.yAxis.li = this.aew;
                 break;
             case "YAxisLogarithmBase":
-                this.yAxis.l9 = this.afp;
+                this.yAxis.l9 = this.af9;
                 break;
             case "YAxisMinimumValue":
-                this.yAxis.l5 = this.afk;
+                this.yAxis.l5 = this.af2;
                 break;
             case "YAxisMaximumValue":
-                this.yAxis.l4 = this.afj;
+                this.yAxis.l4 = this.af1;
                 break;
             case "YAxisMinorInterval":
-                this.yAxis.l6 = this.afl;
+                this.yAxis.l6 = this.af3;
                 break;
             case "NegativeBrushes":
             case "NegativeOutlines":
-                this.agv(function (d, e) {
-                    if (d.d6) {
-                        d.ms(ArrayExtension.getModulus$1(Brush.$, _this.ac5, e), ArrayExtension.getModulus$1(Brush.$, _this.ac6, e));
+                this.ahh(function (d, e) {
+                    if (d.ez) {
+                        d.pz(ArrayExtension.getModulus$1(Brush.$, _this.adl, e), ArrayExtension.getModulus$1(Brush.$, _this.adm, e));
                     }
                 });
                 break;
             case "YAxisAbbreviateLargeNumbers":
-                this.abm(function (d) { return d.la = _this.aeb; });
+                this.ab2(function (d) { return d.la = _this.aet; });
                 break;
             case "IsCategoryHighlightingEnabled":
             case "IsItemHighlightingEnabled":
-                this.tk();
+                this.t0();
                 break;
             case "AutoMarginAndAngleUpdateMode":
-                this.sq(function (d) { return d.t6 = _this.ac8; });
+                this.s6(function (d) { return d.t9 = _this.ado; });
                 break;
             case "ShouldAutoExpandMarginForInitialLabels":
-                this.sq(function (d) { return d.u1 = _this.ad8; });
+                this.s6(function (d) { return d.u4 = _this.aeq; });
                 break;
-            case CategoryChart.af3:
-                this.sq(function (d) { return d.u4 = _this.ad9; });
+            case CategoryChart.agn:
+                this.s6(function (d) { return d.u7 = _this.aer; });
                 break;
             case "AutoExpandMarginExtraPadding":
-                this.sq(function (d) { return d.vr = _this.aex; });
+                this.s6(function (d) { return d.vu = _this.aff; });
                 break;
             case "AutoExpandMarginMaximumValue":
-                this.sq(function (d) { return d.vs = _this.aey; });
+                this.s6(function (d) { return d.vv = _this.afg; });
                 break;
-            case CategoryChart.af8:
-                this.abi(function (d) { return d.b1 = _this.aea; }, a);
+            case CategoryChart.agu:
+                this.aby(function (d) { return d.b1 = _this.aes; }, a);
                 break;
-            case CategoryChart.agm:
-                this.abm(function (d) { return d.b1 = _this.aec; });
+            case CategoryChart.ag8:
+                this.ab2(function (d) { return d.b1 = _this.aeu; });
                 break;
         }
     };
     CategoryChart.$t = markType(CategoryChart, 'CategoryChart', XYChart.$);
-    CategoryChart.af3 = "ShouldConsiderAutoRotationForInitialLabels";
-    CategoryChart.af8 = "XAxisEnhancedIntervalPreferMoreCategoryLabels";
-    CategoryChart.agm = "YAxisEnhancedIntervalPreferMoreCategoryLabels";
+    CategoryChart.agn = "ShouldConsiderAutoRotationForInitialLabels";
+    CategoryChart.agu = "XAxisEnhancedIntervalPreferMoreCategoryLabels";
+    CategoryChart.ag8 = "YAxisEnhancedIntervalPreferMoreCategoryLabels";
     return CategoryChart;
 }(XYChart));
 export { CategoryChart };