igniteui-webcomponents-charts 4.6.0 → 4.7.0

package/esm5/lib/XYChart.js

@@ -24,88 +24,88 @@ var XYChart = /** @class */ /*@__PURE__*/ (function (_super) {
     __extends(XYChart, _super);
     function XYChart() {
         var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.v8 = null;
-        _this.v9 = null;
-        _this.wp = 0;
-        _this.wr = 5;
-        _this.wq = 0;
-        _this.wo = 5;
-        _this.w6 = 5;
-        _this.w8 = 0;
-        _this.w7 = 5;
+        _this.wo = null;
+        _this.wp = null;
         _this.w5 = 0;
-        _this.abz = null;
-        _this.ab6 = null;
-        _this.abx = null;
-        _this.aby = null;
-        _this.w0 = 0;
-        _this.xh = 0;
-        _this.wz = NaN;
-        _this.xg = NaN;
-        _this.w2 = NaN;
-        _this.xj = NaN;
-        _this.w1 = NaN;
-        _this.xi = NaN;
-        _this.wy = NaN;
+        _this.w7 = 5;
+        _this.w6 = 0;
+        _this.w4 = 5;
+        _this.xm = 5;
+        _this.xo = 0;
+        _this.xn = 5;
+        _this.xl = 0;
+        _this.acf = null;
+        _this.acm = null;
+        _this.acd = null;
+        _this.ace = null;
+        _this.xg = 0;
+        _this.xx = 0;
         _this.xf = NaN;
-        _this.ab5 = null;
-        _this.acc = null;
-        _this.yr = null;
-        _this.yv = null;
-        _this.yt = null;
-        _this.yx = null;
-        _this.ym = null;
-        _this.yn = null;
-        _this.ab0 = null;
-        _this.ab7 = null;
-        _this.ws = DeviceUtils.g(1);
+        _this.xw = NaN;
+        _this.xi = NaN;
+        _this.xz = NaN;
+        _this.xh = NaN;
+        _this.xy = NaN;
+        _this.xe = NaN;
+        _this.xv = NaN;
+        _this.acl = null;
+        _this.acs = null;
+        _this.y7 = null;
+        _this.zb = null;
+        _this.y9 = null;
+        _this.zd = null;
+        _this.y2 = null;
+        _this.y3 = null;
+        _this.acg = null;
+        _this.acn = null;
+        _this.w8 = DeviceUtils.g(1);
+        _this.xp = DeviceUtils.g(1);
         _this.w9 = DeviceUtils.g(1);
-        _this.wt = DeviceUtils.g(1);
+        _this.xq = DeviceUtils.g(1);
+        _this.aci = null;
+        _this.acp = null;
+        _this.acj = null;
+        _this.acq = null;
         _this.xa = DeviceUtils.g(1);
-        _this.ab2 = null;
-        _this.ab9 = null;
-        _this.ab3 = null;
-        _this.aca = null;
-        _this.wu = DeviceUtils.g(1);
-        _this.xb = DeviceUtils.g(1);
-        _this.wv = DeviceUtils.g(8);
-        _this.xc = 0;
-        _this.ab4 = null;
-        _this.acb = null;
-        _this.ww = DeviceUtils.g(1);
-        _this.xd = DeviceUtils.g(1);
-        _this.ys = null;
-        _this.yw = null;
-        _this.ab1 = null;
-        _this.ab8 = null;
-        _this.wn = 0;
-        _this.w4 = 0;
-        _this.wm = NaN;
-        _this.w3 = NaN;
-        _this.wx = 0;
-        _this.xe = -90;
-        _this.wi = false;
-        _this.wj = false;
-        _this.abs = 1;
-        _this.acv = 1;
-        _this.abr = 1;
-        _this.abt = 2;
-        _this.act = 0;
-        _this.acu = 1;
-        _this.acz = 0;
-        _this.ac0 = 0;
-        _this.wg = 4;
-        _this.we = 4;
-        _this.yq = null;
-        _this.v2 = null;
-        _this.yu = null;
-        _this.v3 = null;
+        _this.xr = DeviceUtils.g(1);
+        _this.xb = DeviceUtils.g(8);
+        _this.xs = 0;
+        _this.ack = null;
+        _this.acr = null;
+        _this.xc = DeviceUtils.g(1);
+        _this.xt = DeviceUtils.g(1);
+        _this.y8 = null;
+        _this.zc = null;
+        _this.ach = null;
+        _this.aco = null;
+        _this.w3 = 0;
+        _this.xk = 0;
+        _this.w2 = NaN;
+        _this.xj = NaN;
+        _this.xd = 0;
+        _this.xu = -90;
+        _this.wy = false;
+        _this.wz = false;
+        _this.ab8 = 1;
+        _this.adb = 1;
+        _this.ab7 = 1;
+        _this.ab9 = 2;
+        _this.ac9 = 0;
+        _this.ada = 1;
+        _this.adf = 0;
+        _this.adg = 0;
+        _this.ww = 4;
+        _this.wu = 4;
+        _this.y6 = null;
+        _this.wi = null;
+        _this.za = null;
+        _this.wj = null;
         return _this;
     }
     XYChart.prototype.provideContainer = function (a) {
         if (a != null) {
-            var b = this.v6();
-            var c = this.v7();
+            var b = this.wm();
+            var c = this.wn();
             if (b != null) {
                 b.provideRenderer(a);
             }
@@ -115,644 +115,647 @@ var XYChart = /** @class */ /*@__PURE__*/ (function (_super) {
         }
         _super.prototype.provideContainer.call(this, a);
     };
-    XYChart.prototype.sb = function () {
-        _super.prototype.sb.call(this);
-        var a = this.v6();
-        var b = this.v7();
+    XYChart.prototype.sr = function () {
+        _super.prototype.sr.call(this);
+        var a = this.wm();
+        var b = this.wn();
         if (a != null && a.az != null) {
-            this.acf = a.az.textColor;
+            this.acv = a.az.textColor;
         }
         if (b != null && b.az != null) {
-            this.acm = b.az.textColor;
+            this.ac2 = b.az.textColor;
         }
-        this.ack = AxisDefaults.j;
-        this.acr = AxisDefaults.j;
-        this.acg = AxisDefaults.h;
-        this.acn = AxisDefaults.h;
-        this.acj = AxisDefaults.g;
-        this.acq = AxisDefaults.g;
+        this.ac0 = AxisDefaults.j;
+        this.ac7 = AxisDefaults.j;
+        this.acw = AxisDefaults.h;
+        this.ac3 = AxisDefaults.h;
+        this.acz = AxisDefaults.g;
+        this.ac6 = AxisDefaults.g;
     };
-    XYChart.prototype.s1 = function (a, b, c) {
+    XYChart.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 "XAxisLabelLeftMargin":
-                this.abj(function (d) { return d.leftMargin = _this.xr; });
+                this.abz(function (d) { return d.leftMargin = _this.x7; });
                 break;
             case "XAxisLabelTopMargin":
-                this.abj(function (d) { return d.topMargin = _this.xt; });
+                this.abz(function (d) { return d.topMargin = _this.x9; });
                 break;
             case "XAxisLabelRightMargin":
-                this.abj(function (d) { return d.rightMargin = _this.xs; });
+                this.abz(function (d) { return d.rightMargin = _this.x8; });
                 break;
             case "XAxisLabelBottomMargin":
-                this.abj(function (d) { return d.bottomMargin = _this.xq; });
+                this.abz(function (d) { return d.bottomMargin = _this.x6; });
                 break;
             case "YAxisLabelLeftMargin":
-                this.abo(function (d) { return d.leftMargin = _this.x8; });
+                this.ab4(function (d) { return d.leftMargin = _this.yo; });
                 break;
             case "YAxisLabelTopMargin":
-                this.abo(function (d) { return d.topMargin = _this.ya; });
+                this.ab4(function (d) { return d.topMargin = _this.yq; });
                 break;
             case "YAxisLabelRightMargin":
-                this.abo(function (d) { return d.rightMargin = _this.x9; });
+                this.ab4(function (d) { return d.rightMargin = _this.yp; });
                 break;
             case "YAxisLabelBottomMargin":
-                this.abo(function (d) { return d.bottomMargin = _this.x7; });
+                this.ab4(function (d) { return d.bottomMargin = _this.yn; });
                 break;
             case "ActualItemsSource":
             case "ShouldDisplayMockData":
             case "ShouldUseSkeletonStyleForMockData":
-                this.acd = this.u9(this.acf);
-                this.ace = this.u9(this.acm);
+                this.act = this.vp(this.acv);
+                this.acu = this.vp(this.ac2);
                 break;
             case "XAxisLabelTextColor":
-                this.acd = this.u9(this.acf);
+                this.act = this.vp(this.acv);
                 break;
             case "YAxisLabelTextColor":
-                this.ace = this.u9(this.acm);
+                this.acu = this.vp(this.ac2);
                 break;
             case "ActualXAxisLabelTextColor":
-                this.abj(function (d) { return d.textColor = _this.acd; });
+                this.abz(function (d) { return d.textColor = _this.act; });
                 break;
             case "ActualYAxisLabelTextColor":
-                this.abo(function (d) { return d.textColor = _this.ace; });
+                this.ab4(function (d) { return d.textColor = _this.acu; });
                 break;
             case "XAxisTitleMargin":
-                this.abl(function (d) { return d.margin = _this.x2; });
+                this.ab1(function (d) { return d.margin = _this.yi; });
                 break;
             case "YAxisTitleMargin":
-                this.abq(function (d) { return d.margin = _this.yj; });
+                this.ab6(function (d) { return d.margin = _this.yz; });
                 break;
             case "XAxisTitleLeftMargin":
-                this.abl(function (d) { return d.leftMargin = _this.x1; });
+                this.ab1(function (d) { return d.leftMargin = _this.yh; });
                 break;
             case "YAxisTitleLeftMargin":
-                this.abq(function (d) { return d.leftMargin = _this.yi; });
+                this.ab6(function (d) { return d.leftMargin = _this.yy; });
                 break;
             case "XAxisTitleTopMargin":
-                this.abl(function (d) { return d.topMargin = _this.x4; });
+                this.ab1(function (d) { return d.topMargin = _this.yk; });
                 break;
             case "YAxisTitleTopMargin":
-                this.abq(function (d) { return d.topMargin = _this.yl; });
+                this.ab6(function (d) { return d.topMargin = _this.y1; });
                 break;
             case "XAxisTitleRightMargin":
-                this.abl(function (d) { return d.rightMargin = _this.x3; });
+                this.ab1(function (d) { return d.rightMargin = _this.yj; });
                 break;
             case "YAxisTitleRightMargin":
-                this.abq(function (d) { return d.rightMargin = _this.yk; });
+                this.ab6(function (d) { return d.rightMargin = _this.y0; });
                 break;
             case "XAxisTitleBottomMargin":
-                this.abl(function (d) { return d.bottomMargin = _this.x0; });
+                this.ab1(function (d) { return d.bottomMargin = _this.yg; });
                 break;
             case "YAxisTitleBottomMargin":
-                this.abq(function (d) { return d.bottomMargin = _this.yh; });
+                this.ab6(function (d) { return d.bottomMargin = _this.yx; });
                 break;
             case "XAxisTitleTextColor":
-                this.abl(function (d) { return d.textColor = _this.acl; });
+                this.ab1(function (d) { return d.textColor = _this.ac1; });
                 break;
             case "YAxisTitleTextColor":
-                this.abq(function (d) { return d.textColor = _this.acs; });
+                this.ab6(function (d) { return d.textColor = _this.ac8; });
                 break;
             case "XAxisFormatLabel":
-                this.abh(function (d) { return d.au = _this.wa; });
+                this.abx(function (d) { return d.au = _this.wq; });
                 break;
             case "YAxisFormatLabel":
-                this.abm(function (d) { return d.au = _this.wb; });
+                this.ab2(function (d) { return d.au = _this.wr; });
                 break;
         }
     };
-    Object.defineProperty(XYChart.prototype, "wa", {
+    Object.defineProperty(XYChart.prototype, "wq", {
         get: function () {
-            return this.v8;
+            return this.wo;
         },
         set: function (a) {
-            var b = this.wa;
+            var b = this.wq;
             if (a != b) {
-                this.v8 = a;
-                this.sy("XAxisFormatLabel", b, this.wa);
+                this.wo = a;
+                this.te("XAxisFormatLabel", b, this.wq);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "wb", {
+    Object.defineProperty(XYChart.prototype, "wr", {
         get: function () {
-            return this.v9;
+            return this.wp;
         },
         set: function (a) {
-            var b = this.wb;
+            var b = this.wr;
             if (a != b) {
-                this.v9 = a;
-                this.sy("YAxisFormatLabel", b, this.wb);
+                this.wp = a;
+                this.te("YAxisFormatLabel", b, this.wr);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "xr", {
+    Object.defineProperty(XYChart.prototype, "x7", {
         get: function () {
-            return this.wp;
+            return this.w5;
         },
         set: function (a) {
-            var b = this.xr;
+            var b = this.x7;
             if (a != b) {
-                this.wp = a;
-                this.sy("XAxisLabelLeftMargin", b, this.xr);
+                this.w5 = a;
+                this.te("XAxisLabelLeftMargin", b, this.x7);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "xt", {
+    Object.defineProperty(XYChart.prototype, "x9", {
         get: function () {
-            return this.wr;
+            return this.w7;
         },
         set: function (a) {
-            var b = this.xt;
+            var b = this.x9;
             if (a != b) {
-                this.wr = a;
-                this.sy("XAxisLabelTopMargin", b, this.xt);
+                this.w7 = a;
+                this.te("XAxisLabelTopMargin", b, this.x9);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "xs", {
+    Object.defineProperty(XYChart.prototype, "x8", {
         get: function () {
-            return this.wq;
+            return this.w6;
         },
         set: function (a) {
-            var b = this.xs;
+            var b = this.x8;
             if (a != b) {
-                this.wq = a;
-                this.sy("XAxisLabelRightMargin", b, this.xs);
+                this.w6 = a;
+                this.te("XAxisLabelRightMargin", b, this.x8);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "xq", {
+    Object.defineProperty(XYChart.prototype, "x6", {
         get: function () {
-            return this.wo;
+            return this.w4;
         },
         set: function (a) {
-            var b = this.xq;
+            var b = this.x6;
             if (a != b) {
-                this.wo = a;
-                this.sy("XAxisLabelBottomMargin", b, this.xq);
+                this.w4 = a;
+                this.te("XAxisLabelBottomMargin", b, this.x6);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "x8", {
+    Object.defineProperty(XYChart.prototype, "yo", {
         get: function () {
-            return this.w6;
+            return this.xm;
         },
         set: function (a) {
-            var b = this.x8;
+            var b = this.yo;
             if (a != b) {
-                this.w6 = a;
-                this.sy("YAxisLabelLeftMargin", b, this.x8);
+                this.xm = a;
+                this.te("YAxisLabelLeftMargin", b, this.yo);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "ya", {
+    Object.defineProperty(XYChart.prototype, "yq", {
         get: function () {
-            return this.w8;
+            return this.xo;
         },
         set: function (a) {
-            var b = this.ya;
+            var b = this.yq;
             if (a != b) {
-                this.w8 = a;
-                this.sy("YAxisLabelTopMargin", b, this.ya);
+                this.xo = a;
+                this.te("YAxisLabelTopMargin", b, this.yq);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "x9", {
+    Object.defineProperty(XYChart.prototype, "yp", {
         get: function () {
-            return this.w7;
+            return this.xn;
         },
         set: function (a) {
-            var b = this.x9;
+            var b = this.yp;
             if (a != b) {
-                this.w7 = a;
-                this.sy("YAxisLabelRightMargin", b, this.x9);
+                this.xn = a;
+                this.te("YAxisLabelRightMargin", b, this.yp);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "x7", {
+    Object.defineProperty(XYChart.prototype, "yn", {
         get: function () {
-            return this.w5;
+            return this.xl;
         },
         set: function (a) {
-            var b = this.x7;
+            var b = this.yn;
             if (a != b) {
-                this.w5 = a;
-                this.sy("YAxisLabelBottomMargin", b, this.x7);
+                this.xl = a;
+                this.te("YAxisLabelBottomMargin", b, this.yn);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "acf", {
+    Object.defineProperty(XYChart.prototype, "acv", {
         get: function () {
-            return this.abz;
+            return this.acf;
         },
         set: function (a) {
-            var b = this.acf;
+            var b = this.acv;
             if (a != b) {
-                this.abz = a;
-                this.sy("XAxisLabelTextColor", b, this.acf);
+                this.acf = a;
+                this.te("XAxisLabelTextColor", b, this.acv);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "acm", {
+    Object.defineProperty(XYChart.prototype, "ac2", {
         get: function () {
-            return this.ab6;
+            return this.acm;
         },
         set: function (a) {
-            var b = this.acm;
+            var b = this.ac2;
             if (a != b) {
-                this.ab6 = a;
-                this.sy("YAxisLabelTextColor", b, this.acm);
+                this.acm = a;
+                this.te("YAxisLabelTextColor", b, this.ac2);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "acd", {
+    Object.defineProperty(XYChart.prototype, "act", {
         get: function () {
-            return this.abx;
+            return this.acd;
         },
         set: function (a) {
-            var b = this.abx;
+            var b = this.acd;
             if (a != b) {
-                this.abx = a;
-                this.sy("ActualXAxisLabelTextColor", b, this.acd);
+                this.acd = a;
+                this.te("ActualXAxisLabelTextColor", b, this.act);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "ace", {
+    Object.defineProperty(XYChart.prototype, "acu", {
         get: function () {
-            return this.aby;
+            return this.ace;
         },
         set: function (a) {
-            var b = this.aby;
+            var b = this.ace;
             if (a != b) {
-                this.aby = a;
-                this.sy("ActualYAxisLabelTextColor", b, this.ace);
+                this.ace = a;
+                this.te("ActualYAxisLabelTextColor", b, this.acu);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "x2", {
+    Object.defineProperty(XYChart.prototype, "yi", {
         get: function () {
-            return this.w0;
+            return this.xg;
         },
         set: function (a) {
-            var b = this.x2;
+            var b = this.yi;
             if (a != b) {
-                this.w0 = a;
-                this.sy("XAxisTitleMargin", b, this.x2);
+                this.xg = a;
+                this.te("XAxisTitleMargin", b, this.yi);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "yj", {
+    Object.defineProperty(XYChart.prototype, "yz", {
         get: function () {
-            return this.xh;
+            return this.xx;
         },
         set: function (a) {
-            var b = this.yj;
+            var b = this.yz;
             if (a != b) {
-                this.xh = a;
-                this.sy("YAxisTitleMargin", b, this.yj);
+                this.xx = a;
+                this.te("YAxisTitleMargin", b, this.yz);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "x1", {
+    Object.defineProperty(XYChart.prototype, "yh", {
         get: function () {
-            return this.wz;
+            return this.xf;
         },
         set: function (a) {
-            var b = this.x1;
+            var b = this.yh;
             if (a != b) {
-                this.wz = a;
-                this.sy("XAxisTitleLeftMargin", b, this.x1);
+                this.xf = a;
+                this.te("XAxisTitleLeftMargin", b, this.yh);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "yi", {
+    Object.defineProperty(XYChart.prototype, "yy", {
         get: function () {
-            return this.xg;
+            return this.xw;
         },
         set: function (a) {
-            var b = this.yi;
+            var b = this.yy;
             if (a != b) {
-                this.xg = a;
-                this.sy("YAxisTitleLeftMargin", b, this.yi);
+                this.xw = a;
+                this.te("YAxisTitleLeftMargin", b, this.yy);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "x4", {
+    Object.defineProperty(XYChart.prototype, "yk", {
         get: function () {
-            return this.w2;
+            return this.xi;
         },
         set: function (a) {
-            var b = this.x4;
+            var b = this.yk;
             if (a != b) {
-                this.w2 = a;
-                this.sy("XAxisTitleTopMargin", b, this.x4);
+                this.xi = a;
+                this.te("XAxisTitleTopMargin", b, this.yk);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "yl", {
+    Object.defineProperty(XYChart.prototype, "y1", {
         get: function () {
-            return this.xj;
+            return this.xz;
         },
         set: function (a) {
-            var b = this.yl;
+            var b = this.y1;
             if (a != b) {
-                this.xj = a;
-                this.sy("YAxisTitleTopMargin", b, this.yl);
+                this.xz = a;
+                this.te("YAxisTitleTopMargin", b, this.y1);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "x3", {
+    Object.defineProperty(XYChart.prototype, "yj", {
         get: function () {
-            return this.w1;
+            return this.xh;
         },
         set: function (a) {
-            var b = this.x3;
+            var b = this.yj;
             if (a != b) {
-                this.w1 = a;
-                this.sy("XAxisTitleRightMargin", b, this.x3);
+                this.xh = a;
+                this.te("XAxisTitleRightMargin", b, this.yj);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "yk", {
+    Object.defineProperty(XYChart.prototype, "y0", {
         get: function () {
-            return this.xi;
+            return this.xy;
         },
         set: function (a) {
-            var b = this.yk;
+            var b = this.y0;
             if (a != b) {
-                this.xi = a;
-                this.sy("YAxisTitleRightMargin", b, this.yk);
+                this.xy = a;
+                this.te("YAxisTitleRightMargin", b, this.y0);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "x0", {
+    Object.defineProperty(XYChart.prototype, "yg", {
         get: function () {
-            return this.wy;
+            return this.xe;
         },
         set: function (a) {
-            var b = this.x0;
+            var b = this.yg;
             if (a != b) {
-                this.wy = a;
-                this.sy("XAxisTitleBottomMargin", b, this.x0);
+                this.xe = a;
+                this.te("XAxisTitleBottomMargin", b, this.yg);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "yh", {
+    Object.defineProperty(XYChart.prototype, "yx", {
         get: function () {
-            return this.xf;
+            return this.xv;
         },
         set: function (a) {
-            var b = this.yh;
+            var b = this.yx;
             if (a != b) {
-                this.xf = a;
-                this.sy("YAxisTitleBottomMargin", b, this.yh);
+                this.xv = a;
+                this.te("YAxisTitleBottomMargin", b, this.yx);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "acl", {
+    Object.defineProperty(XYChart.prototype, "ac1", {
         get: function () {
-            return this.ab5;
+            return this.acl;
         },
         set: function (a) {
-            var b = this.acl;
+            var b = this.ac1;
             if (a != b) {
-                this.ab5 = a;
-                this.sy("XAxisTitleTextColor", b, this.acl);
+                this.acl = a;
+                this.te("XAxisTitleTextColor", b, this.ac1);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "acs", {
+    Object.defineProperty(XYChart.prototype, "ac8", {
         get: function () {
-            return this.acc;
+            return this.acs;
         },
         set: function (a) {
-            var b = this.acs;
+            var b = this.ac8;
             if (a != b) {
-                this.acc = a;
-                this.sy("YAxisTitleTextColor", b, this.acs);
+                this.acs = a;
+                this.te("YAxisTitleTextColor", b, this.ac8);
             }
         },
         enumerable: false,
         configurable: true
     });
-    XYChart.prototype.s2 = function (a, b, c) {
+    XYChart.prototype.ti = function (a, b, c) {
         var _this = this;
-        _super.prototype.s2.call(this, a, b, c);
+        _super.prototype.ti.call(this, a, b, c);
         switch (a) {
             case "XAxisLabelTextStyle":
-                this.abj(function (d) { return d.textStyle = _this.zf; });
+                this.abz(function (d) { return d.textStyle = _this.zv; });
                 break;
             case "YAxisLabelTextStyle":
-                this.abo(function (d) { return d.textStyle = _this.aak; });
+                this.ab4(function (d) { return d.textStyle = _this.aa0; });
                 break;
             case "XAxisTitleTextStyle":
-                this.abl(function (d) { return d.textStyle = _this.z3; });
+                this.ab1(function (d) { return d.textStyle = _this.aaj; });
                 break;
             case "YAxisTitleTextStyle":
-                this.abq(function (d) { return d.textStyle = _this.aa8; });
+                this.ab6(function (d) { return d.textStyle = _this.abo; });
                 break;
         }
     };
-    Object.defineProperty(XYChart.prototype, "zf", {
+    Object.defineProperty(XYChart.prototype, "zv", {
         get: function () {
-            return this.yr;
+            return this.y7;
         },
         set: function (a) {
-            var b = this.zf;
+            var b = this.zv;
             if (a != b) {
-                this.yr = a;
-                this.sy("XAxisLabelTextStyle", b, this.zf);
+                this.y7 = a;
+                this.te("XAxisLabelTextStyle", b, this.zv);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "aak", {
+    Object.defineProperty(XYChart.prototype, "aa0", {
         get: function () {
-            return this.yv;
+            return this.zb;
         },
         set: function (a) {
-            var b = this.aak;
+            var b = this.aa0;
             if (a != b) {
-                this.yv = a;
-                this.sy("YAxisLabelTextStyle", b, this.aak);
+                this.zb = a;
+                this.te("YAxisLabelTextStyle", b, this.aa0);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "z3", {
+    Object.defineProperty(XYChart.prototype, "aaj", {
         get: function () {
-            return this.yt;
+            return this.y9;
         },
         set: function (a) {
-            var b = this.z3;
+            var b = this.aaj;
             if (a != b) {
-                this.yt = a;
-                this.sy("XAxisTitleTextStyle", b, this.z3);
+                this.y9 = a;
+                this.te("XAxisTitleTextStyle", b, this.aaj);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "aa8", {
+    Object.defineProperty(XYChart.prototype, "abo", {
         get: function () {
-            return this.yx;
+            return this.zd;
         },
         set: function (a) {
-            var b = this.aa8;
+            var b = this.abo;
             if (a != b) {
-                this.yx = a;
-                this.sy("YAxisTitleTextStyle", b, this.aa8);
+                this.zd = a;
+                this.te("YAxisTitleTextStyle", b, this.abo);
             }
         },
         enumerable: false,
         configurable: true
     });
-    XYChart.prototype.abe = function (a) {
+    XYChart.prototype.abu = function (a) {
         var _this = this;
-        this.abb(a, function (b) { return b.leftMargin = _this.xr; });
-        this.abb(a, function (b) { return b.topMargin = _this.xt; });
-        this.abb(a, function (b) { return b.rightMargin = _this.xs; });
-        this.abb(a, function (b) { return b.bottomMargin = _this.xq; });
-        this.abb(a, function (b) { return b.textColor = _this.acd; });
-        this.abc(a, function (b) { return b.textColor = _this.acl; });
-        this.abc(a, function (b) { return b.leftMargin = _this.x1; });
-        this.abc(a, function (b) { return b.topMargin = _this.x4; });
-        this.abc(a, function (b) { return b.rightMargin = _this.x3; });
-        this.abc(a, function (b) { return b.bottomMargin = _this.x0; });
-        this.abb(a, function (b) { return b.textStyle = _this.zf; });
-        this.abc(a, function (b) { return b.textStyle = _this.z3; });
+        this.abr(a, function (b) { return b.leftMargin = _this.x7; });
+        this.abr(a, function (b) { return b.topMargin = _this.x9; });
+        this.abr(a, function (b) { return b.rightMargin = _this.x8; });
+        this.abr(a, function (b) { return b.bottomMargin = _this.x6; });
+        this.abr(a, function (b) { return b.textColor = _this.act; });
+        this.abs(a, function (b) { return b.textColor = _this.ac1; });
+        this.abs(a, function (b) { return b.leftMargin = _this.yh; });
+        this.abs(a, function (b) { return b.topMargin = _this.yk; });
+        this.abs(a, function (b) { return b.rightMargin = _this.yj; });
+        this.abs(a, function (b) { return b.bottomMargin = _this.yg; });
+        this.abr(a, function (b) { return b.textStyle = _this.zv; });
+        this.abs(a, function (b) { return b.textStyle = _this.aaj; });
     };
-    XYChart.prototype.abg = function (a) {
+    XYChart.prototype.abw = function (a) {
         var _this = this;
-        this.abb(a, function (b) { return b.leftMargin = _this.x8; });
-        this.abb(a, function (b) { return b.topMargin = _this.ya; });
-        this.abb(a, function (b) { return b.rightMargin = _this.x9; });
-        this.abb(a, function (b) { return b.bottomMargin = _this.x7; });
-        this.abb(a, function (b) { return b.textColor = _this.ace; });
-        this.abc(a, function (b) { return b.textColor = _this.acs; });
-        this.abc(a, function (b) { return b.leftMargin = _this.yi; });
-        this.abc(a, function (b) { return b.topMargin = _this.yl; });
-        this.abc(a, function (b) { return b.rightMargin = _this.yk; });
-        this.abc(a, function (b) { return b.bottomMargin = _this.yh; });
-        this.abb(a, function (b) { return b.textStyle = _this.aak; });
-        this.abc(a, function (b) { return b.textStyle = _this.aa8; });
+        this.abr(a, function (b) { return b.leftMargin = _this.yo; });
+        this.abr(a, function (b) { return b.topMargin = _this.yq; });
+        this.abr(a, function (b) { return b.rightMargin = _this.yp; });
+        this.abr(a, function (b) { return b.bottomMargin = _this.yn; });
+        this.abr(a, function (b) { return b.textColor = _this.acu; });
+        this.abs(a, function (b) { return b.textColor = _this.ac8; });
+        this.abs(a, function (b) { return b.leftMargin = _this.yy; });
+        this.abs(a, function (b) { return b.topMargin = _this.y1; });
+        this.abs(a, function (b) { return b.rightMargin = _this.y0; });
+        this.abs(a, function (b) { return b.bottomMargin = _this.yx; });
+        this.abr(a, function (b) { return b.textStyle = _this.aa0; });
+        this.abs(a, function (b) { return b.textStyle = _this.abo; });
     };
-    XYChart.prototype.tj = function (a) {
+    XYChart.prototype.tz = function (a) {
         var b = this.bc(a);
-        var c = this.c1(a, b);
+        var c = this.c2(a, b);
         if (c == null) {
             return;
         }
         c.itemsSource = a.data;
-        c.name = this.og(a);
-        c.title = this.oh(a, b);
+        if (a.highlightedData != null) {
+            c.highlightedItemsSource = a.highlightedData;
+        }
+        c.name = this.or(a);
+        c.title = this.os(a, b);
         this.dataChart.series.add(c);
     };
-    XYChart.prototype.abh = function (a) {
-        this.abi(a, null);
+    XYChart.prototype.abx = function (a) {
+        this.aby(a, null);
     };
-    XYChart.prototype.abi = function (a, b) {
-        a(this.v6());
+    XYChart.prototype.aby = function (a, b) {
+        a(this.wm());
     };
-    XYChart.prototype.abn = function (a, b) {
-        a(this.v7());
+    XYChart.prototype.ab3 = function (a, b) {
+        a(this.wn());
     };
-    XYChart.prototype.abm = function (a) {
-        this.abn(a, true);
+    XYChart.prototype.ab2 = function (a) {
+        this.ab3(a, true);
     };
-    XYChart.prototype.rv = function (a, b) {
-        this.abh(a);
-        this.abn(a, b);
+    XYChart.prototype.sb = function (a, b) {
+        this.abx(a);
+        this.ab3(a, b);
     };
-    XYChart.prototype.abl = function (a) {
-        this.abc(this.v6(), a);
+    XYChart.prototype.ab1 = function (a) {
+        this.abs(this.wm(), a);
     };
-    XYChart.prototype.abq = function (a) {
-        this.abc(this.v7(), a);
+    XYChart.prototype.ab6 = function (a) {
+        this.abs(this.wn(), a);
     };
-    XYChart.prototype.abo = function (a) {
-        this.abb(this.v7(), a);
+    XYChart.prototype.ab4 = function (a) {
+        this.abr(this.wn(), a);
     };
-    XYChart.prototype.abj = function (a) {
-        this.abb(this.v6(), a);
+    XYChart.prototype.abz = function (a) {
+        this.abr(this.wm(), a);
     };
-    XYChart.prototype.xk = function (a) {
-        var b = this.v6();
-        return b.ej(a, new ScalerParams(1, this.vh, this.vg, b.ch));
+    XYChart.prototype.x0 = function (a) {
+        var b = this.wm();
+        return b.ej(a, new ScalerParams(1, this.vx, this.vw, b.ch));
     };
-    XYChart.prototype.xm = function (a) {
-        var b = this.v6();
-        return b.em(a, new ScalerParams(1, this.vh, this.vg, b.ch));
+    XYChart.prototype.x2 = function (a) {
+        var b = this.wm();
+        return b.em(a, new ScalerParams(1, this.vx, this.vw, b.ch));
     };
-    XYChart.prototype.xl = function (a) {
-        var b = this.v7();
-        return b.ej(a, new ScalerParams(1, this.vh, this.vg, b.ch));
+    XYChart.prototype.x1 = function (a) {
+        var b = this.wn();
+        return b.ej(a, new ScalerParams(1, this.vx, this.vw, b.ch));
     };
-    XYChart.prototype.xn = function (a) {
-        var b = this.v7();
-        return b.em(a, new ScalerParams(1, this.vh, this.vg, b.ch));
+    XYChart.prototype.x3 = function (a) {
+        var b = this.wn();
+        return b.em(a, new ScalerParams(1, this.vx, this.vw, b.ch));
     };
-    XYChart.prototype.tg = function (a) {
-        _super.prototype.tg.call(this, a);
+    XYChart.prototype.tw = function (a) {
+        _super.prototype.tw.call(this, a);
         if (a == null) {
             return;
         }
         if (a.axes != null) {
-            var b = this.v6();
-            var c = this.v7();
+            var b = this.wm();
+            var c = this.wn();
             if (a.axes.contains(b)) {
                 a.axes.remove(b);
             }
@@ -761,7 +764,7 @@ var XYChart = /** @class */ /*@__PURE__*/ (function (_super) {
             }
         }
     };
-    XYChart.y0 = function (a, b) {
+    XYChart.zg = function (a, b) {
         var e_1, _a;
         try {
             for (var _b = __values(fromEnum(b)), _c = _b.next(); !_c.done; _c = _b.next()) {
@@ -788,98 +791,98 @@ var XYChart = /** @class */ /*@__PURE__*/ (function (_super) {
         }
         return null;
     };
-    XYChart.prototype.r6 = function (a) {
-        _super.prototype.r6.call(this, a);
+    XYChart.prototype.sm = function (a) {
+        _super.prototype.sm.call(this, a);
         if (a == this.dataChart) {
-            this.dataChart.axes.add(this.v6());
-            this.dataChart.axes.add(this.v7());
+            this.dataChart.axes.add(this.wm());
+            this.dataChart.axes.add(this.wn());
         }
     };
-    XYChart.prototype.abd = function (a) {
+    XYChart.prototype.abt = function (a) {
         var _this = this;
-        if (a != null && this.ka != null && a.fl == null) {
-            a.provideRenderer(this.ka);
+        if (a != null && this.kj != null && a.fl == null) {
+            a.provideRenderer(this.kj);
         }
-        a.jw = this.acg;
-        a.er = this.xu;
-        a.jx = this.ach;
-        a.eu = this.xv;
-        a.jz = this.acj;
-        a.fg = this.xw;
-        a.jy = this.aci;
-        a.fh = this.xx;
-        a.j0 = this.ack;
-        a.fi = this.xy;
+        a.jw = this.acw;
+        a.er = this.ya;
+        a.jx = this.acx;
+        a.eu = this.yb;
+        a.jz = this.acz;
+        a.fg = this.yc;
+        a.jy = this.acy;
+        a.fh = this.yd;
+        a.j0 = this.ac0;
+        a.fi = this.ye;
         a.c4 = true;
-        a.cu = this.gd;
-        a.cw = this.gd;
-        var b = a == this.v6();
+        a.cu = this.gm;
+        a.cw = this.gm;
+        var b = a == this.wm();
         if (b) {
-            a.g6 = this.zu;
+            a.g6 = this.aaa;
         }
-        a.f0 = this.yo;
-        a.gg = this.y6;
-        a.ah = this.v4;
-        this.abb(a, function (c) { return c.angle = _this.xp; });
-        this.abb(a, function (c) {
-            if (c.extent != _this.xo) {
-                c.extent = _this.xo;
+        a.f0 = this.y4;
+        a.gg = this.zm;
+        a.ah = this.wk;
+        this.abr(a, function (c) { return c.angle = _this.x5; });
+        this.abr(a, function (c) {
+            if (c.extent != _this.x4) {
+                c.extent = _this.x4;
             }
         });
-        this.abb(a, function (c) { return c.horizontalAlignment = _this.abu; });
-        this.abb(a, function (c) { return c.verticalAlignment = _this.acw; });
-        this.abb(a, function (c) { return c.visibility = _this.ac1; });
-        this.abb(a, function (c) { return c.location = _this.wc(_this.wf); });
-        this.abc(a, function (c) { return c.horizontalAlignment = _this.abv; });
-        this.abc(a, function (c) { return c.angle = _this.xz; });
-        this.abe(a);
+        this.abr(a, function (c) { return c.horizontalAlignment = _this.aca; });
+        this.abr(a, function (c) { return c.verticalAlignment = _this.adc; });
+        this.abr(a, function (c) { return c.visibility = _this.adh; });
+        this.abr(a, function (c) { return c.location = _this.ws(_this.wv); });
+        this.abs(a, function (c) { return c.horizontalAlignment = _this.acb; });
+        this.abs(a, function (c) { return c.angle = _this.yf; });
+        this.abu(a);
     };
-    XYChart.prototype.abf = function (a) {
+    XYChart.prototype.abv = function (a) {
         var _this = this;
         if (a == null) {
             return;
         }
-        if (this.ka != null && a.fl == null) {
-            a.provideRenderer(this.ka);
+        if (this.kj != null && a.fl == null) {
+            a.provideRenderer(this.kj);
         }
-        a.cu = this.gd;
-        a.cw = this.gd;
-        this.abb(a, function (b) { return b.angle = _this.x6; });
-        this.abb(a, function (b) {
-            if (b.extent != _this.x5) {
-                b.extent = _this.x5;
+        a.cu = this.gm;
+        a.cw = this.gm;
+        this.abr(a, function (b) { return b.angle = _this.ym; });
+        this.abr(a, function (b) {
+            if (b.extent != _this.yl) {
+                b.extent = _this.yl;
             }
         });
-        this.abb(a, function (b) { return b.horizontalAlignment = _this.abw; });
-        this.abb(a, function (b) { return b.verticalAlignment = _this.acx; });
-        this.abb(a, function (b) { return b.visibility = _this.ac2; });
-        this.abb(a, function (b) { return b.location = _this.wd(_this.wh); });
-        this.abc(a, function (b) { return b.verticalAlignment = _this.acy; });
-        this.abc(a, function (b) { return b.angle = _this.yg; });
-        a.jw = this.acn;
-        a.er = this.yb;
-        a.jx = this.aco;
-        a.eu = this.yc;
-        a.jz = this.acq;
-        a.fg = this.yd;
-        a.jy = this.acp;
-        a.fh = this.ye;
-        a.j0 = this.acr;
-        a.fi = this.yf;
-        var b = a == this.v7();
+        this.abr(a, function (b) { return b.horizontalAlignment = _this.acc; });
+        this.abr(a, function (b) { return b.verticalAlignment = _this.add; });
+        this.abr(a, function (b) { return b.visibility = _this.adi; });
+        this.abr(a, function (b) { return b.location = _this.wt(_this.wx); });
+        this.abs(a, function (b) { return b.verticalAlignment = _this.ade; });
+        this.abs(a, function (b) { return b.angle = _this.yw; });
+        a.jw = this.ac3;
+        a.er = this.yr;
+        a.jx = this.ac4;
+        a.eu = this.ys;
+        a.jz = this.ac6;
+        a.fg = this.yt;
+        a.jy = this.ac5;
+        a.fh = this.yu;
+        a.j0 = this.ac7;
+        a.fi = this.yv;
+        var b = a == this.wn();
         if (b) {
-            a.g6 = this.aaz;
+            a.g6 = this.abf;
         }
-        a.gg = this.aab;
-        a.ah = this.v5;
-        this.abg(a);
+        a.gg = this.aar;
+        a.ah = this.wl;
+        this.abw(a);
     };
-    XYChart.prototype.r3 = function () {
-        _super.prototype.r3.call(this);
-        this.abd(this.v6());
-        this.abf(this.v7());
+    XYChart.prototype.sj = function () {
+        _super.prototype.sj.call(this);
+        this.abt(this.wm());
+        this.abv(this.wn());
     };
-    XYChart.prototype.abb = function (a, b) {
+    XYChart.prototype.abr = function (a, b) {
         if (a == null) {
             return;
         }
@@ -896,7 +899,7 @@ var XYChart = /** @class */ /*@__PURE__*/ (function (_super) {
         }
         b(a.az);
     };
-    XYChart.prototype.abc = function (a, b) {
+    XYChart.prototype.abs = function (a, b) {
         if (a == null) {
             return;
         }
@@ -913,171 +916,171 @@ var XYChart = /** @class */ /*@__PURE__*/ (function (_super) {
         }
         b(a.bf);
     };
-    XYChart.prototype.sy = function (a, b, c) {
+    XYChart.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 "XAxisLabelAngle":
-                this.abj(function (d) { return d.angle = _this.xp; });
+                this.abz(function (d) { return d.angle = _this.x5; });
                 break;
             case "YAxisLabelAngle":
-                this.abo(function (d) { return d.angle = _this.x6; });
+                this.ab4(function (d) { return d.angle = _this.ym; });
                 break;
             case "XAxisLabelHorizontalAlignment":
-                this.abj(function (d) { return d.horizontalAlignment = _this.abu; });
+                this.abz(function (d) { return d.horizontalAlignment = _this.aca; });
                 break;
             case "YAxisLabelHorizontalAlignment":
-                this.abo(function (d) { return d.horizontalAlignment = _this.abw; });
+                this.ab4(function (d) { return d.horizontalAlignment = _this.acc; });
                 break;
             case "XAxisLabelVerticalAlignment":
-                this.abj(function (d) { return d.verticalAlignment = _this.acw; });
+                this.abz(function (d) { return d.verticalAlignment = _this.adc; });
                 break;
             case "YAxisLabelVerticalAlignment":
-                this.abo(function (d) { return d.verticalAlignment = _this.acx; });
+                this.ab4(function (d) { return d.verticalAlignment = _this.add; });
                 break;
             case "XAxisLabelVisibility":
-                this.abj(function (d) { return d.visibility = _this.ac1; });
+                this.abz(function (d) { return d.visibility = _this.adh; });
                 break;
             case "YAxisLabelVisibility":
-                this.abo(function (d) { return d.visibility = _this.ac2; });
+                this.ab4(function (d) { return d.visibility = _this.adi; });
                 break;
             case "XAxisLabel":
-                this.abh(function (d) { return d.f0 = _this.yo; });
+                this.abx(function (d) { return d.f0 = _this.y4; });
                 break;
             case "YAxisLabel":
-                this.abm(function (d) { return d.f0 = _this.yp; });
+                this.ab2(function (d) { return d.f0 = _this.y5; });
                 break;
             case "XAxisLabelFormat":
-                this.abh(function (d) { return d.gg = _this.y6; });
+                this.abx(function (d) { return d.gg = _this.zm; });
                 break;
             case "XAxisLabelFormatSpecifiers":
-                this.abh(function (d) { return d.ah = _this.v4; });
+                this.abx(function (d) { return d.ah = _this.wk; });
                 break;
             case "YAxisLabelFormat":
-                this.abm(function (d) { return d.gg = _this.aab; });
+                this.ab2(function (d) { return d.gg = _this.aar; });
                 break;
             case "YAxisLabelFormatSpecifiers":
-                this.abm(function (d) { return d.ah = _this.v5; });
+                this.ab2(function (d) { return d.ah = _this.wl; });
                 break;
             case "XAxisTitleAngle":
-                this.abl(function (d) { return d.angle = _this.xz; });
+                this.ab1(function (d) { return d.angle = _this.yf; });
                 break;
             case "YAxisTitleAngle":
-                this.abq(function (d) { return d.angle = _this.yg; });
+                this.ab6(function (d) { return d.angle = _this.yw; });
                 break;
             case "XAxisTitleAlignment":
-                this.abl(function (d) { return d.horizontalAlignment = _this.abv; });
+                this.ab1(function (d) { return d.horizontalAlignment = _this.acb; });
                 break;
             case "YAxisTitleAlignment":
-                this.abq(function (d) { return d.verticalAlignment = _this.acy; });
+                this.ab6(function (d) { return d.verticalAlignment = _this.ade; });
                 break;
             case "XAxisTitle":
-                this.abh(function (d) { return d.g6 = _this.zu; });
+                this.abx(function (d) { return d.g6 = _this.aaa; });
                 break;
             case "YAxisTitle":
-                this.abn(function (d) { return d.g6 = _this.aaz; }, false);
+                this.ab3(function (d) { return d.g6 = _this.abf; }, false);
                 break;
             case "XAxisMajorStroke":
-                this.abi(function (d) { return d.jw = _this.acg; }, a);
+                this.aby(function (d) { return d.jw = _this.acw; }, a);
                 break;
             case "YAxisMajorStroke":
-                this.abm(function (d) { return d.jw = _this.acn; });
+                this.ab2(function (d) { return d.jw = _this.ac3; });
                 break;
             case "XAxisMajorStrokeThickness":
-                this.abi(function (d) { return d.er = _this.xu; }, a);
+                this.aby(function (d) { return d.er = _this.ya; }, a);
                 break;
             case "YAxisMajorStrokeThickness":
-                this.abm(function (d) { return d.er = _this.yb; });
+                this.ab2(function (d) { return d.er = _this.yr; });
                 break;
             case "XAxisMinorStroke":
-                this.abh(function (d) { return d.jx = _this.ach; });
+                this.abx(function (d) { return d.jx = _this.acx; });
                 break;
             case "YAxisMinorStroke":
-                this.abm(function (d) { return d.jx = _this.aco; });
+                this.ab2(function (d) { return d.jx = _this.ac4; });
                 break;
             case "XAxisMinorStrokeThickness":
-                this.abh(function (d) { return d.eu = _this.xv; });
+                this.abx(function (d) { return d.eu = _this.yb; });
                 break;
             case "YAxisMinorStrokeThickness":
-                this.abm(function (d) { return d.eu = _this.yc; });
+                this.ab2(function (d) { return d.eu = _this.ys; });
                 break;
             case "XAxisTickLength":
-                this.abh(function (d) { return d.fh = _this.xx; });
+                this.abx(function (d) { return d.fh = _this.yd; });
                 break;
             case "YAxisTickLength":
-                this.abm(function (d) { return d.fh = _this.ye; });
+                this.ab2(function (d) { return d.fh = _this.yu; });
                 break;
             case "XAxisTickStroke":
-                this.abh(function (d) { return d.j0 = _this.ack; });
+                this.abx(function (d) { return d.j0 = _this.ac0; });
                 break;
             case "YAxisTickStroke":
-                this.abm(function (d) { return d.j0 = _this.acr; });
+                this.ab2(function (d) { return d.j0 = _this.ac7; });
                 break;
             case "XAxisTickStrokeThickness":
-                this.abh(function (d) { return d.fi = _this.xy; });
+                this.abx(function (d) { return d.fi = _this.ye; });
                 break;
             case "YAxisTickStrokeThickness":
-                this.abm(function (d) { return d.fi = _this.yf; });
+                this.ab2(function (d) { return d.fi = _this.yv; });
                 break;
             case "XAxisStroke":
-                this.abh(function (d) { return d.jz = _this.acj; });
+                this.abx(function (d) { return d.jz = _this.acz; });
                 break;
             case "YAxisStroke":
-                this.abm(function (d) { return d.jz = _this.acq; });
+                this.ab2(function (d) { return d.jz = _this.ac6; });
                 break;
             case "XAxisStrokeThickness":
-                this.abh(function (d) { return d.fg = _this.xw; });
+                this.abx(function (d) { return d.fg = _this.yc; });
                 break;
             case "YAxisStrokeThickness":
-                this.abm(function (d) { return d.fg = _this.yd; });
+                this.ab2(function (d) { return d.fg = _this.yt; });
                 break;
             case "XAxisExtent":
-                this.abj(function (d) { return d.extent = _this.xo; });
+                this.abz(function (d) { return d.extent = _this.x4; });
                 break;
             case "YAxisExtent":
-                this.abo(function (d) { return d.extent = _this.x5; });
+                this.ab4(function (d) { return d.extent = _this.yl; });
                 break;
             case "XAxisStrip":
-                this.abh(function (d) { return d.jy = _this.aci; });
+                this.abx(function (d) { return d.jy = _this.acy; });
                 break;
             case "YAxisStrip":
-                this.abm(function (d) { return d.jy = _this.acp; });
+                this.ab2(function (d) { return d.jy = _this.ac5; });
                 break;
             case "XAxisInverted":
-                this.abh(function (d) { return d.ch = _this.wk; });
+                this.abx(function (d) { return d.ch = _this.w0; });
                 break;
             case "YAxisInverted":
-                this.abm(function (d) { return d.ch = _this.wl; });
+                this.ab2(function (d) { return d.ch = _this.w1; });
                 break;
             case "YAxisLabelLocation":
-                this.abp();
+                this.ab5();
                 break;
             case "XAxisLabelLocation":
-                this.abk();
+                this.ab0();
                 break;
         }
     };
-    XYChart.prototype.abp = function () {
-        var a = this.wd(this.wh);
+    XYChart.prototype.ab5 = function () {
+        var a = this.wt(this.wx);
         if (a == 2 || a == 7) {
-            this.abw = 2;
+            this.acc = 2;
         }
         else {
-            this.abw = 0;
+            this.acc = 0;
         }
-        this.abo(function (b) { return b.location = a; });
+        this.ab4(function (b) { return b.location = a; });
     };
-    XYChart.prototype.abk = function () {
-        var a = this.wc(this.wf);
+    XYChart.prototype.ab0 = function () {
+        var a = this.ws(this.wv);
         if (a == 1 || a == 5) {
-            this.acw = 0;
+            this.adc = 0;
         }
         else {
-            this.acw = 2;
+            this.adc = 2;
         }
-        this.abj(function (b) { return b.location = a; });
+        this.abz(function (b) { return b.location = a; });
     };
-    XYChart.prototype.wd = function (a) {
+    XYChart.prototype.wt = function (a) {
         if (a == 0) {
             return 2;
         }
@@ -1099,7 +1102,7 @@ var XYChart = /** @class */ /*@__PURE__*/ (function (_super) {
             }
         }
     };
-    XYChart.prototype.wc = function (a) {
+    XYChart.prototype.ws = function (a) {
         if (a == 1) {
             return 1;
         }
@@ -1116,663 +1119,663 @@ var XYChart = /** @class */ /*@__PURE__*/ (function (_super) {
             return 1;
         }
     };
-    Object.defineProperty(XYChart.prototype, "yo", {
+    Object.defineProperty(XYChart.prototype, "y4", {
         get: function () {
-            return this.ym;
+            return this.y2;
         },
         set: function (a) {
-            var b = this.yo;
+            var b = this.y4;
             if (a != b) {
-                this.ym = a;
-                this.sy("XAxisLabel", b, this.yo);
+                this.y2 = a;
+                this.te("XAxisLabel", b, this.y4);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "yp", {
+    Object.defineProperty(XYChart.prototype, "y5", {
         get: function () {
-            return this.yn;
+            return this.y3;
         },
         set: function (a) {
-            var b = this.yp;
+            var b = this.y5;
             if (a != b) {
-                this.yn = a;
-                this.sy("YAxisLabel", b, this.yp);
+                this.y3 = a;
+                this.te("YAxisLabel", b, this.y5);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "acg", {
+    Object.defineProperty(XYChart.prototype, "acw", {
         get: function () {
-            return this.ab0;
+            return this.acg;
         },
         set: function (a) {
-            var b = this.acg;
+            var b = this.acw;
             if (a != b) {
-                this.ab0 = a;
-                this.sy("XAxisMajorStroke", b, this.acg);
+                this.acg = a;
+                this.te("XAxisMajorStroke", b, this.acw);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "acn", {
+    Object.defineProperty(XYChart.prototype, "ac3", {
         get: function () {
-            return this.ab7;
+            return this.acn;
         },
         set: function (a) {
-            var b = this.acn;
+            var b = this.ac3;
             if (a != b) {
-                this.ab7 = a;
-                this.sy("YAxisMajorStroke", b, this.acn);
+                this.acn = a;
+                this.te("YAxisMajorStroke", b, this.ac3);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "xu", {
+    Object.defineProperty(XYChart.prototype, "ya", {
         get: function () {
-            return this.ws;
+            return this.w8;
         },
         set: function (a) {
-            var b = this.xu;
+            var b = this.ya;
             if (a != b) {
-                this.ws = a;
-                this.sy("XAxisMajorStrokeThickness", b, this.xu);
+                this.w8 = a;
+                this.te("XAxisMajorStrokeThickness", b, this.ya);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "yb", {
+    Object.defineProperty(XYChart.prototype, "yr", {
         get: function () {
-            return this.w9;
+            return this.xp;
         },
         set: function (a) {
-            var b = this.yb;
+            var b = this.yr;
             if (a != b) {
-                this.w9 = a;
-                this.sy("YAxisMajorStrokeThickness", b, this.yb);
+                this.xp = a;
+                this.te("YAxisMajorStrokeThickness", b, this.yr);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "xv", {
+    Object.defineProperty(XYChart.prototype, "yb", {
         get: function () {
-            return this.wt;
+            return this.w9;
         },
         set: function (a) {
-            var b = this.xv;
+            var b = this.yb;
             if (a != b) {
-                this.wt = a;
-                this.sy("XAxisMinorStrokeThickness", b, this.xv);
+                this.w9 = a;
+                this.te("XAxisMinorStrokeThickness", b, this.yb);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "yc", {
+    Object.defineProperty(XYChart.prototype, "ys", {
         get: function () {
-            return this.xa;
+            return this.xq;
         },
         set: function (a) {
-            var b = this.yc;
+            var b = this.ys;
             if (a != b) {
-                this.xa = a;
-                this.sy("YAxisMinorStrokeThickness", b, this.yc);
+                this.xq = a;
+                this.te("YAxisMinorStrokeThickness", b, this.ys);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "aci", {
+    Object.defineProperty(XYChart.prototype, "acy", {
         get: function () {
-            return this.ab2;
+            return this.aci;
         },
         set: function (a) {
-            var b = this.aci;
+            var b = this.acy;
             if (a != b) {
-                this.ab2 = a;
-                this.sy("XAxisStrip", b, this.aci);
+                this.aci = a;
+                this.te("XAxisStrip", b, this.acy);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "acp", {
+    Object.defineProperty(XYChart.prototype, "ac5", {
         get: function () {
-            return this.ab9;
+            return this.acp;
         },
         set: function (a) {
-            var b = this.acp;
+            var b = this.ac5;
             if (a != b) {
-                this.ab9 = a;
-                this.sy("YAxisStrip", b, this.acp);
+                this.acp = a;
+                this.te("YAxisStrip", b, this.ac5);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "acj", {
+    Object.defineProperty(XYChart.prototype, "acz", {
         get: function () {
-            return this.ab3;
+            return this.acj;
         },
         set: function (a) {
-            var b = this.acj;
+            var b = this.acz;
             if (a != b) {
-                this.ab3 = a;
-                this.sy("XAxisStroke", b, this.acj);
+                this.acj = a;
+                this.te("XAxisStroke", b, this.acz);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "acq", {
+    Object.defineProperty(XYChart.prototype, "ac6", {
         get: function () {
-            return this.aca;
+            return this.acq;
         },
         set: function (a) {
-            var b = this.acq;
+            var b = this.ac6;
             if (a != b) {
-                this.aca = a;
-                this.sy("YAxisStroke", b, this.acq);
+                this.acq = a;
+                this.te("YAxisStroke", b, this.ac6);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "xw", {
+    Object.defineProperty(XYChart.prototype, "yc", {
         get: function () {
-            return this.wu;
+            return this.xa;
         },
         set: function (a) {
-            var b = this.xw;
+            var b = this.yc;
             if (a != b) {
-                this.wu = a;
-                this.sy("XAxisStrokeThickness", b, this.xw);
+                this.xa = a;
+                this.te("XAxisStrokeThickness", b, this.yc);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "yd", {
+    Object.defineProperty(XYChart.prototype, "yt", {
         get: function () {
-            return this.xb;
+            return this.xr;
         },
         set: function (a) {
-            var b = this.yd;
+            var b = this.yt;
             if (a != b) {
-                this.xb = a;
-                this.sy("YAxisStrokeThickness", b, this.yd);
+                this.xr = a;
+                this.te("YAxisStrokeThickness", b, this.yt);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "xx", {
+    Object.defineProperty(XYChart.prototype, "yd", {
         get: function () {
-            return this.wv;
+            return this.xb;
         },
         set: function (a) {
-            var b = this.xx;
+            var b = this.yd;
             if (a != b) {
-                this.wv = a;
-                this.sy("XAxisTickLength", b, this.xx);
+                this.xb = a;
+                this.te("XAxisTickLength", b, this.yd);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "ye", {
+    Object.defineProperty(XYChart.prototype, "yu", {
         get: function () {
-            return this.xc;
+            return this.xs;
         },
         set: function (a) {
-            var b = this.ye;
+            var b = this.yu;
             if (a != b) {
-                this.xc = a;
-                this.sy("YAxisTickLength", b, this.ye);
+                this.xs = a;
+                this.te("YAxisTickLength", b, this.yu);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "ack", {
+    Object.defineProperty(XYChart.prototype, "ac0", {
         get: function () {
-            return this.ab4;
+            return this.ack;
         },
         set: function (a) {
-            var b = this.ack;
+            var b = this.ac0;
             if (a != b) {
-                this.ab4 = a;
-                this.sy("XAxisTickStroke", b, this.ack);
+                this.ack = a;
+                this.te("XAxisTickStroke", b, this.ac0);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "acr", {
+    Object.defineProperty(XYChart.prototype, "ac7", {
         get: function () {
-            return this.acb;
+            return this.acr;
         },
         set: function (a) {
-            var b = this.acr;
+            var b = this.ac7;
             if (a != b) {
-                this.acb = a;
-                this.sy("YAxisTickStroke", b, this.acr);
+                this.acr = a;
+                this.te("YAxisTickStroke", b, this.ac7);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "xy", {
+    Object.defineProperty(XYChart.prototype, "ye", {
         get: function () {
-            return this.ww;
+            return this.xc;
         },
         set: function (a) {
-            var b = this.xy;
+            var b = this.ye;
             if (a != b) {
-                this.ww = a;
-                this.sy("XAxisTickStrokeThickness", b, this.xy);
+                this.xc = a;
+                this.te("XAxisTickStrokeThickness", b, this.ye);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "yf", {
+    Object.defineProperty(XYChart.prototype, "yv", {
         get: function () {
-            return this.xd;
+            return this.xt;
         },
         set: function (a) {
-            var b = this.yf;
+            var b = this.yv;
             if (a != b) {
-                this.xd = a;
-                this.sy("YAxisTickStrokeThickness", b, this.yf);
+                this.xt = a;
+                this.te("YAxisTickStrokeThickness", b, this.yv);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "zu", {
+    Object.defineProperty(XYChart.prototype, "aaa", {
         get: function () {
-            return this.ys;
+            return this.y8;
         },
         set: function (a) {
-            var b = this.zu;
+            var b = this.aaa;
             if (a != b) {
-                this.ys = a;
-                this.sy("XAxisTitle", b, this.zu);
+                this.y8 = a;
+                this.te("XAxisTitle", b, this.aaa);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "aaz", {
+    Object.defineProperty(XYChart.prototype, "abf", {
         get: function () {
-            return this.yw;
+            return this.zc;
         },
         set: function (a) {
-            var b = this.aaz;
+            var b = this.abf;
             if (a != b) {
-                this.yw = a;
-                this.sy("YAxisTitle", b, this.aaz);
+                this.zc = a;
+                this.te("YAxisTitle", b, this.abf);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "ach", {
+    Object.defineProperty(XYChart.prototype, "acx", {
         get: function () {
-            return this.ab1;
+            return this.ach;
         },
         set: function (a) {
-            var b = this.ach;
+            var b = this.acx;
             if (a != b) {
-                this.ab1 = a;
-                this.sy("XAxisMinorStroke", b, this.ach);
+                this.ach = a;
+                this.te("XAxisMinorStroke", b, this.acx);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "aco", {
+    Object.defineProperty(XYChart.prototype, "ac4", {
         get: function () {
-            return this.ab8;
+            return this.aco;
         },
         set: function (a) {
-            var b = this.aco;
+            var b = this.ac4;
             if (a != b) {
-                this.ab8 = a;
-                this.sy("YAxisMinorStroke", b, this.aco);
+                this.aco = a;
+                this.te("YAxisMinorStroke", b, this.ac4);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "xp", {
+    Object.defineProperty(XYChart.prototype, "x5", {
         get: function () {
-            return this.wn;
+            return this.w3;
         },
         set: function (a) {
-            var b = this.xp;
+            var b = this.x5;
             if (a != b) {
-                this.wn = a;
-                this.sy("XAxisLabelAngle", b, this.xp);
+                this.w3 = a;
+                this.te("XAxisLabelAngle", b, this.x5);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "x6", {
+    Object.defineProperty(XYChart.prototype, "ym", {
         get: function () {
-            return this.w4;
+            return this.xk;
         },
         set: function (a) {
-            var b = this.x6;
+            var b = this.ym;
             if (a != b) {
-                this.w4 = a;
-                this.sy("YAxisLabelAngle", b, this.x6);
+                this.xk = a;
+                this.te("YAxisLabelAngle", b, this.ym);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "xo", {
+    Object.defineProperty(XYChart.prototype, "x4", {
         get: function () {
-            return this.wm;
+            return this.w2;
         },
         set: function (a) {
-            var b = this.xo;
+            var b = this.x4;
             if (a != b) {
-                this.wm = a;
-                this.sy("XAxisExtent", b, this.xo);
+                this.w2 = a;
+                this.te("XAxisExtent", b, this.x4);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "x5", {
+    Object.defineProperty(XYChart.prototype, "yl", {
         get: function () {
-            return this.w3;
+            return this.xj;
         },
         set: function (a) {
-            var b = this.x5;
+            var b = this.yl;
             if (a != b) {
-                this.w3 = a;
-                this.sy("YAxisExtent", b, this.x5);
+                this.xj = a;
+                this.te("YAxisExtent", b, this.yl);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "xz", {
+    Object.defineProperty(XYChart.prototype, "yf", {
         get: function () {
-            return this.wx;
+            return this.xd;
         },
         set: function (a) {
-            var b = this.xz;
+            var b = this.yf;
             if (a != b) {
-                this.wx = a;
-                this.sy("XAxisTitleAngle", b, this.xz);
+                this.xd = a;
+                this.te("XAxisTitleAngle", b, this.yf);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "yg", {
+    Object.defineProperty(XYChart.prototype, "yw", {
         get: function () {
-            return this.xe;
+            return this.xu;
         },
         set: function (a) {
-            var b = this.yg;
+            var b = this.yw;
             if (a != b) {
-                this.xe = a;
-                this.sy("YAxisTitleAngle", b, this.yg);
+                this.xu = a;
+                this.te("YAxisTitleAngle", b, this.yw);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "wk", {
+    Object.defineProperty(XYChart.prototype, "w0", {
         get: function () {
-            return this.wi;
+            return this.wy;
         },
         set: function (a) {
-            var b = this.wk;
+            var b = this.w0;
             if (a != b) {
-                this.wi = a;
-                this.sy("XAxisInverted", b, this.wk);
+                this.wy = a;
+                this.te("XAxisInverted", b, this.w0);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "wl", {
+    Object.defineProperty(XYChart.prototype, "w1", {
         get: function () {
-            return this.wj;
+            return this.wz;
         },
         set: function (a) {
-            var b = this.wl;
+            var b = this.w1;
             if (a != b) {
-                this.wj = a;
-                this.sy("YAxisInverted", b, this.wl);
+                this.wz = a;
+                this.te("YAxisInverted", b, this.w1);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "abv", {
+    Object.defineProperty(XYChart.prototype, "acb", {
         get: function () {
-            return this.abs;
+            return this.ab8;
         },
         set: function (a) {
-            var b = this.abv;
+            var b = this.acb;
             if (a != b) {
-                this.abs = a;
-                this.sy("XAxisTitleAlignment", enumGetBox(HorizontalAlignment_$type, b), enumGetBox(HorizontalAlignment_$type, this.abv));
+                this.ab8 = a;
+                this.te("XAxisTitleAlignment", enumGetBox(HorizontalAlignment_$type, b), enumGetBox(HorizontalAlignment_$type, this.acb));
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "acy", {
+    Object.defineProperty(XYChart.prototype, "ade", {
         get: function () {
-            return this.acv;
+            return this.adb;
         },
         set: function (a) {
-            var b = this.acy;
+            var b = this.ade;
             if (a != b) {
-                this.acv = a;
-                this.sy("YAxisTitleAlignment", enumGetBox(VerticalAlignment_$type, b), enumGetBox(VerticalAlignment_$type, this.acy));
+                this.adb = a;
+                this.te("YAxisTitleAlignment", enumGetBox(VerticalAlignment_$type, b), enumGetBox(VerticalAlignment_$type, this.ade));
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "abu", {
+    Object.defineProperty(XYChart.prototype, "aca", {
         get: function () {
-            return this.abr;
+            return this.ab7;
         },
         set: function (a) {
-            var b = this.abu;
+            var b = this.aca;
             if (a != b) {
-                this.abr = a;
-                this.sy("XAxisLabelHorizontalAlignment", enumGetBox(HorizontalAlignment_$type, b), enumGetBox(HorizontalAlignment_$type, this.abu));
+                this.ab7 = a;
+                this.te("XAxisLabelHorizontalAlignment", enumGetBox(HorizontalAlignment_$type, b), enumGetBox(HorizontalAlignment_$type, this.aca));
             }
         },
         enumerable: false,
         configurable: true
     });
-    XYChart.prototype.get_abw = function () {
-        return this.abt;
+    XYChart.prototype.get_acc = function () {
+        return this.ab9;
     };
-    XYChart.prototype.set_abw = function (a) {
-        var b = this.abw;
+    XYChart.prototype.set_acc = function (a) {
+        var b = this.acc;
         if (a != b) {
-            this.abt = a;
-            this.sy("YAxisLabelHorizontalAlignment", enumGetBox(HorizontalAlignment_$type, b), enumGetBox(HorizontalAlignment_$type, this.abw));
+            this.ab9 = a;
+            this.te("YAxisLabelHorizontalAlignment", enumGetBox(HorizontalAlignment_$type, b), enumGetBox(HorizontalAlignment_$type, this.acc));
         }
     };
-    Object.defineProperty(XYChart.prototype, "abw", {
+    Object.defineProperty(XYChart.prototype, "acc", {
         get: function () {
-            return this.get_abw();
+            return this.get_acc();
         },
         set: function (a) {
-            this.set_abw(a);
+            this.set_acc(a);
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "acw", {
+    Object.defineProperty(XYChart.prototype, "adc", {
         get: function () {
-            return this.act;
+            return this.ac9;
         },
         set: function (a) {
-            var b = this.acw;
+            var b = this.adc;
             if (a != b) {
-                this.act = a;
-                this.sy("XAxisLabelVerticalAlignment", enumGetBox(VerticalAlignment_$type, b), enumGetBox(VerticalAlignment_$type, this.acw));
+                this.ac9 = a;
+                this.te("XAxisLabelVerticalAlignment", enumGetBox(VerticalAlignment_$type, b), enumGetBox(VerticalAlignment_$type, this.adc));
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "acx", {
+    Object.defineProperty(XYChart.prototype, "add", {
         get: function () {
-            return this.acu;
+            return this.ada;
         },
         set: function (a) {
-            var b = this.acx;
+            var b = this.add;
             if (a != b) {
-                this.acu = a;
-                this.sy("YAxisLabelVerticalAlignment", enumGetBox(VerticalAlignment_$type, b), enumGetBox(VerticalAlignment_$type, this.acx));
+                this.ada = a;
+                this.te("YAxisLabelVerticalAlignment", enumGetBox(VerticalAlignment_$type, b), enumGetBox(VerticalAlignment_$type, this.add));
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "ac1", {
+    Object.defineProperty(XYChart.prototype, "adh", {
         get: function () {
-            return this.acz;
+            return this.adf;
         },
         set: function (a) {
-            var b = this.ac1;
+            var b = this.adh;
             if (a != b) {
-                this.acz = a;
-                this.sy("XAxisLabelVisibility", enumGetBox(Visibility_$type, b), enumGetBox(Visibility_$type, this.ac1));
+                this.adf = a;
+                this.te("XAxisLabelVisibility", enumGetBox(Visibility_$type, b), enumGetBox(Visibility_$type, this.adh));
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "ac2", {
+    Object.defineProperty(XYChart.prototype, "adi", {
         get: function () {
-            return this.ac0;
+            return this.adg;
         },
         set: function (a) {
-            var b = this.ac2;
+            var b = this.adi;
             if (a != b) {
-                this.ac0 = a;
-                this.sy("YAxisLabelVisibility", enumGetBox(Visibility_$type, b), enumGetBox(Visibility_$type, this.ac2));
+                this.adg = a;
+                this.te("YAxisLabelVisibility", enumGetBox(Visibility_$type, b), enumGetBox(Visibility_$type, this.adi));
             }
         },
         enumerable: false,
         configurable: true
     });
-    XYChart.prototype.get_wh = function () {
-        return this.wg;
+    XYChart.prototype.get_wx = function () {
+        return this.ww;
     };
-    XYChart.prototype.set_wh = function (a) {
-        var b = this.wh;
+    XYChart.prototype.set_wx = function (a) {
+        var b = this.wx;
         if (a != b) {
-            this.wg = a;
-            this.sy("YAxisLabelLocation", enumGetBox(YAxisLabelLocation_$type, b), enumGetBox(YAxisLabelLocation_$type, this.wh));
+            this.ww = a;
+            this.te("YAxisLabelLocation", enumGetBox(YAxisLabelLocation_$type, b), enumGetBox(YAxisLabelLocation_$type, this.wx));
         }
     };
-    Object.defineProperty(XYChart.prototype, "wh", {
+    Object.defineProperty(XYChart.prototype, "wx", {
         get: function () {
-            return this.get_wh();
+            return this.get_wx();
         },
         set: function (a) {
-            this.set_wh(a);
+            this.set_wx(a);
         },
         enumerable: false,
         configurable: true
     });
-    XYChart.prototype.get_wf = function () {
-        return this.we;
+    XYChart.prototype.get_wv = function () {
+        return this.wu;
     };
-    XYChart.prototype.set_wf = function (a) {
-        var b = this.wf;
+    XYChart.prototype.set_wv = function (a) {
+        var b = this.wv;
         if (a != b) {
-            this.we = a;
-            this.sy("XAxisLabelLocation", enumGetBox(XAxisLabelLocation_$type, b), enumGetBox(XAxisLabelLocation_$type, this.wf));
+            this.wu = a;
+            this.te("XAxisLabelLocation", enumGetBox(XAxisLabelLocation_$type, b), enumGetBox(XAxisLabelLocation_$type, this.wv));
         }
     };
-    Object.defineProperty(XYChart.prototype, "wf", {
+    Object.defineProperty(XYChart.prototype, "wv", {
         get: function () {
-            return this.get_wf();
+            return this.get_wv();
         },
         set: function (a) {
-            this.set_wf(a);
+            this.set_wv(a);
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "y6", {
+    Object.defineProperty(XYChart.prototype, "zm", {
         get: function () {
-            return this.yq;
+            return this.y6;
         },
         set: function (a) {
-            var b = this.yq;
+            var b = this.y6;
             if (a != b) {
-                this.yq = a;
-                this.sy("XAxisLabelFormat", b, this.yq);
+                this.y6 = a;
+                this.te("XAxisLabelFormat", b, this.y6);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "v4", {
+    Object.defineProperty(XYChart.prototype, "wk", {
         get: function () {
-            return this.v2;
+            return this.wi;
         },
         set: function (a) {
-            var b = this.v2;
+            var b = this.wi;
             if (a != b) {
-                this.v2 = a;
-                this.sy("XAxisLabelFormatSpecifiers", b, this.v2);
+                this.wi = a;
+                this.te("XAxisLabelFormatSpecifiers", b, this.wi);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "aab", {
+    Object.defineProperty(XYChart.prototype, "aar", {
         get: function () {
-            return this.yu;
+            return this.za;
         },
         set: function (a) {
-            var b = this.yu;
+            var b = this.za;
             if (a != b) {
-                this.yu = a;
-                this.sy("YAxisLabelFormat", b, this.yu);
+                this.za = a;
+                this.te("YAxisLabelFormat", b, this.za);
             }
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(XYChart.prototype, "v5", {
+    Object.defineProperty(XYChart.prototype, "wl", {
         get: function () {
-            return this.v3;
+            return this.wj;
         },
         set: function (a) {
-            var b = this.v3;
+            var b = this.wj;
             if (a != b) {
-                this.v3 = a;
-                this.sy("YAxisLabelFormatSpecifiers", b, this.v3);
+                this.wj = a;
+                this.te("YAxisLabelFormatSpecifiers", b, this.wj);
             }
         },
         enumerable: false,