igniteui-webcomponents-charts 6.0.0 → 6.0.1

package/esm5/lib/CategoryChart.js

@@ -38,211 +38,211 @@ var CategoryChart = /** @class */ /*@__PURE__*/ (function (_super) {
     __extends(CategoryChart, _super);
     function CategoryChart() {
         var _this = _super.call(this) || this;
-        _this.aj6 = 1000;
-        _this.aj7 = 1000;
-        _this.ah9 = null;
-        _this.aia = null;
-        _this.aht = 9;
-        _this.ahv = 1;
-        _this.aif = false;
-        _this.aig = true;
-        _this.ahx = 0;
-        _this.ah7 = 0;
-        _this.ai3 = 0;
-        _this.ai6 = 0;
-        _this.ai2 = 0;
-        _this.ai5 = 0;
-        _this.ai4 = 1;
-        _this.ai7 = 0;
-        _this.ajd = NaN;
-        _this.ahp = 1;
-        _this.aih = true;
-        _this.aii = true;
-        _this.ai0 = DeviceUtils.g(2);
-        _this.ai1 = DeviceUtils.g(60);
-        _this.aim = true;
-        _this.aij = true;
-        _this.ail = false;
-        _this.ahr = 0;
-        _this.ain = false;
-        _this.aj8 = 10;
-        _this.ajf = NaN;
-        _this.aje = NaN;
-        _this.ajg = 0;
-        _this.ahl = null;
-        _this.ahm = null;
-        _this.aik = true;
-        _this.ai8 = 3;
-        _this.ai9 = NaN;
-        _this.aja = NaN;
-        _this.ajb = NaN;
-        _this.ajc = NaN;
-        _this.aid = false;
-        _this.aie = false;
-        _this.aiz = null;
+        _this.ako = 1000;
+        _this.akp = 1000;
+        _this.air = null;
+        _this.ais = null;
+        _this.aib = 9;
+        _this.aid = 1;
+        _this.aix = false;
+        _this.aiy = true;
+        _this.aif = 0;
+        _this.aip = 0;
+        _this.ajl = 0;
+        _this.ajo = 0;
+        _this.ajk = 0;
+        _this.ajn = 0;
+        _this.ajm = 1;
+        _this.ajp = 0;
+        _this.ajv = NaN;
+        _this.ah7 = 1;
+        _this.aiz = true;
+        _this.ai0 = true;
+        _this.aji = DeviceUtils.g(2);
+        _this.ajj = DeviceUtils.g(60);
+        _this.ai4 = true;
+        _this.ai1 = true;
+        _this.ai3 = false;
+        _this.ah9 = 0;
+        _this.ai5 = false;
+        _this.akq = 10;
+        _this.ajx = NaN;
+        _this.ajw = NaN;
+        _this.ajy = 0;
+        _this.ah3 = null;
+        _this.ah4 = null;
+        _this.ai2 = true;
+        _this.ajq = 3;
+        _this.ajr = NaN;
+        _this.ajs = NaN;
+        _this.ajt = NaN;
+        _this.aju = NaN;
+        _this.aiv = false;
+        _this.aiw = false;
+        _this.ajh = null;
         DVContainer.instance.registerIfLoaded("CategoryChartToolbarFactoryManager");
-        _this.u2();
+        _this.u8();
         return _this;
     }
-    CategoryChart.prototype.vm = function () {
-        _super.prototype.vm.call(this);
+    CategoryChart.prototype.vs = function () {
+        _super.prototype.vs.call(this);
         if (this.dataChart == null) {
             return;
         }
-        var a = this.dataChart.c9.j.e();
-        this.ahn = a.d;
-        this.aho = a.e;
-        if (this.agx == null) {
-            this.agx = a.k;
+        var a = this.dataChart.dc.j.e();
+        this.ah5 = a.d;
+        this.ah6 = a.e;
+        if (this.ahf == null) {
+            this.ahf = a.k;
         }
-        if (this.ag4 == null) {
-            this.ag4 = a.k;
+        if (this.ahm == null) {
+            this.ahm = a.k;
         }
-        this.acw = 0;
-        this.ag5 = AxisDefaults.axis_MajorBrush;
-        this.ag8 = null;
-        this.ag1 = AxisDefaults.axis_LineBrush;
-        this.agy = null;
-        this.acf = AxisDefaults.categoryAxis_TickLength;
-        this.ag2 = AxisDefaults.axis_TickBrush;
-        this.acg = AxisDefaults.axis_TickStroke;
+        this.ada = 0;
+        this.ahn = AxisDefaults.axis_MajorBrush;
+        this.ahq = null;
+        this.ahj = AxisDefaults.axis_LineBrush;
+        this.ahg = null;
+        this.acr = AxisDefaults.categoryAxis_TickLength;
+        this.ahk = AxisDefaults.axis_TickBrush;
+        this.acs = AxisDefaults.axis_TickStroke;
         this.crosshairsAnnotationEnabled = true;
-        this.gq = true;
+        this.gu = true;
         this.crosshairsDisplayMode = 0;
-        this.jq = Defaults.crosshairLineThickness;
-        this.yy = Defaults.crosshairLineBrush;
-        this.yt = Defaults.crosshairXAxisAnnotationBackground;
-        this.yu = Defaults.crosshairXAxisAnnotationTextColor;
-        this.air = true;
+        this.ju = Defaults.crosshairLineThickness;
+        this.y4 = Defaults.crosshairLineBrush;
+        this.yz = Defaults.crosshairXAxisAnnotationBackground;
+        this.y0 = Defaults.crosshairXAxisAnnotationTextColor;
+        this.ai9 = true;
     };
-    CategoryChart.prototype.vo = function (a, b) {
-        _super.prototype.vo.call(this, a, b);
-        a.kf = this.aj9;
-        a.kg = this.aka;
-        a.df = this.aib;
-        a.dg = this.aic;
+    CategoryChart.prototype.vu = function (a, b) {
+        _super.prototype.vu.call(this, a, b);
+        a.kf = this.akr;
+        a.kg = this.aks;
+        a.df = this.ait;
+        a.dg = this.aiu;
     };
-    CategoryChart.prototype.wh = function (a, b, c) {
+    CategoryChart.prototype.wn = function (a, b, c) {
         var _this = this;
-        _super.prototype.wh.call(this, a, b, c);
+        _super.prototype.wn.call(this, a, b, c);
         switch (a) {
             case "TransitionInDuration":
-                this.vb(function (d) { return d.kf = _this.aj9; });
+                this.vh(function (d) { return d.kf = _this.akr; });
                 break;
             case "TransitionOutDuration":
-                this.vb(function (d) { return d.kg = _this.aka; });
+                this.vh(function (d) { return d.kg = _this.aks; });
                 break;
             case "TransitionInEasingFunction":
-                this.vb(function (d) { return d.df = _this.aib; });
+                this.vh(function (d) { return d.df = _this.ait; });
                 break;
             case "TransitionOutEasingFunction":
-                this.vb(function (d) { return d.dg = _this.aic; });
+                this.vh(function (d) { return d.dg = _this.aiu; });
                 break;
         }
     };
-    Object.defineProperty(CategoryChart.prototype, "aj9", {
+    Object.defineProperty(CategoryChart.prototype, "akr", {
         get: function () {
-            return this.aj6;
+            return this.ako;
         },
         set: function (a) {
-            var b = this.aj9;
+            var b = this.akr;
             if (a != b) {
-                this.aj6 = a;
-                this.wd("TransitionInDuration", b, this.aj9);
+                this.ako = a;
+                this.wj("TransitionInDuration", b, this.akr);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aka", {
+    Object.defineProperty(CategoryChart.prototype, "aks", {
         get: function () {
-            return this.aj7;
+            return this.akp;
         },
         set: function (a) {
-            var b = this.aka;
+            var b = this.aks;
             if (a != b) {
-                this.aj7 = a;
-                this.wd("TransitionOutDuration", b, this.aka);
+                this.akp = a;
+                this.wj("TransitionOutDuration", b, this.aks);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aib", {
+    Object.defineProperty(CategoryChart.prototype, "ait", {
         get: function () {
-            return this.ah9;
+            return this.air;
         },
         set: function (a) {
-            var b = this.aib;
+            var b = this.ait;
             if (a != b) {
-                this.ah9 = a;
-                this.wd("TransitionInEasingFunction", b, this.aib);
+                this.air = a;
+                this.wj("TransitionInEasingFunction", b, this.ait);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aic", {
+    Object.defineProperty(CategoryChart.prototype, "aiu", {
         get: function () {
-            return this.aia;
+            return this.ais;
         },
         set: function (a) {
-            var b = this.aic;
+            var b = this.aiu;
             if (a != b) {
-                this.aia = a;
-                this.wd("TransitionOutEasingFunction", b, this.aic);
+                this.ais = a;
+                this.wj("TransitionOutEasingFunction", b, this.aiu);
             }
         },
         enumerable: false,
         configurable: true
     });
-    CategoryChart.prototype.akg = function () {
-        var cvd_ = this.l5();
+    CategoryChart.prototype.aky = function () {
+        var cvd_ = this.l9();
         cvd_.scaleByViewport();
         return (cvd_.serialize());
     };
-    CategoryChart.prototype.vh = function (a, b) {
-        _super.prototype.vh.call(this, a, b);
-        a.ej = this.gj;
-        a.x1 = this.ais;
-        a.x4 = this.ait;
-        a.yr = this.ajh;
-        a.ys = this.aji;
-        a.w6 = this.ahq;
-    };
     CategoryChart.prototype.vn = function (a, b) {
         _super.prototype.vn.call(this, a, b);
+        a.en = this.gl;
+        a.yd = this.aja;
+        a.yg = this.ajb;
+        a.y3 = this.ajz;
+        a.y4 = this.aj0;
+        a.xi = this.ah8;
+    };
+    CategoryChart.prototype.vt = function (a, b) {
+        _super.prototype.vt.call(this, a, b);
         var c = typeCast(HorizontalAnchoredCategorySeries.$, a);
         if (c == null) {
             return;
         }
-        c.aa1 = this.ahw;
-        c.zq = this.air;
-        c.za = this.ahy;
-        c.c6 = this.ah8;
+        c.aa4 = this.aie;
+        c.zq = this.ai9;
+        c.za = this.aig;
+        c.c6 = this.aiq;
         c.trendLineBrush = ArrayExtension.getModulus$1(Brush.$, this.af, b);
         c.trendLineType = this.ec;
-        c.trendLineThickness = this.km;
+        c.trendLineThickness = this.kq;
         c.xf = this.c2(a, b);
         if (a.fn) {
-            a.r7(ArrayExtension.getModulus$1(Brush.$, this.ahn, b), ArrayExtension.getModulus$1(Brush.$, this.aho, b));
+            a.r7(ArrayExtension.getModulus$1(Brush.$, this.ah5, b), ArrayExtension.getModulus$1(Brush.$, this.ah6, b));
         }
     };
-    CategoryChart.prototype.ahz = function () {
+    CategoryChart.prototype.aih = function () {
         return new CategoryXAxis();
     };
-    CategoryChart.prototype.ah3 = function () {
+    CategoryChart.prototype.ail = function () {
         return new NumericYAxis();
     };
-    CategoryChart.prototype.ux = function () {
-        this.xAxis = this.ahz();
+    CategoryChart.prototype.u3 = function () {
+        this.xAxis = this.aih();
         this.xAxis.name = "xAxis";
         var a = this.xAxis;
-        a.propertyChanged = delegateCombine(a.propertyChanged, runOn(this, this.alk));
-        this.yAxis = this.ah3();
+        a.propertyChanged = delegateCombine(a.propertyChanged, runOn(this, this.al2));
+        this.yAxis = this.ail();
         this.yAxis.name = "yAxis";
         var b = this.yAxis;
-        b.propertyChanged = delegateCombine(b.propertyChanged, runOn(this, this.all));
+        b.propertyChanged = delegateCombine(b.propertyChanged, runOn(this, this.al3));
         if (this.xAxis.az == null) {
             this.xAxis.az = new AxisLabelSettings();
         }
@@ -250,20 +250,20 @@ var CategoryChart = /** @class */ /*@__PURE__*/ (function (_super) {
             this.yAxis.az = new AxisLabelSettings();
         }
     };
-    CategoryChart.prototype.afx = function (a) {
-        _super.prototype.afx.call(this, a);
-        a.lf = this.aiv;
-        a.lj = this.aix;
-        a.b1 = this.aiw;
+    CategoryChart.prototype.agf = function (a) {
+        _super.prototype.agf.call(this, a);
+        a.lf = this.ajd;
+        a.lj = this.ajf;
+        a.b1 = this.aje;
     };
-    CategoryChart.prototype.afv = function (a) {
-        _super.prototype.afv.call(this, a);
-        a.b1 = this.aiu;
-        a.zoomMaximumCategoryRange = this.ajv;
-        a.zoomToCategoryRange = this.ajx;
-        a.zoomToCategoryStart = this.ajy;
-        a.zoomMaximumItemSpan = this.ajw;
-        a.zoomToItemSpan = this.ajz;
+    CategoryChart.prototype.agd = function (a) {
+        _super.prototype.agd.call(this, a);
+        a.b1 = this.ajc;
+        a.zoomMaximumCategoryRange = this.akd;
+        a.zoomToCategoryRange = this.akf;
+        a.zoomToCategoryStart = this.akg;
+        a.zoomMaximumItemSpan = this.ake;
+        a.zoomToItemSpan = this.akh;
     };
     CategoryChart.prototype.get_cb = function () {
         return 0;
@@ -275,570 +275,570 @@ var CategoryChart = /** @class */ /*@__PURE__*/ (function (_super) {
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ahu", {
+    Object.defineProperty(CategoryChart.prototype, "aic", {
         get: function () {
-            return this.aht;
+            return this.aib;
         },
         set: function (a) {
-            if (a != this.aht) {
-                var b = this.ahu;
-                this.aht = a;
-                this.wd("ChartType", enumGetBox(CategoryChartType_$type, b), enumGetBox(CategoryChartType_$type, this.ahu));
+            if (a != this.aib) {
+                var b = this.aic;
+                this.aib = a;
+                this.wj("ChartType", enumGetBox(CategoryChartType_$type, b), enumGetBox(CategoryChartType_$type, this.aic));
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ahw", {
+    Object.defineProperty(CategoryChart.prototype, "aie", {
         get: function () {
-            return this.ahv;
+            return this.aid;
         },
         set: function (a) {
-            var b = this.ahw;
+            var b = this.aie;
             if (a != b) {
-                this.ahv = a;
-                this.wd("MarkerCollisionAvoidance", enumGetBox(CategorySeriesMarkerCollisionAvoidance_$type, b), enumGetBox(CategorySeriesMarkerCollisionAvoidance_$type, this.ahw));
+                this.aid = a;
+                this.wj("MarkerCollisionAvoidance", enumGetBox(CategorySeriesMarkerCollisionAvoidance_$type, b), enumGetBox(CategorySeriesMarkerCollisionAvoidance_$type, this.aie));
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aiq", {
+    Object.defineProperty(CategoryChart.prototype, "ai8", {
         get: function () {
-            return this.aif;
+            return this.aix;
         },
         set: function (a) {
-            var b = this.aiq;
+            var b = this.ai8;
             if (a != b) {
-                this.aif = a;
-                this.wd("IsSplineShapePartOfRange", b, this.aiq);
+                this.aix = a;
+                this.wj("IsSplineShapePartOfRange", b, this.ai8);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "air", {
+    Object.defineProperty(CategoryChart.prototype, "ai9", {
         get: function () {
-            return this.aig;
+            return this.aiy;
         },
         set: function (a) {
-            var b = this.air;
+            var b = this.ai9;
             if (a != b) {
-                this.aig = a;
-                this.wd("IsTransitionInEnabled", b, this.air);
+                this.aiy = a;
+                this.wj("IsTransitionInEnabled", b, this.ai9);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ahy", {
+    Object.defineProperty(CategoryChart.prototype, "aig", {
         get: function () {
-            return this.ahx;
+            return this.aif;
         },
         set: function (a) {
-            var b = this.ahy;
+            var b = this.aig;
             if (a != b) {
-                this.ahx = a;
-                this.wd("TransitionInMode", enumGetBox(CategoryTransitionInMode_$type, b), enumGetBox(CategoryTransitionInMode_$type, this.ahy));
+                this.aif = a;
+                this.wj("TransitionInMode", enumGetBox(CategoryTransitionInMode_$type, b), enumGetBox(CategoryTransitionInMode_$type, this.aig));
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ah8", {
+    Object.defineProperty(CategoryChart.prototype, "aiq", {
         get: function () {
-            return this.ah7;
+            return this.aip;
         },
         set: function (a) {
-            var b = this.ah8;
+            var b = this.aiq;
             if (a != b) {
-                this.ah7 = a;
-                this.wd("TransitionInSpeedType", enumGetBox(TransitionInSpeedType_$type, b), enumGetBox(TransitionInSpeedType_$type, this.ah8));
+                this.aip = a;
+                this.wj("TransitionInSpeedType", enumGetBox(TransitionInSpeedType_$type, b), enumGetBox(TransitionInSpeedType_$type, this.aiq));
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ajq", {
+    Object.defineProperty(CategoryChart.prototype, "aj8", {
         get: function () {
-            return this.ai3;
+            return this.ajl;
         },
         set: function (a) {
-            var b = this.ajq;
+            var b = this.aj8;
             if (a != b) {
-                this.ai3 = a;
-                this.wd("XAxisInterval", b, this.ajq);
+                this.ajl = a;
+                this.wj("XAxisInterval", b, this.aj8);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ajt", {
+    Object.defineProperty(CategoryChart.prototype, "akb", {
         get: function () {
-            return this.ai6;
+            return this.ajo;
         },
         set: function (a) {
-            var b = this.ajt;
+            var b = this.akb;
             if (a != b) {
-                this.ai6 = a;
-                this.wd("XAxisMinorInterval", b, this.ajt);
+                this.ajo = a;
+                this.wj("XAxisMinorInterval", b, this.akb);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ajp", {
+    Object.defineProperty(CategoryChart.prototype, "aj7", {
         get: function () {
-            return this.ai2;
+            return this.ajk;
         },
         set: function (a) {
-            var b = this.ajp;
+            var b = this.aj7;
             if (a != b) {
-                this.ai2 = a;
-                this.wd("XAxisGap", b, this.ajp);
+                this.ajk = a;
+                this.wj("XAxisGap", b, this.aj7);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ajs", {
+    Object.defineProperty(CategoryChart.prototype, "aka", {
         get: function () {
-            return this.ai5;
+            return this.ajn;
         },
         set: function (a) {
-            var b = this.ajs;
+            var b = this.aka;
             if (a != b) {
-                this.ai5 = a;
-                this.wd("XAxisMinimumGapSize", b, this.ajs);
+                this.ajn = a;
+                this.wj("XAxisMinimumGapSize", b, this.aka);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ajr", {
+    Object.defineProperty(CategoryChart.prototype, "aj9", {
         get: function () {
-            return this.ai4;
+            return this.ajm;
         },
         set: function (a) {
-            var b = this.ajr;
+            var b = this.aj9;
             if (a != b) {
-                this.ai4 = a;
-                this.wd("XAxisMaximumGap", b, this.ajr);
+                this.ajm = a;
+                this.wj("XAxisMaximumGap", b, this.aj9);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aju", {
+    Object.defineProperty(CategoryChart.prototype, "akc", {
         get: function () {
-            return this.ai7;
+            return this.ajp;
         },
         set: function (a) {
-            var b = this.aju;
+            var b = this.akc;
             if (a != b) {
-                this.ai7 = a;
-                this.wd("XAxisOverlap", b, this.aju);
+                this.ajp = a;
+                this.wj("XAxisOverlap", b, this.akc);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aj2", {
+    Object.defineProperty(CategoryChart.prototype, "akk", {
         get: function () {
-            return this.ajd;
+            return this.ajv;
         },
         set: function (a) {
-            var b = this.aj2;
+            var b = this.akk;
             if (a != b) {
-                this.ajd = a;
-                this.wd("YAxisInterval", b, this.aj2);
+                this.ajv = a;
+                this.wj("YAxisInterval", b, this.akk);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ahq", {
+    Object.defineProperty(CategoryChart.prototype, "ah8", {
         get: function () {
-            return this.ahp;
+            return this.ah7;
         },
         set: function (a) {
-            var b = this.ahq;
+            var b = this.ah8;
             if (a != b) {
-                this.ahp = a;
-                this.wd("AutoMarginAndAngleUpdateMode", enumGetBox(AutoMarginsAndAngleUpdateMode_$type, b), enumGetBox(AutoMarginsAndAngleUpdateMode_$type, this.ahq));
+                this.ah7 = a;
+                this.wj("AutoMarginAndAngleUpdateMode", enumGetBox(AutoMarginsAndAngleUpdateMode_$type, b), enumGetBox(AutoMarginsAndAngleUpdateMode_$type, this.ah8));
             }
         },
         enumerable: false,
         configurable: true
     });
-    CategoryChart.prototype.alm = function () {
+    CategoryChart.prototype.al4 = function () {
         if (this.dataChart != null) {
-            this.dataChart.aac();
+            this.dataChart.aao();
         }
     };
-    Object.defineProperty(CategoryChart.prototype, "ais", {
+    Object.defineProperty(CategoryChart.prototype, "aja", {
         get: function () {
-            return this.aih;
+            return this.aiz;
         },
         set: function (a) {
-            var b = this.ais;
+            var b = this.aja;
             if (a != b) {
-                this.aih = a;
-                this.wd("ShouldAutoExpandMarginForInitialLabels", b, this.ais);
+                this.aiz = a;
+                this.wj("ShouldAutoExpandMarginForInitialLabels", b, this.aja);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ait", {
+    Object.defineProperty(CategoryChart.prototype, "ajb", {
         get: function () {
-            return this.aii;
+            return this.ai0;
         },
         set: function (a) {
-            var b = this.ait;
+            var b = this.ajb;
             if (a != b) {
-                this.aii = a;
-                this.wd(CategoryChart.akp, b, this.ait);
+                this.ai0 = a;
+                this.wj(CategoryChart.ak7, b, this.ajb);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ajh", {
+    Object.defineProperty(CategoryChart.prototype, "ajz", {
         get: function () {
-            return this.ai0;
+            return this.aji;
         },
         set: function (a) {
-            var b = this.ajh;
+            var b = this.ajz;
             if (a != b) {
-                this.ai0 = a;
-                this.wd("AutoExpandMarginExtraPadding", b, this.ajh);
+                this.aji = a;
+                this.wj("AutoExpandMarginExtraPadding", b, this.ajz);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aji", {
+    Object.defineProperty(CategoryChart.prototype, "aj0", {
         get: function () {
-            return this.ai1;
+            return this.ajj;
         },
         set: function (a) {
-            var b = this.aji;
+            var b = this.aj0;
             if (a != b) {
-                this.ai1 = a;
-                this.wd("AutoExpandMarginMaximumValue", b, this.aji);
+                this.ajj = a;
+                this.wj("AutoExpandMarginMaximumValue", b, this.aj0);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aix", {
+    Object.defineProperty(CategoryChart.prototype, "ajf", {
         get: function () {
-            return this.aim;
+            return this.ai4;
         },
         set: function (a) {
-            var b = this.aix;
+            var b = this.ajf;
             if (a != b) {
-                this.aim = a;
-                this.wd("YAxisFavorLabellingScaleEnd", b, this.aix);
+                this.ai4 = a;
+                this.wj("YAxisFavorLabellingScaleEnd", b, this.ajf);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aiu", {
+    Object.defineProperty(CategoryChart.prototype, "ajc", {
         get: function () {
-            return this.aij;
+            return this.ai1;
         },
         set: function (a) {
-            var b = this.aiu;
+            var b = this.ajc;
             if (a != b) {
-                this.aij = a;
-                this.wd(CategoryChart.akw, b, this.aiu);
+                this.ai1 = a;
+                this.wj(CategoryChart.ale, b, this.ajc);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aiw", {
+    Object.defineProperty(CategoryChart.prototype, "aje", {
         get: function () {
-            return this.ail;
+            return this.ai3;
         },
         set: function (a) {
-            var b = this.aiw;
+            var b = this.aje;
             if (a != b) {
-                this.ail = a;
-                this.wd(CategoryChart.ala, b, this.aiw);
+                this.ai3 = a;
+                this.wj(CategoryChart.als, b, this.aje);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ahs", {
+    Object.defineProperty(CategoryChart.prototype, "aia", {
         get: function () {
-            return this.ahr;
+            return this.ah9;
         },
         set: function (a) {
-            var b = this.ahs;
+            var b = this.aia;
             if (a != b) {
-                this.ahr = a;
-                this.wd("YAxisAutoRangeBufferMode", enumGetBox(AxisRangeBufferMode_$type, b), enumGetBox(AxisRangeBufferMode_$type, this.ahs));
+                this.ah9 = a;
+                this.wj("YAxisAutoRangeBufferMode", enumGetBox(AxisRangeBufferMode_$type, b), enumGetBox(AxisRangeBufferMode_$type, this.aia));
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aiy", {
+    Object.defineProperty(CategoryChart.prototype, "ajg", {
         get: function () {
-            return this.ain;
+            return this.ai5;
         },
         set: function (a) {
-            var b = this.aiy;
+            var b = this.ajg;
             if (a != b) {
-                this.ain = a;
-                this.wd("YAxisIsLogarithmic", b, this.aiy);
+                this.ai5 = a;
+                this.wj("YAxisIsLogarithmic", b, this.ajg);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "akb", {
+    Object.defineProperty(CategoryChart.prototype, "akt", {
         get: function () {
-            return this.aj8;
+            return this.akq;
         },
         set: function (a) {
-            var b = this.akb;
+            var b = this.akt;
             if (a != b) {
-                this.aj8 = a;
-                this.wd("YAxisLogarithmBase", b, this.akb);
+                this.akq = a;
+                this.wj("YAxisLogarithmBase", b, this.akt);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aj4", {
+    Object.defineProperty(CategoryChart.prototype, "akm", {
         get: function () {
-            return this.ajf;
+            return this.ajx;
         },
         set: function (a) {
-            var b = this.aj4;
+            var b = this.akm;
             if (a != b) {
-                this.ajf = a;
-                this.wd("YAxisMinimumValue", b, this.aj4);
+                this.ajx = a;
+                this.wj("YAxisMinimumValue", b, this.akm);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aj3", {
+    Object.defineProperty(CategoryChart.prototype, "akl", {
         get: function () {
-            return this.aje;
+            return this.ajw;
         },
         set: function (a) {
-            var b = this.aj3;
+            var b = this.akl;
             if (a != b) {
-                this.aje = a;
-                this.wd("YAxisMaximumValue", b, this.aj3);
+                this.ajw = a;
+                this.wj("YAxisMaximumValue", b, this.akl);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aj5", {
+    Object.defineProperty(CategoryChart.prototype, "akn", {
         get: function () {
-            return this.ajg;
+            return this.ajy;
         },
         set: function (a) {
-            var b = this.aj5;
+            var b = this.akn;
             if (a != b) {
-                this.ajg = a;
-                this.wd("YAxisMinorInterval", b, this.aj5);
+                this.ajy = a;
+                this.wj("YAxisMinorInterval", b, this.akn);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ajo", {
+    Object.defineProperty(CategoryChart.prototype, "aj6", {
         get: function () {
             return this.xAxis.m1;
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ajn", {
+    Object.defineProperty(CategoryChart.prototype, "aj5", {
         get: function () {
             return this.xAxis.m0;
         },
         enumerable: false,
         configurable: true
     });
-    CategoryChart.prototype.ajk = function () {
-        return this.ajo;
+    CategoryChart.prototype.aj2 = function () {
+        return this.aj6;
     };
-    CategoryChart.prototype.ajm = function () {
-        return this.aj1;
+    CategoryChart.prototype.aj4 = function () {
+        return this.akj;
     };
-    CategoryChart.prototype.ajj = function () {
-        return this.ajn;
+    CategoryChart.prototype.aj1 = function () {
+        return this.aj5;
     };
-    CategoryChart.prototype.ajl = function () {
-        return this.aj0;
+    CategoryChart.prototype.aj3 = function () {
+        return this.aki;
     };
-    Object.defineProperty(CategoryChart.prototype, "aj1", {
+    Object.defineProperty(CategoryChart.prototype, "akj", {
         get: function () {
             return this.yAxis.l4;
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aj0", {
+    Object.defineProperty(CategoryChart.prototype, "aki", {
         get: function () {
             return this.yAxis.l3;
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ahn", {
+    Object.defineProperty(CategoryChart.prototype, "ah5", {
         get: function () {
-            return this.ahl;
+            return this.ah3;
         },
         set: function (a) {
-            var b = this.ahn;
+            var b = this.ah5;
             if (a != b) {
-                this.ahl = a;
-                this.wd("NegativeBrushes", b, this.ahn);
+                this.ah3 = a;
+                this.wj("NegativeBrushes", b, this.ah5);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aho", {
+    Object.defineProperty(CategoryChart.prototype, "ah6", {
         get: function () {
-            return this.ahm;
+            return this.ah4;
         },
         set: function (a) {
-            var b = this.aho;
+            var b = this.ah6;
             if (a != b) {
-                this.ahm = a;
-                this.wd("NegativeOutlines", b, this.aho);
+                this.ah4 = a;
+                this.wj("NegativeOutlines", b, this.ah6);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aiv", {
+    Object.defineProperty(CategoryChart.prototype, "ajd", {
         get: function () {
-            return this.aik;
+            return this.ai2;
         },
         set: function (a) {
-            var b = this.aiv;
+            var b = this.ajd;
             if (a != b) {
-                this.aik = a;
-                this.wd("YAxisAbbreviateLargeNumbers", b, this.aiv);
+                this.ai2 = a;
+                this.wj("YAxisAbbreviateLargeNumbers", b, this.ajd);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ajv", {
+    Object.defineProperty(CategoryChart.prototype, "akd", {
         get: function () {
-            return this.ai8;
+            return this.ajq;
         },
         set: function (a) {
-            var b = this.ajv;
+            var b = this.akd;
             if (a != b) {
-                this.ai8 = a;
-                this.wd("XAxisZoomMaximumCategoryRange", b, this.ajv);
+                this.ajq = a;
+                this.wj("XAxisZoomMaximumCategoryRange", b, this.akd);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ajw", {
+    Object.defineProperty(CategoryChart.prototype, "ake", {
         get: function () {
-            return this.ai9;
+            return this.ajr;
         },
         set: function (a) {
-            var b = this.ajw;
+            var b = this.ake;
             if (a != b) {
-                this.ai9 = a;
-                this.wd("XAxisZoomMaximumItemSpan", b, this.ajw);
+                this.ajr = a;
+                this.wj("XAxisZoomMaximumItemSpan", b, this.ake);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ajx", {
+    Object.defineProperty(CategoryChart.prototype, "akf", {
         get: function () {
-            return this.aja;
+            return this.ajs;
         },
         set: function (a) {
-            var b = this.ajx;
+            var b = this.akf;
             if (a != b) {
-                this.aja = a;
-                this.wd("XAxisZoomToCategoryRange", b, this.ajx);
+                this.ajs = a;
+                this.wj("XAxisZoomToCategoryRange", b, this.akf);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ajy", {
+    Object.defineProperty(CategoryChart.prototype, "akg", {
         get: function () {
-            return this.ajb;
+            return this.ajt;
         },
         set: function (a) {
-            var b = this.ajy;
+            var b = this.akg;
             if (a != b) {
-                this.ajb = a;
-                this.wd("XAxisZoomToCategoryStart", b, this.ajy);
+                this.ajt = a;
+                this.wj("XAxisZoomToCategoryStart", b, this.akg);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "ajz", {
+    Object.defineProperty(CategoryChart.prototype, "akh", {
         get: function () {
-            return this.ajc;
+            return this.aju;
         },
         set: function (a) {
-            var b = this.ajz;
+            var b = this.akh;
             if (a != b) {
-                this.ajc = a;
-                this.wd("XAxisZoomToItemSpan", b, this.ajz);
+                this.aju = a;
+                this.wj("XAxisZoomToItemSpan", b, this.akh);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aio", {
+    Object.defineProperty(CategoryChart.prototype, "ai6", {
         get: function () {
-            return this.aid;
+            return this.aiv;
         },
         set: function (a) {
-            var b = this.aio;
+            var b = this.ai6;
             if (a != b) {
-                this.aid = a;
-                this.wd("IsCategoryHighlightingEnabled", b, this.aio);
+                this.aiv = a;
+                this.wj("IsCategoryHighlightingEnabled", b, this.ai6);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(CategoryChart.prototype, "aip", {
+    Object.defineProperty(CategoryChart.prototype, "ai7", {
         get: function () {
-            return this.aie;
+            return this.aiw;
         },
         set: function (a) {
-            var b = this.aip;
+            var b = this.ai7;
             if (a != b) {
-                this.aie = a;
-                this.wd("IsItemHighlightingEnabled", b, this.aip);
+                this.aiw = a;
+                this.wj("IsItemHighlightingEnabled", b, this.ai7);
             }
         },
         enumerable: false,
         configurable: true
     });
-    CategoryChart.prototype.get_h2 = function () {
+    CategoryChart.prototype.get_h6 = function () {
         var a = new List$1(DataSeriesType_$type, 0);
         if (TypeRegistrar.isRegistered("AreaSeries")) {
             a.add(2);
@@ -869,24 +869,24 @@ var CategoryChart = /** @class */ /*@__PURE__*/ (function (_super) {
         }
         return a;
     };
-    Object.defineProperty(CategoryChart.prototype, "h2", {
+    Object.defineProperty(CategoryChart.prototype, "h6", {
         get: function () {
-            return this.get_h2();
+            return this.get_h6();
         },
         enumerable: false,
         configurable: true
     });
-    CategoryChart.prototype.h8 = function () {
-        if (this.aiz == null) {
-            this.aiz = CategoryChartMockDataGenerator.a();
+    CategoryChart.prototype.ic = function () {
+        if (this.ajh == null) {
+            this.ajh = CategoryChartMockDataGenerator.a();
         }
-        return this.aiz;
+        return this.ajh;
     };
     CategoryChart.prototype.c1 = function (a) {
         if (a != null) {
             var b = _super.prototype.c1.call(this, a);
             if (b == 2) {
-                if (a.fm && this.g1) {
+                if (a.fm && this.g5) {
                     return 13;
                 }
             }
@@ -897,42 +897,42 @@ var CategoryChart = /** @class */ /*@__PURE__*/ (function (_super) {
         if (a != null) {
             var b = _super.prototype.c1.call(this, a);
             if (b == 2) {
-                if (a.fm && this.g1) {
+                if (a.fm && this.g5) {
                     return 13;
                 }
             }
         }
         return _super.prototype.c3.call(this, a);
     };
-    CategoryChart.prototype.get_hk = function () {
+    CategoryChart.prototype.get_ho = function () {
         return true;
     };
-    CategoryChart.prototype.alk = function (a, b) {
+    CategoryChart.prototype.al2 = function (a, b) {
         switch (b.propertyName) {
             case "ActualMinimum":
-                this.wv("XAxisActualMinimum");
+                this.w1("XAxisActualMinimum");
                 break;
             case "ActualMaximum":
-                this.wv("XAxisActualMaximum");
+                this.w1("XAxisActualMaximum");
                 break;
         }
     };
-    CategoryChart.prototype.all = function (a, b) {
+    CategoryChart.prototype.al3 = function (a, b) {
         switch (b.propertyName) {
             case "ActualMinimumValue":
-                this.wv("YAxisActualMinimum");
+                this.w1("YAxisActualMinimum");
                 break;
             case "ActualMaximumValue":
-                this.wv("YAxisActualMaximum");
+                this.w1("YAxisActualMaximum");
                 break;
         }
     };
-    CategoryChart.prototype.xa = function () {
-        _super.prototype.xa.call(this);
-        this.xAxis.f2 = this.ac6 == null ? XYChart.adi(this.xAxis, this.bf.dataSeries) : this.ac6;
+    CategoryChart.prototype.xg = function () {
+        _super.prototype.xg.call(this);
+        this.xAxis.f2 = this.adk == null ? XYChart.adw(this.xAxis, this.bf.dataSeries) : this.adk;
         this.xAxis.itemsSource = this.dataChart != null && this.dataChart.series.count > 0 ? this.dataChart.series._inner[0].itemsSource : null;
-        if (this.ais) {
-            this.v1(function (a) { return a.aac(); });
+        if (this.aja) {
+            this.v7(function (a) { return a.aao(); });
         }
     };
     Object.defineProperty(CategoryChart.prototype, "xAxis", {
@@ -955,7 +955,7 @@ var CategoryChart = /** @class */ /*@__PURE__*/ (function (_super) {
         enumerable: false,
         configurable: true
     });
-    CategoryChart.prototype.ah2 = function (a, b) {
+    CategoryChart.prototype.aik = function (a, b) {
         switch (a) {
             case 2: return this.df(1);
             case 3: return this.df(10);
@@ -966,15 +966,15 @@ var CategoryChart = /** @class */ /*@__PURE__*/ (function (_super) {
             case 4: return this.df(4);
             case 5: return this.df(5);
             case 8: return this.df(8);
-            case 9: return this.ah1(b);
+            case 9: return this.aij(b);
             default: return this.df(1);
         }
     };
-    CategoryChart.prototype.ah1 = function (a) {
+    CategoryChart.prototype.aij = function (a) {
         return this.df(a);
     };
     CategoryChart.prototype.be = function (a) {
-        switch (this.ahu) {
+        switch (this.aic) {
             case 1: return 2;
             case 0: return 0;
             case 3: return 10;
@@ -989,23 +989,23 @@ var CategoryChart = /** @class */ /*@__PURE__*/ (function (_super) {
         }
     };
     CategoryChart.prototype.dc = function (a, b) {
-        var c = this.ah2(this.ahu, a.suggestedSeries);
-        c.abr = a.findMatchingHint(0).path;
+        var c = this.aik(this.aic, a.suggestedSeries);
+        c.abu = a.findMatchingHint(0).path;
         c.xAxis = this.xAxis;
         c.yAxis = this.yAxis;
         return c;
     };
-    CategoryChart.prototype.w8 = function (a) {
+    CategoryChart.prototype.xe = function (a) {
         if (a.suggestedSecondaryAxis == 2) {
             this.yAxis.lo = true;
             this.yAxis.mm = 10;
         }
     };
-    CategoryChart.prototype.xb = function () {
-        this.yAxis.lo = this.aiy;
-        this.yAxis.mm = this.akb;
+    CategoryChart.prototype.xh = function () {
+        this.yAxis.lo = this.ajg;
+        this.yAxis.mm = this.akt;
     };
-    CategoryChart.prototype.get_h1 = function () {
+    CategoryChart.prototype.get_h5 = function () {
         return ((function () {
             var $ret = new List$1(IDataSeriesAdapterRule_$type, 0);
             $ret.add(new SimpleCategorySeriesRule());
@@ -1013,24 +1013,24 @@ var CategoryChart = /** @class */ /*@__PURE__*/ (function (_super) {
             return $ret;
         })());
     };
-    Object.defineProperty(CategoryChart.prototype, "h1", {
+    Object.defineProperty(CategoryChart.prototype, "h5", {
         get: function () {
-            return this.get_h1();
+            return this.get_h5();
         },
         enumerable: false,
         configurable: true
     });
-    CategoryChart.prototype.ur = function (a, b) {
+    CategoryChart.prototype.ux = function (a, b) {
         var c = typeCast(HorizontalAnchoredCategorySeries.$, a);
         if (c != null) {
-            c.aa1 = this.ahw;
+            c.aa4 = this.aie;
             c.xf = this.c2(a, b);
         }
     };
-    CategoryChart.prototype.ali = function (a) {
-        this.alj(function (b, c) { return a(b); });
+    CategoryChart.prototype.al0 = function (a) {
+        this.al1(function (b, c) { return a(b); });
     };
-    CategoryChart.prototype.alj = function (a) {
+    CategoryChart.prototype.al1 = function (a) {
         if (this.dataChart == null) {
             return;
         }
@@ -1042,27 +1042,27 @@ var CategoryChart = /** @class */ /*@__PURE__*/ (function (_super) {
             a(c, b);
         }
     };
-    CategoryChart.prototype.aao = function () {
+    CategoryChart.prototype.aau = function () {
         return this.xAxis;
     };
-    CategoryChart.prototype.aap = function () {
+    CategoryChart.prototype.aav = function () {
         return this.yAxis;
     };
-    CategoryChart.prototype.ah5 = function () {
+    CategoryChart.prototype.ain = function () {
         return this.df(30);
     };
-    CategoryChart.prototype.ah6 = function () {
+    CategoryChart.prototype.aio = function () {
         return this.df(31);
     };
-    CategoryChart.prototype.hy = function (a, b) {
-        var c = _super.prototype.hy.call(this, a, b);
+    CategoryChart.prototype.h2 = function (a, b) {
+        var c = _super.prototype.h2.call(this, a, b);
         if (c != null) {
             var d = new List$1(Series.$, 0);
-            if (this.aid) {
-                d.add(this.ah5());
+            if (this.aiv) {
+                d.add(this.ain());
             }
-            if (this.aie) {
-                d.add(this.ah6());
+            if (this.aiw) {
+                d.add(this.aio());
             }
             for (var e = 0; e < d.count; e++) {
                 var f = d._inner[e];
@@ -1080,32 +1080,32 @@ var CategoryChart = /** @class */ /*@__PURE__*/ (function (_super) {
             return this.a9;
         }
     };
-    CategoryChart.prototype.xf = function (a, b, c) {
-        _super.prototype.xf.call(this, a, b, c);
+    CategoryChart.prototype.xl = function (a, b, c) {
+        _super.prototype.xl.call(this, a, b, c);
         if (this.bf.dataSeries.count > 0) {
-            if (stringIsNullOrEmpty(this.nz)) {
+            if (stringIsNullOrEmpty(this.n3)) {
                 this.ce.setXMemberPath(a, c.getMemberPathFor(16));
             }
-            if (stringIsNullOrEmpty(this.n1)) {
+            if (stringIsNullOrEmpty(this.n5)) {
                 this.ce.setYMemberPath(a, c.getMemberPathFor(0));
             }
-            if (stringIsNullOrEmpty(this.nm)) {
+            if (stringIsNullOrEmpty(this.nq)) {
                 this.ce.setLabelMemberPath(a, c.getMemberPathFor(0));
             }
-            if (stringIsNullOrEmpty(this.ni)) {
+            if (stringIsNullOrEmpty(this.nm)) {
                 this.ce.setContentMemberPath(a, c.getMemberPathFor(0));
             }
         }
     };
-    CategoryChart.prototype.g4 = function () {
+    CategoryChart.prototype.g8 = function () {
         if (this.crosshairsDisplayMode == 4 || this.crosshairsDisplayMode == 3) {
             return true;
         }
         else if (this.crosshairsDisplayMode == 0) {
-            if (this.ahu == 2 || this.ahu == 8) {
+            if (this.aic == 2 || this.aic == 8) {
                 return false;
             }
-            else if (this.ahu == 9 && this.bf != null && this.bf.dataSeries != null && this.bf.dataSeries.count > 0) {
+            else if (this.aic == 9 && this.bf != null && this.bf.dataSeries != null && this.bf.dataSeries.count > 0) {
                 var a = this.bf.dataSeries._inner[0].suggestedSeries;
                 if (a == 1 || a == 8) {
                     return false;
@@ -1115,134 +1115,134 @@ var CategoryChart = /** @class */ /*@__PURE__*/ (function (_super) {
         }
         return false;
     };
-    CategoryChart.prototype.get_hb = function () {
+    CategoryChart.prototype.get_hf = function () {
         return DVContainer.instance.checkLoaded("CategoryChartToolbarFactoryManager");
     };
-    CategoryChart.prototype.wd = function (a, b, c) {
+    CategoryChart.prototype.wj = function (a, b, c) {
         var _this = this;
-        _super.prototype.wd.call(this, a, b, c);
+        _super.prototype.wj.call(this, a, b, c);
         switch (a) {
             case "ChartType":
-                this.u8();
+                this.ve();
                 break;
             case "MarkerCollisionAvoidance":
-                this.ali(function (d) { return d.aa1 = _this.ahw; });
+                this.al0(function (d) { return d.aa4 = _this.aie; });
                 break;
             case "IsTransitionInEnabled":
-                this.ali(function (d) { return d.zq = _this.air; });
+                this.al0(function (d) { return d.zq = _this.ai9; });
                 break;
             case "IsSplineShapePartOfRange":
-                this.ali(function (d) {
+                this.al0(function (d) {
                     if (d.f1) {
-                        d.r8(_this.aiq);
+                        d.r8(_this.ai8);
                     }
                 });
                 break;
             case "TransitionInMode":
-                this.ali(function (d) { return d.za = _this.ahy; });
+                this.al0(function (d) { return d.za = _this.aig; });
                 break;
             case "TransitionInSpeedType":
-                this.ali(function (d) { return d.c6 = _this.ah8; });
+                this.al0(function (d) { return d.c6 = _this.aiq; });
                 break;
             case "XAxisInterval":
-                this.xAxis.mw = this.ajq;
+                this.xAxis.mw = this.aj8;
                 break;
             case "XAxisMinorInterval":
-                this.xAxis.mx = this.ajt;
+                this.xAxis.mx = this.akb;
                 break;
             case "XAxisGap":
-                this.xAxis.k5 = this.ajp;
+                this.xAxis.k5 = this.aj7;
                 break;
             case "XAxisOverlap":
-                this.xAxis.le = this.aju;
+                this.xAxis.le = this.akc;
                 break;
             case "XAxisMinimumGapSize":
-                this.xAxis.ld = this.ajs;
+                this.xAxis.ld = this.aka;
                 break;
             case "XAxisMaximumGap":
-                this.xAxis.lc = this.ajr;
+                this.xAxis.lc = this.aj9;
                 break;
             case "XAxisZoomMaximumCategoryRange":
-                this.xAxis.zoomMaximumCategoryRange = this.ajv;
+                this.xAxis.zoomMaximumCategoryRange = this.akd;
                 break;
             case "XAxisZoomMaximumItemSpan":
-                this.xAxis.zoomMaximumItemSpan = this.ajw;
+                this.xAxis.zoomMaximumItemSpan = this.ake;
                 break;
             case "XAxisZoomToCategoryRange":
-                this.xAxis.zoomToCategoryRange = this.ajx;
+                this.xAxis.zoomToCategoryRange = this.akf;
                 break;
             case "XAxisZoomToCategoryStart":
-                this.xAxis.zoomToCategoryStart = this.ajy;
+                this.xAxis.zoomToCategoryStart = this.akg;
                 break;
             case "XAxisZoomToItemSpan":
-                this.xAxis.zoomToItemSpan = this.ajz;
+                this.xAxis.zoomToItemSpan = this.akh;
                 break;
             case "YAxisInterval":
-                this.yAxis.l8 = this.aj2;
+                this.yAxis.l8 = this.akk;
                 break;
             case "YAxisFavorLabellingScaleEnd":
-                this.yAxis.lj = this.aix;
+                this.yAxis.lj = this.ajf;
                 break;
             case "YAxisAutoRangeBufferMode":
-                this.yAxis.ky = this.ahs;
+                this.yAxis.ky = this.aia;
                 break;
             case "YAxisIsLogarithmic":
-                this.yAxis.lo = this.aiy;
+                this.yAxis.lo = this.ajg;
                 break;
             case "YAxisLogarithmBase":
-                this.yAxis.mm = this.akb;
+                this.yAxis.mm = this.akt;
                 break;
             case "YAxisMinimumValue":
-                this.yAxis.mc = this.aj4;
+                this.yAxis.mc = this.akm;
                 break;
             case "YAxisMaximumValue":
-                this.yAxis.mb = this.aj3;
+                this.yAxis.mb = this.akl;
                 break;
             case "YAxisMinorInterval":
-                this.yAxis.md = this.aj5;
+                this.yAxis.md = this.akn;
                 break;
             case "NegativeBrushes":
             case "NegativeOutlines":
-                this.alj(function (d, e) {
+                this.al1(function (d, e) {
                     if (d.fn) {
-                        d.r7(ArrayExtension.getModulus$1(Brush.$, _this.ahn, e), ArrayExtension.getModulus$1(Brush.$, _this.aho, e));
+                        d.r7(ArrayExtension.getModulus$1(Brush.$, _this.ah5, e), ArrayExtension.getModulus$1(Brush.$, _this.ah6, e));
                     }
                 });
                 break;
             case "YAxisAbbreviateLargeNumbers":
-                this.af4(function (d) { return d.lf = _this.aiv; });
+                this.agm(function (d) { return d.lf = _this.ajd; });
                 break;
             case "IsCategoryHighlightingEnabled":
             case "IsItemHighlightingEnabled":
-                this.u8();
+                this.ve();
                 break;
             case "AutoMarginAndAngleUpdateMode":
-                this.v1(function (d) { return d.w6 = _this.ahq; });
+                this.v7(function (d) { return d.xi = _this.ah8; });
                 break;
             case "ShouldAutoExpandMarginForInitialLabels":
-                this.v1(function (d) { return d.x1 = _this.ais; });
+                this.v7(function (d) { return d.yd = _this.aja; });
                 break;
-            case CategoryChart.akp:
-                this.v1(function (d) { return d.x4 = _this.ait; });
+            case CategoryChart.ak7:
+                this.v7(function (d) { return d.yg = _this.ajb; });
                 break;
             case "AutoExpandMarginExtraPadding":
-                this.v1(function (d) { return d.yr = _this.ajh; });
+                this.v7(function (d) { return d.y3 = _this.ajz; });
                 break;
             case "AutoExpandMarginMaximumValue":
-                this.v1(function (d) { return d.ys = _this.aji; });
+                this.v7(function (d) { return d.y4 = _this.aj0; });
                 break;
-            case CategoryChart.akw:
-                this.af0(function (d) { return d.b1 = _this.aiu; }, a);
+            case CategoryChart.ale:
+                this.agi(function (d) { return d.b1 = _this.ajc; }, a);
                 break;
-            case CategoryChart.ala:
-                this.af4(function (d) { return d.b1 = _this.aiw; });
+            case CategoryChart.als:
+                this.agm(function (d) { return d.b1 = _this.aje; });
                 break;
         }
     };
     CategoryChart.$t = markType(CategoryChart, 'CategoryChart', XYChart.$);
-    CategoryChart.akp = "ShouldConsiderAutoRotationForInitialLabels";
-    CategoryChart.akw = "XAxisEnhancedIntervalPreferMoreCategoryLabels";
-    CategoryChart.ala = "YAxisEnhancedIntervalPreferMoreCategoryLabels";
+    CategoryChart.ak7 = "ShouldConsiderAutoRotationForInitialLabels";
+    CategoryChart.ale = "XAxisEnhancedIntervalPreferMoreCategoryLabels";
+    CategoryChart.als = "YAxisEnhancedIntervalPreferMoreCategoryLabels";
     return CategoryChart;
 }(XYChart));
 export { CategoryChart };