igniteui-angular-maps 20.1.0 → 20.2.0-beta.0

package/esm2015/lib/XamGeographicMap_combined.js

@@ -43,94 +43,94 @@ export let XamGeographicMap = /*@__PURE__*/ (() => {
     class XamGeographicMap extends SeriesViewer {
         constructor() {
             super();
-            this.y2 = null;
-            this.yr = false;
-            this.yj = 1;
-            this.yy = 0;
-            this.z9 = null;
-            this.yg = null;
-            this.yc = null;
-            this.ye = null;
-            this.yi = null;
-            this.z5 = { $type: Point_$type, x: NaN, y: NaN };
-            this.aac = null;
-            this.yx = 1;
+            this.z6 = null;
+            this.zv = false;
+            this.zn = 1;
+            this.z2 = 0;
+            this.abd = null;
+            this.zk = null;
+            this.zg = null;
+            this.zi = null;
+            this.zm = null;
+            this.aa9 = { $type: Point_$type, x: NaN, y: NaN };
+            this.abg = null;
+            this.z1 = 1;
             this.imageTilesReady = null;
-            this.yq = null;
-            this.aab = Rect.empty;
-            this.yy = SphericalMercatorVerticalScaler.am(XamGeographicMap.aaa.bottom) - SphericalMercatorVerticalScaler.am(XamGeographicMap.aaa.top);
+            this.zu = null;
+            this.abf = Rect.empty;
+            this.z2 = SphericalMercatorVerticalScaler.am(XamGeographicMap.abe.bottom) - SphericalMercatorVerticalScaler.am(XamGeographicMap.abe.top);
             this.ab = XamGeographicMap.$;
             this.backgroundContent = new OpenStreetMapImagery();
             let a = ((() => {
                 let $ret = new NumericXAxis();
-                $ret.b0 = this;
+                $ret.b2 = this;
                 return $ret;
             })());
-            a.dd = true;
-            this.yd = a;
-            this.yd.r8 = new SphericalMercatorHorizontalScaler();
+            a.dk = true;
+            this.zh = a;
+            this.zh.ta = new SphericalMercatorHorizontalScaler();
             let b = ((() => {
                 let $ret = new NumericYAxis();
-                $ret.b0 = this;
+                $ret.b2 = this;
                 return $ret;
             })());
-            b.dd = true;
-            this.yf = b;
-            this.yf.r8 = new SphericalMercatorVerticalScaler();
-            this.zk();
-            this.zr();
-            this.oz();
+            b.dk = true;
+            this.zj = b;
+            this.zj.ta = new SphericalMercatorVerticalScaler();
+            this.aao();
+            this.aav();
+            this.po();
         }
         provideContainer(a) {
             super.provideContainer(a);
-            this.yd.provideRenderer(a);
-            this.yf.provideRenderer(a);
+            this.zh.provideRenderer(a);
+            this.zj.provideRenderer(a);
         }
-        oz() {
-            super.oz();
-            this.yp.fv(this.h3);
+        po() {
+            super.po();
+            this.zt.fy(this.ij);
         }
-        f2() {
-            return this.yv;
+        gg() {
+            return this.zz;
         }
-        f3() {
-            return this.yv;
+        gh() {
+            return this.zz;
         }
-        ym() {
-            if (this.yk == 0) {
-                if (this.yr) {
+        zq() {
+            if (this.zo == 0) {
+                if (this.zv) {
                     return 2;
                 }
             }
             return 1;
         }
-        get yl() {
-            return this.yj;
+        get zp() {
+            return this.zn;
         }
-        set yl(a) {
-            this.yj = a;
+        set zp(a) {
+            this.zn = a;
         }
-        get aae() {
-            return this.z9;
+        get abi() {
+            return this.abd;
         }
-        set aae(a) {
-            let b = Rect.l_op_Inequality(this.z9, a);
+        set abi(a) {
+            let b = Rect.l_op_Inequality(this.abd, a);
             if (b) {
-                let c = this.z9;
-                this.z9 = a;
-                this.ry("ActualWorldRect", c, a);
+                let c = this.abd;
+                this.abd = a;
+                this.sr("ActualWorldRect", c, a);
             }
         }
-        aai() {
-            return this.aae;
+        abm() {
+            return this.abi;
         }
-        zk() {
-            if (this.aaq.isEmpty) {
+        aao() {
+            if (this.abu.isEmpty) {
                 return;
             }
-            this.aae = this.aao(this.aaq, this.c4 == 1);
+            this.abi = this.abs(this.abu, this.db == 1);
         }
-        aao(a, b) {
+        abs(a, b) {
             let c = a.top;
             let d = a.left;
             let e = a.width;
@@ -138,25 +138,25 @@ export let XamGeographicMap = /*@__PURE__*/ (() => {
             let g = SphericalMercatorVerticalScaler.am(a.bottom);
             let h = SphericalMercatorVerticalScaler.am(a.top);
             let i = g - h;
-            let j = a.width / XamGeographicMap.aaa.width;
-            let k = SphericalMercatorVerticalScaler.am(XamGeographicMap.aaa.top);
+            let j = a.width / XamGeographicMap.abe.width;
+            let k = SphericalMercatorVerticalScaler.am(XamGeographicMap.abe.top);
             let l = i / j;
-            if (i / j > this.yy) {
-                let m = i / this.yy;
+            if (i / j > this.z2) {
+                let m = i / this.z2;
                 let n = m - j;
-                d = d - (n / 2) * XamGeographicMap.aaa.width;
-                e = m * XamGeographicMap.aaa.width;
+                d = d - (n / 2) * XamGeographicMap.abe.width;
+                e = m * XamGeographicMap.abe.width;
                 if (b) {
-                    if (d < XamGeographicMap.aaa.left) {
-                        d += (XamGeographicMap.aaa.left - d);
+                    if (d < XamGeographicMap.abe.left) {
+                        d += (XamGeographicMap.abe.left - d);
                     }
-                    else if ((d + e) > XamGeographicMap.aaa.right) {
-                        d -= ((d + e) - XamGeographicMap.aaa.right);
+                    else if ((d + e) > XamGeographicMap.abe.right) {
+                        d -= ((d + e) - XamGeographicMap.abe.right);
                     }
                 }
             }
-            else if (i / j < this.yy) {
-                let o = this.yy * j;
+            else if (i / j < this.z2) {
+                let o = this.z2 * j;
                 let p = o - i;
                 let q = h - (p / 2);
                 let r = g + (p / 2);
@@ -165,9 +165,9 @@ export let XamGeographicMap = /*@__PURE__*/ (() => {
                         q += (k - q);
                         r += (k - q);
                     }
-                    else if (r > (k + this.yy)) {
-                        q -= ((r) - (k + this.yy));
-                        r -= ((r) - (k + this.yy));
+                    else if (r > (k + this.z2)) {
+                        q -= ((r) - (k + this.z2));
+                        r -= ((r) - (k + this.z2));
                     }
                 }
                 c = SphericalMercatorVerticalScaler.aq(q);
@@ -177,76 +177,76 @@ export let XamGeographicMap = /*@__PURE__*/ (() => {
             return s;
         }
         get backgroundContent() {
-            return this.yg;
+            return this.zk;
         }
         set backgroundContent(a) {
             let b = a != this.backgroundContent;
             if (b) {
                 let c = this.backgroundContent;
-                this.yg = a;
-                this.ry("BackgroundContent", c, a);
+                this.zk = a;
+                this.sr("BackgroundContent", c, a);
             }
         }
-        get yd() {
-            return this.yc;
+        get zh() {
+            return this.zg;
         }
-        set yd(a) {
-            let b = a != this.yd;
+        set zh(a) {
+            let b = a != this.zh;
             if (b) {
-                let c = this.yd;
-                this.yc = a;
-                this.ry("XAxis", c, a);
+                let c = this.zh;
+                this.zg = a;
+                this.sr("XAxis", c, a);
             }
         }
-        get yf() {
-            return this.ye;
+        get zj() {
+            return this.zi;
         }
-        set yf(a) {
-            let b = a != this.yf;
+        set zj(a) {
+            let b = a != this.zj;
             if (b) {
-                let c = this.yf;
-                this.ye = a;
-                this.ry("YAxis", c, a);
+                let c = this.zj;
+                this.zi = a;
+                this.sr("YAxis", c, a);
             }
         }
         getZoomRectFromGeoRect(a) {
             return this.getZoomFromGeographicRect(a);
         }
-        zu(a) {
-            this.x6 = a;
+        aay(a) {
+            this.za = a;
         }
-        zt(a) {
-            this.aaq = a;
+        aax(a) {
+            this.abu = a;
         }
         getZoomFromGeographicRect(a) {
-            return this.aag(a, true, 0);
+            return this.abk(a, true, 0);
         }
-        aaf(a, b) {
-            return this.aag(a, false, b);
+        abj(a, b) {
+            return this.abk(a, false, b);
         }
-        aag(a, b, c) {
+        abk(a, b, c) {
             let d = a;
             if (b) {
-                d = this.aao(a, false);
-            }
-            let e = this.yd;
-            let f = this.yf;
-            let g = new ScalerParams(1, XamGeographicMap.aad, this.x5, e.df);
-            g.c = this.xr;
-            let h = new ScalerParams(1, XamGeographicMap.aad, this.x5, f.df);
-            h.c = this.xr;
-            let i = this.yd.ft(d.left, g);
-            let j = this.yd.ft(d.right, g);
-            let k = this.yf.ft(d.top, h);
-            let l = this.yf.ft(d.bottom, h);
-            let m = (i - c) / this.x5.width;
-            let n = (l - c) / this.x5.height;
-            let o = (j - i + (c * 2)) / this.x5.width;
-            let p = (k - l + (c * 2)) / this.x5.height;
+                d = this.abs(a, false);
+            }
+            let e = this.zh;
+            let f = this.zj;
+            let g = new ScalerParams(1, XamGeographicMap.abh, this.y9, e.dn);
+            g.c = this.yv;
+            let h = new ScalerParams(1, XamGeographicMap.abh, this.y9, f.dn);
+            h.c = this.yv;
+            let i = this.zh.f5(d.left, g);
+            let j = this.zh.f5(d.right, g);
+            let k = this.zj.f5(d.top, h);
+            let l = this.zj.f5(d.bottom, h);
+            let m = (i - c) / this.y9.width;
+            let n = (l - c) / this.y9.height;
+            let o = (j - i + (c * 2)) / this.y9.width;
+            let p = (k - l + (c * 2)) / this.y9.height;
             let q = new Rect(0, m, n, o, p);
-            q.intersect(XamGeographicMap.aad);
+            q.intersect(XamGeographicMap.abh);
             if (q.isEmpty) {
-                q = XamGeographicMap.aad;
+                q = XamGeographicMap.abh;
             }
             return q;
         }
@@ -256,188 +256,188 @@ export let XamGeographicMap = /*@__PURE__*/ (() => {
             let e = b.x - a.x;
             let f = a.y - b.y;
             if (e < 0 || f < 0) {
-                return XamGeographicMap.aad;
+                return XamGeographicMap.abh;
             }
             else {
                 let g = new Rect(0, c, d, e, f);
                 return this.getZoomFromGeographicRect(g);
             }
         }
-        aak(a) {
-            let b = this.yd;
-            let c = this.yf;
-            let d = new ScalerParams(1, a, this.x5, b.df);
-            d.c = this.xr;
-            let e = new ScalerParams(1, a, this.x5, c.df);
-            e.c = this.xr;
-            let f = this.xq;
-            let g = b.fw(f.left, d);
-            let h = c.fw(f.top, e);
-            let i = b.fw(f.right, d);
-            let j = c.fw(f.bottom, e);
+        abo(a) {
+            let b = this.zh;
+            let c = this.zj;
+            let d = new ScalerParams(1, a, this.y9, b.dn);
+            d.c = this.yv;
+            let e = new ScalerParams(1, a, this.y9, c.dn);
+            e.c = this.yv;
+            let f = this.yu;
+            let g = b.f8(f.left, d);
+            let h = c.f8(f.top, e);
+            let i = b.f8(f.right, d);
+            let j = c.f8(f.bottom, e);
             let k = i - g;
             let l = h - j;
             let m = new Rect(0, g, j, k, l);
-            if (this.c4 == 1) {
-                m.intersect(XamGeographicMap.aaa);
+            if (this.db == 1) {
+                m.intersect(XamGeographicMap.abe);
                 if (m.isEmpty) {
-                    m = XamGeographicMap.aaa;
+                    m = XamGeographicMap.abe;
                 }
             }
             return m;
         }
-        z6(a) {
-            let b = this.yd.p6(a.x);
-            let c = this.yf.p6(a.y);
+        aba(a) {
+            let b = this.zh.q8(a.x);
+            let c = this.zj.q8(a.y);
             return { $type: Point_$type, x: b, y: c };
         }
-        z7(a) {
-            let b = this.yd.gg(a.x);
-            let c = this.yf.gg(a.y);
+        abb(a) {
+            let b = this.zh.gs(a.x);
+            let c = this.zj.gs(a.y);
             return { $type: Point_$type, x: b, y: c };
         }
-        z8(a) {
-            return this.z7(a);
+        abc(a) {
+            return this.abb(a);
         }
-        zh() {
+        aal() {
             let a = typeCast(GeographicMapImagery.$, this.backgroundContent);
             if (a != null) {
                 a.clearTileCache();
             }
         }
-        zn(a) {
+        aar(a) {
         }
-        gx() {
+        hc() {
             return true;
         }
-        zp() {
-            this.yp.ee();
-            for (let a of fromEnum(this.series)) {
-                a.sl();
+        aat() {
+            this.zt.eh();
+            for (let a of fromEnum(this.b9)) {
+                a.st();
             }
         }
-        zs() {
-            if (this.yo == 2) {
-                if (!this.x5.isEmpty && this.x5.width > 0 && this.x5.height > 0) {
-                    let a = this.yd.p6(this.x5.left + (this.x5.width / 2));
-                    let b = this.yf.p6(this.x5.top + (this.x5.height / 2));
-                    this.z5 = { $type: Point_$type, x: a, y: b };
+        aaw() {
+            if (this.zs == 2) {
+                if (!this.y9.isEmpty && this.y9.width > 0 && this.y9.height > 0) {
+                    let a = this.zh.q8(this.y9.left + (this.y9.width / 2));
+                    let b = this.zj.q8(this.y9.top + (this.y9.height / 2));
+                    this.aa9 = { $type: Point_$type, x: a, y: b };
                 }
             }
             else {
-                if (!this.x5.isEmpty && this.x5.width > 0 && this.x5.height > 0) {
-                    let c = this.yd.p6(this.x5.left);
-                    let d = this.yf.p6(this.x5.top);
-                    this.z5 = { $type: Point_$type, x: c, y: d };
+                if (!this.y9.isEmpty && this.y9.width > 0 && this.y9.height > 0) {
+                    let c = this.zh.q8(this.y9.left);
+                    let d = this.zj.q8(this.y9.top);
+                    this.aa9 = { $type: Point_$type, x: c, y: d };
                 }
             }
         }
-        zo() {
-            if (isNaN_(this.z5.x) || isNaN_(this.z5.y)) {
-                this.zs();
+        aas() {
+            if (isNaN_(this.aa9.x) || isNaN_(this.aa9.y)) {
+                this.aaw();
             }
-            let a = this.z5.x;
-            let b = this.z5.y;
+            let a = this.aa9.x;
+            let b = this.aa9.y;
             if (!isNaN_(a) && !isNaN_(b)) {
-                let c = this.xn.left;
-                let d = this.xn.top;
-                let e = this.xn.width;
-                let f = this.xn.height;
-                if (e > this.aac.width) {
+                let c = this.yr.left;
+                let d = this.yr.top;
+                let e = this.yr.width;
+                let f = this.yr.height;
+                if (e > this.abg.width) {
                 }
                 else {
-                    let g = new ScalerParams(1, XamGeographicMap.aad, this.x5, this.yd.df);
-                    g.c = this.xr;
-                    let h = this.yd.ft(a, g);
-                    if (this.yo == 2) {
-                        let i = h / this.x5.width;
+                    let g = new ScalerParams(1, XamGeographicMap.abh, this.y9, this.zh.dn);
+                    g.c = this.yv;
+                    let h = this.zh.f5(a, g);
+                    if (this.zs == 2) {
+                        let i = h / this.y9.width;
                         c = i - (e / 2);
                     }
                     else {
-                        c = h / this.x5.width;
+                        c = h / this.y9.width;
                     }
-                    if (c + e > this.aac.right) {
-                        c = this.aac.right - e;
+                    if (c + e > this.abg.right) {
+                        c = this.abg.right - e;
                     }
-                    else if (c < this.aac.left) {
-                        c = this.aac.left;
+                    else if (c < this.abg.left) {
+                        c = this.abg.left;
                     }
                 }
-                if (f > this.aac.height) {
+                if (f > this.abg.height) {
                 }
                 else {
-                    let j = new ScalerParams(1, XamGeographicMap.aad, this.x5, this.yf.df);
-                    j.c = this.xr;
-                    let k = this.yf.ft(b, j);
-                    if (this.yo == 2) {
-                        let l = k / this.x5.height;
+                    let j = new ScalerParams(1, XamGeographicMap.abh, this.y9, this.zj.dn);
+                    j.c = this.yv;
+                    let k = this.zj.f5(b, j);
+                    if (this.zs == 2) {
+                        let l = k / this.y9.height;
                         d = l - (f / 2);
                     }
                     else {
-                        d = k / this.x5.height;
+                        d = k / this.y9.height;
                     }
-                    if (d + f > this.aac.bottom) {
-                        d = this.aac.bottom - f;
+                    if (d + f > this.abg.bottom) {
+                        d = this.abg.bottom - f;
                     }
-                    else if (d < this.aac.top) {
-                        d = this.aac.top;
+                    else if (d < this.abg.top) {
+                        d = this.abg.top;
                     }
                 }
-                this.ta(new Rect(0, c, d, e, f), false);
+                this.ud(new Rect(0, c, d, e, f), false);
             }
         }
-        get_ft() {
+        get_f6() {
             return true;
         }
-        xo() {
-            let a = super.xo();
-            if (this.yd == null || this.yf == null) {
+        ys() {
+            let a = super.ys();
+            if (this.zh == null || this.zj == null) {
                 return a;
             }
-            this.xz();
+            this.y3();
             let b = a.left;
             let c = a.top;
-            if (this.c4 == 1) {
-                if (this.x6.width > this.aac.width) {
-                    b = 0.5 - (this.x6.width / 2);
+            if (this.db == 1) {
+                if (this.za.width > this.abg.width) {
+                    b = 0.5 - (this.za.width / 2);
                 }
-                else if (b + a.width > this.aac.right) {
-                    b = this.aac.right - this.x6.width;
+                else if (b + a.width > this.abg.right) {
+                    b = this.abg.right - this.za.width;
                 }
-                else if (b < this.aac.left) {
-                    b = this.aac.left;
+                else if (b < this.abg.left) {
+                    b = this.abg.left;
                 }
-                if (this.x6.height > this.aac.height) {
-                    c = 0.5 - (this.x6.height / 2);
+                if (this.za.height > this.abg.height) {
+                    c = 0.5 - (this.za.height / 2);
                 }
-                else if (c + this.x6.height > this.aac.bottom) {
-                    c = this.aac.bottom - this.x6.height;
+                else if (c + this.za.height > this.abg.bottom) {
+                    c = this.abg.bottom - this.za.height;
                 }
-                else if (c < this.aac.top) {
-                    c = this.aac.top;
+                else if (c < this.abg.top) {
+                    c = this.abg.top;
                 }
             }
             let d = false;
-            if (!this.yu && this.c4 == 2 && this.yr) {
+            if (!this.zy && this.db == 2 && this.zv) {
                 if (b > 1) {
                     b = (b - Math.floor(b)) + 1;
                 }
                 if (b < 0) {
                     b = 0 - (Math.ceil(b) - b);
                 }
-                if ((a.right - this.aac.right) > 0 && ((a.right - this.aac.right) / a.width) > 0.8) {
-                    b = this.aac.left - (a.width - (a.right - this.aac.right));
+                if ((a.right - this.abg.right) > 0 && ((a.right - this.abg.right) / a.width) > 0.8) {
+                    b = this.abg.left - (a.width - (a.right - this.abg.right));
                     d = true;
                 }
-                else if (a.left < this.aac.left && (Math.abs(a.left - this.aac.left) / a.width) > 0.8) {
-                    b = this.aac.right - (Math.abs(a.left - this.aac.left));
+                else if (a.left < this.abg.left && (Math.abs(a.left - this.abg.left) / a.width) > 0.8) {
+                    b = this.abg.right - (Math.abs(a.left - this.abg.left));
                     d = true;
                 }
             }
             let e = new Rect(0, b, c, a.width, a.height);
-            if (this.yu) {
-                let f = this.aaf(this.aaq, 1);
-                f = this.aah(f);
+            if (this.zy) {
+                let f = this.abj(this.abu, 1);
+                f = this.abl(f);
                 let g = e.left + e.width / 2;
                 let h = e.top + e.height / 2;
                 if (e.width > f.width) {
@@ -472,17 +472,17 @@ export let XamGeographicMap = /*@__PURE__*/ (() => {
                 }
             }
             if (d) {
-                this.ff = true;
-                this.x6 = e;
-                this.ff = false;
+                this.fp = true;
+                this.za = e;
+                this.fp = false;
             }
             return e;
         }
-        n2(a, b) {
+        oj(a, b) {
             let c = true;
             let d = true;
             let e = 0;
-            let f = this.xz();
+            let f = this.y3();
             let g = 0;
             let h = 0;
             if ((a.right - f.right) > 0) {
@@ -499,39 +499,39 @@ export let XamGeographicMap = /*@__PURE__*/ (() => {
             }
             if (c) {
                 if (d) {
-                    let i = this.yc.ft(-180, b);
-                    let j = this.yc.ft(180, b);
+                    let i = this.zg.f5(-180, b);
+                    let j = this.zg.f5(180, b);
                     e = j - i;
                 }
                 else {
-                    let k = this.yc.ft(-180, b);
-                    let l = this.yc.ft(180, b);
+                    let k = this.zg.f5(-180, b);
+                    let l = this.zg.f5(180, b);
                     e = k - l;
                 }
             }
             return new Tuple$2(Boolean_$type, Number_$type, c, e);
         }
-        xz() {
-            let a = new ScalerParams(1, XamGeographicMap.aad, this.x5, this.yd.df);
-            a.c = this.xr;
-            let b = new ScalerParams(1, XamGeographicMap.aad, this.x5, this.yf.df);
-            b.c = this.xr;
-            let c = this.yd.ft(XamGeographicMap.aaa.left, a);
-            let d = this.yd.ft(XamGeographicMap.aaa.right, a);
-            let e = this.yf.ft(XamGeographicMap.aaa.top, b);
-            let f = this.yf.ft(XamGeographicMap.aaa.bottom, b);
-            this.aac = new Rect(0, c / this.x5.width, f / this.x5.height, (d - c) / this.x5.width, (e - f) / this.x5.height);
-            return this.aac;
-        }
-        aah(a) {
-            let b = this.h7;
+        y3() {
+            let a = new ScalerParams(1, XamGeographicMap.abh, this.y9, this.zh.dn);
+            a.c = this.yv;
+            let b = new ScalerParams(1, XamGeographicMap.abh, this.y9, this.zj.dn);
+            b.c = this.yv;
+            let c = this.zh.f5(XamGeographicMap.abe.left, a);
+            let d = this.zh.f5(XamGeographicMap.abe.right, a);
+            let e = this.zj.f5(XamGeographicMap.abe.top, b);
+            let f = this.zj.f5(XamGeographicMap.abe.bottom, b);
+            this.abg = new Rect(0, c / this.y9.width, f / this.y9.height, (d - c) / this.y9.width, (e - f) / this.y9.height);
+            return this.abg;
+        }
+        abl(a) {
+            let b = this.io;
             let c = 0.5 * (a.left + a.right);
             let d = 0.5 * (a.top + a.bottom);
             let e = a.width;
             let f = a.height;
-            let g = MathUtil.d(a.width, b, 1);
-            let h = MathUtil.d(a.height, b, 1);
-            let i = this.x5;
+            let g = MathUtil.e(a.width, b, 1);
+            let h = MathUtil.e(a.height, b, 1);
+            let i = this.y9;
             let j = i.width / i.height;
             let k = g * i.width;
             let l = h * i.height;
@@ -570,8 +570,8 @@ export let XamGeographicMap = /*@__PURE__*/ (() => {
             }
             return new Rect(0, p, q, r - p, s - q);
         }
-        xp(a) {
-            super.xp(this.x5);
+        yt(a) {
+            super.yt(this.y9);
             if (a.isEmpty) {
                 return Rect.empty;
             }
@@ -586,275 +586,275 @@ export let XamGeographicMap = /*@__PURE__*/ (() => {
             }
             return b;
         }
-        aaj(a) {
-            return this.xp(a);
+        abn(a) {
+            return this.yt(a);
         }
-        dn() {
+        dv() {
             return new XamGeographicMapView(this);
         }
-        zj(a) {
+        aan(a) {
             if (a != null) {
-                a.b0 = this;
+                a.b2 = this;
             }
         }
-        q5(a) {
-            super.q5(a);
-            this.yp = a;
+        rw(a) {
+            super.rw(a);
+            this.zt = a;
         }
-        rg(a, b) {
-            super.rg(a, b);
-            this.sy(this.yd);
-            this.sy(this.yf);
+        r7(a, b) {
+            super.r7(a, b);
+            this.tz(this.zh);
+            this.tz(this.zj);
             if (Rect.l_op_Inequality(a, b)) {
-                this.zo();
+                this.aas();
             }
-            if (this.yu) {
-                this.xn = this.xo();
+            if (this.zy) {
+                this.yr = this.ys();
             }
-            this.zv();
+            this.aaz();
         }
-        get yz() {
-            return this.yx;
+        get z3() {
+            return this.z1;
         }
-        set yz(a) {
-            let b = this.yx;
-            this.yx = a;
-            this.ry("ActualWindowScale", b, this.yx);
+        set z3(a) {
+            let b = this.z1;
+            this.z1 = a;
+            this.sr("ActualWindowScale", b, this.z1);
         }
-        id() {
-            return this.yz;
+        iu() {
+            return this.z3;
         }
-        ie() {
-            return this.yz;
+        iv() {
+            return this.z3;
         }
-        sx() {
-            super.sx();
-            let a = Math.min(this.xn.width, this.xn.height);
-            this.yz = a;
+        ty() {
+            super.ty();
+            let a = Math.min(this.yr.width, this.yr.height);
+            this.z3 = a;
         }
-        gl() {
-            return this.yr;
+        g0() {
+            return this.zv;
         }
-        c5() {
-            if (this.c6 == 0) {
-                if (this.ys) {
+        dc() {
+            if (this.dd == 0) {
+                if (this.zw) {
                     return 2;
                 }
             }
-            return this.c6;
+            return this.dd;
         }
-        rh(a, b, c, d) {
-            super.rh(a, b, c, d);
+        r8(a, b, c, d) {
+            super.r8(a, b, c, d);
             switch (b) {
                 case "ZoomCoercionMode":
-                    this.zk();
+                    this.aao();
                     break;
                 case "WindowRect":
-                    this.zs();
+                    this.aaw();
                     break;
                 case XamGeographicMap.$$p[0]:
-                    this.yl = this.ym();
-                    if (this.yi != null) {
-                        this.yi.isHorizontalWrappingEnabled = this.yl == 2;
+                    this.zp = this.zq();
+                    if (this.zm != null) {
+                        this.zm.isHorizontalWrappingEnabled = this.zp == 2;
                     }
                     break;
                 case XamGeographicMap.$$p[1]:
-                    this.yr = this.ys;
-                    this.yl = this.ym();
-                    this.c4 = this.c5();
-                    if (this.yi != null) {
-                        this.yi.isHorizontalWrappingEnabled = this.yl == 2;
+                    this.zv = this.zw;
+                    this.zp = this.zq();
+                    this.db = this.dc();
+                    if (this.zm != null) {
+                        this.zm.isHorizontalWrappingEnabled = this.zp == 2;
                     }
                     break;
                 case XamGeographicMap.$$p[4]:
-                    this.xn = this.xo();
+                    this.yr = this.ys();
                     break;
                 case "BackgroundContent":
-                    if (this.yi != null) {
-                        let e = this.yi;
-                        e.imageTilesReady = delegateRemove(e.imageTilesReady, runOn(this, this.zl));
-                        this.yi.deferralHandler = null;
+                    if (this.zm != null) {
+                        let e = this.zm;
+                        e.imageTilesReady = delegateRemove(e.imageTilesReady, runOn(this, this.aap));
+                        this.zm.deferralHandler = null;
                     }
-                    this.yi = typeCast(GeographicMapImagery.$, this.backgroundContent);
-                    if (this.yi != null) {
-                        let f = this.yi;
-                        f.imageTilesReady = delegateCombine(f.imageTilesReady, runOn(this, this.zl));
-                        this.yi.deferralHandler = this;
-                        this.yi.isHorizontalWrappingEnabled = this.yl == 2;
+                    this.zm = typeCast(GeographicMapImagery.$, this.backgroundContent);
+                    if (this.zm != null) {
+                        let f = this.zm;
+                        f.imageTilesReady = delegateCombine(f.imageTilesReady, runOn(this, this.aap));
+                        this.zm.deferralHandler = this;
+                        this.zm.isHorizontalWrappingEnabled = this.zp == 2;
                     }
-                    this.yp.fu(typeCast(GeographicMapImagery.$, c), typeCast(GeographicMapImagery.$, d));
-                    if (this.yi != null) {
-                        this.yi.geographicMap = this;
-                        this.yp.fr(this.xn);
-                        this.yp.fv(this.h3);
+                    this.zt.fx(typeCast(GeographicMapImagery.$, c), typeCast(GeographicMapImagery.$, d));
+                    if (this.zm != null) {
+                        this.zm.geographicMap = this;
+                        this.zt.fu(this.yr);
+                        this.zt.fy(this.ij);
                     }
                     break;
                 case "YAxis":
                 case "XAxis":
-                    this.zq(c);
-                    this.zj(d);
+                    this.aau(c);
+                    this.aan(d);
                     break;
                 case XamGeographicMap.$$p[6]:
-                    if (!this.yt) {
-                        this.x6 = XamGeographicMap.aad;
+                    if (!this.zx) {
+                        this.za = XamGeographicMap.abh;
                     }
-                    this.zk();
-                    this.zr();
-                    this.zs();
-                    this.xn = this.xo();
-                    this.yp.fs();
+                    this.aao();
+                    this.aav();
+                    this.aaw();
+                    this.yr = this.ys();
+                    this.zt.fv();
                     break;
                 case "ActualWindowRect":
-                    this.yp.fr(this.xn);
+                    this.zt.fu(this.yr);
                     break;
                 case "ActualWorldRect":
-                    for (let g of fromEnum(this.series)) {
-                        g.rz(false);
+                    for (let g of fromEnum(this.b9)) {
+                        g.r7(false);
                     }
                     break;
                 case XamGeographicMap.$$p[5]:
-                    this.yz = this.y0;
+                    this.z3 = this.z4;
                     break;
                 case "ActualWindowScale":
-                    if (!this.gt) {
-                        this.s8(this.id(), this.ie());
+                    if (!this.g8) {
+                        this.ua(this.iu(), this.iv());
                     }
                     break;
                 case "ActualPixelScalingRatio":
-                    this.yp.fv(this.h3);
+                    this.zt.fy(this.ij);
                     break;
                 case "WindowRectMinWidth":
                 case "WindowRectMinHeight":
                     let h = d;
                     if (isNaN_(h) || isInfinity(h)) {
-                        this.h7 = 5E-06;
-                        this.h6 = 5E-06;
+                        this.io = 5E-06;
+                        this.im = 5E-06;
                     }
                     else {
-                        this.h7 = h;
-                        this.h6 = h;
+                        this.io = h;
+                        this.im = h;
                     }
                     break;
                 case XamGeographicMap.$$p[7]:
-                    this.s4();
+                    this.t5();
                     break;
                 case "MarkerAutomaticBehavior":
-                    for (let i of fromEnum(this.series)) {
-                        i.qn();
+                    for (let i of fromEnum(this.b9)) {
+                        i.qu();
                     }
                     break;
             }
         }
-        zl(a, b) {
+        aap(a, b) {
             if (this.imageTilesReady != null) {
                 this.imageTilesReady(this, new ImageTilesReadyEventArgs());
             }
         }
-        zq(a) {
+        aau(a) {
             if (a != null) {
-                a.b0 = null;
+                a.b2 = null;
             }
         }
-        zr() {
-            if (this.yd != null) {
-                this.yd.p3 = this.aae.left;
-                this.yd.p2 = this.aae.right;
+        aav() {
+            if (this.zh != null) {
+                this.zh.q5 = this.abi.left;
+                this.zh.q4 = this.abi.right;
             }
-            if (this.yf != null) {
-                this.yf.p3 = this.aae.top;
-                this.yf.p2 = this.aae.bottom;
+            if (this.zj != null) {
+                this.zj.q5 = this.abi.top;
+                this.zj.q4 = this.abi.bottom;
             }
-            this.yd.d3(true);
-            this.yf.d3(true);
+            this.zh.ed(true);
+            this.zj.ed(true);
         }
         getFontInfo() {
-            this.yq = this.yp.fo;
-            return this.yq;
+            this.zu = this.zt.fr;
+            return this.zu;
         }
-        wr() {
-            return this.yp.fw;
+        xv() {
+            return this.zt.fz;
         }
         getFontBrush() {
-            return this.yp.fx;
+            return this.zt.f0;
         }
-        sq(a, b) {
+        tk(a, b) {
             if (typeCast(ItfConverter.$, b) !== null) {
                 let c = b;
                 let d = a;
                 d.itemsSource = c.triangulationSource.points;
-                d.xk = c.triangulationSource.triangles;
+                d.xt = c.triangulationSource.triangles;
             }
             else {
-                super.sq(a, b);
+                super.tk(a, b);
             }
         }
         register(a, b) {
-            this.sd(a, b);
+            this.s6(a, b);
         }
         unRegister(a) {
-            this.sw(a);
+            this.tx(a);
         }
         deferredRefresh() {
-            this.og();
+            this.o0();
         }
         deferAction(a) {
-            if (this.y2 != null) {
-                this.y2.setTimeout(a, 0);
+            if (this.z6 != null) {
+                this.z6.setTimeout(a, 0);
             }
             else {
                 window.setTimeout(a, 0);
             }
         }
-        zi(a) {
-            this.s3(a);
+        aam(a) {
+            this.t4(a);
         }
-        y3() {
+        z7() {
             let a = new ChartVisualData();
-            let b = this.yd.hb();
-            let c = this.yf.hb();
+            let b = this.zh.hr();
+            let c = this.zj.hr();
             a.axes.add1(b);
             a.axes.add1(c);
-            for (let d = 0; d < this.series.count; d++) {
-                let e = this.series._inner[d].kq();
+            for (let d = 0; d < this.b9.count; d++) {
+                let e = this.b9._inner[d].kv();
                 a.series.add1(e);
             }
             a.name = this.name;
-            a.contentArea = RectData.b(this.x5);
-            a.centralArea = RectData.b(this.x5);
-            a.plotArea = RectData.b(this.x5);
+            a.contentArea = RectData.b(this.y9);
+            a.centralArea = RectData.b(this.y9);
+            a.plotArea = RectData.b(this.y9);
             return a;
         }
-        xv(a, b, c) {
+        yz(a, b, c) {
             return a;
         }
-        zm() {
+        aaq() {
         }
-        get aap() {
-            return this.aab;
+        get abt() {
+            return this.abf;
         }
-        set aap(a) {
-            this.aab = a;
+        set abt(a) {
+            this.abf = a;
         }
-        zw(a) {
-            this.aap = a;
-            this.zv();
+        aa0(a) {
+            this.abt = a;
+            this.aaz();
         }
-        zv() {
-            if (this.yw && !this.aap.isEmpty) {
-                let a = this.getZoomFromGeographicRect(this.aap);
-                this.aap = Rect.empty;
-                this.ta(a, false);
+        aaz() {
+            if (this.z0 && !this.abt.isEmpty) {
+                let a = this.getZoomFromGeographicRect(this.abt);
+                this.abt = Rect.empty;
+                this.ud(a, false);
             }
         }
-        get yw() {
-            return !this.x5.isEmpty && !this.xr.isEmpty;
+        get z0() {
+            return !this.y9.isEmpty && !this.yv.isEmpty;
         }
     }
     XamGeographicMap.$t = markType(XamGeographicMap, 'XamGeographicMap', SeriesViewer.$, [IMapRenderDeferralHandler_$type]);
-    XamGeographicMap.yn = 0;
-    XamGeographicMap.aaa = new Rect(2, { $type: Point_$type, x: -180, y: -85.05112878 }, { $type: Point_$type, x: 180, y: 85.05112878 });
-    XamGeographicMap.aad = new Rect(0, 0, 0, 1, 1);
-    XamGeographicMap.$$p = markDep(DependencyProperty, PropertyMetadata, XamGeographicMap, 'ry', ['BackgroundTilingMode:yk:zx', [MapBackgroundTilingMode_$type, enumGetBox(MapBackgroundTilingMode_$type, 0)], 'IsHorizontalWrappingEnabled:ys:zy', [0, false], 'ResizeBehavior:yo:zz', [MapResizeBehavior_$type, enumGetBox(MapResizeBehavior_$type, XamGeographicMap.yn)], 'SuppressZoomResetOnWorldRectChange:yt:z0', [0, false], 'UseWorldRectForZoomBounds:yu:z1', [0, false], 'WindowScale:y0:z2', [1, NaN], 'WorldRect:aaq:z3', [Rect.$, XamGeographicMap.aaa], 'Zoomable:yv:z4', [0, true]]);
+    XamGeographicMap.zr = 0;
+    XamGeographicMap.abe = new Rect(2, { $type: Point_$type, x: -180, y: -85.05112878 }, { $type: Point_$type, x: 180, y: 85.05112878 });
+    XamGeographicMap.abh = new Rect(0, 0, 0, 1, 1);
+    XamGeographicMap.$$p = markDep(DependencyProperty, PropertyMetadata, XamGeographicMap, 'sr', ['BackgroundTilingMode:zo:aa1', [MapBackgroundTilingMode_$type, enumGetBox(MapBackgroundTilingMode_$type, 0)], 'IsHorizontalWrappingEnabled:zw:aa2', [0, false], 'ResizeBehavior:zs:aa3', [MapResizeBehavior_$type, enumGetBox(MapResizeBehavior_$type, XamGeographicMap.zr)], 'SuppressZoomResetOnWorldRectChange:zx:aa4', [0, false], 'UseWorldRectForZoomBounds:zy:aa5', [0, false], 'WindowScale:z4:aa6', [1, NaN], 'WorldRect:abu:aa7', [Rect.$, XamGeographicMap.abe], 'Zoomable:zz:aa8', [0, true]]);
     return XamGeographicMap;
 })();
 /**
@@ -984,20 +984,20 @@ export let GeographicMapImagery = /*@__PURE__*/ (() => {
                 return a;
             }
             let b = new Rect(0, 0, 0, a.width, a.height);
-            let c = this.geographicMap.aaj(b);
-            let d = XamGeographicMap.aaa;
-            let e = this.geographicMap.aae;
+            let c = this.geographicMap.abn(b);
+            let d = XamGeographicMap.abe;
+            let e = this.geographicMap.abi;
             let f = Math.min(this.windowRect.height, this.windowRect.width);
             let g = e.width / d.width;
             this.ao.a5 = (b.width / c.width) * f * g;
-            let h = this.geographicMap.yd;
-            let i = this.geographicMap.yf;
-            let j = new ScalerParams(1, this.windowRect, b, h.df);
+            let h = this.geographicMap.zh;
+            let i = this.geographicMap.zj;
+            let j = new ScalerParams(1, this.windowRect, b, h.dn);
             j.c = c;
-            let k = new ScalerParams(1, this.windowRect, b, i.df);
+            let k = new ScalerParams(1, this.windowRect, b, i.dn);
             k.c = c;
-            let l = h.ft(d.left, j);
-            let m = i.ft(d.bottom, k);
+            let l = h.f5(d.left, j);
+            let m = i.f5(d.bottom, k);
             let n = (-l / b.width) * this.ao.a5;
             let o = (-m / b.height) * this.ao.a5 * (b.height / b.width);
             this.ao.cm = { $type: Point_$type, x: n, y: o };
@@ -1091,41 +1091,41 @@ export let GeographicXYTriangulatingSeriesView = /*@__PURE__*/ (() => {
         }
         ci() {
             super.ci();
-            let a = this.cu.xb;
-            a.yb = this.cu.xn;
-            a.yj = this.cu.xl;
-            a.trianglesSource = this.cu.xk;
-            a.xz = this.cu.xq;
-            a.x1 = this.cu.xs;
-            a.x3 = this.cu.xu;
+            let a = this.cu.xk;
+            a.yk = this.cu.xw;
+            a.ys = this.cu.xu;
+            a.trianglesSource = this.cu.xt;
+            a.x8 = this.cu.xz;
+            a.ya = this.cu.x1;
+            a.yc = this.cu.x3;
         }
         cx() {
-            let a = this.cu.xb;
+            let a = this.cu.xk;
             if (this.cu.dc == null) {
-                a.w9 = null;
-                a.xa = null;
+                a.xi = null;
+                a.xj = null;
                 return;
             }
-            a.w9 = this.cu.dc.yd;
-            a.xa = this.cu.dc.yf;
+            a.xi = this.cu.dc.zh;
+            a.xj = this.cu.dc.zj;
         }
         cw() {
-            this.cu.xb.yb = this.cu.xn;
+            this.cu.xk.yk = this.cu.xw;
         }
         cv() {
-            this.cu.xb.yj = this.cu.xl;
+            this.cu.xk.ys = this.cu.xu;
         }
         cy() {
-            this.cu.xb.trianglesSource = this.cu.xk;
+            this.cu.xk.trianglesSource = this.cu.xt;
         }
         cz() {
-            this.cu.xb.xz = this.cu.xq;
+            this.cu.xk.x8 = this.cu.xz;
         }
         c0() {
-            this.cu.xb.x1 = this.cu.xs;
+            this.cu.xk.ya = this.cu.x1;
         }
         c1() {
-            this.cu.xb.x3 = this.cu.xu;
+            this.cu.xk.yc = this.cu.x3;
         }
     }
     GeographicXYTriangulatingSeriesView.$t = markType(GeographicXYTriangulatingSeriesView, 'GeographicXYTriangulatingSeriesView', HostSeriesView.$);
@@ -1148,19 +1148,19 @@ export let GeographicScatterAreaSeriesView = /*@__PURE__*/ (() => {
         }
         ci() {
             super.ci();
-            if (this.c2.x5 != null) {
-                this.c2.x5.zi = this.c2.x9;
-                this.c2.x5.y6 = this.c2.x4;
+            if (this.c2.ye != null) {
+                this.c2.ye.zr = this.c2.yi;
+                this.c2.ye.zf = this.c2.yd;
             }
         }
         c3() {
-            if (this.c2.x5 != null) {
-                this.c2.x5.zi = this.c2.x9;
+            if (this.c2.ye != null) {
+                this.c2.ye.zr = this.c2.yi;
             }
         }
         c4() {
-            if (this.c2.x5 != null) {
-                this.c2.x5.y6 = this.c2.x4;
+            if (this.c2.ye != null) {
+                this.c2.ye.zf = this.c2.yd;
             }
         }
     }
@@ -1174,29 +1174,29 @@ export let XamGeographicMapView = /*@__PURE__*/ (() => {
     class XamGeographicMapView extends SeriesViewerView {
         constructor(a) {
             super(a);
-            this.fn = null;
+            this.fq = null;
+            this.f2 = null;
+            this.f0 = null;
             this.fz = null;
-            this.fx = null;
-            this.fw = null;
-            this.fo = null;
-            this.fp = NaN;
-            this.fz = Rect.empty;
-            this.fn = a;
-            this.fn.wk = 2;
-            this.fn.jh = 5E-06;
+            this.fr = null;
+            this.fs = NaN;
+            this.f2 = Rect.empty;
+            this.fq = a;
+            this.fq.xo = 2;
+            this.fq.jw = 5E-06;
         }
         m(a) {
             return 2;
         }
-        bk(a) {
+        bn(a) {
             this.j.bw(a);
-            this.fn.zi(a);
-            this.el();
+            this.fq.aam(a);
+            this.eo();
         }
-        get_ap() {
+        get_aq() {
             return true;
         }
-        d4() {
+        d7() {
             let a;
             let b;
             let c;
@@ -1208,63 +1208,63 @@ export let XamGeographicMapView = /*@__PURE__*/ (() => {
             c = f.p2;
             d = f.p3;
             e = f.p4;
-            this.fx = c;
-            this.fo = d;
-            this.fw = e;
+            this.f0 = c;
+            this.fr = d;
+            this.fz = e;
             let g = this.j.e();
-            this.fn.ag = g.a;
-            this.fn.aj = g.f;
-            this.fn.ah = g.b != null ? g.b : new BrushCollection();
-            this.fn.ai = g.c != null ? g.c : new BrushCollection();
-            if (this.fn.ah.count == 0) {
+            this.fq.ag = g.a;
+            this.fq.aj = g.f;
+            this.fq.ah = g.b != null ? g.b : new BrushCollection();
+            this.fq.ai = g.c != null ? g.c : new BrushCollection();
+            if (this.fq.ah.count == 0) {
                 for (let h = 0; h < g.a.count; h++) {
-                    this.fn.ah.add(g.a.item(h));
+                    this.fq.ah.add(g.a.item(h));
                 }
             }
             if (g.c.count == 0) {
                 for (let i = 0; i < g.f.count; i++) {
-                    this.fn.ai.add(g.f.item(i));
+                    this.fq.ai.add(g.f.item(i));
                 }
             }
         }
-        du(a) {
-            super.du(a);
-            if (this.fn.backgroundContent != null) {
-                let b = this.fn.backgroundContent;
+        dx(a) {
+            super.dx(a);
+            if (this.fq.backgroundContent != null) {
+                let b = this.fq.backgroundContent;
                 b.be(this.j.ae);
                 b.bd(a);
             }
         }
-        dv(a) {
-            super.dv(a);
-            this.fz = a;
-            if (this.fn.backgroundContent != null) {
-                let b = this.fn.backgroundContent;
-                b.bf(this.fz);
+        dy(a) {
+            super.dy(a);
+            this.f2 = a;
+            if (this.fq.backgroundContent != null) {
+                let b = this.fq.backgroundContent;
+                b.bf(this.f2);
             }
         }
-        fy() {
-            return new Rect(0, 0, 0, this.fz.width, this.fz.height);
+        f1() {
+            return new Rect(0, 0, 0, this.f2.width, this.f2.height);
         }
-        fs() {
-            if (this.fn.backgroundContent != null) {
-                let a = this.fn.backgroundContent;
+        fv() {
+            if (this.fq.backgroundContent != null) {
+                let a = this.fq.backgroundContent;
                 a.a6();
             }
         }
-        fr(a) {
-            if (this.fn.yi != null) {
-                this.fn.yi.windowRect = a;
+        fu(a) {
+            if (this.fq.zm != null) {
+                this.fq.zm.windowRect = a;
             }
         }
-        fu(a, b) {
-            if (this.fn.yi != null) {
-                this.fn.yi.windowRect = this.fn.xn;
+        fx(a, b) {
+            if (this.fq.zm != null) {
+                this.fq.zm.windowRect = this.fq.yr;
             }
             if (a != null) {
                 let c = a.ao;
                 if (c != null) {
-                    this.fn.al.h.remove(c.ag);
+                    this.fq.al.h.remove(c.ag);
                 }
                 a.bd(null);
                 a.be(null);
@@ -1272,48 +1272,48 @@ export let XamGeographicMapView = /*@__PURE__*/ (() => {
             if (b != null) {
                 let d = b.ao;
                 if (d != null) {
-                    this.fn.al.h.add(d.ag);
+                    this.fq.al.h.add(d.ag);
                 }
-                if (!this.fz.isEmpty) {
-                    this.dv(this.fz);
+                if (!this.f2.isEmpty) {
+                    this.dy(this.f2);
                 }
                 if (this.w != null) {
-                    this.du(this.w);
+                    this.dx(this.w);
                 }
             }
             if (b == null) {
-                this.ft(this.w);
+                this.fw(this.w);
             }
         }
-        ft(a) {
-            let b = this.fn.h3;
+        fw(a) {
+            let b = this.fq.ij;
             if (b != 1) {
                 a.aa();
                 a.ab(b, b);
             }
-            a.l(this.fz.left, this.fz.top, this.fz.width, this.fz.height);
+            a.l(this.f2.left, this.f2.top, this.f2.width, this.f2.height);
             if (b != 1) {
                 a.z();
             }
         }
-        d1() {
-            this.fd.ad = Defaults.crosshairLineThickness;
-            this.fe.ad = Defaults.crosshairLineThickness;
-            this.fd._stroke = Defaults.crosshairLineBrush;
-            this.fe._stroke = Defaults.crosshairLineBrush;
-            super.d1();
+        d4() {
+            this.fg.ad = Defaults.crosshairLineThickness;
+            this.fh.ad = Defaults.crosshairLineThickness;
+            this.fg._stroke = Defaults.crosshairLineBrush;
+            this.fh._stroke = Defaults.crosshairLineBrush;
+            super.d4();
         }
-        fv(a) {
-            this.fp = a;
-            if (this.fn.backgroundContent != null) {
-                this.fn.backgroundContent.bc(a);
+        fy(a) {
+            this.fs = a;
+            if (this.fq.backgroundContent != null) {
+                this.fq.backgroundContent.bc(a);
             }
         }
-        get fq() {
-            return this.fp;
+        get ft() {
+            return this.fs;
         }
-        set fq(a) {
-            this.fp = a;
+        set ft(a) {
+            this.fs = a;
         }
     }
     XamGeographicMapView.$t = markType(XamGeographicMapView, 'XamGeographicMapView', SeriesViewerView.$);
@@ -1358,39 +1358,39 @@ export let GeographicXYTriangulatingSeries = /*@__PURE__*/ (() => {
         ct() {
             return new GeographicXYTriangulatingSeriesView(this);
         }
-        q8(a) {
-            super.q8(a);
-            this.xj = a;
+        rg(a) {
+            super.rg(a);
+            this.xs = a;
         }
-        rh(a, b, c, d) {
-            super.rh(a, b, c, d);
+        rp(a, b, c, d) {
+            super.rp(a, b, c, d);
             switch (b) {
                 case "SeriesViewer":
-                    this.xj.cx();
+                    this.xs.cx();
                     break;
                 case GeographicXYTriangulatingSeries.$$p[1]:
-                    this.xj.cw();
+                    this.xs.cw();
                     break;
                 case GeographicXYTriangulatingSeries.$$p[0]:
-                    this.xj.cv();
+                    this.xs.cv();
                     break;
                 case GeographicXYTriangulatingSeries.$$p[5]:
-                    this.xj.cy();
+                    this.xs.cy();
                     break;
                 case GeographicXYTriangulatingSeries.$$p[2]:
-                    this.xj.cz();
+                    this.xs.cz();
                     break;
                 case GeographicXYTriangulatingSeries.$$p[3]:
-                    this.xj.c0();
+                    this.xs.c0();
                     break;
                 case GeographicXYTriangulatingSeries.$$p[4]:
-                    this.xj.c1();
+                    this.xs.c1();
                     break;
             }
         }
     }
     GeographicXYTriangulatingSeries.$t = markType(GeographicXYTriangulatingSeries, 'GeographicXYTriangulatingSeries', GeographicMapSeriesHost.$);
-    GeographicXYTriangulatingSeries.$$p = markDep(DependencyProperty, PropertyMetadata, GeographicXYTriangulatingSeries, 'raisePropertyChanged', ['LatitudeMemberPath:xl:xw', [2, "pointY"], 'LongitudeMemberPath:xn:xx', [2, "pointX"], 'TriangleVertexMemberPath1:xq:xz', [2, "v1"], 'TriangleVertexMemberPath2:xs:x0', [2, "v2"], 'TriangleVertexMemberPath3:xu:x1', [2, "v3"], 'TrianglesSource:xk:xy', [IEnumerable_$type, null]]);
+    GeographicXYTriangulatingSeries.$$p = markDep(DependencyProperty, PropertyMetadata, GeographicXYTriangulatingSeries, 'raisePropertyChanged', ['LatitudeMemberPath:xu:x5', [2, "pointY"], 'LongitudeMemberPath:xw:x6', [2, "pointX"], 'TriangleVertexMemberPath1:xz:x8', [2, "v1"], 'TriangleVertexMemberPath2:x1:x9', [2, "v2"], 'TriangleVertexMemberPath3:x3:ya', [2, "v3"], 'TrianglesSource:xt:x7', [IEnumerable_$type, null]]);
     return GeographicXYTriangulatingSeries;
 })();
 /**
@@ -1400,59 +1400,59 @@ export let GeographicScatterAreaSeries = /*@__PURE__*/ (() => {
     class GeographicScatterAreaSeries extends GeographicXYTriangulatingSeries {
         constructor() {
             super();
-            this.x2 = null;
+            this.yb = null;
             this.triangulationStatusChanged = null;
             this.ab = GeographicScatterAreaSeries.$;
         }
         bk() {
             return new GeographicScatterAreaSeries();
         }
-        get_ew() {
+        get_ex() {
             return true;
         }
-        get x4() {
-            return this.x2;
+        get yd() {
+            return this.yb;
         }
-        set x4(a) {
-            let b = this.x2 != a;
+        set yd(a) {
+            let b = this.yb != a;
             if (b) {
-                let c = this.x2;
-                if (this.x2 != null) {
-                    let d = this.x2;
-                    d.propertyChanged = delegateRemove(d.propertyChanged, runOn(this, this.yc));
+                let c = this.yb;
+                if (this.yb != null) {
+                    let d = this.yb;
+                    d.propertyChanged = delegateRemove(d.propertyChanged, runOn(this, this.yl));
                 }
-                this.x2 = a;
-                if (this.x2 != null) {
-                    let e = this.x2;
-                    e.propertyChanged = delegateCombine(e.propertyChanged, runOn(this, this.yc));
+                this.yb = a;
+                if (this.yb != null) {
+                    let e = this.yb;
+                    e.propertyChanged = delegateCombine(e.propertyChanged, runOn(this, this.yl));
                 }
-                this.raisePropertyChanged("ColorScale", c, this.x2);
-                if (this.x5 != null) {
-                    this.x5.y6 = a;
+                this.raisePropertyChanged("ColorScale", c, this.yb);
+                if (this.ye != null) {
+                    this.ye.zf = a;
                 }
             }
         }
-        yc(a, b) {
-            this.x7.c4();
-            this.ye();
-            this.rz(false);
+        yl(a, b) {
+            this.yg.c4();
+            this.yn();
+            this.r7(false);
         }
-        ye() {
-            if (this.x5 != null) {
-                this.x3 = this.x5.y5;
+        yn() {
+            if (this.ye != null) {
+                this.yc = this.ye.ze;
             }
         }
-        sq() {
-            super.sq();
-            this.ye();
+        sy() {
+            super.sy();
+            this.yn();
         }
-        xa() {
-            this.x5 = new ScatterAreaSeries();
-            let a = this.x5;
-            a.triangulationStatusChanged = delegateCombine(a.triangulationStatusChanged, runOn(this, this.yd));
-            return this.x5;
+        xj() {
+            this.ye = new ScatterAreaSeries();
+            let a = this.ye;
+            a.triangulationStatusChanged = delegateCombine(a.triangulationStatusChanged, runOn(this, this.ym));
+            return this.ye;
         }
-        yd(a, b) {
+        ym(a, b) {
             if (this.triangulationStatusChanged != null) {
                 this.triangulationStatusChanged(this, b);
             }
@@ -1460,30 +1460,30 @@ export let GeographicScatterAreaSeries = /*@__PURE__*/ (() => {
         ct() {
             return new GeographicScatterAreaSeriesView(this);
         }
-        q8(a) {
-            super.q8(a);
-            this.x7 = a;
+        rg(a) {
+            super.rg(a);
+            this.yg = a;
         }
-        rh(a, b, c, d) {
-            super.rh(a, b, c, d);
+        rp(a, b, c, d) {
+            super.rp(a, b, c, d);
             switch (b) {
                 case GeographicScatterAreaSeries.$$p[1]:
-                    this.x7.c3();
+                    this.yg.c3();
                     break;
                 case "ColorScale":
-                    this.x7.c4();
-                    this.ye();
+                    this.yg.c4();
+                    this.yn();
                     break;
             }
         }
-        get_g8() {
+        get_hd() {
             return true;
         }
-        set_g8(a) {
-            super.set_g8(a);
+        set_hd(a) {
+            super.set_hd(a);
         }
     }
     GeographicScatterAreaSeries.$t = markType(GeographicScatterAreaSeries, 'GeographicScatterAreaSeries', GeographicXYTriangulatingSeries.$);
-    GeographicScatterAreaSeries.$$p = markDep(DependencyProperty, PropertyMetadata, GeographicScatterAreaSeries, 'raisePropertyChanged', ['ActualColorScale:x3:yf', [ColorScale.$, null], 'ColorMemberPath:x9:yg', [2, "value"]]);
+    GeographicScatterAreaSeries.$$p = markDep(DependencyProperty, PropertyMetadata, GeographicScatterAreaSeries, 'raisePropertyChanged', ['ActualColorScale:yc:yo', [ColorScale.$, null], 'ColorMemberPath:yi:yp', [2, "value"]]);
     return GeographicScatterAreaSeries;
 })();