igniteui-webcomponents-charts 5.0.0-beta.2 → 5.0.0

package/esm2015/lib/RadialBaseChart.js

@@ -23,87 +23,87 @@ export let RadialBaseChart = /*@__PURE__*/ (() => {
     class RadialBaseChart extends DomainChart {
         constructor() {
             super(...arguments);
-            this.zc = null;
-            this.zd = null;
-            this.zr = 0;
-            this.zt = 5;
-            this.zs = 0;
-            this.zq = 5;
-            this.z8 = 5;
-            this.aaa = 0;
-            this.z9 = 5;
-            this.z7 = 0;
-            this.ae1 = null;
-            this.ae8 = null;
-            this.aez = null;
-            this.ae0 = null;
-            this.z2 = 0;
+            this.zo = null;
+            this.zp = null;
+            this.z3 = 0;
+            this.z5 = 5;
+            this.z4 = 0;
+            this.z2 = 5;
+            this.aak = 5;
+            this.aam = 0;
+            this.aal = 5;
             this.aaj = 0;
-            this.z1 = NaN;
-            this.aai = NaN;
-            this.z4 = NaN;
-            this.aal = NaN;
-            this.z3 = NaN;
-            this.aak = NaN;
-            this.z0 = NaN;
-            this.aah = NaN;
-            this.ae7 = null;
-            this.afe = null;
-            this.abt = null;
-            this.abx = null;
-            this.abv = null;
-            this.abz = null;
-            this.abo = null;
-            this.abp = null;
-            this.ae2 = null;
-            this.ae9 = null;
-            this.zu = DeviceUtils.g(1);
-            this.aab = DeviceUtils.g(1);
-            this.zv = DeviceUtils.g(1);
-            this.aac = DeviceUtils.g(1);
-            this.ae4 = null;
+            this.afd = null;
+            this.afk = null;
             this.afb = null;
-            this.ae5 = null;
             this.afc = null;
-            this.zw = DeviceUtils.g(1);
-            this.aad = DeviceUtils.g(1);
-            this.zx = DeviceUtils.g(8);
             this.aae = 0;
-            this.ae6 = null;
-            this.afd = null;
-            this.zy = DeviceUtils.g(1);
-            this.aaf = DeviceUtils.g(1);
-            this.abu = null;
-            this.aby = null;
-            this.ae3 = null;
-            this.afa = null;
-            this.zp = 0;
-            this.z6 = 0;
-            this.zo = NaN;
-            this.z5 = NaN;
-            this.zz = 0;
-            this.aag = -90;
-            this.zk = false;
-            this.zl = false;
-            this.aeu = 1;
-            this.afx = 1;
-            this.aet = 1;
-            this.aev = 2;
-            this.afv = 0;
-            this.afw = 1;
-            this.af1 = 0;
-            this.af2 = 0;
-            this.zi = 4;
-            this.y8 = 4;
-            this.abs = null;
-            this.y4 = null;
-            this.abw = null;
-            this.y5 = null;
+            this.aav = 0;
+            this.aad = NaN;
+            this.aau = NaN;
+            this.aag = NaN;
+            this.aax = NaN;
+            this.aaf = NaN;
+            this.aaw = NaN;
+            this.aac = NaN;
+            this.aat = NaN;
+            this.afj = null;
+            this.afq = null;
+            this.ab5 = null;
+            this.ab9 = null;
+            this.ab7 = null;
+            this.acb = null;
+            this.ab0 = null;
+            this.ab1 = null;
+            this.afe = null;
+            this.afl = null;
+            this.z6 = DeviceUtils.g(1);
+            this.aan = DeviceUtils.g(1);
+            this.z7 = DeviceUtils.g(1);
+            this.aao = DeviceUtils.g(1);
+            this.afg = null;
+            this.afn = null;
+            this.afh = null;
+            this.afo = null;
+            this.z8 = DeviceUtils.g(1);
+            this.aap = DeviceUtils.g(1);
+            this.z9 = DeviceUtils.g(8);
+            this.aaq = 0;
+            this.afi = null;
+            this.afp = null;
+            this.aaa = DeviceUtils.g(1);
+            this.aar = DeviceUtils.g(1);
+            this.ab6 = null;
+            this.aca = null;
+            this.aff = null;
+            this.afm = null;
+            this.z1 = 0;
+            this.aai = 0;
+            this.z0 = NaN;
+            this.aah = NaN;
+            this.aab = 0;
+            this.aas = -90;
+            this.zw = false;
+            this.zx = false;
+            this.ae6 = 1;
+            this.af9 = 1;
+            this.ae5 = 1;
+            this.ae7 = 2;
+            this.af7 = 0;
+            this.af8 = 1;
+            this.agd = 0;
+            this.age = 0;
+            this.zu = 4;
+            this.zk = 4;
+            this.ab4 = null;
+            this.zg = null;
+            this.ab8 = null;
+            this.zh = null;
         }
         provideContainer(a) {
             if (a != null) {
-                let b = this.za();
-                let c = this.zb();
+                let b = this.zm();
+                let c = this.zn();
                 if (b != null) {
                     b.provideRenderer(a);
                 }
@@ -113,523 +113,523 @@ export let RadialBaseChart = /*@__PURE__*/ (() => {
             }
             super.provideContainer(a);
         }
-        ur() {
-            super.ur();
-            let a = this.za();
-            let b = this.zb();
+        ux() {
+            super.ux();
+            let a = this.zm();
+            let b = this.zn();
             if (a != null && a.az != null) {
-                this.afh = a.az.textColor;
+                this.aft = a.az.textColor;
             }
             if (b != null && b.az != null) {
-                this.afo = b.az.textColor;
+                this.af0 = b.az.textColor;
             }
-            this.afm = AxisDefaults.j;
-            this.aft = AxisDefaults.j;
-            this.afi = AxisDefaults.h;
-            this.afp = AxisDefaults.h;
-            this.afl = AxisDefaults.g;
-            this.afs = AxisDefaults.g;
+            this.afy = AxisDefaults.j;
+            this.af5 = AxisDefaults.j;
+            this.afu = AxisDefaults.h;
+            this.af1 = AxisDefaults.h;
+            this.afx = AxisDefaults.g;
+            this.af4 = AxisDefaults.g;
         }
-        vi(a, b, c) {
-            super.vi(a, b, c);
+        vo(a, b, c) {
+            super.vo(a, b, c);
             switch (a) {
                 case "AngleAxisLabelLeftMargin":
-                    this.ael((d) => d.leftMargin = this.aap);
+                    this.aex((d) => d.leftMargin = this.aa1);
                     break;
                 case "AngleAxisLabelTopMargin":
-                    this.ael((d) => d.topMargin = this.aar);
+                    this.aex((d) => d.topMargin = this.aa3);
                     break;
                 case "AngleAxisLabelRightMargin":
-                    this.ael((d) => d.rightMargin = this.aaq);
+                    this.aex((d) => d.rightMargin = this.aa2);
                     break;
                 case "AngleAxisLabelBottomMargin":
-                    this.ael((d) => d.bottomMargin = this.aao);
+                    this.aex((d) => d.bottomMargin = this.aa0);
                     break;
                 case "ValueAxisLabelLeftMargin":
-                    this.aeq((d) => d.leftMargin = this.aba);
+                    this.ae2((d) => d.leftMargin = this.abm);
                     break;
                 case "ValueAxisLabelTopMargin":
-                    this.aeq((d) => d.topMargin = this.abc);
+                    this.ae2((d) => d.topMargin = this.abo);
                     break;
                 case "ValueAxisLabelRightMargin":
-                    this.aeq((d) => d.rightMargin = this.abb);
+                    this.ae2((d) => d.rightMargin = this.abn);
                     break;
                 case "ValueAxisLabelBottomMargin":
-                    this.aeq((d) => d.bottomMargin = this.aa9);
+                    this.ae2((d) => d.bottomMargin = this.abl);
                     break;
                 case "ActualItemsSource":
                 case "ShouldDisplayMockData":
                 case "ShouldUseSkeletonStyleForMockData":
-                    this.aff = this.x4(this.afh);
-                    this.afg = this.x4(this.afo);
+                    this.afr = this.yg(this.aft);
+                    this.afs = this.yg(this.af0);
                     break;
                 case "AngleAxisLabelTextColor":
-                    this.aff = this.x4(this.afh);
+                    this.afr = this.yg(this.aft);
                     break;
                 case "ValueAxisLabelTextColor":
-                    this.afg = this.x4(this.afo);
+                    this.afs = this.yg(this.af0);
                     break;
                 case "ActualAngleAxisLabelTextColor":
-                    this.ael((d) => d.textColor = this.aff);
+                    this.aex((d) => d.textColor = this.afr);
                     break;
                 case "ActualValueAxisLabelTextColor":
-                    this.aeq((d) => d.textColor = this.afg);
+                    this.ae2((d) => d.textColor = this.afs);
                     break;
                 case "AngleAxisTitleMargin":
-                    this.aen((d) => d.margin = this.aa0);
+                    this.aez((d) => d.margin = this.abc);
                     break;
                 case "ValueAxisTitleMargin":
-                    this.aes((d) => d.margin = this.abl);
+                    this.ae4((d) => d.margin = this.abx);
                     break;
                 case "AngleAxisTitleLeftMargin":
-                    this.aen((d) => d.leftMargin = this.aaz);
+                    this.aez((d) => d.leftMargin = this.abb);
                     break;
                 case "ValueAxisTitleLeftMargin":
-                    this.aes((d) => d.leftMargin = this.abk);
+                    this.ae4((d) => d.leftMargin = this.abw);
                     break;
                 case "AngleAxisTitleTopMargin":
-                    this.aen((d) => d.topMargin = this.aa2);
+                    this.aez((d) => d.topMargin = this.abe);
                     break;
                 case "ValueAxisTitleTopMargin":
-                    this.aes((d) => d.topMargin = this.abn);
+                    this.ae4((d) => d.topMargin = this.abz);
                     break;
                 case "AngleAxisTitleRightMargin":
-                    this.aen((d) => d.rightMargin = this.aa1);
+                    this.aez((d) => d.rightMargin = this.abd);
                     break;
                 case "ValueAxisTitleRightMargin":
-                    this.aes((d) => d.rightMargin = this.abm);
+                    this.ae4((d) => d.rightMargin = this.aby);
                     break;
                 case "AngleAxisTitleBottomMargin":
-                    this.aen((d) => d.bottomMargin = this.aay);
+                    this.aez((d) => d.bottomMargin = this.aba);
                     break;
                 case "ValueAxisTitleBottomMargin":
-                    this.aes((d) => d.bottomMargin = this.abj);
+                    this.ae4((d) => d.bottomMargin = this.abv);
                     break;
                 case "AngleAxisTitleTextColor":
-                    this.aen((d) => d.textColor = this.afn);
+                    this.aez((d) => d.textColor = this.afz);
                     break;
                 case "ValueAxisTitleTextColor":
-                    this.aes((d) => d.textColor = this.afu);
+                    this.ae4((d) => d.textColor = this.af6);
                     break;
                 case "AngleAxisFormatLabel":
-                    this.aej((d) => d.au = this.ze);
+                    this.aev((d) => d.au = this.zq);
                     break;
                 case "ValueAxisFormatLabel":
-                    this.aeo((d) => d.au = this.zf);
+                    this.ae0((d) => d.au = this.zr);
                     break;
             }
         }
-        get ze() {
-            return this.zc;
+        get zq() {
+            return this.zo;
         }
-        set ze(a) {
-            let b = this.ze;
+        set zq(a) {
+            let b = this.zq;
             if (a != b) {
-                this.zc = a;
-                this.vf("AngleAxisFormatLabel", b, this.ze);
+                this.zo = a;
+                this.vl("AngleAxisFormatLabel", b, this.zq);
             }
         }
-        get zf() {
-            return this.zd;
+        get zr() {
+            return this.zp;
         }
-        set zf(a) {
-            let b = this.zf;
+        set zr(a) {
+            let b = this.zr;
             if (a != b) {
-                this.zd = a;
-                this.vf("ValueAxisFormatLabel", b, this.zf);
+                this.zp = a;
+                this.vl("ValueAxisFormatLabel", b, this.zr);
             }
         }
-        get aap() {
-            return this.zr;
+        get aa1() {
+            return this.z3;
         }
-        set aap(a) {
-            let b = this.aap;
+        set aa1(a) {
+            let b = this.aa1;
             if (a != b) {
-                this.zr = a;
-                this.vf("AngleAxisLabelLeftMargin", b, this.aap);
+                this.z3 = a;
+                this.vl("AngleAxisLabelLeftMargin", b, this.aa1);
             }
         }
-        get aar() {
-            return this.zt;
+        get aa3() {
+            return this.z5;
         }
-        set aar(a) {
-            let b = this.aar;
+        set aa3(a) {
+            let b = this.aa3;
             if (a != b) {
-                this.zt = a;
-                this.vf("AngleAxisLabelTopMargin", b, this.aar);
+                this.z5 = a;
+                this.vl("AngleAxisLabelTopMargin", b, this.aa3);
             }
         }
-        get aaq() {
-            return this.zs;
+        get aa2() {
+            return this.z4;
         }
-        set aaq(a) {
-            let b = this.aaq;
+        set aa2(a) {
+            let b = this.aa2;
             if (a != b) {
-                this.zs = a;
-                this.vf("AngleAxisLabelRightMargin", b, this.aaq);
+                this.z4 = a;
+                this.vl("AngleAxisLabelRightMargin", b, this.aa2);
             }
         }
-        get aao() {
-            return this.zq;
+        get aa0() {
+            return this.z2;
         }
-        set aao(a) {
-            let b = this.aao;
+        set aa0(a) {
+            let b = this.aa0;
             if (a != b) {
-                this.zq = a;
-                this.vf("AngleAxisLabelBottomMargin", b, this.aao);
+                this.z2 = a;
+                this.vl("AngleAxisLabelBottomMargin", b, this.aa0);
             }
         }
-        get aba() {
-            return this.z8;
+        get abm() {
+            return this.aak;
         }
-        set aba(a) {
-            let b = this.aba;
+        set abm(a) {
+            let b = this.abm;
             if (a != b) {
-                this.z8 = a;
-                this.vf("ValueAxisLabelLeftMargin", b, this.aba);
+                this.aak = a;
+                this.vl("ValueAxisLabelLeftMargin", b, this.abm);
             }
         }
-        get abc() {
-            return this.aaa;
+        get abo() {
+            return this.aam;
         }
-        set abc(a) {
-            let b = this.abc;
+        set abo(a) {
+            let b = this.abo;
             if (a != b) {
-                this.aaa = a;
-                this.vf("ValueAxisLabelTopMargin", b, this.abc);
+                this.aam = a;
+                this.vl("ValueAxisLabelTopMargin", b, this.abo);
             }
         }
-        get abb() {
-            return this.z9;
+        get abn() {
+            return this.aal;
         }
-        set abb(a) {
-            let b = this.abb;
+        set abn(a) {
+            let b = this.abn;
             if (a != b) {
-                this.z9 = a;
-                this.vf("ValueAxisLabelRightMargin", b, this.abb);
+                this.aal = a;
+                this.vl("ValueAxisLabelRightMargin", b, this.abn);
             }
         }
-        get aa9() {
-            return this.z7;
+        get abl() {
+            return this.aaj;
         }
-        set aa9(a) {
-            let b = this.aa9;
+        set abl(a) {
+            let b = this.abl;
             if (a != b) {
-                this.z7 = a;
-                this.vf("ValueAxisLabelBottomMargin", b, this.aa9);
+                this.aaj = a;
+                this.vl("ValueAxisLabelBottomMargin", b, this.abl);
             }
         }
-        get afh() {
-            return this.ae1;
+        get aft() {
+            return this.afd;
         }
-        set afh(a) {
-            let b = this.afh;
+        set aft(a) {
+            let b = this.aft;
             if (a != b) {
-                this.ae1 = a;
-                this.vf("AngleAxisLabelTextColor", b, this.afh);
+                this.afd = a;
+                this.vl("AngleAxisLabelTextColor", b, this.aft);
             }
         }
-        get afo() {
-            return this.ae8;
+        get af0() {
+            return this.afk;
         }
-        set afo(a) {
-            let b = this.afo;
+        set af0(a) {
+            let b = this.af0;
             if (a != b) {
-                this.ae8 = a;
-                this.vf("ValueAxisLabelTextColor", b, this.afo);
+                this.afk = a;
+                this.vl("ValueAxisLabelTextColor", b, this.af0);
             }
         }
-        get aff() {
-            return this.aez;
+        get afr() {
+            return this.afb;
         }
-        set aff(a) {
-            let b = this.aez;
+        set afr(a) {
+            let b = this.afb;
             if (a != b) {
-                this.aez = a;
-                this.vf("ActualAngleAxisLabelTextColor", b, this.aff);
+                this.afb = a;
+                this.vl("ActualAngleAxisLabelTextColor", b, this.afr);
             }
         }
-        get afg() {
-            return this.ae0;
+        get afs() {
+            return this.afc;
         }
-        set afg(a) {
-            let b = this.ae0;
+        set afs(a) {
+            let b = this.afc;
             if (a != b) {
-                this.ae0 = a;
-                this.vf("ActualValueAxisLabelTextColor", b, this.afg);
+                this.afc = a;
+                this.vl("ActualValueAxisLabelTextColor", b, this.afs);
             }
         }
-        get aa0() {
-            return this.z2;
+        get abc() {
+            return this.aae;
         }
-        set aa0(a) {
-            let b = this.aa0;
+        set abc(a) {
+            let b = this.abc;
             if (a != b) {
-                this.z2 = a;
-                this.vf("AngleAxisTitleMargin", b, this.aa0);
+                this.aae = a;
+                this.vl("AngleAxisTitleMargin", b, this.abc);
             }
         }
-        get abl() {
-            return this.aaj;
+        get abx() {
+            return this.aav;
         }
-        set abl(a) {
-            let b = this.abl;
+        set abx(a) {
+            let b = this.abx;
             if (a != b) {
-                this.aaj = a;
-                this.vf("ValueAxisTitleMargin", b, this.abl);
+                this.aav = a;
+                this.vl("ValueAxisTitleMargin", b, this.abx);
             }
         }
-        get aaz() {
-            return this.z1;
+        get abb() {
+            return this.aad;
         }
-        set aaz(a) {
-            let b = this.aaz;
+        set abb(a) {
+            let b = this.abb;
             if (a != b) {
-                this.z1 = a;
-                this.vf("AngleAxisTitleLeftMargin", b, this.aaz);
+                this.aad = a;
+                this.vl("AngleAxisTitleLeftMargin", b, this.abb);
             }
         }
-        get abk() {
-            return this.aai;
+        get abw() {
+            return this.aau;
         }
-        set abk(a) {
-            let b = this.abk;
+        set abw(a) {
+            let b = this.abw;
             if (a != b) {
-                this.aai = a;
-                this.vf("ValueAxisTitleLeftMargin", b, this.abk);
+                this.aau = a;
+                this.vl("ValueAxisTitleLeftMargin", b, this.abw);
             }
         }
-        get aa2() {
-            return this.z4;
+        get abe() {
+            return this.aag;
         }
-        set aa2(a) {
-            let b = this.aa2;
+        set abe(a) {
+            let b = this.abe;
             if (a != b) {
-                this.z4 = a;
-                this.vf("AngleAxisTitleTopMargin", b, this.aa2);
+                this.aag = a;
+                this.vl("AngleAxisTitleTopMargin", b, this.abe);
             }
         }
-        get abn() {
-            return this.aal;
+        get abz() {
+            return this.aax;
         }
-        set abn(a) {
-            let b = this.abn;
+        set abz(a) {
+            let b = this.abz;
             if (a != b) {
-                this.aal = a;
-                this.vf("ValueAxisTitleTopMargin", b, this.abn);
+                this.aax = a;
+                this.vl("ValueAxisTitleTopMargin", b, this.abz);
             }
         }
-        get aa1() {
-            return this.z3;
+        get abd() {
+            return this.aaf;
         }
-        set aa1(a) {
-            let b = this.aa1;
+        set abd(a) {
+            let b = this.abd;
             if (a != b) {
-                this.z3 = a;
-                this.vf("AngleAxisTitleRightMargin", b, this.aa1);
+                this.aaf = a;
+                this.vl("AngleAxisTitleRightMargin", b, this.abd);
             }
         }
-        get abm() {
-            return this.aak;
+        get aby() {
+            return this.aaw;
         }
-        set abm(a) {
-            let b = this.abm;
+        set aby(a) {
+            let b = this.aby;
             if (a != b) {
-                this.aak = a;
-                this.vf("ValueAxisTitleRightMargin", b, this.abm);
+                this.aaw = a;
+                this.vl("ValueAxisTitleRightMargin", b, this.aby);
             }
         }
-        get aay() {
-            return this.z0;
+        get aba() {
+            return this.aac;
         }
-        set aay(a) {
-            let b = this.aay;
+        set aba(a) {
+            let b = this.aba;
             if (a != b) {
-                this.z0 = a;
-                this.vf("AngleAxisTitleBottomMargin", b, this.aay);
+                this.aac = a;
+                this.vl("AngleAxisTitleBottomMargin", b, this.aba);
             }
         }
-        get abj() {
-            return this.aah;
+        get abv() {
+            return this.aat;
         }
-        set abj(a) {
-            let b = this.abj;
+        set abv(a) {
+            let b = this.abv;
             if (a != b) {
-                this.aah = a;
-                this.vf("ValueAxisTitleBottomMargin", b, this.abj);
+                this.aat = a;
+                this.vl("ValueAxisTitleBottomMargin", b, this.abv);
             }
         }
-        get afn() {
-            return this.ae7;
+        get afz() {
+            return this.afj;
         }
-        set afn(a) {
-            let b = this.afn;
+        set afz(a) {
+            let b = this.afz;
             if (a != b) {
-                this.ae7 = a;
-                this.vf("AngleAxisTitleTextColor", b, this.afn);
+                this.afj = a;
+                this.vl("AngleAxisTitleTextColor", b, this.afz);
             }
         }
-        get afu() {
-            return this.afe;
+        get af6() {
+            return this.afq;
         }
-        set afu(a) {
-            let b = this.afu;
+        set af6(a) {
+            let b = this.af6;
             if (a != b) {
-                this.afe = a;
-                this.vf("ValueAxisTitleTextColor", b, this.afu);
+                this.afq = a;
+                this.vl("ValueAxisTitleTextColor", b, this.af6);
             }
         }
-        vj(a, b, c) {
-            super.vj(a, b, c);
+        vp(a, b, c) {
+            super.vp(a, b, c);
             switch (a) {
                 case "AngleAxisLabelTextStyle":
-                    this.ael((d) => d.textStyle = this.acg);
+                    this.aex((d) => d.textStyle = this.acs);
                     break;
                 case "ValueAxisLabelTextStyle":
-                    this.aeq((d) => d.textStyle = this.adm);
+                    this.ae2((d) => d.textStyle = this.ady);
                     break;
                 case "AngleAxisTitleTextStyle":
-                    this.aen((d) => d.textStyle = this.ac4);
+                    this.aez((d) => d.textStyle = this.adg);
                     break;
                 case "ValueAxisTitleTextStyle":
-                    this.aes((d) => d.textStyle = this.aea);
+                    this.ae4((d) => d.textStyle = this.aem);
                     break;
             }
         }
-        get acg() {
-            return this.abt;
+        get acs() {
+            return this.ab5;
         }
-        set acg(a) {
-            let b = this.acg;
+        set acs(a) {
+            let b = this.acs;
             if (a != b) {
-                this.abt = a;
-                this.vf("AngleAxisLabelTextStyle", b, this.acg);
+                this.ab5 = a;
+                this.vl("AngleAxisLabelTextStyle", b, this.acs);
             }
         }
-        get adm() {
-            return this.abx;
+        get ady() {
+            return this.ab9;
         }
-        set adm(a) {
-            let b = this.adm;
+        set ady(a) {
+            let b = this.ady;
             if (a != b) {
-                this.abx = a;
-                this.vf("ValueAxisLabelTextStyle", b, this.adm);
+                this.ab9 = a;
+                this.vl("ValueAxisLabelTextStyle", b, this.ady);
             }
         }
-        get ac4() {
-            return this.abv;
+        get adg() {
+            return this.ab7;
         }
-        set ac4(a) {
-            let b = this.ac4;
+        set adg(a) {
+            let b = this.adg;
             if (a != b) {
-                this.abv = a;
-                this.vf("AngleAxisTitleTextStyle", b, this.ac4);
+                this.ab7 = a;
+                this.vl("AngleAxisTitleTextStyle", b, this.adg);
             }
         }
-        get aea() {
-            return this.abz;
+        get aem() {
+            return this.acb;
         }
-        set aea(a) {
-            let b = this.aea;
+        set aem(a) {
+            let b = this.aem;
             if (a != b) {
-                this.abz = a;
-                this.vf("ValueAxisTitleTextStyle", b, this.aea);
+                this.acb = a;
+                this.vl("ValueAxisTitleTextStyle", b, this.aem);
             }
         }
-        aeg(a) {
-            this.aed(a, (b) => b.leftMargin = this.aap);
-            this.aed(a, (b) => b.topMargin = this.aar);
-            this.aed(a, (b) => b.rightMargin = this.aaq);
-            this.aed(a, (b) => b.bottomMargin = this.aao);
-            this.aed(a, (b) => b.textColor = this.aff);
-            this.aee(a, (b) => b.textColor = this.afn);
-            this.aee(a, (b) => b.leftMargin = this.aaz);
-            this.aee(a, (b) => b.topMargin = this.aa2);
-            this.aee(a, (b) => b.rightMargin = this.aa1);
-            this.aee(a, (b) => b.bottomMargin = this.aay);
-            this.aed(a, (b) => b.textStyle = this.acg);
-            this.aee(a, (b) => b.textStyle = this.ac4);
-        }
-        aei(a) {
-            this.aed(a, (b) => b.leftMargin = this.aba);
-            this.aed(a, (b) => b.topMargin = this.abc);
-            this.aed(a, (b) => b.rightMargin = this.abb);
-            this.aed(a, (b) => b.bottomMargin = this.aa9);
-            this.aed(a, (b) => b.textColor = this.afg);
-            this.aee(a, (b) => b.textColor = this.afu);
-            this.aee(a, (b) => b.leftMargin = this.abk);
-            this.aee(a, (b) => b.topMargin = this.abn);
-            this.aee(a, (b) => b.rightMargin = this.abm);
-            this.aee(a, (b) => b.bottomMargin = this.abj);
-            this.aed(a, (b) => b.textStyle = this.adm);
-            this.aee(a, (b) => b.textStyle = this.aea);
-        }
-        v3(a) {
+        aes(a) {
+            this.aep(a, (b) => b.leftMargin = this.aa1);
+            this.aep(a, (b) => b.topMargin = this.aa3);
+            this.aep(a, (b) => b.rightMargin = this.aa2);
+            this.aep(a, (b) => b.bottomMargin = this.aa0);
+            this.aep(a, (b) => b.textColor = this.afr);
+            this.aeq(a, (b) => b.textColor = this.afz);
+            this.aeq(a, (b) => b.leftMargin = this.abb);
+            this.aeq(a, (b) => b.topMargin = this.abe);
+            this.aeq(a, (b) => b.rightMargin = this.abd);
+            this.aeq(a, (b) => b.bottomMargin = this.aba);
+            this.aep(a, (b) => b.textStyle = this.acs);
+            this.aeq(a, (b) => b.textStyle = this.adg);
+        }
+        aeu(a) {
+            this.aep(a, (b) => b.leftMargin = this.abm);
+            this.aep(a, (b) => b.topMargin = this.abo);
+            this.aep(a, (b) => b.rightMargin = this.abn);
+            this.aep(a, (b) => b.bottomMargin = this.abl);
+            this.aep(a, (b) => b.textColor = this.afs);
+            this.aeq(a, (b) => b.textColor = this.af6);
+            this.aeq(a, (b) => b.leftMargin = this.abw);
+            this.aeq(a, (b) => b.topMargin = this.abz);
+            this.aeq(a, (b) => b.rightMargin = this.aby);
+            this.aeq(a, (b) => b.bottomMargin = this.abv);
+            this.aep(a, (b) => b.textStyle = this.ady);
+            this.aeq(a, (b) => b.textStyle = this.aem);
+        }
+        wf(a) {
             let b = this.bi(a);
-            let c = this.da(a, b);
+            let c = this.dg(a, b);
             if (c == null) {
                 return;
             }
-            c.itemsSource = this.hw(a);
+            c.itemsSource = this.h2(a);
             if (a.highlightedData != null) {
-                c.highlightedItemsSource = this.hx(a);
+                c.highlightedItemsSource = this.h3(a);
             }
-            c.name = this.qe(a);
-            c.title = this.qf(a, b);
+            c.name = this.qk(a);
+            c.title = this.ql(a, b);
             this.dataChart.series.add(c);
         }
-        aej(a) {
-            this.aek(a, null);
+        aev(a) {
+            this.aew(a, null);
         }
-        aek(a, b) {
-            a(this.za());
+        aew(a, b) {
+            a(this.zm());
         }
-        aep(a, b) {
-            a(this.zb());
+        ae1(a, b) {
+            a(this.zn());
         }
-        aeo(a) {
-            this.aep(a, true);
+        ae0(a) {
+            this.ae1(a, true);
         }
-        ub(a, b) {
-            this.aej(a);
-            this.aep(a, b);
+        uh(a, b) {
+            this.aev(a);
+            this.ae1(a, b);
         }
-        aen(a) {
-            this.aee(this.za(), a);
+        aez(a) {
+            this.aeq(this.zm(), a);
         }
-        aes(a) {
-            this.aee(this.zb(), a);
+        ae4(a) {
+            this.aeq(this.zn(), a);
         }
-        aeq(a) {
-            this.aed(this.zb(), a);
+        ae2(a) {
+            this.aep(this.zn(), a);
         }
-        ael(a) {
-            this.aed(this.za(), a);
+        aex(a) {
+            this.aep(this.zm(), a);
         }
-        aa3(a) {
-            let b = this.za();
-            return b.ek(a, new ScalerParams(1, this.yd, this.yc, b.ch));
+        abf(a) {
+            let b = this.zm();
+            return b.ek(a, new ScalerParams(1, this.yp, this.yo, b.ch));
         }
-        aa5(a) {
-            let b = this.za();
-            return b.en(a, new ScalerParams(1, this.yd, this.yc, b.ch));
+        abh(a) {
+            let b = this.zm();
+            return b.en(a, new ScalerParams(1, this.yp, this.yo, b.ch));
         }
-        aa4(a) {
-            let b = this.zb();
-            return b.ek(a, new ScalerParams(1, this.yd, this.yc, b.ch));
+        abg(a) {
+            let b = this.zn();
+            return b.ek(a, new ScalerParams(1, this.yp, this.yo, b.ch));
         }
-        aa6(a) {
-            let b = this.zb();
-            return b.en(a, new ScalerParams(1, this.yd, this.yc, b.ch));
+        abi(a) {
+            let b = this.zn();
+            return b.en(a, new ScalerParams(1, this.yp, this.yo, b.ch));
         }
-        v0(a) {
-            super.v0(a);
+        wc(a) {
+            super.wc(a);
             if (a == null) {
                 return;
             }
             if (a.axes != null) {
-                let b = this.za();
-                let c = this.zb();
+                let b = this.zm();
+                let c = this.zn();
                 if (a.axes.contains(b)) {
                     a.axes.remove(b);
                 }
@@ -638,7 +638,7 @@ export let RadialBaseChart = /*@__PURE__*/ (() => {
                 }
             }
         }
-        static ac7(a, b) {
+        static adj(a, b) {
             for (let c of fromEnum(b)) {
                 let d = c.findMatchingHint(16);
                 if (d != null) {
@@ -648,96 +648,96 @@ export let RadialBaseChart = /*@__PURE__*/ (() => {
             }
             return null;
         }
-        um(a, b) {
-            super.um(a, b);
+        us(a, b) {
+            super.us(a, b);
             if (a == this.dataChart) {
-                this.dataChart.axes.add(this.za());
-                this.dataChart.axes.add(this.zb());
-            }
-        }
-        aef(a) {
-            if (a != null && this.lo != null && a.fm == null) {
-                a.provideRenderer(this.lo);
-            }
-            a.jx = this.afi;
-            a.es = this.aas;
-            a.jy = this.afj;
-            a.ev = this.aat;
-            a.j0 = this.afl;
-            a.fh = this.aau;
-            a.jz = this.afk;
-            a.fi = this.aav;
-            a.j1 = this.afm;
-            a.fj = this.aaw;
+                this.dataChart.axes.add(this.zm());
+                this.dataChart.axes.add(this.zn());
+            }
+        }
+        aer(a) {
+            if (a != null && this.lu != null && a.fm == null) {
+                a.provideRenderer(this.lu);
+            }
+            a.jx = this.afu;
+            a.es = this.aa4;
+            a.jy = this.afv;
+            a.ev = this.aa5;
+            a.j0 = this.afx;
+            a.fh = this.aa6;
+            a.jz = this.afw;
+            a.fi = this.aa7;
+            a.j1 = this.afy;
+            a.fj = this.aa8;
             a.c4 = true;
-            a.cu = this.ha;
-            a.cw = this.ha;
-            let b = a == this.za();
+            a.cu = this.hg;
+            a.cw = this.hg;
+            let b = a == this.zm();
             if (b) {
-                a.g7 = this.acv;
-            }
-            a.f1 = this.abq;
-            a.gh = this.ab7;
-            a.ah = this.y6;
-            this.aed(a, (c) => c.angle = this.aan);
-            this.aed(a, (c) => {
-                if (c.extent != this.aam) {
-                    c.extent = this.aam;
+                a.g7 = this.ac7;
+            }
+            a.f1 = this.ab2;
+            a.gh = this.acj;
+            a.ah = this.zi;
+            this.aep(a, (c) => c.angle = this.aaz);
+            this.aep(a, (c) => {
+                if (c.extent != this.aay) {
+                    c.extent = this.aay;
                 }
             });
-            this.aed(a, (c) => c.horizontalAlignment = this.aew);
-            this.aed(a, (c) => c.verticalAlignment = this.afy);
-            this.aed(a, (c) => c.visibility = this.af3);
-            this.aed(a, (c) => c.location = this.zg(this.y9));
-            this.aee(a, (c) => c.horizontalAlignment = this.aex);
-            this.aee(a, (c) => c.angle = this.aax);
-            this.aeg(a);
-        }
-        aeh(a) {
+            this.aep(a, (c) => c.horizontalAlignment = this.ae8);
+            this.aep(a, (c) => c.verticalAlignment = this.aga);
+            this.aep(a, (c) => c.visibility = this.agf);
+            this.aep(a, (c) => c.location = this.zs(this.zl));
+            this.aeq(a, (c) => c.horizontalAlignment = this.ae9);
+            this.aeq(a, (c) => c.angle = this.aa9);
+            this.aes(a);
+        }
+        aet(a) {
             if (a == null) {
                 return;
             }
-            if (this.lo != null && a.fm == null) {
-                a.provideRenderer(this.lo);
+            if (this.lu != null && a.fm == null) {
+                a.provideRenderer(this.lu);
             }
-            a.cu = this.ha;
-            a.cw = this.ha;
-            this.aed(a, (b) => b.angle = this.aa8);
-            this.aed(a, (b) => {
-                if (b.extent != this.aa7) {
-                    b.extent = this.aa7;
+            a.cu = this.hg;
+            a.cw = this.hg;
+            this.aep(a, (b) => b.angle = this.abk);
+            this.aep(a, (b) => {
+                if (b.extent != this.abj) {
+                    b.extent = this.abj;
                 }
             });
-            this.aed(a, (b) => b.horizontalAlignment = this.aey);
-            this.aed(a, (b) => b.verticalAlignment = this.afz);
-            this.aed(a, (b) => b.visibility = this.af4);
-            this.aed(a, (b) => b.location = this.zh(this.zj));
-            this.aee(a, (b) => b.verticalAlignment = this.af0);
-            this.aee(a, (b) => b.angle = this.abi);
-            a.jx = this.afp;
-            a.es = this.abd;
-            a.jy = this.afq;
-            a.ev = this.abe;
-            a.j0 = this.afs;
-            a.fh = this.abf;
-            a.jz = this.afr;
-            a.fi = this.abg;
-            a.j1 = this.aft;
-            a.fj = this.abh;
-            let b = a == this.zb();
+            this.aep(a, (b) => b.horizontalAlignment = this.afa);
+            this.aep(a, (b) => b.verticalAlignment = this.agb);
+            this.aep(a, (b) => b.visibility = this.agg);
+            this.aep(a, (b) => b.location = this.zt(this.zv));
+            this.aeq(a, (b) => b.verticalAlignment = this.agc);
+            this.aeq(a, (b) => b.angle = this.abu);
+            a.jx = this.af1;
+            a.es = this.abp;
+            a.jy = this.af2;
+            a.ev = this.abq;
+            a.j0 = this.af4;
+            a.fh = this.abr;
+            a.jz = this.af3;
+            a.fi = this.abs;
+            a.j1 = this.af5;
+            a.fj = this.abt;
+            let b = a == this.zn();
             if (b) {
-                a.g7 = this.ad1;
+                a.g7 = this.aed;
             }
-            a.gh = this.add;
-            a.ah = this.y7;
-            this.aei(a);
+            a.gh = this.adp;
+            a.ah = this.zj;
+            this.aeu(a);
         }
-        uj() {
-            super.uj();
-            this.aef(this.za());
-            this.aeh(this.zb());
+        up() {
+            super.up();
+            this.aer(this.zm());
+            this.aet(this.zn());
         }
-        aed(a, b) {
+        aep(a, b) {
             if (a == null) {
                 return;
             }
@@ -754,7 +754,7 @@ export let RadialBaseChart = /*@__PURE__*/ (() => {
             }
             b(a.az);
         }
-        aee(a, b) {
+        aeq(a, b) {
             if (a == null) {
                 return;
             }
@@ -771,170 +771,170 @@ export let RadialBaseChart = /*@__PURE__*/ (() => {
             }
             b(a.bf);
         }
-        vf(a, b, c) {
-            super.vf(a, b, c);
+        vl(a, b, c) {
+            super.vl(a, b, c);
             switch (a) {
                 case "AngleAxisLabelAngle":
-                    this.ael((d) => d.angle = this.aan);
+                    this.aex((d) => d.angle = this.aaz);
                     break;
                 case "ValueAxisLabelAngle":
-                    this.aeq((d) => d.angle = this.aa8);
+                    this.ae2((d) => d.angle = this.abk);
                     break;
                 case "AngleAxisLabelHorizontalAlignment":
-                    this.ael((d) => d.horizontalAlignment = this.aew);
+                    this.aex((d) => d.horizontalAlignment = this.ae8);
                     break;
                 case "ValueAxisLabelHorizontalAlignment":
-                    this.aeq((d) => d.horizontalAlignment = this.aey);
+                    this.ae2((d) => d.horizontalAlignment = this.afa);
                     break;
                 case "AngleAxisLabelVerticalAlignment":
-                    this.ael((d) => d.verticalAlignment = this.afy);
+                    this.aex((d) => d.verticalAlignment = this.aga);
                     break;
                 case "ValueAxisLabelVerticalAlignment":
-                    this.aeq((d) => d.verticalAlignment = this.afz);
+                    this.ae2((d) => d.verticalAlignment = this.agb);
                     break;
                 case "AngleAxisLabelVisibility":
-                    this.ael((d) => d.visibility = this.af3);
+                    this.aex((d) => d.visibility = this.agf);
                     break;
                 case "ValueAxisLabelVisibility":
-                    this.aeq((d) => d.visibility = this.af4);
+                    this.ae2((d) => d.visibility = this.agg);
                     break;
                 case "AngleAxisLabel":
-                    this.aej((d) => d.f1 = this.abq);
+                    this.aev((d) => d.f1 = this.ab2);
                     break;
                 case "ValueAxisLabel":
-                    this.aeo((d) => d.f1 = this.abr);
+                    this.ae0((d) => d.f1 = this.ab3);
                     break;
                 case "AngleAxisLabelFormat":
-                    this.aej((d) => d.gh = this.ab7);
+                    this.aev((d) => d.gh = this.acj);
                     break;
                 case "AngleAxisLabelFormatSpecifiers":
-                    this.aej((d) => d.ah = this.y6);
+                    this.aev((d) => d.ah = this.zi);
                     break;
                 case "ValueAxisLabelFormat":
-                    this.aeo((d) => d.gh = this.add);
+                    this.ae0((d) => d.gh = this.adp);
                     break;
                 case "ValueAxisLabelFormatSpecifiers":
-                    this.aeo((d) => d.ah = this.y7);
+                    this.ae0((d) => d.ah = this.zj);
                     break;
                 case "AngleAxisTitleAngle":
-                    this.aen((d) => d.angle = this.aax);
+                    this.aez((d) => d.angle = this.aa9);
                     break;
                 case "ValueAxisTitleAngle":
-                    this.aes((d) => d.angle = this.abi);
+                    this.ae4((d) => d.angle = this.abu);
                     break;
                 case "AngleAxisTitleAlignment":
-                    this.aen((d) => d.horizontalAlignment = this.aex);
+                    this.aez((d) => d.horizontalAlignment = this.ae9);
                     break;
                 case "ValueAxisTitleAlignment":
-                    this.aes((d) => d.verticalAlignment = this.af0);
+                    this.ae4((d) => d.verticalAlignment = this.agc);
                     break;
                 case "AngleAxisTitle":
-                    this.aej((d) => d.g7 = this.acv);
+                    this.aev((d) => d.g7 = this.ac7);
                     break;
                 case "ValueAxisTitle":
-                    this.aep((d) => d.g7 = this.ad1, false);
+                    this.ae1((d) => d.g7 = this.aed, false);
                     break;
                 case "AngleAxisMajorStroke":
-                    this.aek((d) => d.jx = this.afi, a);
+                    this.aew((d) => d.jx = this.afu, a);
                     break;
                 case "ValueAxisMajorStroke":
-                    this.aeo((d) => d.jx = this.afp);
+                    this.ae0((d) => d.jx = this.af1);
                     break;
                 case "AngleAxisMajorStrokeThickness":
-                    this.aek((d) => d.es = this.aas, a);
+                    this.aew((d) => d.es = this.aa4, a);
                     break;
                 case "ValueAxisMajorStrokeThickness":
-                    this.aeo((d) => d.es = this.abd);
+                    this.ae0((d) => d.es = this.abp);
                     break;
                 case "AngleAxisMinorStroke":
-                    this.aej((d) => d.jy = this.afj);
+                    this.aev((d) => d.jy = this.afv);
                     break;
                 case "ValueAxisMinorStroke":
-                    this.aeo((d) => d.jy = this.afq);
+                    this.ae0((d) => d.jy = this.af2);
                     break;
                 case "AngleAxisMinorStrokeThickness":
-                    this.aej((d) => d.ev = this.aat);
+                    this.aev((d) => d.ev = this.aa5);
                     break;
                 case "ValueAxisMinorStrokeThickness":
-                    this.aeo((d) => d.ev = this.abe);
+                    this.ae0((d) => d.ev = this.abq);
                     break;
                 case "AngleAxisTickLength":
-                    this.aej((d) => d.fi = this.aav);
+                    this.aev((d) => d.fi = this.aa7);
                     break;
                 case "ValueAxisTickLength":
-                    this.aeo((d) => d.fi = this.abg);
+                    this.ae0((d) => d.fi = this.abs);
                     break;
                 case "AngleAxisTickStroke":
-                    this.aej((d) => d.j1 = this.afm);
+                    this.aev((d) => d.j1 = this.afy);
                     break;
                 case "ValueAxisTickStroke":
-                    this.aeo((d) => d.j1 = this.aft);
+                    this.ae0((d) => d.j1 = this.af5);
                     break;
                 case "AngleAxisTickStrokeThickness":
-                    this.aej((d) => d.fj = this.aaw);
+                    this.aev((d) => d.fj = this.aa8);
                     break;
                 case "ValueAxisTickStrokeThickness":
-                    this.aeo((d) => d.fj = this.abh);
+                    this.ae0((d) => d.fj = this.abt);
                     break;
                 case "AngleAxisStroke":
-                    this.aej((d) => d.j0 = this.afl);
+                    this.aev((d) => d.j0 = this.afx);
                     break;
                 case "ValueAxisStroke":
-                    this.aeo((d) => d.j0 = this.afs);
+                    this.ae0((d) => d.j0 = this.af4);
                     break;
                 case "AngleAxisStrokeThickness":
-                    this.aej((d) => d.fh = this.aau);
+                    this.aev((d) => d.fh = this.aa6);
                     break;
                 case "ValueAxisStrokeThickness":
-                    this.aeo((d) => d.fh = this.abf);
+                    this.ae0((d) => d.fh = this.abr);
                     break;
                 case "AngleAxisExtent":
-                    this.ael((d) => d.extent = this.aam);
+                    this.aex((d) => d.extent = this.aay);
                     break;
                 case "ValueAxisExtent":
-                    this.aeq((d) => d.extent = this.aa7);
+                    this.ae2((d) => d.extent = this.abj);
                     break;
                 case "AngleAxisStrip":
-                    this.aej((d) => d.jz = this.afk);
+                    this.aev((d) => d.jz = this.afw);
                     break;
                 case "ValueAxisStrip":
-                    this.aeo((d) => d.jz = this.afr);
+                    this.ae0((d) => d.jz = this.af3);
                     break;
                 case "AngleAxisInverted":
-                    this.aej((d) => d.ch = this.zm);
+                    this.aev((d) => d.ch = this.zy);
                     break;
                 case "ValueAxisInverted":
-                    this.aeo((d) => d.ch = this.zn);
+                    this.ae0((d) => d.ch = this.zz);
                     break;
                 case "ValueAxisLabelLocation":
-                    this.aer();
+                    this.ae3();
                     break;
                 case "AngleAxisLabelLocation":
-                    this.aem();
+                    this.aey();
                     break;
             }
         }
-        aer() {
-            let a = this.zh(this.zj);
+        ae3() {
+            let a = this.zt(this.zv);
             if (a == 2 || a == 7) {
-                this.aey = 2;
+                this.afa = 2;
             }
             else {
-                this.aey = 0;
+                this.afa = 0;
             }
-            this.aeq((b) => b.location = a);
+            this.ae2((b) => b.location = a);
         }
-        aem() {
-            let a = this.zg(this.y9);
+        aey() {
+            let a = this.zs(this.zl);
             if (a == 1 || a == 5) {
-                this.afy = 0;
+                this.aga = 0;
             }
             else {
-                this.afy = 2;
+                this.aga = 2;
             }
-            this.ael((b) => b.location = a);
+            this.aex((b) => b.location = a);
         }
-        zh(a) {
+        zt(a) {
             if (a == 0) {
                 return 2;
             }
@@ -948,7 +948,7 @@ export let RadialBaseChart = /*@__PURE__*/ (() => {
                 return 6;
             }
             else {
-                if (this.b9 == 1) {
+                if (this.cf == 1) {
                     return 3;
                 }
                 else {
@@ -956,7 +956,7 @@ export let RadialBaseChart = /*@__PURE__*/ (() => {
                 }
             }
         }
-        zg(a) {
+        zs(a) {
             if (a == 1) {
                 return 1;
             }
@@ -973,482 +973,482 @@ export let RadialBaseChart = /*@__PURE__*/ (() => {
                 return 1;
             }
         }
-        get abq() {
-            return this.abo;
+        get ab2() {
+            return this.ab0;
         }
-        set abq(a) {
-            let b = this.abq;
+        set ab2(a) {
+            let b = this.ab2;
             if (a != b) {
-                this.abo = a;
-                this.vf("AngleAxisLabel", b, this.abq);
+                this.ab0 = a;
+                this.vl("AngleAxisLabel", b, this.ab2);
             }
         }
-        get abr() {
-            return this.abp;
+        get ab3() {
+            return this.ab1;
         }
-        set abr(a) {
-            let b = this.abr;
+        set ab3(a) {
+            let b = this.ab3;
             if (a != b) {
-                this.abp = a;
-                this.vf("ValueAxisLabel", b, this.abr);
+                this.ab1 = a;
+                this.vl("ValueAxisLabel", b, this.ab3);
             }
         }
-        get afi() {
-            return this.ae2;
+        get afu() {
+            return this.afe;
         }
-        set afi(a) {
-            let b = this.afi;
+        set afu(a) {
+            let b = this.afu;
             if (a != b) {
-                this.ae2 = a;
-                this.vf("AngleAxisMajorStroke", b, this.afi);
+                this.afe = a;
+                this.vl("AngleAxisMajorStroke", b, this.afu);
             }
         }
-        get afp() {
-            return this.ae9;
+        get af1() {
+            return this.afl;
         }
-        set afp(a) {
-            let b = this.afp;
+        set af1(a) {
+            let b = this.af1;
             if (a != b) {
-                this.ae9 = a;
-                this.vf("ValueAxisMajorStroke", b, this.afp);
+                this.afl = a;
+                this.vl("ValueAxisMajorStroke", b, this.af1);
             }
         }
-        get aas() {
-            return this.zu;
+        get aa4() {
+            return this.z6;
         }
-        set aas(a) {
-            let b = this.aas;
+        set aa4(a) {
+            let b = this.aa4;
             if (a != b) {
-                this.zu = a;
-                this.vf("AngleAxisMajorStrokeThickness", b, this.aas);
+                this.z6 = a;
+                this.vl("AngleAxisMajorStrokeThickness", b, this.aa4);
             }
         }
-        get abd() {
-            return this.aab;
+        get abp() {
+            return this.aan;
         }
-        set abd(a) {
-            let b = this.abd;
+        set abp(a) {
+            let b = this.abp;
             if (a != b) {
-                this.aab = a;
-                this.vf("ValueAxisMajorStrokeThickness", b, this.abd);
+                this.aan = a;
+                this.vl("ValueAxisMajorStrokeThickness", b, this.abp);
             }
         }
-        get aat() {
-            return this.zv;
+        get aa5() {
+            return this.z7;
         }
-        set aat(a) {
-            let b = this.aat;
+        set aa5(a) {
+            let b = this.aa5;
             if (a != b) {
-                this.zv = a;
-                this.vf("AngleAxisMinorStrokeThickness", b, this.aat);
+                this.z7 = a;
+                this.vl("AngleAxisMinorStrokeThickness", b, this.aa5);
             }
         }
-        get abe() {
-            return this.aac;
+        get abq() {
+            return this.aao;
         }
-        set abe(a) {
-            let b = this.abe;
+        set abq(a) {
+            let b = this.abq;
             if (a != b) {
-                this.aac = a;
-                this.vf("ValueAxisMinorStrokeThickness", b, this.abe);
+                this.aao = a;
+                this.vl("ValueAxisMinorStrokeThickness", b, this.abq);
             }
         }
-        get afk() {
-            return this.ae4;
+        get afw() {
+            return this.afg;
         }
-        set afk(a) {
-            let b = this.afk;
+        set afw(a) {
+            let b = this.afw;
             if (a != b) {
-                this.ae4 = a;
-                this.vf("AngleAxisStrip", b, this.afk);
+                this.afg = a;
+                this.vl("AngleAxisStrip", b, this.afw);
             }
         }
-        get afr() {
-            return this.afb;
+        get af3() {
+            return this.afn;
         }
-        set afr(a) {
-            let b = this.afr;
+        set af3(a) {
+            let b = this.af3;
             if (a != b) {
-                this.afb = a;
-                this.vf("ValueAxisStrip", b, this.afr);
+                this.afn = a;
+                this.vl("ValueAxisStrip", b, this.af3);
             }
         }
-        get afl() {
-            return this.ae5;
+        get afx() {
+            return this.afh;
         }
-        set afl(a) {
-            let b = this.afl;
+        set afx(a) {
+            let b = this.afx;
             if (a != b) {
-                this.ae5 = a;
-                this.vf("AngleAxisStroke", b, this.afl);
+                this.afh = a;
+                this.vl("AngleAxisStroke", b, this.afx);
             }
         }
-        get afs() {
-            return this.afc;
+        get af4() {
+            return this.afo;
         }
-        set afs(a) {
-            let b = this.afs;
+        set af4(a) {
+            let b = this.af4;
             if (a != b) {
-                this.afc = a;
-                this.vf("ValueAxisStroke", b, this.afs);
+                this.afo = a;
+                this.vl("ValueAxisStroke", b, this.af4);
             }
         }
-        get aau() {
-            return this.zw;
+        get aa6() {
+            return this.z8;
         }
-        set aau(a) {
-            let b = this.aau;
+        set aa6(a) {
+            let b = this.aa6;
             if (a != b) {
-                this.zw = a;
-                this.vf("AngleAxisStrokeThickness", b, this.aau);
+                this.z8 = a;
+                this.vl("AngleAxisStrokeThickness", b, this.aa6);
             }
         }
-        get abf() {
-            return this.aad;
+        get abr() {
+            return this.aap;
         }
-        set abf(a) {
-            let b = this.abf;
+        set abr(a) {
+            let b = this.abr;
             if (a != b) {
-                this.aad = a;
-                this.vf("ValueAxisStrokeThickness", b, this.abf);
+                this.aap = a;
+                this.vl("ValueAxisStrokeThickness", b, this.abr);
             }
         }
-        get aav() {
-            return this.zx;
+        get aa7() {
+            return this.z9;
         }
-        set aav(a) {
-            let b = this.aav;
+        set aa7(a) {
+            let b = this.aa7;
             if (a != b) {
-                this.zx = a;
-                this.vf("AngleAxisTickLength", b, this.aav);
+                this.z9 = a;
+                this.vl("AngleAxisTickLength", b, this.aa7);
             }
         }
-        get abg() {
-            return this.aae;
+        get abs() {
+            return this.aaq;
         }
-        set abg(a) {
-            let b = this.abg;
+        set abs(a) {
+            let b = this.abs;
             if (a != b) {
-                this.aae = a;
-                this.vf("ValueAxisTickLength", b, this.abg);
+                this.aaq = a;
+                this.vl("ValueAxisTickLength", b, this.abs);
             }
         }
-        get afm() {
-            return this.ae6;
+        get afy() {
+            return this.afi;
         }
-        set afm(a) {
-            let b = this.afm;
+        set afy(a) {
+            let b = this.afy;
             if (a != b) {
-                this.ae6 = a;
-                this.vf("AngleAxisTickStroke", b, this.afm);
+                this.afi = a;
+                this.vl("AngleAxisTickStroke", b, this.afy);
             }
         }
-        get aft() {
-            return this.afd;
+        get af5() {
+            return this.afp;
         }
-        set aft(a) {
-            let b = this.aft;
+        set af5(a) {
+            let b = this.af5;
             if (a != b) {
-                this.afd = a;
-                this.vf("ValueAxisTickStroke", b, this.aft);
+                this.afp = a;
+                this.vl("ValueAxisTickStroke", b, this.af5);
             }
         }
-        get aaw() {
-            return this.zy;
+        get aa8() {
+            return this.aaa;
         }
-        set aaw(a) {
-            let b = this.aaw;
+        set aa8(a) {
+            let b = this.aa8;
             if (a != b) {
-                this.zy = a;
-                this.vf("AngleAxisTickStrokeThickness", b, this.aaw);
+                this.aaa = a;
+                this.vl("AngleAxisTickStrokeThickness", b, this.aa8);
             }
         }
-        get abh() {
-            return this.aaf;
+        get abt() {
+            return this.aar;
         }
-        set abh(a) {
-            let b = this.abh;
+        set abt(a) {
+            let b = this.abt;
             if (a != b) {
-                this.aaf = a;
-                this.vf("ValueAxisTickStrokeThickness", b, this.abh);
+                this.aar = a;
+                this.vl("ValueAxisTickStrokeThickness", b, this.abt);
             }
         }
-        get acv() {
-            return this.abu;
+        get ac7() {
+            return this.ab6;
         }
-        set acv(a) {
-            let b = this.acv;
+        set ac7(a) {
+            let b = this.ac7;
             if (a != b) {
-                this.abu = a;
-                this.vf("AngleAxisTitle", b, this.acv);
+                this.ab6 = a;
+                this.vl("AngleAxisTitle", b, this.ac7);
             }
         }
-        get ad1() {
-            return this.aby;
+        get aed() {
+            return this.aca;
         }
-        set ad1(a) {
-            let b = this.ad1;
+        set aed(a) {
+            let b = this.aed;
             if (a != b) {
-                this.aby = a;
-                this.vf("ValueAxisTitle", b, this.ad1);
+                this.aca = a;
+                this.vl("ValueAxisTitle", b, this.aed);
             }
         }
-        get afj() {
-            return this.ae3;
+        get afv() {
+            return this.aff;
         }
-        set afj(a) {
-            let b = this.afj;
+        set afv(a) {
+            let b = this.afv;
             if (a != b) {
-                this.ae3 = a;
-                this.vf("AngleAxisMinorStroke", b, this.afj);
+                this.aff = a;
+                this.vl("AngleAxisMinorStroke", b, this.afv);
             }
         }
-        get afq() {
-            return this.afa;
+        get af2() {
+            return this.afm;
         }
-        set afq(a) {
-            let b = this.afq;
+        set af2(a) {
+            let b = this.af2;
             if (a != b) {
-                this.afa = a;
-                this.vf("ValueAxisMinorStroke", b, this.afq);
+                this.afm = a;
+                this.vl("ValueAxisMinorStroke", b, this.af2);
             }
         }
-        get aan() {
-            return this.zp;
+        get aaz() {
+            return this.z1;
         }
-        set aan(a) {
-            let b = this.aan;
+        set aaz(a) {
+            let b = this.aaz;
             if (a != b) {
-                this.zp = a;
-                this.vf("AngleAxisLabelAngle", b, this.aan);
+                this.z1 = a;
+                this.vl("AngleAxisLabelAngle", b, this.aaz);
             }
         }
-        get aa8() {
-            return this.z6;
+        get abk() {
+            return this.aai;
         }
-        set aa8(a) {
-            let b = this.aa8;
+        set abk(a) {
+            let b = this.abk;
             if (a != b) {
-                this.z6 = a;
-                this.vf("ValueAxisLabelAngle", b, this.aa8);
+                this.aai = a;
+                this.vl("ValueAxisLabelAngle", b, this.abk);
             }
         }
-        get aam() {
-            return this.zo;
+        get aay() {
+            return this.z0;
         }
-        set aam(a) {
-            let b = this.aam;
+        set aay(a) {
+            let b = this.aay;
             if (a != b) {
-                this.zo = a;
-                this.vf("AngleAxisExtent", b, this.aam);
+                this.z0 = a;
+                this.vl("AngleAxisExtent", b, this.aay);
             }
         }
-        get aa7() {
-            return this.z5;
+        get abj() {
+            return this.aah;
         }
-        set aa7(a) {
-            let b = this.aa7;
+        set abj(a) {
+            let b = this.abj;
             if (a != b) {
-                this.z5 = a;
-                this.vf("ValueAxisExtent", b, this.aa7);
+                this.aah = a;
+                this.vl("ValueAxisExtent", b, this.abj);
             }
         }
-        get aax() {
-            return this.zz;
+        get aa9() {
+            return this.aab;
         }
-        set aax(a) {
-            let b = this.aax;
+        set aa9(a) {
+            let b = this.aa9;
             if (a != b) {
-                this.zz = a;
-                this.vf("AngleAxisTitleAngle", b, this.aax);
+                this.aab = a;
+                this.vl("AngleAxisTitleAngle", b, this.aa9);
             }
         }
-        get abi() {
-            return this.aag;
+        get abu() {
+            return this.aas;
         }
-        set abi(a) {
-            let b = this.abi;
+        set abu(a) {
+            let b = this.abu;
             if (a != b) {
-                this.aag = a;
-                this.vf("ValueAxisTitleAngle", b, this.abi);
+                this.aas = a;
+                this.vl("ValueAxisTitleAngle", b, this.abu);
             }
         }
-        get zm() {
-            return this.zk;
+        get zy() {
+            return this.zw;
         }
-        set zm(a) {
-            let b = this.zm;
+        set zy(a) {
+            let b = this.zy;
             if (a != b) {
-                this.zk = a;
-                this.vf("AngleAxisInverted", b, this.zm);
+                this.zw = a;
+                this.vl("AngleAxisInverted", b, this.zy);
             }
         }
-        get zn() {
-            return this.zl;
+        get zz() {
+            return this.zx;
         }
-        set zn(a) {
-            let b = this.zn;
+        set zz(a) {
+            let b = this.zz;
             if (a != b) {
-                this.zl = a;
-                this.vf("ValueAxisInverted", b, this.zn);
+                this.zx = a;
+                this.vl("ValueAxisInverted", b, this.zz);
             }
         }
-        get aex() {
-            return this.aeu;
+        get ae9() {
+            return this.ae6;
         }
-        set aex(a) {
-            let b = this.aex;
+        set ae9(a) {
+            let b = this.ae9;
             if (a != b) {
-                this.aeu = a;
-                this.vf("AngleAxisTitleAlignment", enumGetBox(HorizontalAlignment_$type, b), enumGetBox(HorizontalAlignment_$type, this.aex));
+                this.ae6 = a;
+                this.vl("AngleAxisTitleAlignment", enumGetBox(HorizontalAlignment_$type, b), enumGetBox(HorizontalAlignment_$type, this.ae9));
             }
         }
-        get af0() {
-            return this.afx;
+        get agc() {
+            return this.af9;
         }
-        set af0(a) {
-            let b = this.af0;
+        set agc(a) {
+            let b = this.agc;
             if (a != b) {
-                this.afx = a;
-                this.vf("ValueAxisTitleAlignment", enumGetBox(VerticalAlignment_$type, b), enumGetBox(VerticalAlignment_$type, this.af0));
+                this.af9 = a;
+                this.vl("ValueAxisTitleAlignment", enumGetBox(VerticalAlignment_$type, b), enumGetBox(VerticalAlignment_$type, this.agc));
             }
         }
-        get aew() {
-            return this.aet;
+        get ae8() {
+            return this.ae5;
         }
-        set aew(a) {
-            let b = this.aew;
+        set ae8(a) {
+            let b = this.ae8;
             if (a != b) {
-                this.aet = a;
-                this.vf("AngleAxisLabelHorizontalAlignment", enumGetBox(HorizontalAlignment_$type, b), enumGetBox(HorizontalAlignment_$type, this.aew));
+                this.ae5 = a;
+                this.vl("AngleAxisLabelHorizontalAlignment", enumGetBox(HorizontalAlignment_$type, b), enumGetBox(HorizontalAlignment_$type, this.ae8));
             }
         }
-        get_aey() {
-            return this.aev;
+        get_afa() {
+            return this.ae7;
         }
-        set_aey(a) {
-            let b = this.aey;
+        set_afa(a) {
+            let b = this.afa;
             if (a != b) {
-                this.aev = a;
-                this.vf("ValueAxisLabelHorizontalAlignment", enumGetBox(HorizontalAlignment_$type, b), enumGetBox(HorizontalAlignment_$type, this.aey));
+                this.ae7 = a;
+                this.vl("ValueAxisLabelHorizontalAlignment", enumGetBox(HorizontalAlignment_$type, b), enumGetBox(HorizontalAlignment_$type, this.afa));
             }
         }
-        get aey() {
-            return this.get_aey();
+        get afa() {
+            return this.get_afa();
         }
-        set aey(a) {
-            this.set_aey(a);
+        set afa(a) {
+            this.set_afa(a);
         }
-        get afy() {
-            return this.afv;
+        get aga() {
+            return this.af7;
         }
-        set afy(a) {
-            let b = this.afy;
+        set aga(a) {
+            let b = this.aga;
             if (a != b) {
-                this.afv = a;
-                this.vf("AngleAxisLabelVerticalAlignment", enumGetBox(VerticalAlignment_$type, b), enumGetBox(VerticalAlignment_$type, this.afy));
+                this.af7 = a;
+                this.vl("AngleAxisLabelVerticalAlignment", enumGetBox(VerticalAlignment_$type, b), enumGetBox(VerticalAlignment_$type, this.aga));
             }
         }
-        get afz() {
-            return this.afw;
+        get agb() {
+            return this.af8;
         }
-        set afz(a) {
-            let b = this.afz;
+        set agb(a) {
+            let b = this.agb;
             if (a != b) {
-                this.afw = a;
-                this.vf("ValueAxisLabelVerticalAlignment", enumGetBox(VerticalAlignment_$type, b), enumGetBox(VerticalAlignment_$type, this.afz));
+                this.af8 = a;
+                this.vl("ValueAxisLabelVerticalAlignment", enumGetBox(VerticalAlignment_$type, b), enumGetBox(VerticalAlignment_$type, this.agb));
             }
         }
-        get af3() {
-            return this.af1;
+        get agf() {
+            return this.agd;
         }
-        set af3(a) {
-            let b = this.af3;
+        set agf(a) {
+            let b = this.agf;
             if (a != b) {
-                this.af1 = a;
-                this.vf("AngleAxisLabelVisibility", enumGetBox(Visibility_$type, b), enumGetBox(Visibility_$type, this.af3));
+                this.agd = a;
+                this.vl("AngleAxisLabelVisibility", enumGetBox(Visibility_$type, b), enumGetBox(Visibility_$type, this.agf));
             }
         }
-        get af4() {
-            return this.af2;
+        get agg() {
+            return this.age;
         }
-        set af4(a) {
-            let b = this.af4;
+        set agg(a) {
+            let b = this.agg;
             if (a != b) {
-                this.af2 = a;
-                this.vf("ValueAxisLabelVisibility", enumGetBox(Visibility_$type, b), enumGetBox(Visibility_$type, this.af4));
+                this.age = a;
+                this.vl("ValueAxisLabelVisibility", enumGetBox(Visibility_$type, b), enumGetBox(Visibility_$type, this.agg));
             }
         }
-        get_zj() {
-            return this.zi;
+        get_zv() {
+            return this.zu;
         }
-        set_zj(a) {
-            let b = this.zj;
+        set_zv(a) {
+            let b = this.zv;
             if (a != b) {
-                this.zi = a;
-                this.vf("ValueAxisLabelLocation", enumGetBox(ValueAxisLabelLocation_$type, b), enumGetBox(ValueAxisLabelLocation_$type, this.zj));
+                this.zu = a;
+                this.vl("ValueAxisLabelLocation", enumGetBox(ValueAxisLabelLocation_$type, b), enumGetBox(ValueAxisLabelLocation_$type, this.zv));
             }
         }
-        get zj() {
-            return this.get_zj();
+        get zv() {
+            return this.get_zv();
         }
-        set zj(a) {
-            this.set_zj(a);
+        set zv(a) {
+            this.set_zv(a);
         }
-        get_y9() {
-            return this.y8;
+        get_zl() {
+            return this.zk;
         }
-        set_y9(a) {
-            let b = this.y9;
+        set_zl(a) {
+            let b = this.zl;
             if (a != b) {
-                this.y8 = a;
-                this.vf("AngleAxisLabelLocation", enumGetBox(AngleAxisLabelLocation_$type, b), enumGetBox(AngleAxisLabelLocation_$type, this.y9));
+                this.zk = a;
+                this.vl("AngleAxisLabelLocation", enumGetBox(AngleAxisLabelLocation_$type, b), enumGetBox(AngleAxisLabelLocation_$type, this.zl));
             }
         }
-        get y9() {
-            return this.get_y9();
+        get zl() {
+            return this.get_zl();
         }
-        set y9(a) {
-            this.set_y9(a);
+        set zl(a) {
+            this.set_zl(a);
         }
-        get ab7() {
-            return this.abs;
+        get acj() {
+            return this.ab4;
         }
-        set ab7(a) {
-            let b = this.abs;
+        set acj(a) {
+            let b = this.ab4;
             if (a != b) {
-                this.abs = a;
-                this.vf("AngleAxisLabelFormat", b, this.abs);
+                this.ab4 = a;
+                this.vl("AngleAxisLabelFormat", b, this.ab4);
             }
         }
-        get y6() {
-            return this.y4;
+        get zi() {
+            return this.zg;
         }
-        set y6(a) {
-            let b = this.y4;
+        set zi(a) {
+            let b = this.zg;
             if (a != b) {
-                this.y4 = a;
-                this.vf("AngleAxisLabelFormatSpecifiers", b, this.y4);
+                this.zg = a;
+                this.vl("AngleAxisLabelFormatSpecifiers", b, this.zg);
             }
         }
-        get add() {
-            return this.abw;
+        get adp() {
+            return this.ab8;
         }
-        set add(a) {
-            let b = this.abw;
+        set adp(a) {
+            let b = this.ab8;
             if (a != b) {
-                this.abw = a;
-                this.vf("ValueAxisLabelFormat", b, this.abw);
+                this.ab8 = a;
+                this.vl("ValueAxisLabelFormat", b, this.ab8);
             }
         }
-        get y7() {
-            return this.y5;
+        get zj() {
+            return this.zh;
         }
-        set y7(a) {
-            let b = this.y5;
+        set zj(a) {
+            let b = this.zh;
             if (a != b) {
-                this.y5 = a;
-                this.vf("ValueAxisLabelFormatSpecifiers", b, this.y5);
+                this.zh = a;
+                this.vl("ValueAxisLabelFormatSpecifiers", b, this.zh);
             }
         }
     }