igniteui-webcomponents-charts 3.2.3 → 3.5.0

package/esm2015/lib/XYChart.js

@@ -23,87 +23,87 @@ export let XYChart = /*@__PURE__*/ (() => {
     class XYChart extends DomainChart {
         constructor() {
             super(...arguments);
-            this.ty = null;
-            this.tz = null;
-            this.uf = 0;
-            this.uh = 5;
-            this.ug = 0;
-            this.ue = 5;
-            this.uw = 5;
-            this.uy = 0;
-            this.ux = 5;
-            this.uv = 0;
-            this.zp = null;
-            this.zw = null;
-            this.zn = null;
-            this.zo = null;
-            this.uq = 0;
-            this.u7 = 0;
-            this.up = NaN;
-            this.u6 = NaN;
-            this.us = NaN;
-            this.u9 = NaN;
-            this.ur = NaN;
-            this.u8 = NaN;
-            this.uo = NaN;
-            this.u5 = NaN;
-            this.zv = null;
-            this.z2 = null;
-            this.wh = null;
-            this.wl = null;
-            this.wj = null;
-            this.wn = null;
-            this.wc = null;
-            this.wd = null;
-            this.zq = null;
-            this.zx = null;
-            this.ui = DeviceUtils.g(1);
-            this.uz = DeviceUtils.g(1);
-            this.uj = DeviceUtils.g(1);
-            this.u0 = DeviceUtils.g(1);
-            this.zs = null;
-            this.zz = null;
-            this.zt = null;
-            this.z0 = null;
-            this.uk = DeviceUtils.g(1);
-            this.u1 = DeviceUtils.g(1);
-            this.ul = DeviceUtils.g(8);
-            this.u2 = 0;
-            this.zu = null;
-            this.z1 = null;
-            this.um = DeviceUtils.g(1);
-            this.u3 = DeviceUtils.g(1);
-            this.wi = null;
-            this.wm = null;
-            this.zr = null;
-            this.zy = null;
-            this.ud = 0;
-            this.uu = 0;
-            this.uc = NaN;
-            this.ut = NaN;
-            this.un = 0;
-            this.u4 = -90;
-            this.t8 = false;
-            this.t9 = false;
-            this.zi = 1;
-            this.aal = 1;
-            this.zh = 1;
-            this.zj = 2;
-            this.aaj = 0;
-            this.aak = 1;
-            this.aap = 0;
-            this.aaq = 0;
-            this.t6 = 4;
-            this.t4 = 4;
-            this.wg = null;
-            this.ts = null;
-            this.wk = null;
-            this.tt = null;
+            this.vi = null;
+            this.vj = null;
+            this.vz = 0;
+            this.v1 = 5;
+            this.v0 = 0;
+            this.vy = 5;
+            this.wg = 5;
+            this.wi = 0;
+            this.wh = 5;
+            this.wf = 0;
+            this.aa9 = null;
+            this.abg = null;
+            this.aa7 = null;
+            this.aa8 = null;
+            this.wa = 0;
+            this.wr = 0;
+            this.v9 = NaN;
+            this.wq = NaN;
+            this.wc = NaN;
+            this.wt = NaN;
+            this.wb = NaN;
+            this.ws = NaN;
+            this.v8 = NaN;
+            this.wp = NaN;
+            this.abf = null;
+            this.abm = null;
+            this.x1 = null;
+            this.x5 = null;
+            this.x3 = null;
+            this.x7 = null;
+            this.xw = null;
+            this.xx = null;
+            this.aba = null;
+            this.abh = null;
+            this.v2 = DeviceUtils.g(1);
+            this.wj = DeviceUtils.g(1);
+            this.v3 = DeviceUtils.g(1);
+            this.wk = DeviceUtils.g(1);
+            this.abc = null;
+            this.abj = null;
+            this.abd = null;
+            this.abk = null;
+            this.v4 = DeviceUtils.g(1);
+            this.wl = DeviceUtils.g(1);
+            this.v5 = DeviceUtils.g(8);
+            this.wm = 0;
+            this.abe = null;
+            this.abl = null;
+            this.v6 = DeviceUtils.g(1);
+            this.wn = DeviceUtils.g(1);
+            this.x2 = null;
+            this.x6 = null;
+            this.abb = null;
+            this.abi = null;
+            this.vx = 0;
+            this.we = 0;
+            this.vw = NaN;
+            this.wd = NaN;
+            this.v7 = 0;
+            this.wo = -90;
+            this.vs = false;
+            this.vt = false;
+            this.aa2 = 1;
+            this.ab5 = 1;
+            this.aa1 = 1;
+            this.aa3 = 2;
+            this.ab3 = 0;
+            this.ab4 = 1;
+            this.ab9 = 0;
+            this.aca = 0;
+            this.vq = 4;
+            this.vo = 4;
+            this.x0 = null;
+            this.vc = null;
+            this.x4 = null;
+            this.vd = null;
         }
         provideContainer(a) {
             if (a != null) {
-                let b = this.tw();
-                let c = this.tx();
+                let b = this.vg();
+                let c = this.vh();
                 if (b != null) {
                     b.provideRenderer(a);
                 }
@@ -113,520 +113,520 @@ export let XYChart = /*@__PURE__*/ (() => {
             }
             super.provideContainer(a);
         }
-        p7() {
-            super.p7();
-            let a = this.tw();
-            let b = this.tx();
+        rr() {
+            super.rr();
+            let a = this.vg();
+            let b = this.vh();
             if (a != null && a.ay != null) {
-                this.z5 = a.ay.textColor;
+                this.abp = a.ay.textColor;
             }
             if (b != null && b.ay != null) {
-                this.aac = b.ay.textColor;
+                this.abw = b.ay.textColor;
             }
-            this.aaa = AxisDefaults.j;
-            this.aah = AxisDefaults.j;
-            this.z6 = AxisDefaults.h;
-            this.aad = AxisDefaults.h;
-            this.z9 = AxisDefaults.g;
-            this.aag = AxisDefaults.g;
+            this.abu = AxisDefaults.j;
+            this.ab1 = AxisDefaults.j;
+            this.abq = AxisDefaults.h;
+            this.abx = AxisDefaults.h;
+            this.abt = AxisDefaults.g;
+            this.ab0 = AxisDefaults.g;
         }
-        qu(a, b, c) {
-            super.qu(a, b, c);
+        se(a, b, c) {
+            super.se(a, b, c);
             switch (a) {
                 case "XAxisLabelLeftMargin":
-                    this.y9((d) => d.leftMargin = this.vh);
+                    this.aat((d) => d.leftMargin = this.w1);
                     break;
                 case "XAxisLabelTopMargin":
-                    this.y9((d) => d.topMargin = this.vj);
+                    this.aat((d) => d.topMargin = this.w3);
                     break;
                 case "XAxisLabelRightMargin":
-                    this.y9((d) => d.rightMargin = this.vi);
+                    this.aat((d) => d.rightMargin = this.w2);
                     break;
                 case "XAxisLabelBottomMargin":
-                    this.y9((d) => d.bottomMargin = this.vg);
+                    this.aat((d) => d.bottomMargin = this.w0);
                     break;
                 case "YAxisLabelLeftMargin":
-                    this.ze((d) => d.leftMargin = this.vy);
+                    this.aay((d) => d.leftMargin = this.xi);
                     break;
                 case "YAxisLabelTopMargin":
-                    this.ze((d) => d.topMargin = this.v0);
+                    this.aay((d) => d.topMargin = this.xk);
                     break;
                 case "YAxisLabelRightMargin":
-                    this.ze((d) => d.rightMargin = this.vz);
+                    this.aay((d) => d.rightMargin = this.xj);
                     break;
                 case "YAxisLabelBottomMargin":
-                    this.ze((d) => d.bottomMargin = this.vx);
+                    this.aay((d) => d.bottomMargin = this.xh);
                     break;
                 case "ActualItemsSource":
                 case "ShouldDisplayMockData":
                 case "ShouldUseSkeletonStyleForMockData":
-                    this.z3 = this.sz(this.z5);
-                    this.z4 = this.sz(this.aac);
+                    this.abn = this.uj(this.abp);
+                    this.abo = this.uj(this.abw);
                     break;
                 case "XAxisLabelTextColor":
-                    this.z3 = this.sz(this.z5);
+                    this.abn = this.uj(this.abp);
                     break;
                 case "YAxisLabelTextColor":
-                    this.z4 = this.sz(this.aac);
+                    this.abo = this.uj(this.abw);
                     break;
                 case "ActualXAxisLabelTextColor":
-                    this.y9((d) => d.textColor = this.z3);
+                    this.aat((d) => d.textColor = this.abn);
                     break;
                 case "ActualYAxisLabelTextColor":
-                    this.ze((d) => d.textColor = this.z4);
+                    this.aay((d) => d.textColor = this.abo);
                     break;
                 case "XAxisTitleMargin":
-                    this.zb((d) => d.margin = this.vs);
+                    this.aav((d) => d.margin = this.xc);
                     break;
                 case "YAxisTitleMargin":
-                    this.zg((d) => d.margin = this.v9);
+                    this.aa0((d) => d.margin = this.xt);
                     break;
                 case "XAxisTitleLeftMargin":
-                    this.zb((d) => d.leftMargin = this.vr);
+                    this.aav((d) => d.leftMargin = this.xb);
                     break;
                 case "YAxisTitleLeftMargin":
-                    this.zg((d) => d.leftMargin = this.v8);
+                    this.aa0((d) => d.leftMargin = this.xs);
                     break;
                 case "XAxisTitleTopMargin":
-                    this.zb((d) => d.topMargin = this.vu);
+                    this.aav((d) => d.topMargin = this.xe);
                     break;
                 case "YAxisTitleTopMargin":
-                    this.zg((d) => d.topMargin = this.wb);
+                    this.aa0((d) => d.topMargin = this.xv);
                     break;
                 case "XAxisTitleRightMargin":
-                    this.zb((d) => d.rightMargin = this.vt);
+                    this.aav((d) => d.rightMargin = this.xd);
                     break;
                 case "YAxisTitleRightMargin":
-                    this.zg((d) => d.rightMargin = this.wa);
+                    this.aa0((d) => d.rightMargin = this.xu);
                     break;
                 case "XAxisTitleBottomMargin":
-                    this.zb((d) => d.bottomMargin = this.vq);
+                    this.aav((d) => d.bottomMargin = this.xa);
                     break;
                 case "YAxisTitleBottomMargin":
-                    this.zg((d) => d.bottomMargin = this.v7);
+                    this.aa0((d) => d.bottomMargin = this.xr);
                     break;
                 case "XAxisTitleTextColor":
-                    this.zb((d) => d.textColor = this.aab);
+                    this.aav((d) => d.textColor = this.abv);
                     break;
                 case "YAxisTitleTextColor":
-                    this.zg((d) => d.textColor = this.aai);
+                    this.aa0((d) => d.textColor = this.ab2);
                     break;
                 case "XAxisFormatLabel":
-                    this.y7((d) => d.at = this.t0);
+                    this.aar((d) => d.at = this.vk);
                     break;
                 case "YAxisFormatLabel":
-                    this.zc((d) => d.at = this.t1);
+                    this.aaw((d) => d.at = this.vl);
                     break;
             }
         }
-        get t0() {
-            return this.ty;
+        get vk() {
+            return this.vi;
         }
-        set t0(a) {
-            let b = this.t0;
+        set vk(a) {
+            let b = this.vk;
             if (a != b) {
-                this.ty = a;
-                this.qt("XAxisFormatLabel", b, this.t0);
+                this.vi = a;
+                this.sd("XAxisFormatLabel", b, this.vk);
             }
         }
-        get t1() {
-            return this.tz;
+        get vl() {
+            return this.vj;
         }
-        set t1(a) {
-            let b = this.t1;
+        set vl(a) {
+            let b = this.vl;
             if (a != b) {
-                this.tz = a;
-                this.qt("YAxisFormatLabel", b, this.t1);
+                this.vj = a;
+                this.sd("YAxisFormatLabel", b, this.vl);
             }
         }
-        get vh() {
-            return this.uf;
+        get w1() {
+            return this.vz;
         }
-        set vh(a) {
-            let b = this.vh;
+        set w1(a) {
+            let b = this.w1;
             if (a != b) {
-                this.uf = a;
-                this.qt("XAxisLabelLeftMargin", b, this.vh);
+                this.vz = a;
+                this.sd("XAxisLabelLeftMargin", b, this.w1);
             }
         }
-        get vj() {
-            return this.uh;
+        get w3() {
+            return this.v1;
         }
-        set vj(a) {
-            let b = this.vj;
+        set w3(a) {
+            let b = this.w3;
             if (a != b) {
-                this.uh = a;
-                this.qt("XAxisLabelTopMargin", b, this.vj);
+                this.v1 = a;
+                this.sd("XAxisLabelTopMargin", b, this.w3);
             }
         }
-        get vi() {
-            return this.ug;
+        get w2() {
+            return this.v0;
         }
-        set vi(a) {
-            let b = this.vi;
+        set w2(a) {
+            let b = this.w2;
             if (a != b) {
-                this.ug = a;
-                this.qt("XAxisLabelRightMargin", b, this.vi);
+                this.v0 = a;
+                this.sd("XAxisLabelRightMargin", b, this.w2);
             }
         }
-        get vg() {
-            return this.ue;
+        get w0() {
+            return this.vy;
         }
-        set vg(a) {
-            let b = this.vg;
+        set w0(a) {
+            let b = this.w0;
             if (a != b) {
-                this.ue = a;
-                this.qt("XAxisLabelBottomMargin", b, this.vg);
+                this.vy = a;
+                this.sd("XAxisLabelBottomMargin", b, this.w0);
             }
         }
-        get vy() {
-            return this.uw;
+        get xi() {
+            return this.wg;
         }
-        set vy(a) {
-            let b = this.vy;
+        set xi(a) {
+            let b = this.xi;
             if (a != b) {
-                this.uw = a;
-                this.qt("YAxisLabelLeftMargin", b, this.vy);
+                this.wg = a;
+                this.sd("YAxisLabelLeftMargin", b, this.xi);
             }
         }
-        get v0() {
-            return this.uy;
+        get xk() {
+            return this.wi;
         }
-        set v0(a) {
-            let b = this.v0;
+        set xk(a) {
+            let b = this.xk;
             if (a != b) {
-                this.uy = a;
-                this.qt("YAxisLabelTopMargin", b, this.v0);
+                this.wi = a;
+                this.sd("YAxisLabelTopMargin", b, this.xk);
             }
         }
-        get vz() {
-            return this.ux;
+        get xj() {
+            return this.wh;
         }
-        set vz(a) {
-            let b = this.vz;
+        set xj(a) {
+            let b = this.xj;
             if (a != b) {
-                this.ux = a;
-                this.qt("YAxisLabelRightMargin", b, this.vz);
+                this.wh = a;
+                this.sd("YAxisLabelRightMargin", b, this.xj);
             }
         }
-        get vx() {
-            return this.uv;
+        get xh() {
+            return this.wf;
         }
-        set vx(a) {
-            let b = this.vx;
+        set xh(a) {
+            let b = this.xh;
             if (a != b) {
-                this.uv = a;
-                this.qt("YAxisLabelBottomMargin", b, this.vx);
+                this.wf = a;
+                this.sd("YAxisLabelBottomMargin", b, this.xh);
             }
         }
-        get z5() {
-            return this.zp;
+        get abp() {
+            return this.aa9;
         }
-        set z5(a) {
-            let b = this.z5;
+        set abp(a) {
+            let b = this.abp;
             if (a != b) {
-                this.zp = a;
-                this.qt("XAxisLabelTextColor", b, this.z5);
+                this.aa9 = a;
+                this.sd("XAxisLabelTextColor", b, this.abp);
             }
         }
-        get aac() {
-            return this.zw;
+        get abw() {
+            return this.abg;
         }
-        set aac(a) {
-            let b = this.aac;
+        set abw(a) {
+            let b = this.abw;
             if (a != b) {
-                this.zw = a;
-                this.qt("YAxisLabelTextColor", b, this.aac);
+                this.abg = a;
+                this.sd("YAxisLabelTextColor", b, this.abw);
             }
         }
-        get z3() {
-            return this.zn;
+        get abn() {
+            return this.aa7;
         }
-        set z3(a) {
-            let b = this.zn;
+        set abn(a) {
+            let b = this.aa7;
             if (a != b) {
-                this.zn = a;
-                this.qt("ActualXAxisLabelTextColor", b, this.z3);
+                this.aa7 = a;
+                this.sd("ActualXAxisLabelTextColor", b, this.abn);
             }
         }
-        get z4() {
-            return this.zo;
+        get abo() {
+            return this.aa8;
         }
-        set z4(a) {
-            let b = this.zo;
+        set abo(a) {
+            let b = this.aa8;
             if (a != b) {
-                this.zo = a;
-                this.qt("ActualYAxisLabelTextColor", b, this.z4);
+                this.aa8 = a;
+                this.sd("ActualYAxisLabelTextColor", b, this.abo);
             }
         }
-        get vs() {
-            return this.uq;
+        get xc() {
+            return this.wa;
         }
-        set vs(a) {
-            let b = this.vs;
+        set xc(a) {
+            let b = this.xc;
             if (a != b) {
-                this.uq = a;
-                this.qt("XAxisTitleMargin", b, this.vs);
+                this.wa = a;
+                this.sd("XAxisTitleMargin", b, this.xc);
             }
         }
-        get v9() {
-            return this.u7;
+        get xt() {
+            return this.wr;
         }
-        set v9(a) {
-            let b = this.v9;
+        set xt(a) {
+            let b = this.xt;
             if (a != b) {
-                this.u7 = a;
-                this.qt("YAxisTitleMargin", b, this.v9);
+                this.wr = a;
+                this.sd("YAxisTitleMargin", b, this.xt);
             }
         }
-        get vr() {
-            return this.up;
+        get xb() {
+            return this.v9;
         }
-        set vr(a) {
-            let b = this.vr;
+        set xb(a) {
+            let b = this.xb;
             if (a != b) {
-                this.up = a;
-                this.qt("XAxisTitleLeftMargin", b, this.vr);
+                this.v9 = a;
+                this.sd("XAxisTitleLeftMargin", b, this.xb);
             }
         }
-        get v8() {
-            return this.u6;
+        get xs() {
+            return this.wq;
         }
-        set v8(a) {
-            let b = this.v8;
+        set xs(a) {
+            let b = this.xs;
             if (a != b) {
-                this.u6 = a;
-                this.qt("YAxisTitleLeftMargin", b, this.v8);
+                this.wq = a;
+                this.sd("YAxisTitleLeftMargin", b, this.xs);
             }
         }
-        get vu() {
-            return this.us;
+        get xe() {
+            return this.wc;
         }
-        set vu(a) {
-            let b = this.vu;
+        set xe(a) {
+            let b = this.xe;
             if (a != b) {
-                this.us = a;
-                this.qt("XAxisTitleTopMargin", b, this.vu);
+                this.wc = a;
+                this.sd("XAxisTitleTopMargin", b, this.xe);
             }
         }
-        get wb() {
-            return this.u9;
+        get xv() {
+            return this.wt;
         }
-        set wb(a) {
-            let b = this.wb;
+        set xv(a) {
+            let b = this.xv;
             if (a != b) {
-                this.u9 = a;
-                this.qt("YAxisTitleTopMargin", b, this.wb);
+                this.wt = a;
+                this.sd("YAxisTitleTopMargin", b, this.xv);
             }
         }
-        get vt() {
-            return this.ur;
+        get xd() {
+            return this.wb;
         }
-        set vt(a) {
-            let b = this.vt;
+        set xd(a) {
+            let b = this.xd;
             if (a != b) {
-                this.ur = a;
-                this.qt("XAxisTitleRightMargin", b, this.vt);
+                this.wb = a;
+                this.sd("XAxisTitleRightMargin", b, this.xd);
             }
         }
-        get wa() {
-            return this.u8;
+        get xu() {
+            return this.ws;
         }
-        set wa(a) {
-            let b = this.wa;
+        set xu(a) {
+            let b = this.xu;
             if (a != b) {
-                this.u8 = a;
-                this.qt("YAxisTitleRightMargin", b, this.wa);
+                this.ws = a;
+                this.sd("YAxisTitleRightMargin", b, this.xu);
             }
         }
-        get vq() {
-            return this.uo;
+        get xa() {
+            return this.v8;
         }
-        set vq(a) {
-            let b = this.vq;
+        set xa(a) {
+            let b = this.xa;
             if (a != b) {
-                this.uo = a;
-                this.qt("XAxisTitleBottomMargin", b, this.vq);
+                this.v8 = a;
+                this.sd("XAxisTitleBottomMargin", b, this.xa);
             }
         }
-        get v7() {
-            return this.u5;
+        get xr() {
+            return this.wp;
         }
-        set v7(a) {
-            let b = this.v7;
+        set xr(a) {
+            let b = this.xr;
             if (a != b) {
-                this.u5 = a;
-                this.qt("YAxisTitleBottomMargin", b, this.v7);
+                this.wp = a;
+                this.sd("YAxisTitleBottomMargin", b, this.xr);
             }
         }
-        get aab() {
-            return this.zv;
+        get abv() {
+            return this.abf;
         }
-        set aab(a) {
-            let b = this.aab;
+        set abv(a) {
+            let b = this.abv;
             if (a != b) {
-                this.zv = a;
-                this.qt("XAxisTitleTextColor", b, this.aab);
+                this.abf = a;
+                this.sd("XAxisTitleTextColor", b, this.abv);
             }
         }
-        get aai() {
-            return this.z2;
+        get ab2() {
+            return this.abm;
         }
-        set aai(a) {
-            let b = this.aai;
+        set ab2(a) {
+            let b = this.ab2;
             if (a != b) {
-                this.z2 = a;
-                this.qt("YAxisTitleTextColor", b, this.aai);
+                this.abm = a;
+                this.sd("YAxisTitleTextColor", b, this.ab2);
             }
         }
-        qv(a, b, c) {
-            super.qv(a, b, c);
+        sf(a, b, c) {
+            super.sf(a, b, c);
             switch (a) {
                 case "XAxisLabelTextStyle":
-                    this.y9((d) => d.textStyle = this.w5);
+                    this.aat((d) => d.textStyle = this.yp);
                     break;
                 case "YAxisLabelTextStyle":
-                    this.ze((d) => d.textStyle = this.ya);
+                    this.aay((d) => d.textStyle = this.zu);
                     break;
                 case "XAxisTitleTextStyle":
-                    this.zb((d) => d.textStyle = this.xt);
+                    this.aav((d) => d.textStyle = this.zd);
                     break;
                 case "YAxisTitleTextStyle":
-                    this.zg((d) => d.textStyle = this.yy);
+                    this.aa0((d) => d.textStyle = this.aai);
                     break;
             }
         }
-        get w5() {
-            return this.wh;
+        get yp() {
+            return this.x1;
         }
-        set w5(a) {
-            let b = this.w5;
+        set yp(a) {
+            let b = this.yp;
             if (a != b) {
-                this.wh = a;
-                this.qt("XAxisLabelTextStyle", b, this.w5);
+                this.x1 = a;
+                this.sd("XAxisLabelTextStyle", b, this.yp);
             }
         }
-        get ya() {
-            return this.wl;
+        get zu() {
+            return this.x5;
         }
-        set ya(a) {
-            let b = this.ya;
+        set zu(a) {
+            let b = this.zu;
             if (a != b) {
-                this.wl = a;
-                this.qt("YAxisLabelTextStyle", b, this.ya);
+                this.x5 = a;
+                this.sd("YAxisLabelTextStyle", b, this.zu);
             }
         }
-        get xt() {
-            return this.wj;
+        get zd() {
+            return this.x3;
         }
-        set xt(a) {
-            let b = this.xt;
+        set zd(a) {
+            let b = this.zd;
             if (a != b) {
-                this.wj = a;
-                this.qt("XAxisTitleTextStyle", b, this.xt);
+                this.x3 = a;
+                this.sd("XAxisTitleTextStyle", b, this.zd);
             }
         }
-        get yy() {
-            return this.wn;
+        get aai() {
+            return this.x7;
         }
-        set yy(a) {
-            let b = this.yy;
+        set aai(a) {
+            let b = this.aai;
             if (a != b) {
-                this.wn = a;
-                this.qt("YAxisTitleTextStyle", b, this.yy);
-            }
-        }
-        y4(a) {
-            this.y1(a, (b) => b.leftMargin = this.vh);
-            this.y1(a, (b) => b.topMargin = this.vj);
-            this.y1(a, (b) => b.rightMargin = this.vi);
-            this.y1(a, (b) => b.bottomMargin = this.vg);
-            this.y1(a, (b) => b.textColor = this.z3);
-            this.y2(a, (b) => b.textColor = this.aab);
-            this.y2(a, (b) => b.leftMargin = this.vr);
-            this.y2(a, (b) => b.topMargin = this.vu);
-            this.y2(a, (b) => b.rightMargin = this.vt);
-            this.y2(a, (b) => b.bottomMargin = this.vq);
-            this.y1(a, (b) => b.textStyle = this.w5);
-            this.y2(a, (b) => b.textStyle = this.xt);
-        }
-        y6(a) {
-            this.y1(a, (b) => b.leftMargin = this.vy);
-            this.y1(a, (b) => b.topMargin = this.v0);
-            this.y1(a, (b) => b.rightMargin = this.vz);
-            this.y1(a, (b) => b.bottomMargin = this.vx);
-            this.y1(a, (b) => b.textColor = this.z4);
-            this.y2(a, (b) => b.textColor = this.aai);
-            this.y2(a, (b) => b.leftMargin = this.v8);
-            this.y2(a, (b) => b.topMargin = this.wb);
-            this.y2(a, (b) => b.rightMargin = this.wa);
-            this.y2(a, (b) => b.bottomMargin = this.v7);
-            this.y1(a, (b) => b.textStyle = this.ya);
-            this.y2(a, (b) => b.textStyle = this.yy);
-        }
-        rc(a) {
-            let b = this.at(a);
-            let c = this.cf(a, b);
+                this.x7 = a;
+                this.sd("YAxisTitleTextStyle", b, this.aai);
+            }
+        }
+        aao(a) {
+            this.aal(a, (b) => b.leftMargin = this.w1);
+            this.aal(a, (b) => b.topMargin = this.w3);
+            this.aal(a, (b) => b.rightMargin = this.w2);
+            this.aal(a, (b) => b.bottomMargin = this.w0);
+            this.aal(a, (b) => b.textColor = this.abn);
+            this.aam(a, (b) => b.textColor = this.abv);
+            this.aam(a, (b) => b.leftMargin = this.xb);
+            this.aam(a, (b) => b.topMargin = this.xe);
+            this.aam(a, (b) => b.rightMargin = this.xd);
+            this.aam(a, (b) => b.bottomMargin = this.xa);
+            this.aal(a, (b) => b.textStyle = this.yp);
+            this.aam(a, (b) => b.textStyle = this.zd);
+        }
+        aaq(a) {
+            this.aal(a, (b) => b.leftMargin = this.xi);
+            this.aal(a, (b) => b.topMargin = this.xk);
+            this.aal(a, (b) => b.rightMargin = this.xj);
+            this.aal(a, (b) => b.bottomMargin = this.xh);
+            this.aal(a, (b) => b.textColor = this.abo);
+            this.aam(a, (b) => b.textColor = this.ab2);
+            this.aam(a, (b) => b.leftMargin = this.xs);
+            this.aam(a, (b) => b.topMargin = this.xv);
+            this.aam(a, (b) => b.rightMargin = this.xu);
+            this.aam(a, (b) => b.bottomMargin = this.xr);
+            this.aal(a, (b) => b.textStyle = this.zu);
+            this.aam(a, (b) => b.textStyle = this.aai);
+        }
+        sw(a) {
+            let b = this.ba(a);
+            let c = this.cw(a, b);
             if (c == null) {
                 return;
             }
             c.itemsSource = a.data;
-            c.name = this.mt(a);
-            c.title = this.mu(a, b);
+            c.name = this.nz(a);
+            c.title = this.n0(a, b);
             this.dataChart.series.add(c);
         }
-        y7(a) {
-            this.y8(a, null);
+        aar(a) {
+            this.aas(a, null);
         }
-        y8(a, b) {
-            a(this.tw());
+        aas(a, b) {
+            a(this.vg());
         }
-        zd(a, b) {
-            a(this.tx());
+        aax(a, b) {
+            a(this.vh());
         }
-        zc(a) {
-            this.zd(a, true);
+        aaw(a) {
+            this.aax(a, true);
         }
-        pr(a, b) {
-            this.y7(a);
-            this.zd(a, b);
+        rb(a, b) {
+            this.aar(a);
+            this.aax(a, b);
         }
-        zb(a) {
-            this.y2(this.tw(), a);
+        aav(a) {
+            this.aam(this.vg(), a);
         }
-        zg(a) {
-            this.y2(this.tx(), a);
+        aa0(a) {
+            this.aam(this.vh(), a);
         }
-        ze(a) {
-            this.y1(this.tx(), a);
+        aay(a) {
+            this.aal(this.vh(), a);
         }
-        y9(a) {
-            this.y1(this.tw(), a);
+        aat(a) {
+            this.aal(this.vg(), a);
         }
-        va(a) {
-            let b = this.tw();
-            return b.ei(a, new ScalerParams(1, this.s7, this.s6, b.cg));
+        wu(a) {
+            let b = this.vg();
+            return b.ei(a, new ScalerParams(1, this.ur, this.uq, b.cg));
         }
-        vc(a) {
-            let b = this.tw();
-            return b.el(a, new ScalerParams(1, this.s7, this.s6, b.cg));
+        ww(a) {
+            let b = this.vg();
+            return b.el(a, new ScalerParams(1, this.ur, this.uq, b.cg));
         }
-        vb(a) {
-            let b = this.tx();
-            return b.ei(a, new ScalerParams(1, this.s7, this.s6, b.cg));
+        wv(a) {
+            let b = this.vh();
+            return b.ei(a, new ScalerParams(1, this.ur, this.uq, b.cg));
         }
-        vd(a) {
-            let b = this.tx();
-            return b.el(a, new ScalerParams(1, this.s7, this.s6, b.cg));
+        wx(a) {
+            let b = this.vh();
+            return b.el(a, new ScalerParams(1, this.ur, this.uq, b.cg));
         }
-        q9(a) {
-            super.q9(a);
+        st(a) {
+            super.st(a);
             if (a == null) {
                 return;
             }
             if (a.axes != null) {
-                let b = this.tw();
-                let c = this.tx();
+                let b = this.vg();
+                let c = this.vh();
                 if (a.axes.contains(b)) {
                     a.axes.remove(b);
                 }
@@ -635,7 +635,7 @@ export let XYChart = /*@__PURE__*/ (() => {
                 }
             }
         }
-        static wq(a, b) {
+        static ya(a, b) {
             for (let c of fromEnum(b)) {
                 let d = c.findMatchingHint(16);
                 if (d != null) {
@@ -645,96 +645,96 @@ export let XYChart = /*@__PURE__*/ (() => {
             }
             return null;
         }
-        p2(a) {
-            super.p2(a);
+        rm(a) {
+            super.rm(a);
             if (a == this.dataChart) {
-                this.dataChart.axes.add(this.tw());
-                this.dataChart.axes.add(this.tx());
-            }
-        }
-        y3(a) {
-            if (a != null && this.iu != null && a.fk == null) {
-                a.provideRenderer(this.iu);
-            }
-            a.jv = this.z6;
-            a.eq = this.vk;
-            a.jw = this.z7;
-            a.et = this.vl;
-            a.jy = this.z9;
-            a.ff = this.vm;
-            a.jx = this.z8;
-            a.fg = this.vn;
-            a.jz = this.aaa;
-            a.fh = this.vo;
+                this.dataChart.axes.add(this.vg());
+                this.dataChart.axes.add(this.vh());
+            }
+        }
+        aan(a) {
+            if (a != null && this.ju != null && a.fk == null) {
+                a.provideRenderer(this.ju);
+            }
+            a.jv = this.abq;
+            a.eq = this.w4;
+            a.jw = this.abr;
+            a.et = this.w5;
+            a.jy = this.abt;
+            a.ff = this.w6;
+            a.jx = this.abs;
+            a.fg = this.w7;
+            a.jz = this.abu;
+            a.fh = this.w8;
             a.c3 = true;
-            a.ct = this.e8;
-            a.cv = this.e8;
-            let b = a == this.tw();
+            a.ct = this.f0;
+            a.cv = this.f0;
+            let b = a == this.vg();
             if (b) {
-                a.g5 = this.xk;
-            }
-            a.fz = this.we;
-            a.gf = this.ww;
-            a.ag = this.tu;
-            this.y1(a, (c) => c.angle = this.vf);
-            this.y1(a, (c) => {
-                if (c.extent != this.ve) {
-                    c.extent = this.ve;
+                a.g5 = this.y4;
+            }
+            a.fz = this.xy;
+            a.gf = this.yg;
+            a.ag = this.ve;
+            this.aal(a, (c) => c.angle = this.wz);
+            this.aal(a, (c) => {
+                if (c.extent != this.wy) {
+                    c.extent = this.wy;
                 }
             });
-            this.y1(a, (c) => c.horizontalAlignment = this.zk);
-            this.y1(a, (c) => c.verticalAlignment = this.aam);
-            this.y1(a, (c) => c.visibility = this.aar);
-            this.y1(a, (c) => c.location = this.t2(this.t5));
-            this.y2(a, (c) => c.horizontalAlignment = this.zl);
-            this.y2(a, (c) => c.angle = this.vp);
-            this.y4(a);
-        }
-        y5(a) {
+            this.aal(a, (c) => c.horizontalAlignment = this.aa4);
+            this.aal(a, (c) => c.verticalAlignment = this.ab6);
+            this.aal(a, (c) => c.visibility = this.acb);
+            this.aal(a, (c) => c.location = this.vm(this.vp));
+            this.aam(a, (c) => c.horizontalAlignment = this.aa5);
+            this.aam(a, (c) => c.angle = this.w9);
+            this.aao(a);
+        }
+        aap(a) {
             if (a == null) {
                 return;
             }
-            if (this.iu != null && a.fk == null) {
-                a.provideRenderer(this.iu);
+            if (this.ju != null && a.fk == null) {
+                a.provideRenderer(this.ju);
             }
-            a.ct = this.e8;
-            a.cv = this.e8;
-            this.y1(a, (b) => b.angle = this.vw);
-            this.y1(a, (b) => {
-                if (b.extent != this.vv) {
-                    b.extent = this.vv;
+            a.ct = this.f0;
+            a.cv = this.f0;
+            this.aal(a, (b) => b.angle = this.xg);
+            this.aal(a, (b) => {
+                if (b.extent != this.xf) {
+                    b.extent = this.xf;
                 }
             });
-            this.y1(a, (b) => b.horizontalAlignment = this.zm);
-            this.y1(a, (b) => b.verticalAlignment = this.aan);
-            this.y1(a, (b) => b.visibility = this.aas);
-            this.y1(a, (b) => b.location = this.t3(this.t7));
-            this.y2(a, (b) => b.verticalAlignment = this.aao);
-            this.y2(a, (b) => b.angle = this.v6);
-            a.jv = this.aad;
-            a.eq = this.v1;
-            a.jw = this.aae;
-            a.et = this.v2;
-            a.jy = this.aag;
-            a.ff = this.v3;
-            a.jx = this.aaf;
-            a.fg = this.v4;
-            a.jz = this.aah;
-            a.fh = this.v5;
-            let b = a == this.tx();
+            this.aal(a, (b) => b.horizontalAlignment = this.aa6);
+            this.aal(a, (b) => b.verticalAlignment = this.ab7);
+            this.aal(a, (b) => b.visibility = this.acc);
+            this.aal(a, (b) => b.location = this.vn(this.vr));
+            this.aam(a, (b) => b.verticalAlignment = this.ab8);
+            this.aam(a, (b) => b.angle = this.xq);
+            a.jv = this.abx;
+            a.eq = this.xl;
+            a.jw = this.aby;
+            a.et = this.xm;
+            a.jy = this.ab0;
+            a.ff = this.xn;
+            a.jx = this.abz;
+            a.fg = this.xo;
+            a.jz = this.ab1;
+            a.fh = this.xp;
+            let b = a == this.vh();
             if (b) {
-                a.g5 = this.yp;
+                a.g5 = this.z9;
             }
-            a.gf = this.x1;
-            a.ag = this.tv;
-            this.y6(a);
+            a.gf = this.zl;
+            a.ag = this.vf;
+            this.aaq(a);
         }
-        pz() {
-            super.pz();
-            this.y3(this.tw());
-            this.y5(this.tx());
+        rj() {
+            super.rj();
+            this.aan(this.vg());
+            this.aap(this.vh());
         }
-        y1(a, b) {
+        aal(a, b) {
             if (a == null) {
                 return;
             }
@@ -751,7 +751,7 @@ export let XYChart = /*@__PURE__*/ (() => {
             }
             b(a.ay);
         }
-        y2(a, b) {
+        aam(a, b) {
             if (a == null) {
                 return;
             }
@@ -768,170 +768,170 @@ export let XYChart = /*@__PURE__*/ (() => {
             }
             b(a.be);
         }
-        qt(a, b, c) {
-            super.qt(a, b, c);
+        sd(a, b, c) {
+            super.sd(a, b, c);
             switch (a) {
                 case "XAxisLabelAngle":
-                    this.y9((d) => d.angle = this.vf);
+                    this.aat((d) => d.angle = this.wz);
                     break;
                 case "YAxisLabelAngle":
-                    this.ze((d) => d.angle = this.vw);
+                    this.aay((d) => d.angle = this.xg);
                     break;
                 case "XAxisLabelHorizontalAlignment":
-                    this.y9((d) => d.horizontalAlignment = this.zk);
+                    this.aat((d) => d.horizontalAlignment = this.aa4);
                     break;
                 case "YAxisLabelHorizontalAlignment":
-                    this.ze((d) => d.horizontalAlignment = this.zm);
+                    this.aay((d) => d.horizontalAlignment = this.aa6);
                     break;
                 case "XAxisLabelVerticalAlignment":
-                    this.y9((d) => d.verticalAlignment = this.aam);
+                    this.aat((d) => d.verticalAlignment = this.ab6);
                     break;
                 case "YAxisLabelVerticalAlignment":
-                    this.ze((d) => d.verticalAlignment = this.aan);
+                    this.aay((d) => d.verticalAlignment = this.ab7);
                     break;
                 case "XAxisLabelVisibility":
-                    this.y9((d) => d.visibility = this.aar);
+                    this.aat((d) => d.visibility = this.acb);
                     break;
                 case "YAxisLabelVisibility":
-                    this.ze((d) => d.visibility = this.aas);
+                    this.aay((d) => d.visibility = this.acc);
                     break;
                 case "XAxisLabel":
-                    this.y7((d) => d.fz = this.we);
+                    this.aar((d) => d.fz = this.xy);
                     break;
                 case "YAxisLabel":
-                    this.zc((d) => d.fz = this.wf);
+                    this.aaw((d) => d.fz = this.xz);
                     break;
                 case "XAxisLabelFormat":
-                    this.y7((d) => d.gf = this.ww);
+                    this.aar((d) => d.gf = this.yg);
                     break;
                 case "XAxisLabelFormatSpecifiers":
-                    this.y7((d) => d.ag = this.tu);
+                    this.aar((d) => d.ag = this.ve);
                     break;
                 case "YAxisLabelFormat":
-                    this.zc((d) => d.gf = this.x1);
+                    this.aaw((d) => d.gf = this.zl);
                     break;
                 case "YAxisLabelFormatSpecifiers":
-                    this.zc((d) => d.ag = this.tv);
+                    this.aaw((d) => d.ag = this.vf);
                     break;
                 case "XAxisTitleAngle":
-                    this.zb((d) => d.angle = this.vp);
+                    this.aav((d) => d.angle = this.w9);
                     break;
                 case "YAxisTitleAngle":
-                    this.zg((d) => d.angle = this.v6);
+                    this.aa0((d) => d.angle = this.xq);
                     break;
                 case "XAxisTitleAlignment":
-                    this.zb((d) => d.horizontalAlignment = this.zl);
+                    this.aav((d) => d.horizontalAlignment = this.aa5);
                     break;
                 case "YAxisTitleAlignment":
-                    this.zg((d) => d.verticalAlignment = this.aao);
+                    this.aa0((d) => d.verticalAlignment = this.ab8);
                     break;
                 case "XAxisTitle":
-                    this.y7((d) => d.g5 = this.xk);
+                    this.aar((d) => d.g5 = this.y4);
                     break;
                 case "YAxisTitle":
-                    this.zd((d) => d.g5 = this.yp, false);
+                    this.aax((d) => d.g5 = this.z9, false);
                     break;
                 case "XAxisMajorStroke":
-                    this.y8((d) => d.jv = this.z6, a);
+                    this.aas((d) => d.jv = this.abq, a);
                     break;
                 case "YAxisMajorStroke":
-                    this.zc((d) => d.jv = this.aad);
+                    this.aaw((d) => d.jv = this.abx);
                     break;
                 case "XAxisMajorStrokeThickness":
-                    this.y8((d) => d.eq = this.vk, a);
+                    this.aas((d) => d.eq = this.w4, a);
                     break;
                 case "YAxisMajorStrokeThickness":
-                    this.zc((d) => d.eq = this.v1);
+                    this.aaw((d) => d.eq = this.xl);
                     break;
                 case "XAxisMinorStroke":
-                    this.y7((d) => d.jw = this.z7);
+                    this.aar((d) => d.jw = this.abr);
                     break;
                 case "YAxisMinorStroke":
-                    this.zc((d) => d.jw = this.aae);
+                    this.aaw((d) => d.jw = this.aby);
                     break;
                 case "XAxisMinorStrokeThickness":
-                    this.y7((d) => d.et = this.vl);
+                    this.aar((d) => d.et = this.w5);
                     break;
                 case "YAxisMinorStrokeThickness":
-                    this.zc((d) => d.et = this.v2);
+                    this.aaw((d) => d.et = this.xm);
                     break;
                 case "XAxisTickLength":
-                    this.y7((d) => d.fg = this.vn);
+                    this.aar((d) => d.fg = this.w7);
                     break;
                 case "YAxisTickLength":
-                    this.zc((d) => d.fg = this.v4);
+                    this.aaw((d) => d.fg = this.xo);
                     break;
                 case "XAxisTickStroke":
-                    this.y7((d) => d.jz = this.aaa);
+                    this.aar((d) => d.jz = this.abu);
                     break;
                 case "YAxisTickStroke":
-                    this.zc((d) => d.jz = this.aah);
+                    this.aaw((d) => d.jz = this.ab1);
                     break;
                 case "XAxisTickStrokeThickness":
-                    this.y7((d) => d.fh = this.vo);
+                    this.aar((d) => d.fh = this.w8);
                     break;
                 case "YAxisTickStrokeThickness":
-                    this.zc((d) => d.fh = this.v5);
+                    this.aaw((d) => d.fh = this.xp);
                     break;
                 case "XAxisStroke":
-                    this.y7((d) => d.jy = this.z9);
+                    this.aar((d) => d.jy = this.abt);
                     break;
                 case "YAxisStroke":
-                    this.zc((d) => d.jy = this.aag);
+                    this.aaw((d) => d.jy = this.ab0);
                     break;
                 case "XAxisStrokeThickness":
-                    this.y7((d) => d.ff = this.vm);
+                    this.aar((d) => d.ff = this.w6);
                     break;
                 case "YAxisStrokeThickness":
-                    this.zc((d) => d.ff = this.v3);
+                    this.aaw((d) => d.ff = this.xn);
                     break;
                 case "XAxisExtent":
-                    this.y9((d) => d.extent = this.ve);
+                    this.aat((d) => d.extent = this.wy);
                     break;
                 case "YAxisExtent":
-                    this.ze((d) => d.extent = this.vv);
+                    this.aay((d) => d.extent = this.xf);
                     break;
                 case "XAxisStrip":
-                    this.y7((d) => d.jx = this.z8);
+                    this.aar((d) => d.jx = this.abs);
                     break;
                 case "YAxisStrip":
-                    this.zc((d) => d.jx = this.aaf);
+                    this.aaw((d) => d.jx = this.abz);
                     break;
                 case "XAxisInverted":
-                    this.y7((d) => d.cg = this.ua);
+                    this.aar((d) => d.cg = this.vu);
                     break;
                 case "YAxisInverted":
-                    this.zc((d) => d.cg = this.ub);
+                    this.aaw((d) => d.cg = this.vv);
                     break;
                 case "YAxisLabelLocation":
-                    this.zf();
+                    this.aaz();
                     break;
                 case "XAxisLabelLocation":
-                    this.za();
+                    this.aau();
                     break;
             }
         }
-        zf() {
-            let a = this.t3(this.t7);
+        aaz() {
+            let a = this.vn(this.vr);
             if (a == 2 || a == 7) {
-                this.zm = 2;
+                this.aa6 = 2;
             }
             else {
-                this.zm = 0;
+                this.aa6 = 0;
             }
-            this.ze((b) => b.location = a);
+            this.aay((b) => b.location = a);
         }
-        za() {
-            let a = this.t2(this.t5);
+        aau() {
+            let a = this.vm(this.vp);
             if (a == 1 || a == 5) {
-                this.aam = 0;
+                this.ab6 = 0;
             }
             else {
-                this.aam = 2;
+                this.ab6 = 2;
             }
-            this.y9((b) => b.location = a);
+            this.aat((b) => b.location = a);
         }
-        t3(a) {
+        vn(a) {
             if (a == 0) {
                 return 2;
             }
@@ -945,7 +945,7 @@ export let XYChart = /*@__PURE__*/ (() => {
                 return 6;
             }
             else {
-                if (this.bi == 1) {
+                if (this.bz == 1) {
                     return 3;
                 }
                 else {
@@ -953,7 +953,7 @@ export let XYChart = /*@__PURE__*/ (() => {
                 }
             }
         }
-        t2(a) {
+        vm(a) {
             if (a == 1) {
                 return 1;
             }
@@ -970,482 +970,482 @@ export let XYChart = /*@__PURE__*/ (() => {
                 return 1;
             }
         }
-        get we() {
-            return this.wc;
+        get xy() {
+            return this.xw;
         }
-        set we(a) {
-            let b = this.we;
+        set xy(a) {
+            let b = this.xy;
             if (a != b) {
-                this.wc = a;
-                this.qt("XAxisLabel", b, this.we);
+                this.xw = a;
+                this.sd("XAxisLabel", b, this.xy);
             }
         }
-        get wf() {
-            return this.wd;
+        get xz() {
+            return this.xx;
         }
-        set wf(a) {
-            let b = this.wf;
+        set xz(a) {
+            let b = this.xz;
             if (a != b) {
-                this.wd = a;
-                this.qt("YAxisLabel", b, this.wf);
+                this.xx = a;
+                this.sd("YAxisLabel", b, this.xz);
             }
         }
-        get z6() {
-            return this.zq;
+        get abq() {
+            return this.aba;
         }
-        set z6(a) {
-            let b = this.z6;
+        set abq(a) {
+            let b = this.abq;
             if (a != b) {
-                this.zq = a;
-                this.qt("XAxisMajorStroke", b, this.z6);
+                this.aba = a;
+                this.sd("XAxisMajorStroke", b, this.abq);
             }
         }
-        get aad() {
-            return this.zx;
+        get abx() {
+            return this.abh;
         }
-        set aad(a) {
-            let b = this.aad;
+        set abx(a) {
+            let b = this.abx;
             if (a != b) {
-                this.zx = a;
-                this.qt("YAxisMajorStroke", b, this.aad);
+                this.abh = a;
+                this.sd("YAxisMajorStroke", b, this.abx);
             }
         }
-        get vk() {
-            return this.ui;
+        get w4() {
+            return this.v2;
         }
-        set vk(a) {
-            let b = this.vk;
+        set w4(a) {
+            let b = this.w4;
             if (a != b) {
-                this.ui = a;
-                this.qt("XAxisMajorStrokeThickness", b, this.vk);
+                this.v2 = a;
+                this.sd("XAxisMajorStrokeThickness", b, this.w4);
             }
         }
-        get v1() {
-            return this.uz;
+        get xl() {
+            return this.wj;
         }
-        set v1(a) {
-            let b = this.v1;
+        set xl(a) {
+            let b = this.xl;
             if (a != b) {
-                this.uz = a;
-                this.qt("YAxisMajorStrokeThickness", b, this.v1);
+                this.wj = a;
+                this.sd("YAxisMajorStrokeThickness", b, this.xl);
             }
         }
-        get vl() {
-            return this.uj;
+        get w5() {
+            return this.v3;
         }
-        set vl(a) {
-            let b = this.vl;
+        set w5(a) {
+            let b = this.w5;
             if (a != b) {
-                this.uj = a;
-                this.qt("XAxisMinorStrokeThickness", b, this.vl);
+                this.v3 = a;
+                this.sd("XAxisMinorStrokeThickness", b, this.w5);
             }
         }
-        get v2() {
-            return this.u0;
+        get xm() {
+            return this.wk;
         }
-        set v2(a) {
-            let b = this.v2;
+        set xm(a) {
+            let b = this.xm;
             if (a != b) {
-                this.u0 = a;
-                this.qt("YAxisMinorStrokeThickness", b, this.v2);
+                this.wk = a;
+                this.sd("YAxisMinorStrokeThickness", b, this.xm);
             }
         }
-        get z8() {
-            return this.zs;
+        get abs() {
+            return this.abc;
         }
-        set z8(a) {
-            let b = this.z8;
+        set abs(a) {
+            let b = this.abs;
             if (a != b) {
-                this.zs = a;
-                this.qt("XAxisStrip", b, this.z8);
+                this.abc = a;
+                this.sd("XAxisStrip", b, this.abs);
             }
         }
-        get aaf() {
-            return this.zz;
+        get abz() {
+            return this.abj;
         }
-        set aaf(a) {
-            let b = this.aaf;
+        set abz(a) {
+            let b = this.abz;
             if (a != b) {
-                this.zz = a;
-                this.qt("YAxisStrip", b, this.aaf);
+                this.abj = a;
+                this.sd("YAxisStrip", b, this.abz);
             }
         }
-        get z9() {
-            return this.zt;
+        get abt() {
+            return this.abd;
         }
-        set z9(a) {
-            let b = this.z9;
+        set abt(a) {
+            let b = this.abt;
             if (a != b) {
-                this.zt = a;
-                this.qt("XAxisStroke", b, this.z9);
+                this.abd = a;
+                this.sd("XAxisStroke", b, this.abt);
             }
         }
-        get aag() {
-            return this.z0;
+        get ab0() {
+            return this.abk;
         }
-        set aag(a) {
-            let b = this.aag;
+        set ab0(a) {
+            let b = this.ab0;
             if (a != b) {
-                this.z0 = a;
-                this.qt("YAxisStroke", b, this.aag);
+                this.abk = a;
+                this.sd("YAxisStroke", b, this.ab0);
             }
         }
-        get vm() {
-            return this.uk;
+        get w6() {
+            return this.v4;
         }
-        set vm(a) {
-            let b = this.vm;
+        set w6(a) {
+            let b = this.w6;
             if (a != b) {
-                this.uk = a;
-                this.qt("XAxisStrokeThickness", b, this.vm);
+                this.v4 = a;
+                this.sd("XAxisStrokeThickness", b, this.w6);
             }
         }
-        get v3() {
-            return this.u1;
+        get xn() {
+            return this.wl;
         }
-        set v3(a) {
-            let b = this.v3;
+        set xn(a) {
+            let b = this.xn;
             if (a != b) {
-                this.u1 = a;
-                this.qt("YAxisStrokeThickness", b, this.v3);
+                this.wl = a;
+                this.sd("YAxisStrokeThickness", b, this.xn);
             }
         }
-        get vn() {
-            return this.ul;
+        get w7() {
+            return this.v5;
         }
-        set vn(a) {
-            let b = this.vn;
+        set w7(a) {
+            let b = this.w7;
             if (a != b) {
-                this.ul = a;
-                this.qt("XAxisTickLength", b, this.vn);
+                this.v5 = a;
+                this.sd("XAxisTickLength", b, this.w7);
             }
         }
-        get v4() {
-            return this.u2;
+        get xo() {
+            return this.wm;
         }
-        set v4(a) {
-            let b = this.v4;
+        set xo(a) {
+            let b = this.xo;
             if (a != b) {
-                this.u2 = a;
-                this.qt("YAxisTickLength", b, this.v4);
+                this.wm = a;
+                this.sd("YAxisTickLength", b, this.xo);
             }
         }
-        get aaa() {
-            return this.zu;
+        get abu() {
+            return this.abe;
         }
-        set aaa(a) {
-            let b = this.aaa;
+        set abu(a) {
+            let b = this.abu;
             if (a != b) {
-                this.zu = a;
-                this.qt("XAxisTickStroke", b, this.aaa);
+                this.abe = a;
+                this.sd("XAxisTickStroke", b, this.abu);
             }
         }
-        get aah() {
-            return this.z1;
+        get ab1() {
+            return this.abl;
         }
-        set aah(a) {
-            let b = this.aah;
+        set ab1(a) {
+            let b = this.ab1;
             if (a != b) {
-                this.z1 = a;
-                this.qt("YAxisTickStroke", b, this.aah);
+                this.abl = a;
+                this.sd("YAxisTickStroke", b, this.ab1);
             }
         }
-        get vo() {
-            return this.um;
+        get w8() {
+            return this.v6;
         }
-        set vo(a) {
-            let b = this.vo;
+        set w8(a) {
+            let b = this.w8;
             if (a != b) {
-                this.um = a;
-                this.qt("XAxisTickStrokeThickness", b, this.vo);
+                this.v6 = a;
+                this.sd("XAxisTickStrokeThickness", b, this.w8);
             }
         }
-        get v5() {
-            return this.u3;
+        get xp() {
+            return this.wn;
         }
-        set v5(a) {
-            let b = this.v5;
+        set xp(a) {
+            let b = this.xp;
             if (a != b) {
-                this.u3 = a;
-                this.qt("YAxisTickStrokeThickness", b, this.v5);
+                this.wn = a;
+                this.sd("YAxisTickStrokeThickness", b, this.xp);
             }
         }
-        get xk() {
-            return this.wi;
+        get y4() {
+            return this.x2;
         }
-        set xk(a) {
-            let b = this.xk;
+        set y4(a) {
+            let b = this.y4;
             if (a != b) {
-                this.wi = a;
-                this.qt("XAxisTitle", b, this.xk);
+                this.x2 = a;
+                this.sd("XAxisTitle", b, this.y4);
             }
         }
-        get yp() {
-            return this.wm;
+        get z9() {
+            return this.x6;
         }
-        set yp(a) {
-            let b = this.yp;
+        set z9(a) {
+            let b = this.z9;
             if (a != b) {
-                this.wm = a;
-                this.qt("YAxisTitle", b, this.yp);
+                this.x6 = a;
+                this.sd("YAxisTitle", b, this.z9);
             }
         }
-        get z7() {
-            return this.zr;
+        get abr() {
+            return this.abb;
         }
-        set z7(a) {
-            let b = this.z7;
+        set abr(a) {
+            let b = this.abr;
             if (a != b) {
-                this.zr = a;
-                this.qt("XAxisMinorStroke", b, this.z7);
+                this.abb = a;
+                this.sd("XAxisMinorStroke", b, this.abr);
             }
         }
-        get aae() {
-            return this.zy;
+        get aby() {
+            return this.abi;
         }
-        set aae(a) {
-            let b = this.aae;
+        set aby(a) {
+            let b = this.aby;
             if (a != b) {
-                this.zy = a;
-                this.qt("YAxisMinorStroke", b, this.aae);
+                this.abi = a;
+                this.sd("YAxisMinorStroke", b, this.aby);
             }
         }
-        get vf() {
-            return this.ud;
+        get wz() {
+            return this.vx;
         }
-        set vf(a) {
-            let b = this.vf;
+        set wz(a) {
+            let b = this.wz;
             if (a != b) {
-                this.ud = a;
-                this.qt("XAxisLabelAngle", b, this.vf);
+                this.vx = a;
+                this.sd("XAxisLabelAngle", b, this.wz);
             }
         }
-        get vw() {
-            return this.uu;
+        get xg() {
+            return this.we;
         }
-        set vw(a) {
-            let b = this.vw;
+        set xg(a) {
+            let b = this.xg;
             if (a != b) {
-                this.uu = a;
-                this.qt("YAxisLabelAngle", b, this.vw);
+                this.we = a;
+                this.sd("YAxisLabelAngle", b, this.xg);
             }
         }
-        get ve() {
-            return this.uc;
+        get wy() {
+            return this.vw;
         }
-        set ve(a) {
-            let b = this.ve;
+        set wy(a) {
+            let b = this.wy;
             if (a != b) {
-                this.uc = a;
-                this.qt("XAxisExtent", b, this.ve);
+                this.vw = a;
+                this.sd("XAxisExtent", b, this.wy);
             }
         }
-        get vv() {
-            return this.ut;
+        get xf() {
+            return this.wd;
         }
-        set vv(a) {
-            let b = this.vv;
+        set xf(a) {
+            let b = this.xf;
             if (a != b) {
-                this.ut = a;
-                this.qt("YAxisExtent", b, this.vv);
+                this.wd = a;
+                this.sd("YAxisExtent", b, this.xf);
             }
         }
-        get vp() {
-            return this.un;
+        get w9() {
+            return this.v7;
         }
-        set vp(a) {
-            let b = this.vp;
+        set w9(a) {
+            let b = this.w9;
             if (a != b) {
-                this.un = a;
-                this.qt("XAxisTitleAngle", b, this.vp);
+                this.v7 = a;
+                this.sd("XAxisTitleAngle", b, this.w9);
             }
         }
-        get v6() {
-            return this.u4;
+        get xq() {
+            return this.wo;
         }
-        set v6(a) {
-            let b = this.v6;
+        set xq(a) {
+            let b = this.xq;
             if (a != b) {
-                this.u4 = a;
-                this.qt("YAxisTitleAngle", b, this.v6);
+                this.wo = a;
+                this.sd("YAxisTitleAngle", b, this.xq);
             }
         }
-        get ua() {
-            return this.t8;
+        get vu() {
+            return this.vs;
         }
-        set ua(a) {
-            let b = this.ua;
+        set vu(a) {
+            let b = this.vu;
             if (a != b) {
-                this.t8 = a;
-                this.qt("XAxisInverted", b, this.ua);
+                this.vs = a;
+                this.sd("XAxisInverted", b, this.vu);
             }
         }
-        get ub() {
-            return this.t9;
+        get vv() {
+            return this.vt;
         }
-        set ub(a) {
-            let b = this.ub;
+        set vv(a) {
+            let b = this.vv;
             if (a != b) {
-                this.t9 = a;
-                this.qt("YAxisInverted", b, this.ub);
+                this.vt = a;
+                this.sd("YAxisInverted", b, this.vv);
             }
         }
-        get zl() {
-            return this.zi;
+        get aa5() {
+            return this.aa2;
         }
-        set zl(a) {
-            let b = this.zl;
+        set aa5(a) {
+            let b = this.aa5;
             if (a != b) {
-                this.zi = a;
-                this.qt("XAxisTitleAlignment", enumGetBox(HorizontalAlignment_$type, b), enumGetBox(HorizontalAlignment_$type, this.zl));
+                this.aa2 = a;
+                this.sd("XAxisTitleAlignment", enumGetBox(HorizontalAlignment_$type, b), enumGetBox(HorizontalAlignment_$type, this.aa5));
             }
         }
-        get aao() {
-            return this.aal;
+        get ab8() {
+            return this.ab5;
         }
-        set aao(a) {
-            let b = this.aao;
+        set ab8(a) {
+            let b = this.ab8;
             if (a != b) {
-                this.aal = a;
-                this.qt("YAxisTitleAlignment", enumGetBox(VerticalAlignment_$type, b), enumGetBox(VerticalAlignment_$type, this.aao));
+                this.ab5 = a;
+                this.sd("YAxisTitleAlignment", enumGetBox(VerticalAlignment_$type, b), enumGetBox(VerticalAlignment_$type, this.ab8));
             }
         }
-        get zk() {
-            return this.zh;
+        get aa4() {
+            return this.aa1;
         }
-        set zk(a) {
-            let b = this.zk;
+        set aa4(a) {
+            let b = this.aa4;
             if (a != b) {
-                this.zh = a;
-                this.qt("XAxisLabelHorizontalAlignment", enumGetBox(HorizontalAlignment_$type, b), enumGetBox(HorizontalAlignment_$type, this.zk));
+                this.aa1 = a;
+                this.sd("XAxisLabelHorizontalAlignment", enumGetBox(HorizontalAlignment_$type, b), enumGetBox(HorizontalAlignment_$type, this.aa4));
             }
         }
-        get_zm() {
-            return this.zj;
+        get_aa6() {
+            return this.aa3;
         }
-        set_zm(a) {
-            let b = this.zm;
+        set_aa6(a) {
+            let b = this.aa6;
             if (a != b) {
-                this.zj = a;
-                this.qt("YAxisLabelHorizontalAlignment", enumGetBox(HorizontalAlignment_$type, b), enumGetBox(HorizontalAlignment_$type, this.zm));
+                this.aa3 = a;
+                this.sd("YAxisLabelHorizontalAlignment", enumGetBox(HorizontalAlignment_$type, b), enumGetBox(HorizontalAlignment_$type, this.aa6));
             }
         }
-        get zm() {
-            return this.get_zm();
+        get aa6() {
+            return this.get_aa6();
         }
-        set zm(a) {
-            this.set_zm(a);
+        set aa6(a) {
+            this.set_aa6(a);
         }
-        get aam() {
-            return this.aaj;
+        get ab6() {
+            return this.ab3;
         }
-        set aam(a) {
-            let b = this.aam;
+        set ab6(a) {
+            let b = this.ab6;
             if (a != b) {
-                this.aaj = a;
-                this.qt("XAxisLabelVerticalAlignment", enumGetBox(VerticalAlignment_$type, b), enumGetBox(VerticalAlignment_$type, this.aam));
+                this.ab3 = a;
+                this.sd("XAxisLabelVerticalAlignment", enumGetBox(VerticalAlignment_$type, b), enumGetBox(VerticalAlignment_$type, this.ab6));
             }
         }
-        get aan() {
-            return this.aak;
+        get ab7() {
+            return this.ab4;
         }
-        set aan(a) {
-            let b = this.aan;
+        set ab7(a) {
+            let b = this.ab7;
             if (a != b) {
-                this.aak = a;
-                this.qt("YAxisLabelVerticalAlignment", enumGetBox(VerticalAlignment_$type, b), enumGetBox(VerticalAlignment_$type, this.aan));
+                this.ab4 = a;
+                this.sd("YAxisLabelVerticalAlignment", enumGetBox(VerticalAlignment_$type, b), enumGetBox(VerticalAlignment_$type, this.ab7));
             }
         }
-        get aar() {
-            return this.aap;
+        get acb() {
+            return this.ab9;
         }
-        set aar(a) {
-            let b = this.aar;
+        set acb(a) {
+            let b = this.acb;
             if (a != b) {
-                this.aap = a;
-                this.qt("XAxisLabelVisibility", enumGetBox(Visibility_$type, b), enumGetBox(Visibility_$type, this.aar));
+                this.ab9 = a;
+                this.sd("XAxisLabelVisibility", enumGetBox(Visibility_$type, b), enumGetBox(Visibility_$type, this.acb));
             }
         }
-        get aas() {
-            return this.aaq;
+        get acc() {
+            return this.aca;
         }
-        set aas(a) {
-            let b = this.aas;
+        set acc(a) {
+            let b = this.acc;
             if (a != b) {
-                this.aaq = a;
-                this.qt("YAxisLabelVisibility", enumGetBox(Visibility_$type, b), enumGetBox(Visibility_$type, this.aas));
+                this.aca = a;
+                this.sd("YAxisLabelVisibility", enumGetBox(Visibility_$type, b), enumGetBox(Visibility_$type, this.acc));
             }
         }
-        get_t7() {
-            return this.t6;
+        get_vr() {
+            return this.vq;
         }
-        set_t7(a) {
-            let b = this.t7;
+        set_vr(a) {
+            let b = this.vr;
             if (a != b) {
-                this.t6 = a;
-                this.qt("YAxisLabelLocation", enumGetBox(YAxisLabelLocation_$type, b), enumGetBox(YAxisLabelLocation_$type, this.t7));
+                this.vq = a;
+                this.sd("YAxisLabelLocation", enumGetBox(YAxisLabelLocation_$type, b), enumGetBox(YAxisLabelLocation_$type, this.vr));
             }
         }
-        get t7() {
-            return this.get_t7();
+        get vr() {
+            return this.get_vr();
         }
-        set t7(a) {
-            this.set_t7(a);
+        set vr(a) {
+            this.set_vr(a);
         }
-        get_t5() {
-            return this.t4;
+        get_vp() {
+            return this.vo;
         }
-        set_t5(a) {
-            let b = this.t5;
+        set_vp(a) {
+            let b = this.vp;
             if (a != b) {
-                this.t4 = a;
-                this.qt("XAxisLabelLocation", enumGetBox(XAxisLabelLocation_$type, b), enumGetBox(XAxisLabelLocation_$type, this.t5));
+                this.vo = a;
+                this.sd("XAxisLabelLocation", enumGetBox(XAxisLabelLocation_$type, b), enumGetBox(XAxisLabelLocation_$type, this.vp));
             }
         }
-        get t5() {
-            return this.get_t5();
+        get vp() {
+            return this.get_vp();
         }
-        set t5(a) {
-            this.set_t5(a);
+        set vp(a) {
+            this.set_vp(a);
         }
-        get ww() {
-            return this.wg;
+        get yg() {
+            return this.x0;
         }
-        set ww(a) {
-            let b = this.wg;
+        set yg(a) {
+            let b = this.x0;
             if (a != b) {
-                this.wg = a;
-                this.qt("XAxisLabelFormat", b, this.wg);
+                this.x0 = a;
+                this.sd("XAxisLabelFormat", b, this.x0);
             }
         }
-        get tu() {
-            return this.ts;
+        get ve() {
+            return this.vc;
         }
-        set tu(a) {
-            let b = this.ts;
+        set ve(a) {
+            let b = this.vc;
             if (a != b) {
-                this.ts = a;
-                this.qt("XAxisLabelFormatSpecifiers", b, this.ts);
+                this.vc = a;
+                this.sd("XAxisLabelFormatSpecifiers", b, this.vc);
             }
         }
-        get x1() {
-            return this.wk;
+        get zl() {
+            return this.x4;
         }
-        set x1(a) {
-            let b = this.wk;
+        set zl(a) {
+            let b = this.x4;
             if (a != b) {
-                this.wk = a;
-                this.qt("YAxisLabelFormat", b, this.wk);
+                this.x4 = a;
+                this.sd("YAxisLabelFormat", b, this.x4);
             }
         }
-        get tv() {
-            return this.tt;
+        get vf() {
+            return this.vd;
         }
-        set tv(a) {
-            let b = this.tt;
+        set vf(a) {
+            let b = this.vd;
             if (a != b) {
-                this.tt = a;
-                this.qt("YAxisLabelFormatSpecifiers", b, this.tt);
+                this.vd = a;
+                this.sd("YAxisLabelFormatSpecifiers", b, this.vd);
             }
         }
     }