igniteui-webcomponents-charts 6.0.0 → 6.0.1

package/esm2015/lib/XYChart.js

@@ -23,87 +23,91 @@ export let XYChart = /*@__PURE__*/ (() => {
     class XYChart extends DomainChart {
         constructor() {
             super(...arguments);
-            this.aaq = null;
-            this.aar = null;
-            this.aa7 = 0;
-            this.aa9 = 5;
-            this.aa8 = 0;
-            this.aa6 = 5;
-            this.abo = 5;
+            this.aaw = null;
+            this.aax = null;
+            this.abd = 0;
+            this.abf = 5;
+            this.abe = 0;
+            this.abc = 5;
+            this.abw = 5;
+            this.aby = 0;
+            this.abx = 5;
+            this.abv = 0;
+            this.agz = null;
+            this.ag6 = null;
+            this.agx = null;
+            this.agy = null;
             this.abq = 0;
-            this.abp = 5;
-            this.abn = 0;
-            this.agh = null;
-            this.ago = null;
-            this.agf = null;
-            this.agg = null;
-            this.abi = 0;
-            this.abz = 0;
+            this.ab9 = 0;
+            this.abp = NaN;
+            this.ab8 = NaN;
+            this.abs = NaN;
+            this.acb = NaN;
+            this.abr = NaN;
+            this.aca = NaN;
+            this.abo = NaN;
+            this.ab7 = NaN;
+            this.ag5 = null;
+            this.ahc = null;
+            this.adn = null;
+            this.adr = null;
+            this.adp = null;
+            this.adt = null;
+            this.adi = null;
+            this.adj = null;
+            this.ag0 = null;
+            this.ag7 = null;
+            this.abg = DeviceUtils.g(1);
+            this.abz = DeviceUtils.g(1);
+            this.abj = DeviceUtils.g(1);
+            this.ab2 = DeviceUtils.g(1);
+            this.ag2 = null;
+            this.ag9 = null;
+            this.ag3 = null;
+            this.aha = null;
+            this.abk = DeviceUtils.g(1);
+            this.ab3 = DeviceUtils.g(1);
+            this.abl = DeviceUtils.g(8);
+            this.ab4 = 0;
+            this.ag4 = null;
+            this.ahb = null;
+            this.abm = DeviceUtils.g(1);
+            this.ab5 = DeviceUtils.g(1);
+            this.ado = null;
+            this.ads = null;
+            this.ag1 = null;
+            this.ag8 = null;
+            this.abb = 0;
+            this.abu = 0;
+            this.aba = NaN;
+            this.abt = NaN;
             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.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.agq = null;
-            this.aa5 = 0;
-            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;
+            this.abi = NaN;
+            this.ab1 = NaN;
+            this.abn = 0;
+            this.ab6 = -90;
+            this.aa6 = false;
+            this.aa7 = false;
+            this.ags = 1;
+            this.ahv = 1;
+            this.agr = 1;
+            this.agt = 2;
+            this.aht = 0;
+            this.ahu = 1;
+            this.ahz = 0;
+            this.ah0 = 0;
+            this.aa4 = 4;
+            this.aa2 = 4;
+            this.adm = null;
+            this.aaq = null;
+            this.adq = null;
+            this.aar = null;
         }
         provideContainer(a) {
             if (a != null) {
-                let b = this.aao();
-                let c = this.aap();
+                let b = this.aau();
+                let c = this.aav();
                 if (b != null) {
                     b.provideRenderer(a);
                 }
@@ -113,523 +117,523 @@ export let XYChart = /*@__PURE__*/ (() => {
             }
             super.provideContainer(a);
         }
-        vm() {
-            super.vm();
-            let a = this.aao();
-            let b = this.aap();
+        vs() {
+            super.vs();
+            let a = this.aau();
+            let b = this.aav();
             if (a != null && a.az != null) {
-                this.agx = a.az.textColor;
+                this.ahf = a.az.textColor;
             }
             if (b != null && b.az != null) {
-                this.ag4 = b.az.textColor;
+                this.ahm = b.az.textColor;
             }
-            this.ag2 = AxisDefaults.axis_TickBrush;
-            this.ag9 = AxisDefaults.axis_TickBrush;
-            this.agy = AxisDefaults.axis_MajorBrush;
-            this.ag5 = AxisDefaults.axis_MajorBrush;
-            this.ag1 = AxisDefaults.axis_LineBrush;
-            this.ag8 = AxisDefaults.axis_LineBrush;
+            this.ahk = AxisDefaults.axis_TickBrush;
+            this.ahr = AxisDefaults.axis_TickBrush;
+            this.ahg = AxisDefaults.axis_MajorBrush;
+            this.ahn = AxisDefaults.axis_MajorBrush;
+            this.ahj = AxisDefaults.axis_LineBrush;
+            this.ahq = AxisDefaults.axis_LineBrush;
         }
-        wh(a, b, c) {
-            super.wh(a, b, c);
+        wn(a, b, c) {
+            super.wn(a, b, c);
             switch (a) {
                 case "XAxisLabelLeftMargin":
-                    this.af1((d) => d.leftMargin = this.ab9);
+                    this.agj((d) => d.leftMargin = this.acj);
                     break;
                 case "XAxisLabelTopMargin":
-                    this.af1((d) => d.topMargin = this.acb);
+                    this.agj((d) => d.topMargin = this.acl);
                     break;
                 case "XAxisLabelRightMargin":
-                    this.af1((d) => d.rightMargin = this.aca);
+                    this.agj((d) => d.rightMargin = this.ack);
                     break;
                 case "XAxisLabelBottomMargin":
-                    this.af1((d) => d.bottomMargin = this.ab8);
+                    this.agj((d) => d.bottomMargin = this.aci);
                     break;
                 case "YAxisLabelLeftMargin":
-                    this.af6((d) => d.leftMargin = this.acq);
+                    this.ago((d) => d.leftMargin = this.ac2);
                     break;
                 case "YAxisLabelTopMargin":
-                    this.af6((d) => d.topMargin = this.acs);
+                    this.ago((d) => d.topMargin = this.ac4);
                     break;
                 case "YAxisLabelRightMargin":
-                    this.af6((d) => d.rightMargin = this.acr);
+                    this.ago((d) => d.rightMargin = this.ac3);
                     break;
                 case "YAxisLabelBottomMargin":
-                    this.af6((d) => d.bottomMargin = this.acp);
+                    this.ago((d) => d.bottomMargin = this.ac1);
                     break;
                 case "ActualItemsSource":
                 case "ShouldDisplayMockData":
                 case "ShouldUseSkeletonStyleForMockData":
-                    this.agv = this.zi(this.agx);
-                    this.agw = this.zi(this.ag4);
+                    this.ahd = this.zo(this.ahf);
+                    this.ahe = this.zo(this.ahm);
                     break;
                 case "XAxisLabelTextColor":
-                    this.agv = this.zi(this.agx);
+                    this.ahd = this.zo(this.ahf);
                     break;
                 case "YAxisLabelTextColor":
-                    this.agw = this.zi(this.ag4);
+                    this.ahe = this.zo(this.ahm);
                     break;
                 case "ActualXAxisLabelTextColor":
-                    this.af1((d) => d.textColor = this.agv);
+                    this.agj((d) => d.textColor = this.ahd);
                     break;
                 case "ActualYAxisLabelTextColor":
-                    this.af6((d) => d.textColor = this.agw);
+                    this.ago((d) => d.textColor = this.ahe);
                     break;
                 case "XAxisTitleMargin":
-                    this.af3((d) => d.margin = this.ack);
+                    this.agl((d) => d.margin = this.acw);
                     break;
                 case "YAxisTitleMargin":
-                    this.af8((d) => d.margin = this.ac1);
+                    this.agq((d) => d.margin = this.adf);
                     break;
                 case "XAxisTitleLeftMargin":
-                    this.af3((d) => d.leftMargin = this.acj);
+                    this.agl((d) => d.leftMargin = this.acv);
                     break;
                 case "YAxisTitleLeftMargin":
-                    this.af8((d) => d.leftMargin = this.ac0);
+                    this.agq((d) => d.leftMargin = this.ade);
                     break;
                 case "XAxisTitleTopMargin":
-                    this.af3((d) => d.topMargin = this.acm);
+                    this.agl((d) => d.topMargin = this.acy);
                     break;
                 case "YAxisTitleTopMargin":
-                    this.af8((d) => d.topMargin = this.ac3);
+                    this.agq((d) => d.topMargin = this.adh);
                     break;
                 case "XAxisTitleRightMargin":
-                    this.af3((d) => d.rightMargin = this.acl);
+                    this.agl((d) => d.rightMargin = this.acx);
                     break;
                 case "YAxisTitleRightMargin":
-                    this.af8((d) => d.rightMargin = this.ac2);
+                    this.agq((d) => d.rightMargin = this.adg);
                     break;
                 case "XAxisTitleBottomMargin":
-                    this.af3((d) => d.bottomMargin = this.aci);
+                    this.agl((d) => d.bottomMargin = this.acu);
                     break;
                 case "YAxisTitleBottomMargin":
-                    this.af8((d) => d.bottomMargin = this.acz);
+                    this.agq((d) => d.bottomMargin = this.add);
                     break;
                 case "XAxisTitleTextColor":
-                    this.af3((d) => d.textColor = this.ag3);
+                    this.agl((d) => d.textColor = this.ahl);
                     break;
                 case "YAxisTitleTextColor":
-                    this.af8((d) => d.textColor = this.aha);
+                    this.agq((d) => d.textColor = this.ahs);
                     break;
                 case "XAxisFormatLabel":
-                    this.afz((d) => d.au = this.aas);
+                    this.agh((d) => d.au = this.aay);
                     break;
                 case "YAxisFormatLabel":
-                    this.af4((d) => d.au = this.aat);
+                    this.agm((d) => d.au = this.aaz);
                     break;
             }
         }
-        get aas() {
-            return this.aaq;
+        get aay() {
+            return this.aaw;
         }
-        set aas(a) {
-            let b = this.aas;
+        set aay(a) {
+            let b = this.aay;
             if (a != b) {
-                this.aaq = a;
-                this.wd("XAxisFormatLabel", b, this.aas);
+                this.aaw = a;
+                this.wj("XAxisFormatLabel", b, this.aay);
             }
         }
-        get aat() {
-            return this.aar;
+        get aaz() {
+            return this.aax;
         }
-        set aat(a) {
-            let b = this.aat;
+        set aaz(a) {
+            let b = this.aaz;
             if (a != b) {
-                this.aar = a;
-                this.wd("YAxisFormatLabel", b, this.aat);
+                this.aax = a;
+                this.wj("YAxisFormatLabel", b, this.aaz);
             }
         }
-        get ab9() {
-            return this.aa7;
+        get acj() {
+            return this.abd;
         }
-        set ab9(a) {
-            let b = this.ab9;
+        set acj(a) {
+            let b = this.acj;
             if (a != b) {
-                this.aa7 = a;
-                this.wd("XAxisLabelLeftMargin", b, this.ab9);
+                this.abd = a;
+                this.wj("XAxisLabelLeftMargin", b, this.acj);
             }
         }
-        get acb() {
-            return this.aa9;
+        get acl() {
+            return this.abf;
         }
-        set acb(a) {
-            let b = this.acb;
+        set acl(a) {
+            let b = this.acl;
             if (a != b) {
-                this.aa9 = a;
-                this.wd("XAxisLabelTopMargin", b, this.acb);
+                this.abf = a;
+                this.wj("XAxisLabelTopMargin", b, this.acl);
             }
         }
-        get aca() {
-            return this.aa8;
+        get ack() {
+            return this.abe;
         }
-        set aca(a) {
-            let b = this.aca;
+        set ack(a) {
+            let b = this.ack;
             if (a != b) {
-                this.aa8 = a;
-                this.wd("XAxisLabelRightMargin", b, this.aca);
+                this.abe = a;
+                this.wj("XAxisLabelRightMargin", b, this.ack);
             }
         }
-        get ab8() {
-            return this.aa6;
+        get aci() {
+            return this.abc;
         }
-        set ab8(a) {
-            let b = this.ab8;
+        set aci(a) {
+            let b = this.aci;
             if (a != b) {
-                this.aa6 = a;
-                this.wd("XAxisLabelBottomMargin", b, this.ab8);
+                this.abc = a;
+                this.wj("XAxisLabelBottomMargin", b, this.aci);
             }
         }
-        get acq() {
-            return this.abo;
+        get ac2() {
+            return this.abw;
         }
-        set acq(a) {
-            let b = this.acq;
+        set ac2(a) {
+            let b = this.ac2;
             if (a != b) {
-                this.abo = a;
-                this.wd("YAxisLabelLeftMargin", b, this.acq);
+                this.abw = a;
+                this.wj("YAxisLabelLeftMargin", b, this.ac2);
             }
         }
-        get acs() {
-            return this.abq;
+        get ac4() {
+            return this.aby;
         }
-        set acs(a) {
-            let b = this.acs;
+        set ac4(a) {
+            let b = this.ac4;
             if (a != b) {
-                this.abq = a;
-                this.wd("YAxisLabelTopMargin", b, this.acs);
+                this.aby = a;
+                this.wj("YAxisLabelTopMargin", b, this.ac4);
             }
         }
-        get acr() {
-            return this.abp;
+        get ac3() {
+            return this.abx;
         }
-        set acr(a) {
-            let b = this.acr;
+        set ac3(a) {
+            let b = this.ac3;
             if (a != b) {
-                this.abp = a;
-                this.wd("YAxisLabelRightMargin", b, this.acr);
+                this.abx = a;
+                this.wj("YAxisLabelRightMargin", b, this.ac3);
             }
         }
-        get acp() {
-            return this.abn;
+        get ac1() {
+            return this.abv;
         }
-        set acp(a) {
-            let b = this.acp;
+        set ac1(a) {
+            let b = this.ac1;
             if (a != b) {
-                this.abn = a;
-                this.wd("YAxisLabelBottomMargin", b, this.acp);
+                this.abv = a;
+                this.wj("YAxisLabelBottomMargin", b, this.ac1);
             }
         }
-        get agx() {
-            return this.agh;
+        get ahf() {
+            return this.agz;
         }
-        set agx(a) {
-            let b = this.agx;
+        set ahf(a) {
+            let b = this.ahf;
             if (a != b) {
-                this.agh = a;
-                this.wd("XAxisLabelTextColor", b, this.agx);
+                this.agz = a;
+                this.wj("XAxisLabelTextColor", b, this.ahf);
             }
         }
-        get ag4() {
-            return this.ago;
+        get ahm() {
+            return this.ag6;
         }
-        set ag4(a) {
-            let b = this.ag4;
+        set ahm(a) {
+            let b = this.ahm;
             if (a != b) {
-                this.ago = a;
-                this.wd("YAxisLabelTextColor", b, this.ag4);
+                this.ag6 = a;
+                this.wj("YAxisLabelTextColor", b, this.ahm);
             }
         }
-        get agv() {
-            return this.agf;
+        get ahd() {
+            return this.agx;
         }
-        set agv(a) {
-            let b = this.agf;
+        set ahd(a) {
+            let b = this.agx;
             if (a != b) {
-                this.agf = a;
-                this.wd("ActualXAxisLabelTextColor", b, this.agv);
+                this.agx = a;
+                this.wj("ActualXAxisLabelTextColor", b, this.ahd);
             }
         }
-        get agw() {
-            return this.agg;
+        get ahe() {
+            return this.agy;
         }
-        set agw(a) {
-            let b = this.agg;
+        set ahe(a) {
+            let b = this.agy;
             if (a != b) {
-                this.agg = a;
-                this.wd("ActualYAxisLabelTextColor", b, this.agw);
+                this.agy = a;
+                this.wj("ActualYAxisLabelTextColor", b, this.ahe);
             }
         }
-        get ack() {
-            return this.abi;
+        get acw() {
+            return this.abq;
         }
-        set ack(a) {
-            let b = this.ack;
+        set acw(a) {
+            let b = this.acw;
             if (a != b) {
-                this.abi = a;
-                this.wd("XAxisTitleMargin", b, this.ack);
+                this.abq = a;
+                this.wj("XAxisTitleMargin", b, this.acw);
             }
         }
-        get ac1() {
-            return this.abz;
+        get adf() {
+            return this.ab9;
         }
-        set ac1(a) {
-            let b = this.ac1;
+        set adf(a) {
+            let b = this.adf;
             if (a != b) {
-                this.abz = a;
-                this.wd("YAxisTitleMargin", b, this.ac1);
+                this.ab9 = a;
+                this.wj("YAxisTitleMargin", b, this.adf);
             }
         }
-        get acj() {
-            return this.abh;
+        get acv() {
+            return this.abp;
         }
-        set acj(a) {
-            let b = this.acj;
+        set acv(a) {
+            let b = this.acv;
             if (a != b) {
-                this.abh = a;
-                this.wd("XAxisTitleLeftMargin", b, this.acj);
+                this.abp = a;
+                this.wj("XAxisTitleLeftMargin", b, this.acv);
             }
         }
-        get ac0() {
-            return this.aby;
+        get ade() {
+            return this.ab8;
         }
-        set ac0(a) {
-            let b = this.ac0;
+        set ade(a) {
+            let b = this.ade;
             if (a != b) {
-                this.aby = a;
-                this.wd("YAxisTitleLeftMargin", b, this.ac0);
+                this.ab8 = a;
+                this.wj("YAxisTitleLeftMargin", b, this.ade);
             }
         }
-        get acm() {
-            return this.abk;
+        get acy() {
+            return this.abs;
         }
-        set acm(a) {
-            let b = this.acm;
+        set acy(a) {
+            let b = this.acy;
             if (a != b) {
-                this.abk = a;
-                this.wd("XAxisTitleTopMargin", b, this.acm);
+                this.abs = a;
+                this.wj("XAxisTitleTopMargin", b, this.acy);
             }
         }
-        get ac3() {
-            return this.ab1;
+        get adh() {
+            return this.acb;
         }
-        set ac3(a) {
-            let b = this.ac3;
+        set adh(a) {
+            let b = this.adh;
             if (a != b) {
-                this.ab1 = a;
-                this.wd("YAxisTitleTopMargin", b, this.ac3);
+                this.acb = a;
+                this.wj("YAxisTitleTopMargin", b, this.adh);
             }
         }
-        get acl() {
-            return this.abj;
+        get acx() {
+            return this.abr;
         }
-        set acl(a) {
-            let b = this.acl;
+        set acx(a) {
+            let b = this.acx;
             if (a != b) {
-                this.abj = a;
-                this.wd("XAxisTitleRightMargin", b, this.acl);
+                this.abr = a;
+                this.wj("XAxisTitleRightMargin", b, this.acx);
             }
         }
-        get ac2() {
-            return this.ab0;
+        get adg() {
+            return this.aca;
         }
-        set ac2(a) {
-            let b = this.ac2;
+        set adg(a) {
+            let b = this.adg;
             if (a != b) {
-                this.ab0 = a;
-                this.wd("YAxisTitleRightMargin", b, this.ac2);
+                this.aca = a;
+                this.wj("YAxisTitleRightMargin", b, this.adg);
             }
         }
-        get aci() {
-            return this.abg;
+        get acu() {
+            return this.abo;
         }
-        set aci(a) {
-            let b = this.aci;
+        set acu(a) {
+            let b = this.acu;
             if (a != b) {
-                this.abg = a;
-                this.wd("XAxisTitleBottomMargin", b, this.aci);
+                this.abo = a;
+                this.wj("XAxisTitleBottomMargin", b, this.acu);
             }
         }
-        get acz() {
-            return this.abx;
+        get add() {
+            return this.ab7;
         }
-        set acz(a) {
-            let b = this.acz;
+        set add(a) {
+            let b = this.add;
             if (a != b) {
-                this.abx = a;
-                this.wd("YAxisTitleBottomMargin", b, this.acz);
+                this.ab7 = a;
+                this.wj("YAxisTitleBottomMargin", b, this.add);
             }
         }
-        get ag3() {
-            return this.agn;
+        get ahl() {
+            return this.ag5;
         }
-        set ag3(a) {
-            let b = this.ag3;
+        set ahl(a) {
+            let b = this.ahl;
             if (a != b) {
-                this.agn = a;
-                this.wd("XAxisTitleTextColor", b, this.ag3);
+                this.ag5 = a;
+                this.wj("XAxisTitleTextColor", b, this.ahl);
             }
         }
-        get aha() {
-            return this.agu;
+        get ahs() {
+            return this.ahc;
         }
-        set aha(a) {
-            let b = this.aha;
+        set ahs(a) {
+            let b = this.ahs;
             if (a != b) {
-                this.agu = a;
-                this.wd("YAxisTitleTextColor", b, this.aha);
+                this.ahc = a;
+                this.wj("YAxisTitleTextColor", b, this.ahs);
             }
         }
-        wi(a, b, c) {
-            super.wi(a, b, c);
+        wo(a, b, c) {
+            super.wo(a, b, c);
             switch (a) {
                 case "XAxisLabelTextStyle":
-                    this.af1((d) => d.textStyle = this.adx);
+                    this.agj((d) => d.textStyle = this.aeb);
                     break;
                 case "YAxisLabelTextStyle":
-                    this.af6((d) => d.textStyle = this.ae2);
+                    this.ago((d) => d.textStyle = this.afi);
                     break;
                 case "XAxisTitleTextStyle":
-                    this.af3((d) => d.textStyle = this.ael);
+                    this.agl((d) => d.textStyle = this.ae1);
                     break;
                 case "YAxisTitleTextStyle":
-                    this.af8((d) => d.textStyle = this.afq);
+                    this.agq((d) => d.textStyle = this.af8);
                     break;
             }
         }
-        get adx() {
-            return this.ac9;
+        get aeb() {
+            return this.adn;
         }
-        set adx(a) {
-            let b = this.adx;
+        set aeb(a) {
+            let b = this.aeb;
             if (a != b) {
-                this.ac9 = a;
-                this.wd("XAxisLabelTextStyle", b, this.adx);
+                this.adn = a;
+                this.wj("XAxisLabelTextStyle", b, this.aeb);
             }
         }
-        get ae2() {
-            return this.add;
+        get afi() {
+            return this.adr;
         }
-        set ae2(a) {
-            let b = this.ae2;
+        set afi(a) {
+            let b = this.afi;
             if (a != b) {
-                this.add = a;
-                this.wd("YAxisLabelTextStyle", b, this.ae2);
+                this.adr = a;
+                this.wj("YAxisLabelTextStyle", b, this.afi);
             }
         }
-        get ael() {
-            return this.adb;
+        get ae1() {
+            return this.adp;
         }
-        set ael(a) {
-            let b = this.ael;
+        set ae1(a) {
+            let b = this.ae1;
             if (a != b) {
-                this.adb = a;
-                this.wd("XAxisTitleTextStyle", b, this.ael);
+                this.adp = a;
+                this.wj("XAxisTitleTextStyle", b, this.ae1);
             }
         }
-        get afq() {
-            return this.adf;
+        get af8() {
+            return this.adt;
         }
-        set afq(a) {
-            let b = this.afq;
+        set af8(a) {
+            let b = this.af8;
             if (a != b) {
-                this.adf = a;
-                this.wd("YAxisTitleTextStyle", b, this.afq);
+                this.adt = a;
+                this.wj("YAxisTitleTextStyle", b, this.af8);
             }
         }
-        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);
+        age(a) {
+            this.agb(a, (b) => b.leftMargin = this.acj);
+            this.agb(a, (b) => b.topMargin = this.acl);
+            this.agb(a, (b) => b.rightMargin = this.ack);
+            this.agb(a, (b) => b.bottomMargin = this.aci);
+            this.agb(a, (b) => b.textColor = this.ahd);
+            this.agc(a, (b) => b.textColor = this.ahl);
+            this.agc(a, (b) => b.leftMargin = this.acv);
+            this.agc(a, (b) => b.topMargin = this.acy);
+            this.agc(a, (b) => b.rightMargin = this.acx);
+            this.agc(a, (b) => b.bottomMargin = this.acu);
+            this.agb(a, (b) => b.textStyle = this.aeb);
+            this.agc(a, (b) => b.textStyle = this.ae1);
         }
-        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);
+        agg(a) {
+            this.agb(a, (b) => b.leftMargin = this.ac2);
+            this.agb(a, (b) => b.topMargin = this.ac4);
+            this.agb(a, (b) => b.rightMargin = this.ac3);
+            this.agb(a, (b) => b.bottomMargin = this.ac1);
+            this.agb(a, (b) => b.textColor = this.ahe);
+            this.agc(a, (b) => b.textColor = this.ahs);
+            this.agc(a, (b) => b.leftMargin = this.ade);
+            this.agc(a, (b) => b.topMargin = this.adh);
+            this.agc(a, (b) => b.rightMargin = this.adg);
+            this.agc(a, (b) => b.bottomMargin = this.add);
+            this.agb(a, (b) => b.textStyle = this.afi);
+            this.agc(a, (b) => b.textStyle = this.af8);
         }
-        w9(a) {
+        xf(a) {
             let b = this.be(a);
             let c = this.dc(a, b);
             if (c == null) {
                 return;
             }
-            c.itemsSource = this.h6(a);
+            c.itemsSource = this.ia(a);
             if (a.highlightedData != null) {
-                c.highlightedItemsSource = this.h7(a);
+                c.highlightedItemsSource = this.ib(a);
             }
-            c.name = this.q0(a);
-            c.title = this.q1(a, b);
+            c.name = this.q6(a);
+            c.title = this.q7(a, b);
             this.dataChart.series.add(c);
         }
-        afz(a) {
-            this.af0(a, null);
+        agh(a) {
+            this.agi(a, null);
         }
-        af0(a, b) {
-            a(this.aao());
+        agi(a, b) {
+            a(this.aau());
         }
-        af5(a, b) {
-            a(this.aap());
+        agn(a, b) {
+            a(this.aav());
         }
-        af4(a) {
-            this.af5(a, true);
+        agm(a) {
+            this.agn(a, true);
         }
-        u5(a, b) {
-            this.afz(a);
-            this.af5(a, b);
+        vb(a, b) {
+            this.agh(a);
+            this.agn(a, b);
         }
-        af3(a) {
-            this.afu(this.aao(), a);
+        agl(a) {
+            this.agc(this.aau(), a);
         }
-        af8(a) {
-            this.afu(this.aap(), a);
+        agq(a) {
+            this.agc(this.aav(), a);
         }
-        af6(a) {
-            this.aft(this.aap(), a);
+        ago(a) {
+            this.agb(this.aav(), a);
         }
-        af1(a) {
-            this.aft(this.aao(), a);
+        agj(a) {
+            this.agb(this.aau(), a);
         }
-        ab2(a) {
-            let b = this.aao();
-            return b.el(a, new ScalerParams(1, this.zr, this.zq, b.ch));
+        acc(a) {
+            let b = this.aau();
+            return b.el(a, new ScalerParams(1, this.zx, this.zw, b.ch));
         }
-        ab4(a) {
-            let b = this.aao();
-            return b.eo(a, new ScalerParams(1, this.zr, this.zq, b.ch));
+        ace(a) {
+            let b = this.aau();
+            return b.eo(a, new ScalerParams(1, this.zx, this.zw, b.ch));
         }
-        ab3(a) {
-            let b = this.aap();
-            return b.el(a, new ScalerParams(1, this.zr, this.zq, b.ch));
+        acd(a) {
+            let b = this.aav();
+            return b.el(a, new ScalerParams(1, this.zx, this.zw, b.ch));
         }
-        ab5(a) {
-            let b = this.aap();
-            return b.eo(a, new ScalerParams(1, this.zr, this.zq, b.ch));
+        acf(a) {
+            let b = this.aav();
+            return b.eo(a, new ScalerParams(1, this.zx, this.zw, b.ch));
         }
-        w6(a) {
-            super.w6(a);
+        xc(a) {
+            super.xc(a);
             if (a == null) {
                 return;
             }
             if (a.axes != null) {
-                let b = this.aao();
-                let c = this.aap();
+                let b = this.aau();
+                let c = this.aav();
                 if (a.axes.contains(b)) {
                     a.axes.remove(b);
                 }
@@ -638,7 +642,7 @@ export let XYChart = /*@__PURE__*/ (() => {
                 }
             }
         }
-        static adi(a, b) {
+        static adw(a, b) {
             for (let c of fromEnum(b)) {
                 let d = c.findMatchingHint(16);
                 if (d != null) {
@@ -648,96 +652,116 @@ export let XYChart = /*@__PURE__*/ (() => {
             }
             return null;
         }
-        vh(a, b) {
-            super.vh(a, b);
+        vn(a, b) {
+            super.vn(a, b);
             if (a == this.dataChart) {
-                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;
+                this.dataChart.axes.add(this.aau());
+                this.dataChart.axes.add(this.aav());
+            }
+        }
+        agd(a) {
+            if (a != null && this.l8 != null && a.fn == null) {
+                a.provideRenderer(this.l8);
+            }
+            a.jz = this.ahg;
+            a.et = this.acm;
+            a.j0 = this.ahh;
+            a.ew = this.acp;
+            a.j2 = this.ahj;
+            a.fi = this.acq;
+            a.j1 = this.ahi;
+            a.fj = this.acr;
+            a.j3 = this.ahk;
+            a.fk = this.acs;
             a.c4 = true;
             a.cu = this.shouldAvoidAxisAnnotationCollisions;
             a.cw = this.shouldAvoidAxisAnnotationCollisions;
-            let b = a == this.aao();
+            let b = a == this.aau();
             if (b) {
-                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;
+                a.g8 = this.aes;
+            }
+            a.f2 = this.adk;
+            a.gi = this.ad2;
+            a.ah = this.aas;
+            this.agb(a, (c) => c.angle = this.ach);
+            this.agb(a, (c) => {
+                if (c.extent != this.acg) {
+                    c.extent = this.acg;
                 }
             });
-            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) {
+            this.agb(a, (c) => {
+                if (c.maximumExtent != this.acn) {
+                    c.maximumExtent = this.acn;
+                }
+            });
+            this.agb(a, (c) => {
+                if (c.maximumExtentPercentage != this.aco) {
+                    c.maximumExtentPercentage = this.aco;
+                }
+            });
+            this.agb(a, (c) => c.horizontalAlignment = this.agu);
+            this.agb(a, (c) => c.verticalAlignment = this.ahw);
+            this.agb(a, (c) => c.visibility = this.ah1);
+            this.agb(a, (c) => c.location = this.aa0(this.aa3));
+            this.agc(a, (c) => c.horizontalAlignment = this.agv);
+            this.agc(a, (c) => c.angle = this.act);
+            this.age(a);
+        }
+        agf(a) {
             if (a == null) {
                 return;
             }
-            if (this.l4 != null && a.fn == null) {
-                a.provideRenderer(this.l4);
+            if (this.l8 != null && a.fn == null) {
+                a.provideRenderer(this.l8);
             }
             a.cu = this.shouldAvoidAxisAnnotationCollisions;
             a.cw = this.shouldAvoidAxisAnnotationCollisions;
-            this.aft(a, (b) => b.angle = this.aco);
-            this.aft(a, (b) => {
-                if (b.extent != this.acn) {
-                    b.extent = this.acn;
+            this.agb(a, (b) => b.angle = this.ac0);
+            this.agb(a, (b) => {
+                if (b.extent != this.acz) {
+                    b.extent = this.acz;
+                }
+            });
+            this.agb(a, (b) => {
+                if (b.maximumExtent != this.ac6) {
+                    b.maximumExtent = this.ac6;
                 }
             });
-            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();
+            this.agb(a, (b) => {
+                if (b.maximumExtentPercentage != this.ac7) {
+                    b.maximumExtentPercentage = this.ac7;
+                }
+            });
+            this.agb(a, (b) => b.horizontalAlignment = this.agw);
+            this.agb(a, (b) => b.verticalAlignment = this.ahx);
+            this.agb(a, (b) => b.visibility = this.ah2);
+            this.agb(a, (b) => b.location = this.aa1(this.aa5));
+            this.agc(a, (b) => b.verticalAlignment = this.ahy);
+            this.agc(a, (b) => b.angle = this.adc);
+            a.jz = this.ahn;
+            a.et = this.ac5;
+            a.j0 = this.aho;
+            a.ew = this.ac8;
+            a.j2 = this.ahq;
+            a.fi = this.ac9;
+            a.j1 = this.ahp;
+            a.fj = this.ada;
+            a.j3 = this.ahr;
+            a.fk = this.adb;
+            let b = a == this.aav();
             if (b) {
-                a.g8 = this.afh;
+                a.g8 = this.afz;
             }
-            a.gi = this.aet;
-            a.ah = this.aan;
-            this.afy(a);
+            a.gi = this.ae9;
+            a.ah = this.aat;
+            this.agg(a);
         }
-        ve() {
-            super.ve();
-            this.afv(this.aao());
-            this.afx(this.aap());
+        vk() {
+            super.vk();
+            this.agd(this.aau());
+            this.agf(this.aav());
         }
-        aft(a, b) {
+        agb(a, b) {
             if (a == null) {
                 return;
             }
@@ -754,7 +778,7 @@ export let XYChart = /*@__PURE__*/ (() => {
             }
             b(a.az);
         }
-        afu(a, b) {
+        agc(a, b) {
             if (a == null) {
                 return;
             }
@@ -771,170 +795,182 @@ export let XYChart = /*@__PURE__*/ (() => {
             }
             b(a.bf);
         }
-        wd(a, b, c) {
-            super.wd(a, b, c);
+        wj(a, b, c) {
+            super.wj(a, b, c);
             switch (a) {
                 case "XAxisLabelAngle":
-                    this.af1((d) => d.angle = this.ab7);
+                    this.agj((d) => d.angle = this.ach);
                     break;
                 case "YAxisLabelAngle":
-                    this.af6((d) => d.angle = this.aco);
+                    this.ago((d) => d.angle = this.ac0);
                     break;
                 case "XAxisLabelHorizontalAlignment":
-                    this.af1((d) => d.horizontalAlignment = this.agc);
+                    this.agj((d) => d.horizontalAlignment = this.agu);
                     break;
                 case "YAxisLabelHorizontalAlignment":
-                    this.af6((d) => d.horizontalAlignment = this.age);
+                    this.ago((d) => d.horizontalAlignment = this.agw);
                     break;
                 case "XAxisLabelVerticalAlignment":
-                    this.af1((d) => d.verticalAlignment = this.ahe);
+                    this.agj((d) => d.verticalAlignment = this.ahw);
                     break;
                 case "YAxisLabelVerticalAlignment":
-                    this.af6((d) => d.verticalAlignment = this.ahf);
+                    this.ago((d) => d.verticalAlignment = this.ahx);
                     break;
                 case "XAxisLabelVisibility":
-                    this.af1((d) => d.visibility = this.ahj);
+                    this.agj((d) => d.visibility = this.ah1);
                     break;
                 case "YAxisLabelVisibility":
-                    this.af6((d) => d.visibility = this.ahk);
+                    this.ago((d) => d.visibility = this.ah2);
                     break;
                 case "XAxisLabel":
-                    this.afz((d) => d.f2 = this.ac6);
+                    this.agh((d) => d.f2 = this.adk);
                     break;
                 case "YAxisLabel":
-                    this.af4((d) => d.f2 = this.ac7);
+                    this.agm((d) => d.f2 = this.adl);
                     break;
                 case "XAxisLabelFormat":
-                    this.afz((d) => d.gi = this.ado);
+                    this.agh((d) => d.gi = this.ad2);
                     break;
                 case "XAxisLabelFormatSpecifiers":
-                    this.afz((d) => d.ah = this.aam);
+                    this.agh((d) => d.ah = this.aas);
                     break;
                 case "YAxisLabelFormat":
-                    this.af4((d) => d.gi = this.aet);
+                    this.agm((d) => d.gi = this.ae9);
                     break;
                 case "YAxisLabelFormatSpecifiers":
-                    this.af4((d) => d.ah = this.aan);
+                    this.agm((d) => d.ah = this.aat);
                     break;
                 case "XAxisTitleAngle":
-                    this.af3((d) => d.angle = this.ach);
+                    this.agl((d) => d.angle = this.act);
                     break;
                 case "YAxisTitleAngle":
-                    this.af8((d) => d.angle = this.acy);
+                    this.agq((d) => d.angle = this.adc);
                     break;
                 case "XAxisTitleAlignment":
-                    this.af3((d) => d.horizontalAlignment = this.agd);
+                    this.agl((d) => d.horizontalAlignment = this.agv);
                     break;
                 case "YAxisTitleAlignment":
-                    this.af8((d) => d.verticalAlignment = this.ahg);
+                    this.agq((d) => d.verticalAlignment = this.ahy);
                     break;
                 case "XAxisTitle":
-                    this.afz((d) => d.g8 = this.aec);
+                    this.agh((d) => d.g8 = this.aes);
                     break;
                 case "YAxisTitle":
-                    this.af5((d) => d.g8 = this.afh, false);
+                    this.agn((d) => d.g8 = this.afz, false);
                     break;
                 case "XAxisMajorStroke":
-                    this.af0((d) => d.jz = this.agy, a);
+                    this.agi((d) => d.jz = this.ahg, a);
                     break;
                 case "YAxisMajorStroke":
-                    this.af4((d) => d.jz = this.ag5);
+                    this.agm((d) => d.jz = this.ahn);
                     break;
                 case "XAxisMajorStrokeThickness":
-                    this.af0((d) => d.et = this.acc, a);
+                    this.agi((d) => d.et = this.acm, a);
                     break;
                 case "YAxisMajorStrokeThickness":
-                    this.af4((d) => d.et = this.act);
+                    this.agm((d) => d.et = this.ac5);
                     break;
                 case "XAxisMinorStroke":
-                    this.afz((d) => d.j0 = this.agz);
+                    this.agh((d) => d.j0 = this.ahh);
                     break;
                 case "YAxisMinorStroke":
-                    this.af4((d) => d.j0 = this.ag6);
+                    this.agm((d) => d.j0 = this.aho);
                     break;
                 case "XAxisMinorStrokeThickness":
-                    this.afz((d) => d.ew = this.acd);
+                    this.agh((d) => d.ew = this.acp);
                     break;
                 case "YAxisMinorStrokeThickness":
-                    this.af4((d) => d.ew = this.acu);
+                    this.agm((d) => d.ew = this.ac8);
                     break;
                 case "XAxisTickLength":
-                    this.afz((d) => d.fj = this.acf);
+                    this.agh((d) => d.fj = this.acr);
                     break;
                 case "YAxisTickLength":
-                    this.af4((d) => d.fj = this.acw);
+                    this.agm((d) => d.fj = this.ada);
                     break;
                 case "XAxisTickStroke":
-                    this.afz((d) => d.j3 = this.ag2);
+                    this.agh((d) => d.j3 = this.ahk);
                     break;
                 case "YAxisTickStroke":
-                    this.af4((d) => d.j3 = this.ag9);
+                    this.agm((d) => d.j3 = this.ahr);
                     break;
                 case "XAxisTickStrokeThickness":
-                    this.afz((d) => d.fk = this.acg);
+                    this.agh((d) => d.fk = this.acs);
                     break;
                 case "YAxisTickStrokeThickness":
-                    this.af4((d) => d.fk = this.acx);
+                    this.agm((d) => d.fk = this.adb);
                     break;
                 case "XAxisStroke":
-                    this.afz((d) => d.j2 = this.ag1);
+                    this.agh((d) => d.j2 = this.ahj);
                     break;
                 case "YAxisStroke":
-                    this.af4((d) => d.j2 = this.ag8);
+                    this.agm((d) => d.j2 = this.ahq);
                     break;
                 case "XAxisStrokeThickness":
-                    this.afz((d) => d.fi = this.ace);
+                    this.agh((d) => d.fi = this.acq);
                     break;
                 case "YAxisStrokeThickness":
-                    this.af4((d) => d.fi = this.acv);
+                    this.agm((d) => d.fi = this.ac9);
                     break;
                 case "XAxisExtent":
-                    this.af1((d) => d.extent = this.ab6);
+                    this.agj((d) => d.extent = this.acg);
                     break;
                 case "YAxisExtent":
-                    this.af6((d) => d.extent = this.acn);
+                    this.ago((d) => d.extent = this.acz);
+                    break;
+                case "XAxisMaximumExtent":
+                    this.agj((d) => d.maximumExtent = this.acn);
+                    break;
+                case "YAxisMaximumExtent":
+                    this.ago((d) => d.maximumExtent = this.ac6);
+                    break;
+                case "XAxisMaximumExtentPercentage":
+                    this.agj((d) => d.maximumExtentPercentage = this.aco);
+                    break;
+                case "YAxisMaximumExtentPercentage":
+                    this.ago((d) => d.maximumExtentPercentage = this.ac7);
                     break;
                 case "XAxisStrip":
-                    this.afz((d) => d.j1 = this.ag0);
+                    this.agh((d) => d.j1 = this.ahi);
                     break;
                 case "YAxisStrip":
-                    this.af4((d) => d.j1 = this.ag7);
+                    this.agm((d) => d.j1 = this.ahp);
                     break;
                 case "XAxisInverted":
-                    this.afz((d) => d.ch = this.aa2);
+                    this.agh((d) => d.ch = this.aa8);
                     break;
                 case "YAxisInverted":
-                    this.af4((d) => d.ch = this.aa3);
+                    this.agm((d) => d.ch = this.aa9);
                     break;
                 case "YAxisLabelLocation":
-                    this.af7();
+                    this.agp();
                     break;
                 case "XAxisLabelLocation":
-                    this.af2();
+                    this.agk();
                     break;
             }
         }
-        af7() {
-            let a = this.aav(this.aaz);
+        agp() {
+            let a = this.aa1(this.aa5);
             if (a == 2 || a == 7) {
-                this.age = 2;
+                this.agw = 2;
             }
             else {
-                this.age = 0;
+                this.agw = 0;
             }
-            this.af6((b) => b.location = a);
+            this.ago((b) => b.location = a);
         }
-        af2() {
-            let a = this.aau(this.aax);
+        agk() {
+            let a = this.aa0(this.aa3);
             if (a == 1 || a == 5) {
-                this.ahe = 0;
+                this.ahw = 0;
             }
             else {
-                this.ahe = 2;
+                this.ahw = 2;
             }
-            this.af1((b) => b.location = a);
+            this.agj((b) => b.location = a);
         }
-        aav(a) {
+        aa1(a) {
             if (a == 0) {
                 return 2;
             }
@@ -956,7 +992,7 @@ export let XYChart = /*@__PURE__*/ (() => {
                 }
             }
         }
-        aau(a) {
+        aa0(a) {
             if (a == 1) {
                 return 1;
             }
@@ -973,482 +1009,522 @@ export let XYChart = /*@__PURE__*/ (() => {
                 return 1;
             }
         }
-        get ac6() {
-            return this.ac4;
+        get adk() {
+            return this.adi;
         }
-        set ac6(a) {
-            let b = this.ac6;
+        set adk(a) {
+            let b = this.adk;
             if (a != b) {
-                this.ac4 = a;
-                this.wd("XAxisLabel", b, this.ac6);
+                this.adi = a;
+                this.wj("XAxisLabel", b, this.adk);
             }
         }
-        get ac7() {
-            return this.ac5;
+        get adl() {
+            return this.adj;
         }
-        set ac7(a) {
-            let b = this.ac7;
+        set adl(a) {
+            let b = this.adl;
             if (a != b) {
-                this.ac5 = a;
-                this.wd("YAxisLabel", b, this.ac7);
+                this.adj = a;
+                this.wj("YAxisLabel", b, this.adl);
             }
         }
-        get agy() {
-            return this.agi;
+        get ahg() {
+            return this.ag0;
         }
-        set agy(a) {
-            let b = this.agy;
+        set ahg(a) {
+            let b = this.ahg;
             if (a != b) {
-                this.agi = a;
-                this.wd("XAxisMajorStroke", b, this.agy);
+                this.ag0 = a;
+                this.wj("XAxisMajorStroke", b, this.ahg);
             }
         }
-        get ag5() {
-            return this.agp;
+        get ahn() {
+            return this.ag7;
         }
-        set ag5(a) {
-            let b = this.ag5;
+        set ahn(a) {
+            let b = this.ahn;
             if (a != b) {
-                this.agp = a;
-                this.wd("YAxisMajorStroke", b, this.ag5);
+                this.ag7 = a;
+                this.wj("YAxisMajorStroke", b, this.ahn);
             }
         }
-        get acc() {
-            return this.aba;
+        get acm() {
+            return this.abg;
         }
-        set acc(a) {
-            let b = this.acc;
+        set acm(a) {
+            let b = this.acm;
             if (a != b) {
-                this.aba = a;
-                this.wd("XAxisMajorStrokeThickness", b, this.acc);
+                this.abg = a;
+                this.wj("XAxisMajorStrokeThickness", b, this.acm);
             }
         }
-        get act() {
-            return this.abr;
+        get ac5() {
+            return this.abz;
         }
-        set act(a) {
-            let b = this.act;
+        set ac5(a) {
+            let b = this.ac5;
             if (a != b) {
-                this.abr = a;
-                this.wd("YAxisMajorStrokeThickness", b, this.act);
+                this.abz = a;
+                this.wj("YAxisMajorStrokeThickness", b, this.ac5);
             }
         }
-        get acd() {
-            return this.abb;
+        get acp() {
+            return this.abj;
         }
-        set acd(a) {
-            let b = this.acd;
+        set acp(a) {
+            let b = this.acp;
             if (a != b) {
-                this.abb = a;
-                this.wd("XAxisMinorStrokeThickness", b, this.acd);
+                this.abj = a;
+                this.wj("XAxisMinorStrokeThickness", b, this.acp);
             }
         }
-        get acu() {
-            return this.abs;
+        get ac8() {
+            return this.ab2;
         }
-        set acu(a) {
-            let b = this.acu;
+        set ac8(a) {
+            let b = this.ac8;
             if (a != b) {
-                this.abs = a;
-                this.wd("YAxisMinorStrokeThickness", b, this.acu);
+                this.ab2 = a;
+                this.wj("YAxisMinorStrokeThickness", b, this.ac8);
             }
         }
-        get ag0() {
-            return this.agk;
+        get ahi() {
+            return this.ag2;
         }
-        set ag0(a) {
-            let b = this.ag0;
+        set ahi(a) {
+            let b = this.ahi;
             if (a != b) {
-                this.agk = a;
-                this.wd("XAxisStrip", b, this.ag0);
+                this.ag2 = a;
+                this.wj("XAxisStrip", b, this.ahi);
             }
         }
-        get ag7() {
-            return this.agr;
+        get ahp() {
+            return this.ag9;
         }
-        set ag7(a) {
-            let b = this.ag7;
+        set ahp(a) {
+            let b = this.ahp;
             if (a != b) {
-                this.agr = a;
-                this.wd("YAxisStrip", b, this.ag7);
+                this.ag9 = a;
+                this.wj("YAxisStrip", b, this.ahp);
             }
         }
-        get ag1() {
-            return this.agl;
+        get ahj() {
+            return this.ag3;
         }
-        set ag1(a) {
-            let b = this.ag1;
+        set ahj(a) {
+            let b = this.ahj;
             if (a != b) {
-                this.agl = a;
-                this.wd("XAxisStroke", b, this.ag1);
+                this.ag3 = a;
+                this.wj("XAxisStroke", b, this.ahj);
             }
         }
-        get ag8() {
-            return this.ags;
+        get ahq() {
+            return this.aha;
         }
-        set ag8(a) {
-            let b = this.ag8;
+        set ahq(a) {
+            let b = this.ahq;
             if (a != b) {
-                this.ags = a;
-                this.wd("YAxisStroke", b, this.ag8);
+                this.aha = a;
+                this.wj("YAxisStroke", b, this.ahq);
             }
         }
-        get ace() {
-            return this.abc;
+        get acq() {
+            return this.abk;
         }
-        set ace(a) {
-            let b = this.ace;
+        set acq(a) {
+            let b = this.acq;
             if (a != b) {
-                this.abc = a;
-                this.wd("XAxisStrokeThickness", b, this.ace);
+                this.abk = a;
+                this.wj("XAxisStrokeThickness", b, this.acq);
             }
         }
-        get acv() {
-            return this.abt;
+        get ac9() {
+            return this.ab3;
         }
-        set acv(a) {
-            let b = this.acv;
+        set ac9(a) {
+            let b = this.ac9;
             if (a != b) {
-                this.abt = a;
-                this.wd("YAxisStrokeThickness", b, this.acv);
+                this.ab3 = a;
+                this.wj("YAxisStrokeThickness", b, this.ac9);
             }
         }
-        get acf() {
-            return this.abd;
+        get acr() {
+            return this.abl;
         }
-        set acf(a) {
-            let b = this.acf;
+        set acr(a) {
+            let b = this.acr;
             if (a != b) {
-                this.abd = a;
-                this.wd("XAxisTickLength", b, this.acf);
+                this.abl = a;
+                this.wj("XAxisTickLength", b, this.acr);
             }
         }
-        get acw() {
-            return this.abu;
+        get ada() {
+            return this.ab4;
         }
-        set acw(a) {
-            let b = this.acw;
+        set ada(a) {
+            let b = this.ada;
             if (a != b) {
-                this.abu = a;
-                this.wd("YAxisTickLength", b, this.acw);
+                this.ab4 = a;
+                this.wj("YAxisTickLength", b, this.ada);
+            }
+        }
+        get ahk() {
+            return this.ag4;
+        }
+        set ahk(a) {
+            let b = this.ahk;
+            if (a != b) {
+                this.ag4 = a;
+                this.wj("XAxisTickStroke", b, this.ahk);
             }
         }
-        get ag2() {
-            return this.agm;
+        get ahr() {
+            return this.ahb;
         }
-        set ag2(a) {
-            let b = this.ag2;
+        set ahr(a) {
+            let b = this.ahr;
             if (a != b) {
-                this.agm = a;
-                this.wd("XAxisTickStroke", b, this.ag2);
+                this.ahb = a;
+                this.wj("YAxisTickStroke", b, this.ahr);
             }
         }
-        get ag9() {
-            return this.agt;
+        get acs() {
+            return this.abm;
         }
-        set ag9(a) {
-            let b = this.ag9;
+        set acs(a) {
+            let b = this.acs;
             if (a != b) {
-                this.agt = a;
-                this.wd("YAxisTickStroke", b, this.ag9);
+                this.abm = a;
+                this.wj("XAxisTickStrokeThickness", b, this.acs);
             }
         }
-        get acg() {
-            return this.abe;
+        get adb() {
+            return this.ab5;
         }
-        set acg(a) {
-            let b = this.acg;
+        set adb(a) {
+            let b = this.adb;
             if (a != b) {
-                this.abe = a;
-                this.wd("XAxisTickStrokeThickness", b, this.acg);
+                this.ab5 = a;
+                this.wj("YAxisTickStrokeThickness", b, this.adb);
             }
         }
-        get acx() {
-            return this.abv;
+        get aes() {
+            return this.ado;
         }
-        set acx(a) {
-            let b = this.acx;
+        set aes(a) {
+            let b = this.aes;
             if (a != b) {
-                this.abv = a;
-                this.wd("YAxisTickStrokeThickness", b, this.acx);
+                this.ado = a;
+                this.wj("XAxisTitle", b, this.aes);
             }
         }
-        get aec() {
-            return this.ada;
+        get afz() {
+            return this.ads;
         }
-        set aec(a) {
-            let b = this.aec;
+        set afz(a) {
+            let b = this.afz;
             if (a != b) {
-                this.ada = a;
-                this.wd("XAxisTitle", b, this.aec);
+                this.ads = a;
+                this.wj("YAxisTitle", b, this.afz);
             }
         }
-        get afh() {
-            return this.ade;
+        get ahh() {
+            return this.ag1;
         }
-        set afh(a) {
-            let b = this.afh;
+        set ahh(a) {
+            let b = this.ahh;
             if (a != b) {
-                this.ade = a;
-                this.wd("YAxisTitle", b, this.afh);
+                this.ag1 = a;
+                this.wj("XAxisMinorStroke", b, this.ahh);
             }
         }
-        get agz() {
-            return this.agj;
+        get aho() {
+            return this.ag8;
         }
-        set agz(a) {
-            let b = this.agz;
+        set aho(a) {
+            let b = this.aho;
             if (a != b) {
-                this.agj = a;
-                this.wd("XAxisMinorStroke", b, this.agz);
+                this.ag8 = a;
+                this.wj("YAxisMinorStroke", b, this.aho);
             }
         }
-        get ag6() {
-            return this.agq;
+        get ach() {
+            return this.abb;
         }
-        set ag6(a) {
-            let b = this.ag6;
+        set ach(a) {
+            let b = this.ach;
             if (a != b) {
-                this.agq = a;
-                this.wd("YAxisMinorStroke", b, this.ag6);
+                this.abb = a;
+                this.wj("XAxisLabelAngle", b, this.ach);
             }
         }
-        get ab7() {
-            return this.aa5;
+        get ac0() {
+            return this.abu;
         }
-        set ab7(a) {
-            let b = this.ab7;
+        set ac0(a) {
+            let b = this.ac0;
             if (a != b) {
-                this.aa5 = a;
-                this.wd("XAxisLabelAngle", b, this.ab7);
+                this.abu = a;
+                this.wj("YAxisLabelAngle", b, this.ac0);
             }
         }
-        get aco() {
-            return this.abm;
+        get acg() {
+            return this.aba;
         }
-        set aco(a) {
-            let b = this.aco;
+        set acg(a) {
+            let b = this.acg;
             if (a != b) {
-                this.abm = a;
-                this.wd("YAxisLabelAngle", b, this.aco);
+                this.aba = a;
+                this.wj("XAxisExtent", b, this.acg);
             }
         }
-        get ab6() {
-            return this.aa4;
+        get acz() {
+            return this.abt;
         }
-        set ab6(a) {
-            let b = this.ab6;
+        set acz(a) {
+            let b = this.acz;
             if (a != b) {
-                this.aa4 = a;
-                this.wd("XAxisExtent", b, this.ab6);
+                this.abt = a;
+                this.wj("YAxisExtent", b, this.acz);
             }
         }
         get acn() {
-            return this.abl;
+            return this.abh;
         }
         set acn(a) {
             let b = this.acn;
             if (a != b) {
-                this.abl = a;
-                this.wd("YAxisExtent", b, this.acn);
+                this.abh = a;
+                this.wj("XAxisMaximumExtent", b, this.acn);
             }
         }
-        get ach() {
-            return this.abf;
+        get ac6() {
+            return this.ab0;
         }
-        set ach(a) {
-            let b = this.ach;
+        set ac6(a) {
+            let b = this.ac6;
             if (a != b) {
-                this.abf = a;
-                this.wd("XAxisTitleAngle", b, this.ach);
+                this.ab0 = a;
+                this.wj("YAxisMaximumExtent", b, this.ac6);
             }
         }
-        get acy() {
-            return this.abw;
+        get aco() {
+            return this.abi;
         }
-        set acy(a) {
-            let b = this.acy;
+        set aco(a) {
+            let b = this.aco;
             if (a != b) {
-                this.abw = a;
-                this.wd("YAxisTitleAngle", b, this.acy);
+                this.abi = a;
+                this.wj("XAxisMaximumExtentPercentage", b, this.aco);
             }
         }
-        get aa2() {
-            return this.aa0;
+        get ac7() {
+            return this.ab1;
         }
-        set aa2(a) {
-            let b = this.aa2;
+        set ac7(a) {
+            let b = this.ac7;
             if (a != b) {
-                this.aa0 = a;
-                this.wd("XAxisInverted", b, this.aa2);
+                this.ab1 = a;
+                this.wj("YAxisMaximumExtentPercentage", b, this.ac7);
             }
         }
-        get aa3() {
-            return this.aa1;
+        get act() {
+            return this.abn;
         }
-        set aa3(a) {
-            let b = this.aa3;
+        set act(a) {
+            let b = this.act;
             if (a != b) {
-                this.aa1 = a;
-                this.wd("YAxisInverted", b, this.aa3);
+                this.abn = a;
+                this.wj("XAxisTitleAngle", b, this.act);
             }
         }
-        get agd() {
-            return this.aga;
+        get adc() {
+            return this.ab6;
         }
-        set agd(a) {
-            let b = this.agd;
+        set adc(a) {
+            let b = this.adc;
             if (a != b) {
-                this.aga = a;
-                this.wd("XAxisTitleAlignment", enumGetBox(HorizontalAlignment_$type, b), enumGetBox(HorizontalAlignment_$type, this.agd));
+                this.ab6 = a;
+                this.wj("YAxisTitleAngle", b, this.adc);
             }
         }
-        get ahg() {
-            return this.ahd;
+        get aa8() {
+            return this.aa6;
         }
-        set ahg(a) {
-            let b = this.ahg;
+        set aa8(a) {
+            let b = this.aa8;
+            if (a != b) {
+                this.aa6 = a;
+                this.wj("XAxisInverted", b, this.aa8);
+            }
+        }
+        get aa9() {
+            return this.aa7;
+        }
+        set aa9(a) {
+            let b = this.aa9;
+            if (a != b) {
+                this.aa7 = a;
+                this.wj("YAxisInverted", b, this.aa9);
+            }
+        }
+        get agv() {
+            return this.ags;
+        }
+        set agv(a) {
+            let b = this.agv;
             if (a != b) {
-                this.ahd = a;
-                this.wd("YAxisTitleAlignment", enumGetBox(VerticalAlignment_$type, b), enumGetBox(VerticalAlignment_$type, this.ahg));
+                this.ags = a;
+                this.wj("XAxisTitleAlignment", enumGetBox(HorizontalAlignment_$type, b), enumGetBox(HorizontalAlignment_$type, this.agv));
             }
         }
-        get agc() {
-            return this.af9;
+        get ahy() {
+            return this.ahv;
         }
-        set agc(a) {
-            let b = this.agc;
+        set ahy(a) {
+            let b = this.ahy;
             if (a != b) {
-                this.af9 = a;
-                this.wd("XAxisLabelHorizontalAlignment", enumGetBox(HorizontalAlignment_$type, b), enumGetBox(HorizontalAlignment_$type, this.agc));
+                this.ahv = a;
+                this.wj("YAxisTitleAlignment", enumGetBox(VerticalAlignment_$type, b), enumGetBox(VerticalAlignment_$type, this.ahy));
             }
         }
-        get_age() {
-            return this.agb;
+        get agu() {
+            return this.agr;
         }
-        set_age(a) {
-            let b = this.age;
+        set agu(a) {
+            let b = this.agu;
             if (a != b) {
-                this.agb = a;
-                this.wd("YAxisLabelHorizontalAlignment", enumGetBox(HorizontalAlignment_$type, b), enumGetBox(HorizontalAlignment_$type, this.age));
+                this.agr = a;
+                this.wj("XAxisLabelHorizontalAlignment", enumGetBox(HorizontalAlignment_$type, b), enumGetBox(HorizontalAlignment_$type, this.agu));
             }
         }
-        get age() {
-            return this.get_age();
+        get_agw() {
+            return this.agt;
         }
-        set age(a) {
-            this.set_age(a);
+        set_agw(a) {
+            let b = this.agw;
+            if (a != b) {
+                this.agt = a;
+                this.wj("YAxisLabelHorizontalAlignment", enumGetBox(HorizontalAlignment_$type, b), enumGetBox(HorizontalAlignment_$type, this.agw));
+            }
         }
-        get ahe() {
-            return this.ahb;
+        get agw() {
+            return this.get_agw();
         }
-        set ahe(a) {
-            let b = this.ahe;
+        set agw(a) {
+            this.set_agw(a);
+        }
+        get ahw() {
+            return this.aht;
+        }
+        set ahw(a) {
+            let b = this.ahw;
             if (a != b) {
-                this.ahb = a;
-                this.wd("XAxisLabelVerticalAlignment", enumGetBox(VerticalAlignment_$type, b), enumGetBox(VerticalAlignment_$type, this.ahe));
+                this.aht = a;
+                this.wj("XAxisLabelVerticalAlignment", enumGetBox(VerticalAlignment_$type, b), enumGetBox(VerticalAlignment_$type, this.ahw));
             }
         }
-        get ahf() {
-            return this.ahc;
+        get ahx() {
+            return this.ahu;
         }
-        set ahf(a) {
-            let b = this.ahf;
+        set ahx(a) {
+            let b = this.ahx;
             if (a != b) {
-                this.ahc = a;
-                this.wd("YAxisLabelVerticalAlignment", enumGetBox(VerticalAlignment_$type, b), enumGetBox(VerticalAlignment_$type, this.ahf));
+                this.ahu = a;
+                this.wj("YAxisLabelVerticalAlignment", enumGetBox(VerticalAlignment_$type, b), enumGetBox(VerticalAlignment_$type, this.ahx));
             }
         }
-        get ahj() {
-            return this.ahh;
+        get ah1() {
+            return this.ahz;
         }
-        set ahj(a) {
-            let b = this.ahj;
+        set ah1(a) {
+            let b = this.ah1;
             if (a != b) {
-                this.ahh = a;
-                this.wd("XAxisLabelVisibility", enumGetBox(Visibility_$type, b), enumGetBox(Visibility_$type, this.ahj));
+                this.ahz = a;
+                this.wj("XAxisLabelVisibility", enumGetBox(Visibility_$type, b), enumGetBox(Visibility_$type, this.ah1));
             }
         }
-        get ahk() {
-            return this.ahi;
+        get ah2() {
+            return this.ah0;
         }
-        set ahk(a) {
-            let b = this.ahk;
+        set ah2(a) {
+            let b = this.ah2;
             if (a != b) {
-                this.ahi = a;
-                this.wd("YAxisLabelVisibility", enumGetBox(Visibility_$type, b), enumGetBox(Visibility_$type, this.ahk));
+                this.ah0 = a;
+                this.wj("YAxisLabelVisibility", enumGetBox(Visibility_$type, b), enumGetBox(Visibility_$type, this.ah2));
             }
         }
-        get_aaz() {
-            return this.aay;
+        get_aa5() {
+            return this.aa4;
         }
-        set_aaz(a) {
-            let b = this.aaz;
+        set_aa5(a) {
+            let b = this.aa5;
             if (a != b) {
-                this.aay = a;
-                this.wd("YAxisLabelLocation", enumGetBox(YAxisLabelLocation_$type, b), enumGetBox(YAxisLabelLocation_$type, this.aaz));
+                this.aa4 = a;
+                this.wj("YAxisLabelLocation", enumGetBox(YAxisLabelLocation_$type, b), enumGetBox(YAxisLabelLocation_$type, this.aa5));
             }
         }
-        get aaz() {
-            return this.get_aaz();
+        get aa5() {
+            return this.get_aa5();
         }
-        set aaz(a) {
-            this.set_aaz(a);
+        set aa5(a) {
+            this.set_aa5(a);
         }
-        get_aax() {
-            return this.aaw;
+        get_aa3() {
+            return this.aa2;
         }
-        set_aax(a) {
-            let b = this.aax;
+        set_aa3(a) {
+            let b = this.aa3;
             if (a != b) {
-                this.aaw = a;
-                this.wd("XAxisLabelLocation", enumGetBox(XAxisLabelLocation_$type, b), enumGetBox(XAxisLabelLocation_$type, this.aax));
+                this.aa2 = a;
+                this.wj("XAxisLabelLocation", enumGetBox(XAxisLabelLocation_$type, b), enumGetBox(XAxisLabelLocation_$type, this.aa3));
             }
         }
-        get aax() {
-            return this.get_aax();
+        get aa3() {
+            return this.get_aa3();
         }
-        set aax(a) {
-            this.set_aax(a);
+        set aa3(a) {
+            this.set_aa3(a);
         }
-        get ado() {
-            return this.ac8;
+        get ad2() {
+            return this.adm;
         }
-        set ado(a) {
-            let b = this.ac8;
+        set ad2(a) {
+            let b = this.adm;
             if (a != b) {
-                this.ac8 = a;
-                this.wd("XAxisLabelFormat", b, this.ac8);
+                this.adm = a;
+                this.wj("XAxisLabelFormat", b, this.adm);
             }
         }
-        get aam() {
-            return this.aak;
+        get aas() {
+            return this.aaq;
         }
-        set aam(a) {
-            let b = this.aak;
+        set aas(a) {
+            let b = this.aaq;
             if (a != b) {
-                this.aak = a;
-                this.wd("XAxisLabelFormatSpecifiers", b, this.aak);
+                this.aaq = a;
+                this.wj("XAxisLabelFormatSpecifiers", b, this.aaq);
             }
         }
-        get aet() {
-            return this.adc;
+        get ae9() {
+            return this.adq;
         }
-        set aet(a) {
-            let b = this.adc;
+        set ae9(a) {
+            let b = this.adq;
             if (a != b) {
-                this.adc = a;
-                this.wd("YAxisLabelFormat", b, this.adc);
+                this.adq = a;
+                this.wj("YAxisLabelFormat", b, this.adq);
             }
         }
-        get aan() {
-            return this.aal;
+        get aat() {
+            return this.aar;
         }
-        set aan(a) {
-            let b = this.aal;
+        set aat(a) {
+            let b = this.aar;
             if (a != b) {
-                this.aal = a;
-                this.wd("YAxisLabelFormatSpecifiers", b, this.aal);
+                this.aar = a;
+                this.wj("YAxisLabelFormatSpecifiers", b, this.aar);
             }
         }
     }