igniteui-webcomponents-charts 5.4.0 → 5.5.0-beta.0

package/esm2015/lib/XYChart.js

@@ -23,87 +23,87 @@ export let XYChart = /*@__PURE__*/ (() => {
     class XYChart extends DomainChart {
         constructor() {
             super(...arguments);
-            this.aag = null;
-            this.aah = null;
-            this.aax = 0;
-            this.aaz = 5;
-            this.aay = 0;
-            this.aaw = 5;
-            this.abe = 5;
-            this.abg = 0;
-            this.abf = 5;
-            this.abd = 0;
-            this.af7 = null;
-            this.age = null;
-            this.af5 = null;
-            this.af6 = null;
+            this.aaq = null;
+            this.aar = null;
+            this.aa7 = 0;
+            this.aa9 = 5;
             this.aa8 = 0;
-            this.abp = 0;
-            this.aa7 = NaN;
-            this.abo = NaN;
-            this.aba = NaN;
-            this.abr = NaN;
-            this.aa9 = NaN;
-            this.abq = NaN;
-            this.aa6 = NaN;
-            this.abn = NaN;
-            this.agd = null;
-            this.agk = null;
-            this.acz = null;
-            this.ac3 = null;
-            this.ac1 = null;
-            this.ac5 = null;
-            this.acu = null;
-            this.acv = null;
-            this.af8 = null;
-            this.agf = null;
-            this.aa0 = DeviceUtils.g(1);
-            this.abh = DeviceUtils.g(1);
-            this.aa1 = DeviceUtils.g(1);
-            this.abi = DeviceUtils.g(1);
-            this.aga = null;
+            this.aa6 = 5;
+            this.abo = 5;
+            this.abq = 0;
+            this.abp = 5;
+            this.abn = 0;
             this.agh = null;
-            this.agb = null;
+            this.ago = null;
+            this.agf = null;
+            this.agg = null;
+            this.abi = 0;
+            this.abz = 0;
+            this.abh = NaN;
+            this.aby = NaN;
+            this.abk = NaN;
+            this.ab1 = NaN;
+            this.abj = NaN;
+            this.ab0 = NaN;
+            this.abg = NaN;
+            this.abx = NaN;
+            this.agn = null;
+            this.agu = null;
+            this.ac9 = null;
+            this.add = null;
+            this.adb = null;
+            this.adf = null;
+            this.ac4 = null;
+            this.ac5 = null;
             this.agi = null;
-            this.aa2 = DeviceUtils.g(1);
-            this.abj = DeviceUtils.g(1);
-            this.aa3 = DeviceUtils.g(8);
-            this.abk = 0;
-            this.agc = null;
+            this.agp = null;
+            this.aba = DeviceUtils.g(1);
+            this.abr = DeviceUtils.g(1);
+            this.abb = DeviceUtils.g(1);
+            this.abs = DeviceUtils.g(1);
+            this.agk = null;
+            this.agr = null;
+            this.agl = null;
+            this.ags = null;
+            this.abc = DeviceUtils.g(1);
+            this.abt = DeviceUtils.g(1);
+            this.abd = DeviceUtils.g(8);
+            this.abu = 0;
+            this.agm = null;
+            this.agt = null;
+            this.abe = DeviceUtils.g(1);
+            this.abv = DeviceUtils.g(1);
+            this.ada = null;
+            this.ade = null;
             this.agj = null;
-            this.aa4 = DeviceUtils.g(1);
-            this.abl = DeviceUtils.g(1);
-            this.ac0 = null;
-            this.ac4 = null;
-            this.af9 = null;
-            this.agg = null;
-            this.aav = 0;
-            this.abc = 0;
-            this.aau = NaN;
-            this.abb = NaN;
+            this.agq = null;
             this.aa5 = 0;
-            this.abm = -90;
-            this.aaq = false;
-            this.aar = false;
-            this.af0 = 1;
-            this.ag3 = 1;
-            this.afz = 1;
-            this.af1 = 2;
-            this.ag1 = 0;
-            this.ag2 = 1;
-            this.ag7 = 0;
-            this.ag8 = 0;
-            this.aao = 4;
-            this.aam = 4;
-            this.acy = null;
-            this.aaa = null;
-            this.ac2 = null;
-            this.aab = null;
+            this.abm = 0;
+            this.aa4 = NaN;
+            this.abl = NaN;
+            this.abf = 0;
+            this.abw = -90;
+            this.aa0 = false;
+            this.aa1 = false;
+            this.aga = 1;
+            this.ahd = 1;
+            this.af9 = 1;
+            this.agb = 2;
+            this.ahb = 0;
+            this.ahc = 1;
+            this.ahh = 0;
+            this.ahi = 0;
+            this.aay = 4;
+            this.aaw = 4;
+            this.ac8 = null;
+            this.aak = null;
+            this.adc = null;
+            this.aal = null;
         }
         provideContainer(a) {
             if (a != null) {
-                let b = this.aae();
-                let c = this.aaf();
+                let b = this.aao();
+                let c = this.aap();
                 if (b != null) {
                     b.provideRenderer(a);
                 }
@@ -113,458 +113,458 @@ export let XYChart = /*@__PURE__*/ (() => {
             }
             super.provideContainer(a);
         }
-        vd() {
-            super.vd();
-            let a = this.aae();
-            let b = this.aaf();
+        vm() {
+            super.vm();
+            let a = this.aao();
+            let b = this.aap();
             if (a != null && a.az != null) {
-                this.agn = a.az.textColor;
+                this.agx = a.az.textColor;
             }
             if (b != null && b.az != null) {
-                this.agu = b.az.textColor;
+                this.ag4 = b.az.textColor;
             }
-            this.ags = AxisDefaults.j;
-            this.agz = AxisDefaults.j;
-            this.ago = AxisDefaults.h;
-            this.agv = AxisDefaults.h;
-            this.agr = AxisDefaults.g;
-            this.agy = AxisDefaults.g;
+            this.ag2 = AxisDefaults.j;
+            this.ag9 = AxisDefaults.j;
+            this.agy = AxisDefaults.h;
+            this.ag5 = AxisDefaults.h;
+            this.ag1 = AxisDefaults.g;
+            this.ag8 = AxisDefaults.g;
         }
-        v7(a, b, c) {
-            super.v7(a, b, c);
+        wh(a, b, c) {
+            super.wh(a, b, c);
             switch (a) {
                 case "XAxisLabelLeftMargin":
-                    this.afr((d) => d.leftMargin = this.abz);
+                    this.af1((d) => d.leftMargin = this.ab9);
                     break;
                 case "XAxisLabelTopMargin":
-                    this.afr((d) => d.topMargin = this.ab1);
+                    this.af1((d) => d.topMargin = this.acb);
                     break;
                 case "XAxisLabelRightMargin":
-                    this.afr((d) => d.rightMargin = this.ab0);
+                    this.af1((d) => d.rightMargin = this.aca);
                     break;
                 case "XAxisLabelBottomMargin":
-                    this.afr((d) => d.bottomMargin = this.aby);
+                    this.af1((d) => d.bottomMargin = this.ab8);
                     break;
                 case "YAxisLabelLeftMargin":
-                    this.afw((d) => d.leftMargin = this.acg);
+                    this.af6((d) => d.leftMargin = this.acq);
                     break;
                 case "YAxisLabelTopMargin":
-                    this.afw((d) => d.topMargin = this.aci);
+                    this.af6((d) => d.topMargin = this.acs);
                     break;
                 case "YAxisLabelRightMargin":
-                    this.afw((d) => d.rightMargin = this.ach);
+                    this.af6((d) => d.rightMargin = this.acr);
                     break;
                 case "YAxisLabelBottomMargin":
-                    this.afw((d) => d.bottomMargin = this.acf);
+                    this.af6((d) => d.bottomMargin = this.acp);
                     break;
                 case "ActualItemsSource":
                 case "ShouldDisplayMockData":
                 case "ShouldUseSkeletonStyleForMockData":
-                    this.agl = this.y8(this.agn);
-                    this.agm = this.y8(this.agu);
+                    this.agv = this.zi(this.agx);
+                    this.agw = this.zi(this.ag4);
                     break;
                 case "XAxisLabelTextColor":
-                    this.agl = this.y8(this.agn);
+                    this.agv = this.zi(this.agx);
                     break;
                 case "YAxisLabelTextColor":
-                    this.agm = this.y8(this.agu);
+                    this.agw = this.zi(this.ag4);
                     break;
                 case "ActualXAxisLabelTextColor":
-                    this.afr((d) => d.textColor = this.agl);
+                    this.af1((d) => d.textColor = this.agv);
                     break;
                 case "ActualYAxisLabelTextColor":
-                    this.afw((d) => d.textColor = this.agm);
+                    this.af6((d) => d.textColor = this.agw);
                     break;
                 case "XAxisTitleMargin":
-                    this.aft((d) => d.margin = this.aca);
+                    this.af3((d) => d.margin = this.ack);
                     break;
                 case "YAxisTitleMargin":
-                    this.afy((d) => d.margin = this.acr);
+                    this.af8((d) => d.margin = this.ac1);
                     break;
                 case "XAxisTitleLeftMargin":
-                    this.aft((d) => d.leftMargin = this.ab9);
+                    this.af3((d) => d.leftMargin = this.acj);
                     break;
                 case "YAxisTitleLeftMargin":
-                    this.afy((d) => d.leftMargin = this.acq);
+                    this.af8((d) => d.leftMargin = this.ac0);
                     break;
                 case "XAxisTitleTopMargin":
-                    this.aft((d) => d.topMargin = this.acc);
+                    this.af3((d) => d.topMargin = this.acm);
                     break;
                 case "YAxisTitleTopMargin":
-                    this.afy((d) => d.topMargin = this.act);
+                    this.af8((d) => d.topMargin = this.ac3);
                     break;
                 case "XAxisTitleRightMargin":
-                    this.aft((d) => d.rightMargin = this.acb);
+                    this.af3((d) => d.rightMargin = this.acl);
                     break;
                 case "YAxisTitleRightMargin":
-                    this.afy((d) => d.rightMargin = this.acs);
+                    this.af8((d) => d.rightMargin = this.ac2);
                     break;
                 case "XAxisTitleBottomMargin":
-                    this.aft((d) => d.bottomMargin = this.ab8);
+                    this.af3((d) => d.bottomMargin = this.aci);
                     break;
                 case "YAxisTitleBottomMargin":
-                    this.afy((d) => d.bottomMargin = this.acp);
+                    this.af8((d) => d.bottomMargin = this.acz);
                     break;
                 case "XAxisTitleTextColor":
-                    this.aft((d) => d.textColor = this.agt);
+                    this.af3((d) => d.textColor = this.ag3);
                     break;
                 case "YAxisTitleTextColor":
-                    this.afy((d) => d.textColor = this.ag0);
+                    this.af8((d) => d.textColor = this.aha);
                     break;
                 case "XAxisFormatLabel":
-                    this.afp((d) => d.au = this.aai);
+                    this.afz((d) => d.au = this.aas);
                     break;
                 case "YAxisFormatLabel":
-                    this.afu((d) => d.au = this.aaj);
+                    this.af4((d) => d.au = this.aat);
                     break;
             }
         }
-        get aai() {
-            return this.aag;
+        get aas() {
+            return this.aaq;
         }
-        set aai(a) {
-            let b = this.aai;
+        set aas(a) {
+            let b = this.aas;
             if (a != b) {
-                this.aag = a;
-                this.v3("XAxisFormatLabel", b, this.aai);
+                this.aaq = a;
+                this.wd("XAxisFormatLabel", b, this.aas);
             }
         }
-        get aaj() {
-            return this.aah;
+        get aat() {
+            return this.aar;
         }
-        set aaj(a) {
-            let b = this.aaj;
+        set aat(a) {
+            let b = this.aat;
             if (a != b) {
-                this.aah = a;
-                this.v3("YAxisFormatLabel", b, this.aaj);
+                this.aar = a;
+                this.wd("YAxisFormatLabel", b, this.aat);
             }
         }
-        get abz() {
-            return this.aax;
+        get ab9() {
+            return this.aa7;
         }
-        set abz(a) {
-            let b = this.abz;
+        set ab9(a) {
+            let b = this.ab9;
             if (a != b) {
-                this.aax = a;
-                this.v3("XAxisLabelLeftMargin", b, this.abz);
+                this.aa7 = a;
+                this.wd("XAxisLabelLeftMargin", b, this.ab9);
             }
         }
-        get ab1() {
-            return this.aaz;
+        get acb() {
+            return this.aa9;
         }
-        set ab1(a) {
-            let b = this.ab1;
+        set acb(a) {
+            let b = this.acb;
             if (a != b) {
-                this.aaz = a;
-                this.v3("XAxisLabelTopMargin", b, this.ab1);
+                this.aa9 = a;
+                this.wd("XAxisLabelTopMargin", b, this.acb);
             }
         }
-        get ab0() {
-            return this.aay;
+        get aca() {
+            return this.aa8;
         }
-        set ab0(a) {
-            let b = this.ab0;
+        set aca(a) {
+            let b = this.aca;
             if (a != b) {
-                this.aay = a;
-                this.v3("XAxisLabelRightMargin", b, this.ab0);
+                this.aa8 = a;
+                this.wd("XAxisLabelRightMargin", b, this.aca);
             }
         }
-        get aby() {
-            return this.aaw;
+        get ab8() {
+            return this.aa6;
         }
-        set aby(a) {
-            let b = this.aby;
+        set ab8(a) {
+            let b = this.ab8;
             if (a != b) {
-                this.aaw = a;
-                this.v3("XAxisLabelBottomMargin", b, this.aby);
+                this.aa6 = a;
+                this.wd("XAxisLabelBottomMargin", b, this.ab8);
             }
         }
-        get acg() {
-            return this.abe;
+        get acq() {
+            return this.abo;
         }
-        set acg(a) {
-            let b = this.acg;
+        set acq(a) {
+            let b = this.acq;
             if (a != b) {
-                this.abe = a;
-                this.v3("YAxisLabelLeftMargin", b, this.acg);
+                this.abo = a;
+                this.wd("YAxisLabelLeftMargin", b, this.acq);
             }
         }
-        get aci() {
-            return this.abg;
+        get acs() {
+            return this.abq;
         }
-        set aci(a) {
-            let b = this.aci;
+        set acs(a) {
+            let b = this.acs;
             if (a != b) {
-                this.abg = a;
-                this.v3("YAxisLabelTopMargin", b, this.aci);
+                this.abq = a;
+                this.wd("YAxisLabelTopMargin", b, this.acs);
             }
         }
-        get ach() {
-            return this.abf;
+        get acr() {
+            return this.abp;
         }
-        set ach(a) {
-            let b = this.ach;
+        set acr(a) {
+            let b = this.acr;
             if (a != b) {
-                this.abf = a;
-                this.v3("YAxisLabelRightMargin", b, this.ach);
+                this.abp = a;
+                this.wd("YAxisLabelRightMargin", b, this.acr);
             }
         }
-        get acf() {
-            return this.abd;
+        get acp() {
+            return this.abn;
         }
-        set acf(a) {
-            let b = this.acf;
+        set acp(a) {
+            let b = this.acp;
             if (a != b) {
-                this.abd = a;
-                this.v3("YAxisLabelBottomMargin", b, this.acf);
+                this.abn = a;
+                this.wd("YAxisLabelBottomMargin", b, this.acp);
             }
         }
-        get agn() {
-            return this.af7;
+        get agx() {
+            return this.agh;
         }
-        set agn(a) {
-            let b = this.agn;
+        set agx(a) {
+            let b = this.agx;
             if (a != b) {
-                this.af7 = a;
-                this.v3("XAxisLabelTextColor", b, this.agn);
+                this.agh = a;
+                this.wd("XAxisLabelTextColor", b, this.agx);
             }
         }
-        get agu() {
-            return this.age;
+        get ag4() {
+            return this.ago;
         }
-        set agu(a) {
-            let b = this.agu;
+        set ag4(a) {
+            let b = this.ag4;
             if (a != b) {
-                this.age = a;
-                this.v3("YAxisLabelTextColor", b, this.agu);
+                this.ago = a;
+                this.wd("YAxisLabelTextColor", b, this.ag4);
             }
         }
-        get agl() {
-            return this.af5;
+        get agv() {
+            return this.agf;
         }
-        set agl(a) {
-            let b = this.af5;
+        set agv(a) {
+            let b = this.agf;
             if (a != b) {
-                this.af5 = a;
-                this.v3("ActualXAxisLabelTextColor", b, this.agl);
+                this.agf = a;
+                this.wd("ActualXAxisLabelTextColor", b, this.agv);
             }
         }
-        get agm() {
-            return this.af6;
+        get agw() {
+            return this.agg;
         }
-        set agm(a) {
-            let b = this.af6;
+        set agw(a) {
+            let b = this.agg;
             if (a != b) {
-                this.af6 = a;
-                this.v3("ActualYAxisLabelTextColor", b, this.agm);
+                this.agg = a;
+                this.wd("ActualYAxisLabelTextColor", b, this.agw);
             }
         }
-        get aca() {
-            return this.aa8;
+        get ack() {
+            return this.abi;
         }
-        set aca(a) {
-            let b = this.aca;
+        set ack(a) {
+            let b = this.ack;
             if (a != b) {
-                this.aa8 = a;
-                this.v3("XAxisTitleMargin", b, this.aca);
+                this.abi = a;
+                this.wd("XAxisTitleMargin", b, this.ack);
             }
         }
-        get acr() {
-            return this.abp;
+        get ac1() {
+            return this.abz;
         }
-        set acr(a) {
-            let b = this.acr;
+        set ac1(a) {
+            let b = this.ac1;
             if (a != b) {
-                this.abp = a;
-                this.v3("YAxisTitleMargin", b, this.acr);
+                this.abz = a;
+                this.wd("YAxisTitleMargin", b, this.ac1);
             }
         }
-        get ab9() {
-            return this.aa7;
+        get acj() {
+            return this.abh;
         }
-        set ab9(a) {
-            let b = this.ab9;
+        set acj(a) {
+            let b = this.acj;
             if (a != b) {
-                this.aa7 = a;
-                this.v3("XAxisTitleLeftMargin", b, this.ab9);
+                this.abh = a;
+                this.wd("XAxisTitleLeftMargin", b, this.acj);
             }
         }
-        get acq() {
-            return this.abo;
+        get ac0() {
+            return this.aby;
         }
-        set acq(a) {
-            let b = this.acq;
+        set ac0(a) {
+            let b = this.ac0;
             if (a != b) {
-                this.abo = a;
-                this.v3("YAxisTitleLeftMargin", b, this.acq);
+                this.aby = a;
+                this.wd("YAxisTitleLeftMargin", b, this.ac0);
             }
         }
-        get acc() {
-            return this.aba;
+        get acm() {
+            return this.abk;
         }
-        set acc(a) {
-            let b = this.acc;
+        set acm(a) {
+            let b = this.acm;
             if (a != b) {
-                this.aba = a;
-                this.v3("XAxisTitleTopMargin", b, this.acc);
+                this.abk = a;
+                this.wd("XAxisTitleTopMargin", b, this.acm);
             }
         }
-        get act() {
-            return this.abr;
+        get ac3() {
+            return this.ab1;
         }
-        set act(a) {
-            let b = this.act;
+        set ac3(a) {
+            let b = this.ac3;
             if (a != b) {
-                this.abr = a;
-                this.v3("YAxisTitleTopMargin", b, this.act);
+                this.ab1 = a;
+                this.wd("YAxisTitleTopMargin", b, this.ac3);
             }
         }
-        get acb() {
-            return this.aa9;
+        get acl() {
+            return this.abj;
         }
-        set acb(a) {
-            let b = this.acb;
+        set acl(a) {
+            let b = this.acl;
             if (a != b) {
-                this.aa9 = a;
-                this.v3("XAxisTitleRightMargin", b, this.acb);
+                this.abj = a;
+                this.wd("XAxisTitleRightMargin", b, this.acl);
             }
         }
-        get acs() {
-            return this.abq;
+        get ac2() {
+            return this.ab0;
         }
-        set acs(a) {
-            let b = this.acs;
+        set ac2(a) {
+            let b = this.ac2;
             if (a != b) {
-                this.abq = a;
-                this.v3("YAxisTitleRightMargin", b, this.acs);
+                this.ab0 = a;
+                this.wd("YAxisTitleRightMargin", b, this.ac2);
             }
         }
-        get ab8() {
-            return this.aa6;
+        get aci() {
+            return this.abg;
         }
-        set ab8(a) {
-            let b = this.ab8;
+        set aci(a) {
+            let b = this.aci;
             if (a != b) {
-                this.aa6 = a;
-                this.v3("XAxisTitleBottomMargin", b, this.ab8);
+                this.abg = a;
+                this.wd("XAxisTitleBottomMargin", b, this.aci);
             }
         }
-        get acp() {
-            return this.abn;
+        get acz() {
+            return this.abx;
         }
-        set acp(a) {
-            let b = this.acp;
+        set acz(a) {
+            let b = this.acz;
             if (a != b) {
-                this.abn = a;
-                this.v3("YAxisTitleBottomMargin", b, this.acp);
+                this.abx = a;
+                this.wd("YAxisTitleBottomMargin", b, this.acz);
             }
         }
-        get agt() {
-            return this.agd;
+        get ag3() {
+            return this.agn;
         }
-        set agt(a) {
-            let b = this.agt;
+        set ag3(a) {
+            let b = this.ag3;
             if (a != b) {
-                this.agd = a;
-                this.v3("XAxisTitleTextColor", b, this.agt);
+                this.agn = a;
+                this.wd("XAxisTitleTextColor", b, this.ag3);
             }
         }
-        get ag0() {
-            return this.agk;
+        get aha() {
+            return this.agu;
         }
-        set ag0(a) {
-            let b = this.ag0;
+        set aha(a) {
+            let b = this.aha;
             if (a != b) {
-                this.agk = a;
-                this.v3("YAxisTitleTextColor", b, this.ag0);
+                this.agu = a;
+                this.wd("YAxisTitleTextColor", b, this.aha);
             }
         }
-        v8(a, b, c) {
-            super.v8(a, b, c);
+        wi(a, b, c) {
+            super.wi(a, b, c);
             switch (a) {
                 case "XAxisLabelTextStyle":
-                    this.afr((d) => d.textStyle = this.adn);
+                    this.af1((d) => d.textStyle = this.adx);
                     break;
                 case "YAxisLabelTextStyle":
-                    this.afw((d) => d.textStyle = this.aes);
+                    this.af6((d) => d.textStyle = this.ae2);
                     break;
                 case "XAxisTitleTextStyle":
-                    this.aft((d) => d.textStyle = this.aeb);
+                    this.af3((d) => d.textStyle = this.ael);
                     break;
                 case "YAxisTitleTextStyle":
-                    this.afy((d) => d.textStyle = this.afg);
+                    this.af8((d) => d.textStyle = this.afq);
                     break;
             }
         }
-        get adn() {
-            return this.acz;
+        get adx() {
+            return this.ac9;
         }
-        set adn(a) {
-            let b = this.adn;
+        set adx(a) {
+            let b = this.adx;
             if (a != b) {
-                this.acz = a;
-                this.v3("XAxisLabelTextStyle", b, this.adn);
+                this.ac9 = a;
+                this.wd("XAxisLabelTextStyle", b, this.adx);
             }
         }
-        get aes() {
-            return this.ac3;
+        get ae2() {
+            return this.add;
         }
-        set aes(a) {
-            let b = this.aes;
+        set ae2(a) {
+            let b = this.ae2;
             if (a != b) {
-                this.ac3 = a;
-                this.v3("YAxisLabelTextStyle", b, this.aes);
+                this.add = a;
+                this.wd("YAxisLabelTextStyle", b, this.ae2);
             }
         }
-        get aeb() {
-            return this.ac1;
+        get ael() {
+            return this.adb;
         }
-        set aeb(a) {
-            let b = this.aeb;
+        set ael(a) {
+            let b = this.ael;
             if (a != b) {
-                this.ac1 = a;
-                this.v3("XAxisTitleTextStyle", b, this.aeb);
+                this.adb = a;
+                this.wd("XAxisTitleTextStyle", b, this.ael);
             }
         }
-        get afg() {
-            return this.ac5;
+        get afq() {
+            return this.adf;
         }
-        set afg(a) {
-            let b = this.afg;
+        set afq(a) {
+            let b = this.afq;
             if (a != b) {
-                this.ac5 = a;
-                this.v3("YAxisTitleTextStyle", b, this.afg);
-            }
-        }
-        afm(a) {
-            this.afj(a, (b) => b.leftMargin = this.abz);
-            this.afj(a, (b) => b.topMargin = this.ab1);
-            this.afj(a, (b) => b.rightMargin = this.ab0);
-            this.afj(a, (b) => b.bottomMargin = this.aby);
-            this.afj(a, (b) => b.textColor = this.agl);
-            this.afk(a, (b) => b.textColor = this.agt);
-            this.afk(a, (b) => b.leftMargin = this.ab9);
-            this.afk(a, (b) => b.topMargin = this.acc);
-            this.afk(a, (b) => b.rightMargin = this.acb);
-            this.afk(a, (b) => b.bottomMargin = this.ab8);
-            this.afj(a, (b) => b.textStyle = this.adn);
-            this.afk(a, (b) => b.textStyle = this.aeb);
-        }
-        afo(a) {
-            this.afj(a, (b) => b.leftMargin = this.acg);
-            this.afj(a, (b) => b.topMargin = this.aci);
-            this.afj(a, (b) => b.rightMargin = this.ach);
-            this.afj(a, (b) => b.bottomMargin = this.acf);
-            this.afj(a, (b) => b.textColor = this.agm);
-            this.afk(a, (b) => b.textColor = this.ag0);
-            this.afk(a, (b) => b.leftMargin = this.acq);
-            this.afk(a, (b) => b.topMargin = this.act);
-            this.afk(a, (b) => b.rightMargin = this.acs);
-            this.afk(a, (b) => b.bottomMargin = this.acp);
-            this.afj(a, (b) => b.textStyle = this.aes);
-            this.afk(a, (b) => b.textStyle = this.afg);
-        }
-        wz(a) {
+                this.adf = a;
+                this.wd("YAxisTitleTextStyle", b, this.afq);
+            }
+        }
+        afw(a) {
+            this.aft(a, (b) => b.leftMargin = this.ab9);
+            this.aft(a, (b) => b.topMargin = this.acb);
+            this.aft(a, (b) => b.rightMargin = this.aca);
+            this.aft(a, (b) => b.bottomMargin = this.ab8);
+            this.aft(a, (b) => b.textColor = this.agv);
+            this.afu(a, (b) => b.textColor = this.ag3);
+            this.afu(a, (b) => b.leftMargin = this.acj);
+            this.afu(a, (b) => b.topMargin = this.acm);
+            this.afu(a, (b) => b.rightMargin = this.acl);
+            this.afu(a, (b) => b.bottomMargin = this.aci);
+            this.aft(a, (b) => b.textStyle = this.adx);
+            this.afu(a, (b) => b.textStyle = this.ael);
+        }
+        afy(a) {
+            this.aft(a, (b) => b.leftMargin = this.acq);
+            this.aft(a, (b) => b.topMargin = this.acs);
+            this.aft(a, (b) => b.rightMargin = this.acr);
+            this.aft(a, (b) => b.bottomMargin = this.acp);
+            this.aft(a, (b) => b.textColor = this.agw);
+            this.afu(a, (b) => b.textColor = this.aha);
+            this.afu(a, (b) => b.leftMargin = this.ac0);
+            this.afu(a, (b) => b.topMargin = this.ac3);
+            this.afu(a, (b) => b.rightMargin = this.ac2);
+            this.afu(a, (b) => b.bottomMargin = this.acz);
+            this.aft(a, (b) => b.textStyle = this.ae2);
+            this.afu(a, (b) => b.textStyle = this.afq);
+        }
+        w9(a) {
             let b = this.be(a);
             let c = this.dc(a, b);
             if (c == null) {
@@ -574,62 +574,62 @@ export let XYChart = /*@__PURE__*/ (() => {
             if (a.highlightedData != null) {
                 c.highlightedItemsSource = this.h7(a);
             }
-            c.name = this.qt(a);
-            c.title = this.qu(a, b);
+            c.name = this.q0(a);
+            c.title = this.q1(a, b);
             this.dataChart.series.add(c);
         }
-        afp(a) {
-            this.afq(a, null);
+        afz(a) {
+            this.af0(a, null);
         }
-        afq(a, b) {
-            a(this.aae());
+        af0(a, b) {
+            a(this.aao());
         }
-        afv(a, b) {
-            a(this.aaf());
+        af5(a, b) {
+            a(this.aap());
         }
-        afu(a) {
-            this.afv(a, true);
+        af4(a) {
+            this.af5(a, true);
         }
-        uw(a, b) {
-            this.afp(a);
-            this.afv(a, b);
+        u5(a, b) {
+            this.afz(a);
+            this.af5(a, b);
         }
-        aft(a) {
-            this.afk(this.aae(), a);
+        af3(a) {
+            this.afu(this.aao(), a);
         }
-        afy(a) {
-            this.afk(this.aaf(), a);
+        af8(a) {
+            this.afu(this.aap(), a);
         }
-        afw(a) {
-            this.afj(this.aaf(), a);
+        af6(a) {
+            this.aft(this.aap(), a);
         }
-        afr(a) {
-            this.afj(this.aae(), a);
+        af1(a) {
+            this.aft(this.aao(), a);
         }
-        abs(a) {
-            let b = this.aae();
-            return b.el(a, new ScalerParams(1, this.zh, this.zg, b.ch));
+        ab2(a) {
+            let b = this.aao();
+            return b.el(a, new ScalerParams(1, this.zr, this.zq, b.ch));
         }
-        abu(a) {
-            let b = this.aae();
-            return b.eo(a, new ScalerParams(1, this.zh, this.zg, b.ch));
+        ab4(a) {
+            let b = this.aao();
+            return b.eo(a, new ScalerParams(1, this.zr, this.zq, b.ch));
         }
-        abt(a) {
-            let b = this.aaf();
-            return b.el(a, new ScalerParams(1, this.zh, this.zg, b.ch));
+        ab3(a) {
+            let b = this.aap();
+            return b.el(a, new ScalerParams(1, this.zr, this.zq, b.ch));
         }
-        abv(a) {
-            let b = this.aaf();
-            return b.eo(a, new ScalerParams(1, this.zh, this.zg, b.ch));
+        ab5(a) {
+            let b = this.aap();
+            return b.eo(a, new ScalerParams(1, this.zr, this.zq, b.ch));
         }
-        ww(a) {
-            super.ww(a);
+        w6(a) {
+            super.w6(a);
             if (a == null) {
                 return;
             }
             if (a.axes != null) {
-                let b = this.aae();
-                let c = this.aaf();
+                let b = this.aao();
+                let c = this.aap();
                 if (a.axes.contains(b)) {
                     a.axes.remove(b);
                 }
@@ -638,7 +638,7 @@ export let XYChart = /*@__PURE__*/ (() => {
                 }
             }
         }
-        static ac8(a, b) {
+        static adi(a, b) {
             for (let c of fromEnum(b)) {
                 let d = c.findMatchingHint(16);
                 if (d != null) {
@@ -648,96 +648,96 @@ export let XYChart = /*@__PURE__*/ (() => {
             }
             return null;
         }
-        u8(a, b) {
-            super.u8(a, b);
+        vh(a, b) {
+            super.vh(a, b);
             if (a == this.dataChart) {
-                this.dataChart.axes.add(this.aae());
-                this.dataChart.axes.add(this.aaf());
-            }
-        }
-        afl(a) {
-            if (a != null && this.ly != null && a.fn == null) {
-                a.provideRenderer(this.ly);
-            }
-            a.jz = this.ago;
-            a.et = this.ab2;
-            a.j0 = this.agp;
-            a.ew = this.ab3;
-            a.j2 = this.agr;
-            a.fi = this.ab4;
-            a.j1 = this.agq;
-            a.fj = this.ab5;
-            a.j3 = this.ags;
-            a.fk = this.ab6;
+                this.dataChart.axes.add(this.aao());
+                this.dataChart.axes.add(this.aap());
+            }
+        }
+        afv(a) {
+            if (a != null && this.l4 != null && a.fn == null) {
+                a.provideRenderer(this.l4);
+            }
+            a.jz = this.agy;
+            a.et = this.acc;
+            a.j0 = this.agz;
+            a.ew = this.acd;
+            a.j2 = this.ag1;
+            a.fi = this.ace;
+            a.j1 = this.ag0;
+            a.fj = this.acf;
+            a.j3 = this.ag2;
+            a.fk = this.acg;
             a.c4 = true;
             a.cu = this.shouldAvoidAxisAnnotationCollisions;
             a.cw = this.shouldAvoidAxisAnnotationCollisions;
-            let b = a == this.aae();
+            let b = a == this.aao();
             if (b) {
-                a.g8 = this.ad2;
-            }
-            a.f2 = this.acw;
-            a.gi = this.ade;
-            a.ah = this.aac;
-            this.afj(a, (c) => c.angle = this.abx);
-            this.afj(a, (c) => {
-                if (c.extent != this.abw) {
-                    c.extent = this.abw;
+                a.g8 = this.aec;
+            }
+            a.f2 = this.ac6;
+            a.gi = this.ado;
+            a.ah = this.aam;
+            this.aft(a, (c) => c.angle = this.ab7);
+            this.aft(a, (c) => {
+                if (c.extent != this.ab6) {
+                    c.extent = this.ab6;
                 }
             });
-            this.afj(a, (c) => c.horizontalAlignment = this.af2);
-            this.afj(a, (c) => c.verticalAlignment = this.ag4);
-            this.afj(a, (c) => c.visibility = this.ag9);
-            this.afj(a, (c) => c.location = this.aak(this.aan));
-            this.afk(a, (c) => c.horizontalAlignment = this.af3);
-            this.afk(a, (c) => c.angle = this.ab7);
-            this.afm(a);
-        }
-        afn(a) {
+            this.aft(a, (c) => c.horizontalAlignment = this.agc);
+            this.aft(a, (c) => c.verticalAlignment = this.ahe);
+            this.aft(a, (c) => c.visibility = this.ahj);
+            this.aft(a, (c) => c.location = this.aau(this.aax));
+            this.afu(a, (c) => c.horizontalAlignment = this.agd);
+            this.afu(a, (c) => c.angle = this.ach);
+            this.afw(a);
+        }
+        afx(a) {
             if (a == null) {
                 return;
             }
-            if (this.ly != null && a.fn == null) {
-                a.provideRenderer(this.ly);
+            if (this.l4 != null && a.fn == null) {
+                a.provideRenderer(this.l4);
             }
             a.cu = this.shouldAvoidAxisAnnotationCollisions;
             a.cw = this.shouldAvoidAxisAnnotationCollisions;
-            this.afj(a, (b) => b.angle = this.ace);
-            this.afj(a, (b) => {
-                if (b.extent != this.acd) {
-                    b.extent = this.acd;
+            this.aft(a, (b) => b.angle = this.aco);
+            this.aft(a, (b) => {
+                if (b.extent != this.acn) {
+                    b.extent = this.acn;
                 }
             });
-            this.afj(a, (b) => b.horizontalAlignment = this.af4);
-            this.afj(a, (b) => b.verticalAlignment = this.ag5);
-            this.afj(a, (b) => b.visibility = this.aha);
-            this.afj(a, (b) => b.location = this.aal(this.aap));
-            this.afk(a, (b) => b.verticalAlignment = this.ag6);
-            this.afk(a, (b) => b.angle = this.aco);
-            a.jz = this.agv;
-            a.et = this.acj;
-            a.j0 = this.agw;
-            a.ew = this.ack;
-            a.j2 = this.agy;
-            a.fi = this.acl;
-            a.j1 = this.agx;
-            a.fj = this.acm;
-            a.j3 = this.agz;
-            a.fk = this.acn;
-            let b = a == this.aaf();
+            this.aft(a, (b) => b.horizontalAlignment = this.age);
+            this.aft(a, (b) => b.verticalAlignment = this.ahf);
+            this.aft(a, (b) => b.visibility = this.ahk);
+            this.aft(a, (b) => b.location = this.aav(this.aaz));
+            this.afu(a, (b) => b.verticalAlignment = this.ahg);
+            this.afu(a, (b) => b.angle = this.acy);
+            a.jz = this.ag5;
+            a.et = this.act;
+            a.j0 = this.ag6;
+            a.ew = this.acu;
+            a.j2 = this.ag8;
+            a.fi = this.acv;
+            a.j1 = this.ag7;
+            a.fj = this.acw;
+            a.j3 = this.ag9;
+            a.fk = this.acx;
+            let b = a == this.aap();
             if (b) {
-                a.g8 = this.ae7;
+                a.g8 = this.afh;
             }
-            a.gi = this.aej;
-            a.ah = this.aad;
-            this.afo(a);
+            a.gi = this.aet;
+            a.ah = this.aan;
+            this.afy(a);
         }
-        u5() {
-            super.u5();
-            this.afl(this.aae());
-            this.afn(this.aaf());
+        ve() {
+            super.ve();
+            this.afv(this.aao());
+            this.afx(this.aap());
         }
-        afj(a, b) {
+        aft(a, b) {
             if (a == null) {
                 return;
             }
@@ -754,7 +754,7 @@ export let XYChart = /*@__PURE__*/ (() => {
             }
             b(a.az);
         }
-        afk(a, b) {
+        afu(a, b) {
             if (a == null) {
                 return;
             }
@@ -771,170 +771,170 @@ export let XYChart = /*@__PURE__*/ (() => {
             }
             b(a.bf);
         }
-        v3(a, b, c) {
-            super.v3(a, b, c);
+        wd(a, b, c) {
+            super.wd(a, b, c);
             switch (a) {
                 case "XAxisLabelAngle":
-                    this.afr((d) => d.angle = this.abx);
+                    this.af1((d) => d.angle = this.ab7);
                     break;
                 case "YAxisLabelAngle":
-                    this.afw((d) => d.angle = this.ace);
+                    this.af6((d) => d.angle = this.aco);
                     break;
                 case "XAxisLabelHorizontalAlignment":
-                    this.afr((d) => d.horizontalAlignment = this.af2);
+                    this.af1((d) => d.horizontalAlignment = this.agc);
                     break;
                 case "YAxisLabelHorizontalAlignment":
-                    this.afw((d) => d.horizontalAlignment = this.af4);
+                    this.af6((d) => d.horizontalAlignment = this.age);
                     break;
                 case "XAxisLabelVerticalAlignment":
-                    this.afr((d) => d.verticalAlignment = this.ag4);
+                    this.af1((d) => d.verticalAlignment = this.ahe);
                     break;
                 case "YAxisLabelVerticalAlignment":
-                    this.afw((d) => d.verticalAlignment = this.ag5);
+                    this.af6((d) => d.verticalAlignment = this.ahf);
                     break;
                 case "XAxisLabelVisibility":
-                    this.afr((d) => d.visibility = this.ag9);
+                    this.af1((d) => d.visibility = this.ahj);
                     break;
                 case "YAxisLabelVisibility":
-                    this.afw((d) => d.visibility = this.aha);
+                    this.af6((d) => d.visibility = this.ahk);
                     break;
                 case "XAxisLabel":
-                    this.afp((d) => d.f2 = this.acw);
+                    this.afz((d) => d.f2 = this.ac6);
                     break;
                 case "YAxisLabel":
-                    this.afu((d) => d.f2 = this.acx);
+                    this.af4((d) => d.f2 = this.ac7);
                     break;
                 case "XAxisLabelFormat":
-                    this.afp((d) => d.gi = this.ade);
+                    this.afz((d) => d.gi = this.ado);
                     break;
                 case "XAxisLabelFormatSpecifiers":
-                    this.afp((d) => d.ah = this.aac);
+                    this.afz((d) => d.ah = this.aam);
                     break;
                 case "YAxisLabelFormat":
-                    this.afu((d) => d.gi = this.aej);
+                    this.af4((d) => d.gi = this.aet);
                     break;
                 case "YAxisLabelFormatSpecifiers":
-                    this.afu((d) => d.ah = this.aad);
+                    this.af4((d) => d.ah = this.aan);
                     break;
                 case "XAxisTitleAngle":
-                    this.aft((d) => d.angle = this.ab7);
+                    this.af3((d) => d.angle = this.ach);
                     break;
                 case "YAxisTitleAngle":
-                    this.afy((d) => d.angle = this.aco);
+                    this.af8((d) => d.angle = this.acy);
                     break;
                 case "XAxisTitleAlignment":
-                    this.aft((d) => d.horizontalAlignment = this.af3);
+                    this.af3((d) => d.horizontalAlignment = this.agd);
                     break;
                 case "YAxisTitleAlignment":
-                    this.afy((d) => d.verticalAlignment = this.ag6);
+                    this.af8((d) => d.verticalAlignment = this.ahg);
                     break;
                 case "XAxisTitle":
-                    this.afp((d) => d.g8 = this.ad2);
+                    this.afz((d) => d.g8 = this.aec);
                     break;
                 case "YAxisTitle":
-                    this.afv((d) => d.g8 = this.ae7, false);
+                    this.af5((d) => d.g8 = this.afh, false);
                     break;
                 case "XAxisMajorStroke":
-                    this.afq((d) => d.jz = this.ago, a);
+                    this.af0((d) => d.jz = this.agy, a);
                     break;
                 case "YAxisMajorStroke":
-                    this.afu((d) => d.jz = this.agv);
+                    this.af4((d) => d.jz = this.ag5);
                     break;
                 case "XAxisMajorStrokeThickness":
-                    this.afq((d) => d.et = this.ab2, a);
+                    this.af0((d) => d.et = this.acc, a);
                     break;
                 case "YAxisMajorStrokeThickness":
-                    this.afu((d) => d.et = this.acj);
+                    this.af4((d) => d.et = this.act);
                     break;
                 case "XAxisMinorStroke":
-                    this.afp((d) => d.j0 = this.agp);
+                    this.afz((d) => d.j0 = this.agz);
                     break;
                 case "YAxisMinorStroke":
-                    this.afu((d) => d.j0 = this.agw);
+                    this.af4((d) => d.j0 = this.ag6);
                     break;
                 case "XAxisMinorStrokeThickness":
-                    this.afp((d) => d.ew = this.ab3);
+                    this.afz((d) => d.ew = this.acd);
                     break;
                 case "YAxisMinorStrokeThickness":
-                    this.afu((d) => d.ew = this.ack);
+                    this.af4((d) => d.ew = this.acu);
                     break;
                 case "XAxisTickLength":
-                    this.afp((d) => d.fj = this.ab5);
+                    this.afz((d) => d.fj = this.acf);
                     break;
                 case "YAxisTickLength":
-                    this.afu((d) => d.fj = this.acm);
+                    this.af4((d) => d.fj = this.acw);
                     break;
                 case "XAxisTickStroke":
-                    this.afp((d) => d.j3 = this.ags);
+                    this.afz((d) => d.j3 = this.ag2);
                     break;
                 case "YAxisTickStroke":
-                    this.afu((d) => d.j3 = this.agz);
+                    this.af4((d) => d.j3 = this.ag9);
                     break;
                 case "XAxisTickStrokeThickness":
-                    this.afp((d) => d.fk = this.ab6);
+                    this.afz((d) => d.fk = this.acg);
                     break;
                 case "YAxisTickStrokeThickness":
-                    this.afu((d) => d.fk = this.acn);
+                    this.af4((d) => d.fk = this.acx);
                     break;
                 case "XAxisStroke":
-                    this.afp((d) => d.j2 = this.agr);
+                    this.afz((d) => d.j2 = this.ag1);
                     break;
                 case "YAxisStroke":
-                    this.afu((d) => d.j2 = this.agy);
+                    this.af4((d) => d.j2 = this.ag8);
                     break;
                 case "XAxisStrokeThickness":
-                    this.afp((d) => d.fi = this.ab4);
+                    this.afz((d) => d.fi = this.ace);
                     break;
                 case "YAxisStrokeThickness":
-                    this.afu((d) => d.fi = this.acl);
+                    this.af4((d) => d.fi = this.acv);
                     break;
                 case "XAxisExtent":
-                    this.afr((d) => d.extent = this.abw);
+                    this.af1((d) => d.extent = this.ab6);
                     break;
                 case "YAxisExtent":
-                    this.afw((d) => d.extent = this.acd);
+                    this.af6((d) => d.extent = this.acn);
                     break;
                 case "XAxisStrip":
-                    this.afp((d) => d.j1 = this.agq);
+                    this.afz((d) => d.j1 = this.ag0);
                     break;
                 case "YAxisStrip":
-                    this.afu((d) => d.j1 = this.agx);
+                    this.af4((d) => d.j1 = this.ag7);
                     break;
                 case "XAxisInverted":
-                    this.afp((d) => d.ch = this.aas);
+                    this.afz((d) => d.ch = this.aa2);
                     break;
                 case "YAxisInverted":
-                    this.afu((d) => d.ch = this.aat);
+                    this.af4((d) => d.ch = this.aa3);
                     break;
                 case "YAxisLabelLocation":
-                    this.afx();
+                    this.af7();
                     break;
                 case "XAxisLabelLocation":
-                    this.afs();
+                    this.af2();
                     break;
             }
         }
-        afx() {
-            let a = this.aal(this.aap);
+        af7() {
+            let a = this.aav(this.aaz);
             if (a == 2 || a == 7) {
-                this.af4 = 2;
+                this.age = 2;
             }
             else {
-                this.af4 = 0;
+                this.age = 0;
             }
-            this.afw((b) => b.location = a);
+            this.af6((b) => b.location = a);
         }
-        afs() {
-            let a = this.aak(this.aan);
+        af2() {
+            let a = this.aau(this.aax);
             if (a == 1 || a == 5) {
-                this.ag4 = 0;
+                this.ahe = 0;
             }
             else {
-                this.ag4 = 2;
+                this.ahe = 2;
             }
-            this.afr((b) => b.location = a);
+            this.af1((b) => b.location = a);
         }
-        aal(a) {
+        aav(a) {
             if (a == 0) {
                 return 2;
             }
@@ -956,7 +956,7 @@ export let XYChart = /*@__PURE__*/ (() => {
                 }
             }
         }
-        aak(a) {
+        aau(a) {
             if (a == 1) {
                 return 1;
             }
@@ -973,482 +973,482 @@ export let XYChart = /*@__PURE__*/ (() => {
                 return 1;
             }
         }
-        get acw() {
-            return this.acu;
+        get ac6() {
+            return this.ac4;
         }
-        set acw(a) {
-            let b = this.acw;
+        set ac6(a) {
+            let b = this.ac6;
             if (a != b) {
-                this.acu = a;
-                this.v3("XAxisLabel", b, this.acw);
+                this.ac4 = a;
+                this.wd("XAxisLabel", b, this.ac6);
             }
         }
-        get acx() {
-            return this.acv;
+        get ac7() {
+            return this.ac5;
         }
-        set acx(a) {
-            let b = this.acx;
+        set ac7(a) {
+            let b = this.ac7;
             if (a != b) {
-                this.acv = a;
-                this.v3("YAxisLabel", b, this.acx);
+                this.ac5 = a;
+                this.wd("YAxisLabel", b, this.ac7);
             }
         }
-        get ago() {
-            return this.af8;
+        get agy() {
+            return this.agi;
         }
-        set ago(a) {
-            let b = this.ago;
+        set agy(a) {
+            let b = this.agy;
             if (a != b) {
-                this.af8 = a;
-                this.v3("XAxisMajorStroke", b, this.ago);
+                this.agi = a;
+                this.wd("XAxisMajorStroke", b, this.agy);
             }
         }
-        get agv() {
-            return this.agf;
+        get ag5() {
+            return this.agp;
         }
-        set agv(a) {
-            let b = this.agv;
+        set ag5(a) {
+            let b = this.ag5;
             if (a != b) {
-                this.agf = a;
-                this.v3("YAxisMajorStroke", b, this.agv);
+                this.agp = a;
+                this.wd("YAxisMajorStroke", b, this.ag5);
             }
         }
-        get ab2() {
-            return this.aa0;
+        get acc() {
+            return this.aba;
         }
-        set ab2(a) {
-            let b = this.ab2;
+        set acc(a) {
+            let b = this.acc;
             if (a != b) {
-                this.aa0 = a;
-                this.v3("XAxisMajorStrokeThickness", b, this.ab2);
+                this.aba = a;
+                this.wd("XAxisMajorStrokeThickness", b, this.acc);
             }
         }
-        get acj() {
-            return this.abh;
+        get act() {
+            return this.abr;
         }
-        set acj(a) {
-            let b = this.acj;
+        set act(a) {
+            let b = this.act;
             if (a != b) {
-                this.abh = a;
-                this.v3("YAxisMajorStrokeThickness", b, this.acj);
+                this.abr = a;
+                this.wd("YAxisMajorStrokeThickness", b, this.act);
             }
         }
-        get ab3() {
-            return this.aa1;
+        get acd() {
+            return this.abb;
         }
-        set ab3(a) {
-            let b = this.ab3;
+        set acd(a) {
+            let b = this.acd;
             if (a != b) {
-                this.aa1 = a;
-                this.v3("XAxisMinorStrokeThickness", b, this.ab3);
+                this.abb = a;
+                this.wd("XAxisMinorStrokeThickness", b, this.acd);
             }
         }
-        get ack() {
-            return this.abi;
+        get acu() {
+            return this.abs;
         }
-        set ack(a) {
-            let b = this.ack;
+        set acu(a) {
+            let b = this.acu;
             if (a != b) {
-                this.abi = a;
-                this.v3("YAxisMinorStrokeThickness", b, this.ack);
+                this.abs = a;
+                this.wd("YAxisMinorStrokeThickness", b, this.acu);
             }
         }
-        get agq() {
-            return this.aga;
+        get ag0() {
+            return this.agk;
         }
-        set agq(a) {
-            let b = this.agq;
+        set ag0(a) {
+            let b = this.ag0;
             if (a != b) {
-                this.aga = a;
-                this.v3("XAxisStrip", b, this.agq);
+                this.agk = a;
+                this.wd("XAxisStrip", b, this.ag0);
             }
         }
-        get agx() {
-            return this.agh;
+        get ag7() {
+            return this.agr;
         }
-        set agx(a) {
-            let b = this.agx;
+        set ag7(a) {
+            let b = this.ag7;
             if (a != b) {
-                this.agh = a;
-                this.v3("YAxisStrip", b, this.agx);
+                this.agr = a;
+                this.wd("YAxisStrip", b, this.ag7);
             }
         }
-        get agr() {
-            return this.agb;
+        get ag1() {
+            return this.agl;
         }
-        set agr(a) {
-            let b = this.agr;
+        set ag1(a) {
+            let b = this.ag1;
             if (a != b) {
-                this.agb = a;
-                this.v3("XAxisStroke", b, this.agr);
+                this.agl = a;
+                this.wd("XAxisStroke", b, this.ag1);
             }
         }
-        get agy() {
-            return this.agi;
+        get ag8() {
+            return this.ags;
         }
-        set agy(a) {
-            let b = this.agy;
+        set ag8(a) {
+            let b = this.ag8;
             if (a != b) {
-                this.agi = a;
-                this.v3("YAxisStroke", b, this.agy);
+                this.ags = a;
+                this.wd("YAxisStroke", b, this.ag8);
             }
         }
-        get ab4() {
-            return this.aa2;
+        get ace() {
+            return this.abc;
         }
-        set ab4(a) {
-            let b = this.ab4;
+        set ace(a) {
+            let b = this.ace;
             if (a != b) {
-                this.aa2 = a;
-                this.v3("XAxisStrokeThickness", b, this.ab4);
+                this.abc = a;
+                this.wd("XAxisStrokeThickness", b, this.ace);
             }
         }
-        get acl() {
-            return this.abj;
+        get acv() {
+            return this.abt;
         }
-        set acl(a) {
-            let b = this.acl;
+        set acv(a) {
+            let b = this.acv;
             if (a != b) {
-                this.abj = a;
-                this.v3("YAxisStrokeThickness", b, this.acl);
+                this.abt = a;
+                this.wd("YAxisStrokeThickness", b, this.acv);
             }
         }
-        get ab5() {
-            return this.aa3;
+        get acf() {
+            return this.abd;
         }
-        set ab5(a) {
-            let b = this.ab5;
+        set acf(a) {
+            let b = this.acf;
             if (a != b) {
-                this.aa3 = a;
-                this.v3("XAxisTickLength", b, this.ab5);
+                this.abd = a;
+                this.wd("XAxisTickLength", b, this.acf);
             }
         }
-        get acm() {
-            return this.abk;
+        get acw() {
+            return this.abu;
         }
-        set acm(a) {
-            let b = this.acm;
+        set acw(a) {
+            let b = this.acw;
             if (a != b) {
-                this.abk = a;
-                this.v3("YAxisTickLength", b, this.acm);
+                this.abu = a;
+                this.wd("YAxisTickLength", b, this.acw);
             }
         }
-        get ags() {
-            return this.agc;
+        get ag2() {
+            return this.agm;
         }
-        set ags(a) {
-            let b = this.ags;
+        set ag2(a) {
+            let b = this.ag2;
             if (a != b) {
-                this.agc = a;
-                this.v3("XAxisTickStroke", b, this.ags);
+                this.agm = a;
+                this.wd("XAxisTickStroke", b, this.ag2);
             }
         }
-        get agz() {
-            return this.agj;
+        get ag9() {
+            return this.agt;
         }
-        set agz(a) {
-            let b = this.agz;
+        set ag9(a) {
+            let b = this.ag9;
             if (a != b) {
-                this.agj = a;
-                this.v3("YAxisTickStroke", b, this.agz);
+                this.agt = a;
+                this.wd("YAxisTickStroke", b, this.ag9);
             }
         }
-        get ab6() {
-            return this.aa4;
+        get acg() {
+            return this.abe;
         }
-        set ab6(a) {
-            let b = this.ab6;
+        set acg(a) {
+            let b = this.acg;
             if (a != b) {
-                this.aa4 = a;
-                this.v3("XAxisTickStrokeThickness", b, this.ab6);
+                this.abe = a;
+                this.wd("XAxisTickStrokeThickness", b, this.acg);
             }
         }
-        get acn() {
-            return this.abl;
+        get acx() {
+            return this.abv;
         }
-        set acn(a) {
-            let b = this.acn;
+        set acx(a) {
+            let b = this.acx;
             if (a != b) {
-                this.abl = a;
-                this.v3("YAxisTickStrokeThickness", b, this.acn);
+                this.abv = a;
+                this.wd("YAxisTickStrokeThickness", b, this.acx);
             }
         }
-        get ad2() {
-            return this.ac0;
+        get aec() {
+            return this.ada;
         }
-        set ad2(a) {
-            let b = this.ad2;
+        set aec(a) {
+            let b = this.aec;
             if (a != b) {
-                this.ac0 = a;
-                this.v3("XAxisTitle", b, this.ad2);
+                this.ada = a;
+                this.wd("XAxisTitle", b, this.aec);
             }
         }
-        get ae7() {
-            return this.ac4;
+        get afh() {
+            return this.ade;
         }
-        set ae7(a) {
-            let b = this.ae7;
+        set afh(a) {
+            let b = this.afh;
             if (a != b) {
-                this.ac4 = a;
-                this.v3("YAxisTitle", b, this.ae7);
+                this.ade = a;
+                this.wd("YAxisTitle", b, this.afh);
             }
         }
-        get agp() {
-            return this.af9;
+        get agz() {
+            return this.agj;
         }
-        set agp(a) {
-            let b = this.agp;
+        set agz(a) {
+            let b = this.agz;
             if (a != b) {
-                this.af9 = a;
-                this.v3("XAxisMinorStroke", b, this.agp);
+                this.agj = a;
+                this.wd("XAxisMinorStroke", b, this.agz);
             }
         }
-        get agw() {
-            return this.agg;
+        get ag6() {
+            return this.agq;
         }
-        set agw(a) {
-            let b = this.agw;
+        set ag6(a) {
+            let b = this.ag6;
             if (a != b) {
-                this.agg = a;
-                this.v3("YAxisMinorStroke", b, this.agw);
+                this.agq = a;
+                this.wd("YAxisMinorStroke", b, this.ag6);
             }
         }
-        get abx() {
-            return this.aav;
+        get ab7() {
+            return this.aa5;
         }
-        set abx(a) {
-            let b = this.abx;
+        set ab7(a) {
+            let b = this.ab7;
             if (a != b) {
-                this.aav = a;
-                this.v3("XAxisLabelAngle", b, this.abx);
+                this.aa5 = a;
+                this.wd("XAxisLabelAngle", b, this.ab7);
             }
         }
-        get ace() {
-            return this.abc;
+        get aco() {
+            return this.abm;
         }
-        set ace(a) {
-            let b = this.ace;
+        set aco(a) {
+            let b = this.aco;
             if (a != b) {
-                this.abc = a;
-                this.v3("YAxisLabelAngle", b, this.ace);
+                this.abm = a;
+                this.wd("YAxisLabelAngle", b, this.aco);
             }
         }
-        get abw() {
-            return this.aau;
+        get ab6() {
+            return this.aa4;
         }
-        set abw(a) {
-            let b = this.abw;
+        set ab6(a) {
+            let b = this.ab6;
             if (a != b) {
-                this.aau = a;
-                this.v3("XAxisExtent", b, this.abw);
+                this.aa4 = a;
+                this.wd("XAxisExtent", b, this.ab6);
             }
         }
-        get acd() {
-            return this.abb;
+        get acn() {
+            return this.abl;
         }
-        set acd(a) {
-            let b = this.acd;
+        set acn(a) {
+            let b = this.acn;
             if (a != b) {
-                this.abb = a;
-                this.v3("YAxisExtent", b, this.acd);
+                this.abl = a;
+                this.wd("YAxisExtent", b, this.acn);
             }
         }
-        get ab7() {
-            return this.aa5;
+        get ach() {
+            return this.abf;
         }
-        set ab7(a) {
-            let b = this.ab7;
+        set ach(a) {
+            let b = this.ach;
             if (a != b) {
-                this.aa5 = a;
-                this.v3("XAxisTitleAngle", b, this.ab7);
+                this.abf = a;
+                this.wd("XAxisTitleAngle", b, this.ach);
             }
         }
-        get aco() {
-            return this.abm;
+        get acy() {
+            return this.abw;
         }
-        set aco(a) {
-            let b = this.aco;
+        set acy(a) {
+            let b = this.acy;
             if (a != b) {
-                this.abm = a;
-                this.v3("YAxisTitleAngle", b, this.aco);
+                this.abw = a;
+                this.wd("YAxisTitleAngle", b, this.acy);
             }
         }
-        get aas() {
-            return this.aaq;
+        get aa2() {
+            return this.aa0;
         }
-        set aas(a) {
-            let b = this.aas;
+        set aa2(a) {
+            let b = this.aa2;
             if (a != b) {
-                this.aaq = a;
-                this.v3("XAxisInverted", b, this.aas);
+                this.aa0 = a;
+                this.wd("XAxisInverted", b, this.aa2);
             }
         }
-        get aat() {
-            return this.aar;
+        get aa3() {
+            return this.aa1;
         }
-        set aat(a) {
-            let b = this.aat;
+        set aa3(a) {
+            let b = this.aa3;
             if (a != b) {
-                this.aar = a;
-                this.v3("YAxisInverted", b, this.aat);
+                this.aa1 = a;
+                this.wd("YAxisInverted", b, this.aa3);
             }
         }
-        get af3() {
-            return this.af0;
+        get agd() {
+            return this.aga;
         }
-        set af3(a) {
-            let b = this.af3;
+        set agd(a) {
+            let b = this.agd;
             if (a != b) {
-                this.af0 = a;
-                this.v3("XAxisTitleAlignment", enumGetBox(HorizontalAlignment_$type, b), enumGetBox(HorizontalAlignment_$type, this.af3));
+                this.aga = a;
+                this.wd("XAxisTitleAlignment", enumGetBox(HorizontalAlignment_$type, b), enumGetBox(HorizontalAlignment_$type, this.agd));
             }
         }
-        get ag6() {
-            return this.ag3;
+        get ahg() {
+            return this.ahd;
         }
-        set ag6(a) {
-            let b = this.ag6;
+        set ahg(a) {
+            let b = this.ahg;
             if (a != b) {
-                this.ag3 = a;
-                this.v3("YAxisTitleAlignment", enumGetBox(VerticalAlignment_$type, b), enumGetBox(VerticalAlignment_$type, this.ag6));
+                this.ahd = a;
+                this.wd("YAxisTitleAlignment", enumGetBox(VerticalAlignment_$type, b), enumGetBox(VerticalAlignment_$type, this.ahg));
             }
         }
-        get af2() {
-            return this.afz;
+        get agc() {
+            return this.af9;
         }
-        set af2(a) {
-            let b = this.af2;
+        set agc(a) {
+            let b = this.agc;
             if (a != b) {
-                this.afz = a;
-                this.v3("XAxisLabelHorizontalAlignment", enumGetBox(HorizontalAlignment_$type, b), enumGetBox(HorizontalAlignment_$type, this.af2));
+                this.af9 = a;
+                this.wd("XAxisLabelHorizontalAlignment", enumGetBox(HorizontalAlignment_$type, b), enumGetBox(HorizontalAlignment_$type, this.agc));
             }
         }
-        get_af4() {
-            return this.af1;
+        get_age() {
+            return this.agb;
         }
-        set_af4(a) {
-            let b = this.af4;
+        set_age(a) {
+            let b = this.age;
             if (a != b) {
-                this.af1 = a;
-                this.v3("YAxisLabelHorizontalAlignment", enumGetBox(HorizontalAlignment_$type, b), enumGetBox(HorizontalAlignment_$type, this.af4));
+                this.agb = a;
+                this.wd("YAxisLabelHorizontalAlignment", enumGetBox(HorizontalAlignment_$type, b), enumGetBox(HorizontalAlignment_$type, this.age));
             }
         }
-        get af4() {
-            return this.get_af4();
+        get age() {
+            return this.get_age();
         }
-        set af4(a) {
-            this.set_af4(a);
+        set age(a) {
+            this.set_age(a);
         }
-        get ag4() {
-            return this.ag1;
+        get ahe() {
+            return this.ahb;
         }
-        set ag4(a) {
-            let b = this.ag4;
+        set ahe(a) {
+            let b = this.ahe;
             if (a != b) {
-                this.ag1 = a;
-                this.v3("XAxisLabelVerticalAlignment", enumGetBox(VerticalAlignment_$type, b), enumGetBox(VerticalAlignment_$type, this.ag4));
+                this.ahb = a;
+                this.wd("XAxisLabelVerticalAlignment", enumGetBox(VerticalAlignment_$type, b), enumGetBox(VerticalAlignment_$type, this.ahe));
             }
         }
-        get ag5() {
-            return this.ag2;
+        get ahf() {
+            return this.ahc;
         }
-        set ag5(a) {
-            let b = this.ag5;
+        set ahf(a) {
+            let b = this.ahf;
             if (a != b) {
-                this.ag2 = a;
-                this.v3("YAxisLabelVerticalAlignment", enumGetBox(VerticalAlignment_$type, b), enumGetBox(VerticalAlignment_$type, this.ag5));
+                this.ahc = a;
+                this.wd("YAxisLabelVerticalAlignment", enumGetBox(VerticalAlignment_$type, b), enumGetBox(VerticalAlignment_$type, this.ahf));
             }
         }
-        get ag9() {
-            return this.ag7;
+        get ahj() {
+            return this.ahh;
         }
-        set ag9(a) {
-            let b = this.ag9;
+        set ahj(a) {
+            let b = this.ahj;
             if (a != b) {
-                this.ag7 = a;
-                this.v3("XAxisLabelVisibility", enumGetBox(Visibility_$type, b), enumGetBox(Visibility_$type, this.ag9));
+                this.ahh = a;
+                this.wd("XAxisLabelVisibility", enumGetBox(Visibility_$type, b), enumGetBox(Visibility_$type, this.ahj));
             }
         }
-        get aha() {
-            return this.ag8;
+        get ahk() {
+            return this.ahi;
         }
-        set aha(a) {
-            let b = this.aha;
+        set ahk(a) {
+            let b = this.ahk;
             if (a != b) {
-                this.ag8 = a;
-                this.v3("YAxisLabelVisibility", enumGetBox(Visibility_$type, b), enumGetBox(Visibility_$type, this.aha));
+                this.ahi = a;
+                this.wd("YAxisLabelVisibility", enumGetBox(Visibility_$type, b), enumGetBox(Visibility_$type, this.ahk));
             }
         }
-        get_aap() {
-            return this.aao;
+        get_aaz() {
+            return this.aay;
         }
-        set_aap(a) {
-            let b = this.aap;
+        set_aaz(a) {
+            let b = this.aaz;
             if (a != b) {
-                this.aao = a;
-                this.v3("YAxisLabelLocation", enumGetBox(YAxisLabelLocation_$type, b), enumGetBox(YAxisLabelLocation_$type, this.aap));
+                this.aay = a;
+                this.wd("YAxisLabelLocation", enumGetBox(YAxisLabelLocation_$type, b), enumGetBox(YAxisLabelLocation_$type, this.aaz));
             }
         }
-        get aap() {
-            return this.get_aap();
+        get aaz() {
+            return this.get_aaz();
         }
-        set aap(a) {
-            this.set_aap(a);
+        set aaz(a) {
+            this.set_aaz(a);
         }
-        get_aan() {
-            return this.aam;
+        get_aax() {
+            return this.aaw;
         }
-        set_aan(a) {
-            let b = this.aan;
+        set_aax(a) {
+            let b = this.aax;
             if (a != b) {
-                this.aam = a;
-                this.v3("XAxisLabelLocation", enumGetBox(XAxisLabelLocation_$type, b), enumGetBox(XAxisLabelLocation_$type, this.aan));
+                this.aaw = a;
+                this.wd("XAxisLabelLocation", enumGetBox(XAxisLabelLocation_$type, b), enumGetBox(XAxisLabelLocation_$type, this.aax));
             }
         }
-        get aan() {
-            return this.get_aan();
+        get aax() {
+            return this.get_aax();
         }
-        set aan(a) {
-            this.set_aan(a);
+        set aax(a) {
+            this.set_aax(a);
         }
-        get ade() {
-            return this.acy;
+        get ado() {
+            return this.ac8;
         }
-        set ade(a) {
-            let b = this.acy;
+        set ado(a) {
+            let b = this.ac8;
             if (a != b) {
-                this.acy = a;
-                this.v3("XAxisLabelFormat", b, this.acy);
+                this.ac8 = a;
+                this.wd("XAxisLabelFormat", b, this.ac8);
             }
         }
-        get aac() {
-            return this.aaa;
+        get aam() {
+            return this.aak;
         }
-        set aac(a) {
-            let b = this.aaa;
+        set aam(a) {
+            let b = this.aak;
             if (a != b) {
-                this.aaa = a;
-                this.v3("XAxisLabelFormatSpecifiers", b, this.aaa);
+                this.aak = a;
+                this.wd("XAxisLabelFormatSpecifiers", b, this.aak);
             }
         }
-        get aej() {
-            return this.ac2;
+        get aet() {
+            return this.adc;
         }
-        set aej(a) {
-            let b = this.ac2;
+        set aet(a) {
+            let b = this.adc;
             if (a != b) {
-                this.ac2 = a;
-                this.v3("YAxisLabelFormat", b, this.ac2);
+                this.adc = a;
+                this.wd("YAxisLabelFormat", b, this.adc);
             }
         }
-        get aad() {
-            return this.aab;
+        get aan() {
+            return this.aal;
         }
-        set aad(a) {
-            let b = this.aab;
+        set aan(a) {
+            let b = this.aal;
             if (a != b) {
-                this.aab = a;
-                this.v3("YAxisLabelFormatSpecifiers", b, this.aab);
+                this.aal = a;
+                this.wd("YAxisLabelFormatSpecifiers", b, this.aal);
             }
         }
     }