igniteui-angular-maps 20.0.0 → 20.0.1

package/fesm2015/igniteui-angular-maps.js

@@ -615,10 +615,10 @@ let GeographicMapSeriesHost = /*@__PURE__*/ (() => {
                 case "SeriesViewer":
                     this.w5.dc = this.dc;
                     if (c != null) {
-                        c.rd(this.w5);
+                        c.rn(this.w5);
                     }
                     if (d != null) {
-                        this.dc.nh(this.w5);
+                        this.dc.nq(this.w5);
                     }
                     this.w5.rf(this.wx);
                     this.w5.index = this.index;
@@ -717,7 +717,7 @@ let GeographicMapSeriesHost = /*@__PURE__*/ (() => {
                 return;
             }
             if (!isNaN_(this.w7)) {
-                if (this.dc.wh.width > this.w7) {
+                if (this.dc.wt.width > this.w7) {
                     let hs_ = this.w5;
                     let v_ = 1;
                     hs_.visibility = v_;
@@ -886,22 +886,22 @@ let XamGeographicMap = /*@__PURE__*/ (() => {
     class XamGeographicMap extends SeriesViewer {
         constructor() {
             super();
-            this.xw = null;
-            this.xl = false;
-            this.xd = 1;
-            this.xs = 0;
-            this.y3 = null;
-            this.xa = null;
-            this.w6 = null;
-            this.w8 = null;
-            this.xc = null;
-            this.yz = { $type: Point_$type, x: NaN, y: NaN };
-            this.y6 = null;
-            this.xr = 1;
-            this.imageTilesReady = null;
+            this.x8 = null;
+            this.xx = false;
+            this.xp = 1;
+            this.x4 = 0;
+            this.zf = null;
+            this.xm = null;
+            this.xi = null;
             this.xk = null;
-            this.y5 = Rect.empty;
-            this.xs = SphericalMercatorVerticalScaler.am(XamGeographicMap.y4.bottom) - SphericalMercatorVerticalScaler.am(XamGeographicMap.y4.top);
+            this.xo = null;
+            this.zb = { $type: Point_$type, x: NaN, y: NaN };
+            this.zi = null;
+            this.x3 = 1;
+            this.imageTilesReady = null;
+            this.xw = null;
+            this.zh = Rect.empty;
+            this.x4 = SphericalMercatorVerticalScaler.am(XamGeographicMap.zg.bottom) - SphericalMercatorVerticalScaler.am(XamGeographicMap.zg.top);
             this.ab = XamGeographicMap.$;
             this.backgroundContent = new OpenStreetMapImagery();
             let a = ((() => {
@@ -910,70 +910,70 @@ let XamGeographicMap = /*@__PURE__*/ (() => {
                 return $ret;
             })());
             a.cf = true;
-            this.w7 = a;
-            this.w7.n4 = new SphericalMercatorHorizontalScaler();
+            this.xj = a;
+            this.xj.n4 = new SphericalMercatorHorizontalScaler();
             let b = ((() => {
                 let $ret = new NumericYAxis();
                 $ret.bi = this;
                 return $ret;
             })());
             b.cf = true;
-            this.w9 = b;
-            this.w9.n4 = new SphericalMercatorVerticalScaler();
-            this.ye();
-            this.yl();
-            this.n9();
+            this.xl = b;
+            this.xl.n4 = new SphericalMercatorVerticalScaler();
+            this.yq();
+            this.yx();
+            this.oi();
         }
         provideContainer(a) {
             super.provideContainer(a);
-            this.w7.provideRenderer(a);
-            this.w9.provideRenderer(a);
+            this.xj.provideRenderer(a);
+            this.xl.provideRenderer(a);
         }
-        n9() {
-            super.n9();
-            this.xj.fv(this.hk);
+        oi() {
+            super.oi();
+            this.xv.fv(this.hp);
         }
-        fl() {
-            return this.xp;
+        fp() {
+            return this.x1;
         }
-        fm() {
-            return this.xp;
+        fq() {
+            return this.x1;
         }
-        xg() {
-            if (this.xe == 0) {
-                if (this.xl) {
+        xs() {
+            if (this.xq == 0) {
+                if (this.xx) {
                     return 2;
                 }
             }
             return 1;
         }
-        get xf() {
-            return this.xd;
+        get xr() {
+            return this.xp;
         }
-        set xf(a) {
-            this.xd = a;
+        set xr(a) {
+            this.xp = a;
         }
-        get y8() {
-            return this.y3;
+        get zk() {
+            return this.zf;
         }
-        set y8(a) {
-            let b = Rect.l_op_Inequality(this.y3, a);
+        set zk(a) {
+            let b = Rect.l_op_Inequality(this.zf, a);
             if (b) {
-                let c = this.y3;
-                this.y3 = a;
-                this.qv("ActualWorldRect", c, a);
+                let c = this.zf;
+                this.zf = a;
+                this.q5("ActualWorldRect", c, a);
             }
         }
-        zc() {
-            return this.y8;
+        zo() {
+            return this.zk;
         }
-        ye() {
-            if (this.zk.isEmpty) {
+        yq() {
+            if (this.zw.isEmpty) {
                 return;
             }
-            this.y8 = this.zi(this.zk, this.cr == 1);
+            this.zk = this.zu(this.zw, this.cs == 1);
         }
-        zi(a, b) {
+        zu(a, b) {
             let c = a.top;
             let d = a.left;
             let e = a.width;
@@ -981,25 +981,25 @@ let XamGeographicMap = /*@__PURE__*/ (() => {
             let g = SphericalMercatorVerticalScaler.am(a.bottom);
             let h = SphericalMercatorVerticalScaler.am(a.top);
             let i = g - h;
-            let j = a.width / XamGeographicMap.y4.width;
-            let k = SphericalMercatorVerticalScaler.am(XamGeographicMap.y4.top);
+            let j = a.width / XamGeographicMap.zg.width;
+            let k = SphericalMercatorVerticalScaler.am(XamGeographicMap.zg.top);
             let l = i / j;
-            if (i / j > this.xs) {
-                let m = i / this.xs;
+            if (i / j > this.x4) {
+                let m = i / this.x4;
                 let n = m - j;
-                d = d - (n / 2) * XamGeographicMap.y4.width;
-                e = m * XamGeographicMap.y4.width;
+                d = d - (n / 2) * XamGeographicMap.zg.width;
+                e = m * XamGeographicMap.zg.width;
                 if (b) {
-                    if (d < XamGeographicMap.y4.left) {
-                        d += (XamGeographicMap.y4.left - d);
+                    if (d < XamGeographicMap.zg.left) {
+                        d += (XamGeographicMap.zg.left - d);
                     }
-                    else if ((d + e) > XamGeographicMap.y4.right) {
-                        d -= ((d + e) - XamGeographicMap.y4.right);
+                    else if ((d + e) > XamGeographicMap.zg.right) {
+                        d -= ((d + e) - XamGeographicMap.zg.right);
                     }
                 }
             }
-            else if (i / j < this.xs) {
-                let o = this.xs * j;
+            else if (i / j < this.x4) {
+                let o = this.x4 * j;
                 let p = o - i;
                 let q = h - (p / 2);
                 let r = g + (p / 2);
@@ -1008,9 +1008,9 @@ let XamGeographicMap = /*@__PURE__*/ (() => {
                         q += (k - q);
                         r += (k - q);
                     }
-                    else if (r > (k + this.xs)) {
-                        q -= ((r) - (k + this.xs));
-                        r -= ((r) - (k + this.xs));
+                    else if (r > (k + this.x4)) {
+                        q -= ((r) - (k + this.x4));
+                        r -= ((r) - (k + this.x4));
                     }
                 }
                 c = SphericalMercatorVerticalScaler.aq(q);
@@ -1020,76 +1020,76 @@ let XamGeographicMap = /*@__PURE__*/ (() => {
             return s;
         }
         get backgroundContent() {
-            return this.xa;
+            return this.xm;
         }
         set backgroundContent(a) {
             let b = a != this.backgroundContent;
             if (b) {
                 let c = this.backgroundContent;
-                this.xa = a;
-                this.qv("BackgroundContent", c, a);
+                this.xm = a;
+                this.q5("BackgroundContent", c, a);
             }
         }
-        get w7() {
-            return this.w6;
+        get xj() {
+            return this.xi;
         }
-        set w7(a) {
-            let b = a != this.w7;
+        set xj(a) {
+            let b = a != this.xj;
             if (b) {
-                let c = this.w7;
-                this.w6 = a;
-                this.qv("XAxis", c, a);
+                let c = this.xj;
+                this.xi = a;
+                this.q5("XAxis", c, a);
             }
         }
-        get w9() {
-            return this.w8;
+        get xl() {
+            return this.xk;
         }
-        set w9(a) {
-            let b = a != this.w9;
+        set xl(a) {
+            let b = a != this.xl;
             if (b) {
-                let c = this.w9;
-                this.w8 = a;
-                this.qv("YAxis", c, a);
+                let c = this.xl;
+                this.xk = a;
+                this.q5("YAxis", c, a);
             }
         }
         getZoomRectFromGeoRect(a) {
             return this.getZoomFromGeographicRect(a);
         }
-        yo(a) {
-            this.w0 = a;
+        y0(a) {
+            this.xc = a;
         }
-        yn(a) {
-            this.zk = a;
+        yz(a) {
+            this.zw = a;
         }
         getZoomFromGeographicRect(a) {
-            return this.za(a, true, 0);
+            return this.zm(a, true, 0);
         }
-        y9(a, b) {
-            return this.za(a, false, b);
+        zl(a, b) {
+            return this.zm(a, false, b);
         }
-        za(a, b, c) {
+        zm(a, b, c) {
             let d = a;
             if (b) {
-                d = this.zi(a, false);
-            }
-            let e = this.w7;
-            let f = this.w9;
-            let g = new ScalerParams(1, XamGeographicMap.y7, this.wz, e.ch);
-            g.c = this.wl;
-            let h = new ScalerParams(1, XamGeographicMap.y7, this.wz, f.ch);
-            h.c = this.wl;
-            let i = this.w7.el(d.left, g);
-            let j = this.w7.el(d.right, g);
-            let k = this.w9.el(d.top, h);
-            let l = this.w9.el(d.bottom, h);
-            let m = (i - c) / this.wz.width;
-            let n = (l - c) / this.wz.height;
-            let o = (j - i + (c * 2)) / this.wz.width;
-            let p = (k - l + (c * 2)) / this.wz.height;
+                d = this.zu(a, false);
+            }
+            let e = this.xj;
+            let f = this.xl;
+            let g = new ScalerParams(1, XamGeographicMap.zj, this.xb, e.ch);
+            g.c = this.wx;
+            let h = new ScalerParams(1, XamGeographicMap.zj, this.xb, f.ch);
+            h.c = this.wx;
+            let i = this.xj.el(d.left, g);
+            let j = this.xj.el(d.right, g);
+            let k = this.xl.el(d.top, h);
+            let l = this.xl.el(d.bottom, h);
+            let m = (i - c) / this.xb.width;
+            let n = (l - c) / this.xb.height;
+            let o = (j - i + (c * 2)) / this.xb.width;
+            let p = (k - l + (c * 2)) / this.xb.height;
             let q = new Rect(0, m, n, o, p);
-            q.intersect(XamGeographicMap.y7);
+            q.intersect(XamGeographicMap.zj);
             if (q.isEmpty) {
-                q = XamGeographicMap.y7;
+                q = XamGeographicMap.zj;
             }
             return q;
         }
@@ -1099,21 +1099,21 @@ let XamGeographicMap = /*@__PURE__*/ (() => {
             let e = b.x - a.x;
             let f = a.y - b.y;
             if (e < 0 || f < 0) {
-                return XamGeographicMap.y7;
+                return XamGeographicMap.zj;
             }
             else {
                 let g = new Rect(0, c, d, e, f);
                 return this.getZoomFromGeographicRect(g);
             }
         }
-        ze(a) {
-            let b = this.w7;
-            let c = this.w9;
-            let d = new ScalerParams(1, a, this.wz, b.ch);
-            d.c = this.wl;
-            let e = new ScalerParams(1, a, this.wz, c.ch);
-            e.c = this.wl;
-            let f = this.wk;
+        zq(a) {
+            let b = this.xj;
+            let c = this.xl;
+            let d = new ScalerParams(1, a, this.xb, b.ch);
+            d.c = this.wx;
+            let e = new ScalerParams(1, a, this.xb, c.ch);
+            e.c = this.wx;
+            let f = this.ww;
             let g = b.eo(f.left, d);
             let h = c.eo(f.top, e);
             let i = b.eo(f.right, d);
@@ -1121,166 +1121,166 @@ let XamGeographicMap = /*@__PURE__*/ (() => {
             let k = i - g;
             let l = h - j;
             let m = new Rect(0, g, j, k, l);
-            if (this.cr == 1) {
-                m.intersect(XamGeographicMap.y4);
+            if (this.cs == 1) {
+                m.intersect(XamGeographicMap.zg);
                 if (m.isEmpty) {
-                    m = XamGeographicMap.y4;
+                    m = XamGeographicMap.zg;
                 }
             }
             return m;
         }
-        y0(a) {
-            let b = this.w7.mf(a.x);
-            let c = this.w9.mf(a.y);
+        zc(a) {
+            let b = this.xj.mf(a.x);
+            let c = this.xl.mf(a.y);
             return { $type: Point_$type, x: b, y: c };
         }
-        y1(a) {
-            let b = this.w7.e6(a.x);
-            let c = this.w9.e6(a.y);
+        zd(a) {
+            let b = this.xj.e6(a.x);
+            let c = this.xl.e6(a.y);
             return { $type: Point_$type, x: b, y: c };
         }
-        y2(a) {
-            return this.y1(a);
+        ze(a) {
+            return this.zd(a);
         }
-        yb() {
+        yn() {
             let a = typeCast(GeographicMapImagery.$, this.backgroundContent);
             if (a != null) {
                 a.clearTileCache();
             }
         }
-        yh(a) {
+        yt(a) {
         }
-        gg() {
+        gk() {
             return true;
         }
-        yj() {
-            this.xj.ee();
+        yv() {
+            this.xv.ee();
             for (let a of fromEnum(this.series)) {
                 a.sg();
             }
         }
-        ym() {
-            if (this.xi == 2) {
-                if (!this.wz.isEmpty && this.wz.width > 0 && this.wz.height > 0) {
-                    let a = this.w7.mf(this.wz.left + (this.wz.width / 2));
-                    let b = this.w9.mf(this.wz.top + (this.wz.height / 2));
-                    this.yz = { $type: Point_$type, x: a, y: b };
+        yy() {
+            if (this.xu == 2) {
+                if (!this.xb.isEmpty && this.xb.width > 0 && this.xb.height > 0) {
+                    let a = this.xj.mf(this.xb.left + (this.xb.width / 2));
+                    let b = this.xl.mf(this.xb.top + (this.xb.height / 2));
+                    this.zb = { $type: Point_$type, x: a, y: b };
                 }
             }
             else {
-                if (!this.wz.isEmpty && this.wz.width > 0 && this.wz.height > 0) {
-                    let c = this.w7.mf(this.wz.left);
-                    let d = this.w9.mf(this.wz.top);
-                    this.yz = { $type: Point_$type, x: c, y: d };
+                if (!this.xb.isEmpty && this.xb.width > 0 && this.xb.height > 0) {
+                    let c = this.xj.mf(this.xb.left);
+                    let d = this.xl.mf(this.xb.top);
+                    this.zb = { $type: Point_$type, x: c, y: d };
                 }
             }
         }
-        yi() {
-            if (isNaN_(this.yz.x) || isNaN_(this.yz.y)) {
-                this.ym();
+        yu() {
+            if (isNaN_(this.zb.x) || isNaN_(this.zb.y)) {
+                this.yy();
             }
-            let a = this.yz.x;
-            let b = this.yz.y;
+            let a = this.zb.x;
+            let b = this.zb.y;
             if (!isNaN_(a) && !isNaN_(b)) {
-                let c = this.wh.left;
-                let d = this.wh.top;
-                let e = this.wh.width;
-                let f = this.wh.height;
-                if (e > this.y6.width) {
+                let c = this.wt.left;
+                let d = this.wt.top;
+                let e = this.wt.width;
+                let f = this.wt.height;
+                if (e > this.zi.width) {
                 }
                 else {
-                    let g = new ScalerParams(1, XamGeographicMap.y7, this.wz, this.w7.ch);
-                    g.c = this.wl;
-                    let h = this.w7.el(a, g);
-                    if (this.xi == 2) {
-                        let i = h / this.wz.width;
+                    let g = new ScalerParams(1, XamGeographicMap.zj, this.xb, this.xj.ch);
+                    g.c = this.wx;
+                    let h = this.xj.el(a, g);
+                    if (this.xu == 2) {
+                        let i = h / this.xb.width;
                         c = i - (e / 2);
                     }
                     else {
-                        c = h / this.wz.width;
+                        c = h / this.xb.width;
                     }
-                    if (c + e > this.y6.right) {
-                        c = this.y6.right - e;
+                    if (c + e > this.zi.right) {
+                        c = this.zi.right - e;
                     }
-                    else if (c < this.y6.left) {
-                        c = this.y6.left;
+                    else if (c < this.zi.left) {
+                        c = this.zi.left;
                     }
                 }
-                if (f > this.y6.height) {
+                if (f > this.zi.height) {
                 }
                 else {
-                    let j = new ScalerParams(1, XamGeographicMap.y7, this.wz, this.w9.ch);
-                    j.c = this.wl;
-                    let k = this.w9.el(b, j);
-                    if (this.xi == 2) {
-                        let l = k / this.wz.height;
+                    let j = new ScalerParams(1, XamGeographicMap.zj, this.xb, this.xl.ch);
+                    j.c = this.wx;
+                    let k = this.xl.el(b, j);
+                    if (this.xu == 2) {
+                        let l = k / this.xb.height;
                         d = l - (f / 2);
                     }
                     else {
-                        d = k / this.wz.height;
+                        d = k / this.xb.height;
                     }
-                    if (d + f > this.y6.bottom) {
-                        d = this.y6.bottom - f;
+                    if (d + f > this.zi.bottom) {
+                        d = this.zi.bottom - f;
                     }
-                    else if (d < this.y6.top) {
-                        d = this.y6.top;
+                    else if (d < this.zi.top) {
+                        d = this.zi.top;
                     }
                 }
-                this.r6(new Rect(0, c, d, e, f), false);
+                this.sh(new Rect(0, c, d, e, f), false);
             }
         }
-        get_fd() {
+        get_fh() {
             return true;
         }
-        wi() {
-            let a = super.wi();
-            if (this.w7 == null || this.w9 == null) {
+        wu() {
+            let a = super.wu();
+            if (this.xj == null || this.xl == null) {
                 return a;
             }
-            this.wt();
+            this.w5();
             let b = a.left;
             let c = a.top;
-            if (this.cr == 1) {
-                if (this.w0.width > this.y6.width) {
-                    b = 0.5 - (this.w0.width / 2);
+            if (this.cs == 1) {
+                if (this.xc.width > this.zi.width) {
+                    b = 0.5 - (this.xc.width / 2);
                 }
-                else if (b + a.width > this.y6.right) {
-                    b = this.y6.right - this.w0.width;
+                else if (b + a.width > this.zi.right) {
+                    b = this.zi.right - this.xc.width;
                 }
-                else if (b < this.y6.left) {
-                    b = this.y6.left;
+                else if (b < this.zi.left) {
+                    b = this.zi.left;
                 }
-                if (this.w0.height > this.y6.height) {
-                    c = 0.5 - (this.w0.height / 2);
+                if (this.xc.height > this.zi.height) {
+                    c = 0.5 - (this.xc.height / 2);
                 }
-                else if (c + this.w0.height > this.y6.bottom) {
-                    c = this.y6.bottom - this.w0.height;
+                else if (c + this.xc.height > this.zi.bottom) {
+                    c = this.zi.bottom - this.xc.height;
                 }
-                else if (c < this.y6.top) {
-                    c = this.y6.top;
+                else if (c < this.zi.top) {
+                    c = this.zi.top;
                 }
             }
             let d = false;
-            if (!this.xo && this.cr == 2 && this.xl) {
+            if (!this.x0 && this.cs == 2 && this.xx) {
                 if (b > 1) {
                     b = (b - Math.floor(b)) + 1;
                 }
                 if (b < 0) {
                     b = 0 - (Math.ceil(b) - b);
                 }
-                if ((a.right - this.y6.right) > 0 && ((a.right - this.y6.right) / a.width) > 0.8) {
-                    b = this.y6.left - (a.width - (a.right - this.y6.right));
+                if ((a.right - this.zi.right) > 0 && ((a.right - this.zi.right) / a.width) > 0.8) {
+                    b = this.zi.left - (a.width - (a.right - this.zi.right));
                     d = true;
                 }
-                else if (a.left < this.y6.left && (Math.abs(a.left - this.y6.left) / a.width) > 0.8) {
-                    b = this.y6.right - (Math.abs(a.left - this.y6.left));
+                else if (a.left < this.zi.left && (Math.abs(a.left - this.zi.left) / a.width) > 0.8) {
+                    b = this.zi.right - (Math.abs(a.left - this.zi.left));
                     d = true;
                 }
             }
             let e = new Rect(0, b, c, a.width, a.height);
-            if (this.xo) {
-                let f = this.y9(this.zk, 1);
-                f = this.zb(f);
+            if (this.x0) {
+                let f = this.zl(this.zw, 1);
+                f = this.zn(f);
                 let g = e.left + e.width / 2;
                 let h = e.top + e.height / 2;
                 if (e.width > f.width) {
@@ -1315,17 +1315,17 @@ let XamGeographicMap = /*@__PURE__*/ (() => {
                 }
             }
             if (d) {
-                this.ez = true;
-                this.w0 = e;
-                this.ez = false;
+                this.e3 = true;
+                this.xc = e;
+                this.e3 = false;
             }
             return e;
         }
-        nd(a, b) {
+        nm(a, b) {
             let c = true;
             let d = true;
             let e = 0;
-            let f = this.wt();
+            let f = this.w5();
             let g = 0;
             let h = 0;
             if ((a.right - f.right) > 0) {
@@ -1342,39 +1342,39 @@ let XamGeographicMap = /*@__PURE__*/ (() => {
             }
             if (c) {
                 if (d) {
-                    let i = this.w6.el(-180, b);
-                    let j = this.w6.el(180, b);
+                    let i = this.xi.el(-180, b);
+                    let j = this.xi.el(180, b);
                     e = j - i;
                 }
                 else {
-                    let k = this.w6.el(-180, b);
-                    let l = this.w6.el(180, b);
+                    let k = this.xi.el(-180, b);
+                    let l = this.xi.el(180, b);
                     e = k - l;
                 }
             }
             return new Tuple$2(Boolean_$type, Number_$type, c, e);
         }
-        wt() {
-            let a = new ScalerParams(1, XamGeographicMap.y7, this.wz, this.w7.ch);
-            a.c = this.wl;
-            let b = new ScalerParams(1, XamGeographicMap.y7, this.wz, this.w9.ch);
-            b.c = this.wl;
-            let c = this.w7.el(XamGeographicMap.y4.left, a);
-            let d = this.w7.el(XamGeographicMap.y4.right, a);
-            let e = this.w9.el(XamGeographicMap.y4.top, b);
-            let f = this.w9.el(XamGeographicMap.y4.bottom, b);
-            this.y6 = new Rect(0, c / this.wz.width, f / this.wz.height, (d - c) / this.wz.width, (e - f) / this.wz.height);
-            return this.y6;
-        }
-        zb(a) {
-            let b = this.ho;
+        w5() {
+            let a = new ScalerParams(1, XamGeographicMap.zj, this.xb, this.xj.ch);
+            a.c = this.wx;
+            let b = new ScalerParams(1, XamGeographicMap.zj, this.xb, this.xl.ch);
+            b.c = this.wx;
+            let c = this.xj.el(XamGeographicMap.zg.left, a);
+            let d = this.xj.el(XamGeographicMap.zg.right, a);
+            let e = this.xl.el(XamGeographicMap.zg.top, b);
+            let f = this.xl.el(XamGeographicMap.zg.bottom, b);
+            this.zi = new Rect(0, c / this.xb.width, f / this.xb.height, (d - c) / this.xb.width, (e - f) / this.xb.height);
+            return this.zi;
+        }
+        zn(a) {
+            let b = this.ht;
             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.wz;
+            let i = this.xb;
             let j = i.width / i.height;
             let k = g * i.width;
             let l = h * i.height;
@@ -1413,8 +1413,8 @@ let XamGeographicMap = /*@__PURE__*/ (() => {
             }
             return new Rect(0, p, q, r - p, s - q);
         }
-        wj(a) {
-            super.wj(this.wz);
+        wv(a) {
+            super.wv(this.xb);
             if (a.isEmpty) {
                 return Rect.empty;
             }
@@ -1429,126 +1429,126 @@ let XamGeographicMap = /*@__PURE__*/ (() => {
             }
             return b;
         }
-        zd(a) {
-            return this.wj(a);
+        zp(a) {
+            return this.wv(a);
         }
-        c8() {
+        db() {
             return new XamGeographicMapView(this);
         }
-        yd(a) {
+        yp(a) {
             if (a != null) {
                 a.bi = this;
             }
         }
-        qe(a) {
-            super.qe(a);
-            this.xj = a;
+        qo(a) {
+            super.qo(a);
+            this.xv = a;
         }
-        qp(a, b) {
-            super.qp(a, b);
-            this.ru(this.w7);
-            this.ru(this.w9);
+        qz(a, b) {
+            super.qz(a, b);
+            this.r5(this.xj);
+            this.r5(this.xl);
             if (Rect.l_op_Inequality(a, b)) {
-                this.yi();
+                this.yu();
             }
-            if (this.xo) {
-                this.wh = this.wi();
+            if (this.x0) {
+                this.wt = this.wu();
             }
-            this.yp();
+            this.y1();
         }
-        get xt() {
-            return this.xr;
+        get x5() {
+            return this.x3;
         }
-        set xt(a) {
-            let b = this.xr;
-            this.xr = a;
-            this.qv("ActualWindowScale", b, this.xr);
+        set x5(a) {
+            let b = this.x3;
+            this.x3 = a;
+            this.q5("ActualWindowScale", b, this.x3);
         }
-        hu() {
-            return this.xt;
+        hz() {
+            return this.x5;
         }
-        hv() {
-            return this.xt;
+        h0() {
+            return this.x5;
         }
-        rt() {
-            super.rt();
-            let a = Math.min(this.wh.width, this.wh.height);
-            this.xt = a;
+        r4() {
+            super.r4();
+            let a = Math.min(this.wt.width, this.wt.height);
+            this.x5 = a;
         }
-        f4() {
-            return this.xl;
+        f8() {
+            return this.xx;
         }
-        cs() {
-            if (this.ct == 0) {
-                if (this.xm) {
+        ct() {
+            if (this.cu == 0) {
+                if (this.xy) {
                     return 2;
                 }
             }
-            return this.ct;
+            return this.cu;
         }
-        qq(a, b, c, d) {
-            super.qq(a, b, c, d);
+        q0(a, b, c, d) {
+            super.q0(a, b, c, d);
             switch (b) {
                 case "ZoomCoercionMode":
-                    this.ye();
+                    this.yq();
                     break;
                 case "WindowRect":
-                    this.ym();
+                    this.yy();
                     break;
                 case XamGeographicMap.$$p[0]:
-                    this.xf = this.xg();
-                    if (this.xc != null) {
-                        this.xc.isHorizontalWrappingEnabled = this.xf == 2;
+                    this.xr = this.xs();
+                    if (this.xo != null) {
+                        this.xo.isHorizontalWrappingEnabled = this.xr == 2;
                     }
                     break;
                 case XamGeographicMap.$$p[1]:
-                    this.xl = this.xm;
-                    this.xf = this.xg();
-                    this.cr = this.cs();
-                    if (this.xc != null) {
-                        this.xc.isHorizontalWrappingEnabled = this.xf == 2;
+                    this.xx = this.xy;
+                    this.xr = this.xs();
+                    this.cs = this.ct();
+                    if (this.xo != null) {
+                        this.xo.isHorizontalWrappingEnabled = this.xr == 2;
                     }
                     break;
                 case XamGeographicMap.$$p[4]:
-                    this.wh = this.wi();
+                    this.wt = this.wu();
                     break;
                 case "BackgroundContent":
-                    if (this.xc != null) {
-                        let e = this.xc;
-                        e.imageTilesReady = delegateRemove(e.imageTilesReady, runOn(this, this.yf));
-                        this.xc.deferralHandler = null;
+                    if (this.xo != null) {
+                        let e = this.xo;
+                        e.imageTilesReady = delegateRemove(e.imageTilesReady, runOn(this, this.yr));
+                        this.xo.deferralHandler = null;
                     }
-                    this.xc = typeCast(GeographicMapImagery.$, this.backgroundContent);
-                    if (this.xc != null) {
-                        let f = this.xc;
-                        f.imageTilesReady = delegateCombine(f.imageTilesReady, runOn(this, this.yf));
-                        this.xc.deferralHandler = this;
-                        this.xc.isHorizontalWrappingEnabled = this.xf == 2;
+                    this.xo = typeCast(GeographicMapImagery.$, this.backgroundContent);
+                    if (this.xo != null) {
+                        let f = this.xo;
+                        f.imageTilesReady = delegateCombine(f.imageTilesReady, runOn(this, this.yr));
+                        this.xo.deferralHandler = this;
+                        this.xo.isHorizontalWrappingEnabled = this.xr == 2;
                     }
-                    this.xj.fu(typeCast(GeographicMapImagery.$, c), typeCast(GeographicMapImagery.$, d));
-                    if (this.xc != null) {
-                        this.xc.geographicMap = this;
-                        this.xj.fr(this.wh);
-                        this.xj.fv(this.hk);
+                    this.xv.fu(typeCast(GeographicMapImagery.$, c), typeCast(GeographicMapImagery.$, d));
+                    if (this.xo != null) {
+                        this.xo.geographicMap = this;
+                        this.xv.fr(this.wt);
+                        this.xv.fv(this.hp);
                     }
                     break;
                 case "YAxis":
                 case "XAxis":
-                    this.yk(c);
-                    this.yd(d);
+                    this.yw(c);
+                    this.yp(d);
                     break;
                 case XamGeographicMap.$$p[6]:
-                    if (!this.xn) {
-                        this.w0 = XamGeographicMap.y7;
+                    if (!this.xz) {
+                        this.xc = XamGeographicMap.zj;
                     }
-                    this.ye();
-                    this.yl();
-                    this.ym();
-                    this.wh = this.wi();
-                    this.xj.fs();
+                    this.yq();
+                    this.yx();
+                    this.yy();
+                    this.wt = this.wu();
+                    this.xv.fs();
                     break;
                 case "ActualWindowRect":
-                    this.xj.fr(this.wh);
+                    this.xv.fr(this.wt);
                     break;
                 case "ActualWorldRect":
                     for (let g of fromEnum(this.series)) {
@@ -1556,30 +1556,30 @@ let XamGeographicMap = /*@__PURE__*/ (() => {
                     }
                     break;
                 case XamGeographicMap.$$p[5]:
-                    this.xt = this.xu;
+                    this.x5 = this.x6;
                     break;
                 case "ActualWindowScale":
-                    if (!this.gc) {
-                        this.r4(this.hu(), this.hv());
+                    if (!this.gg) {
+                        this.sf(this.hz(), this.h0());
                     }
                     break;
                 case "ActualPixelScalingRatio":
-                    this.xj.fv(this.hk);
+                    this.xv.fv(this.hp);
                     break;
                 case "WindowRectMinWidth":
                 case "WindowRectMinHeight":
                     let h = d;
                     if (isNaN_(h) || isInfinity(h)) {
-                        this.ho = 5E-06;
-                        this.hn = 5E-06;
+                        this.ht = 5E-06;
+                        this.hs = 5E-06;
                     }
                     else {
-                        this.ho = h;
-                        this.hn = h;
+                        this.ht = h;
+                        this.hs = h;
                     }
                     break;
                 case XamGeographicMap.$$p[7]:
-                    this.r0();
+                    this.sb();
                     break;
                 case "MarkerAutomaticBehavior":
                     for (let i of fromEnum(this.series)) {
@@ -1588,39 +1588,39 @@ let XamGeographicMap = /*@__PURE__*/ (() => {
                     break;
             }
         }
-        yf(a, b) {
+        yr(a, b) {
             if (this.imageTilesReady != null) {
                 this.imageTilesReady(this, new ImageTilesReadyEventArgs());
             }
         }
-        yk(a) {
+        yw(a) {
             if (a != null) {
                 a.bi = null;
             }
         }
-        yl() {
-            if (this.w7 != null) {
-                this.w7.mc = this.y8.left;
-                this.w7.mb = this.y8.right;
+        yx() {
+            if (this.xj != null) {
+                this.xj.mc = this.zk.left;
+                this.xj.mb = this.zk.right;
             }
-            if (this.w9 != null) {
-                this.w9.mc = this.y8.top;
-                this.w9.mb = this.y8.bottom;
+            if (this.xl != null) {
+                this.xl.mc = this.zk.top;
+                this.xl.mb = this.zk.bottom;
             }
-            this.w7.c2(true);
-            this.w9.c2(true);
+            this.xj.c2(true);
+            this.xl.c2(true);
         }
         getFontInfo() {
-            this.xk = this.xj.fo;
-            return this.xk;
+            this.xw = this.xv.fo;
+            return this.xw;
         }
-        vl() {
-            return this.xj.fw;
+        vx() {
+            return this.xv.fw;
         }
         getFontBrush() {
-            return this.xj.fx;
+            return this.xv.fx;
         }
-        rm(a, b) {
+        rx(a, b) {
             if (typeCast(ItfConverter.$, b) !== null) {
                 let c = b;
                 let d = a;
@@ -1628,33 +1628,33 @@ let XamGeographicMap = /*@__PURE__*/ (() => {
                 d.xe = c.triangulationSource.triangles;
             }
             else {
-                super.rm(a, b);
+                super.rx(a, b);
             }
         }
         register(a, b) {
-            this.ra(a, b);
+            this.rk(a, b);
         }
         unRegister(a) {
-            this.rs(a);
+            this.r3(a);
         }
         deferredRefresh() {
-            this.nr();
+            this.n0();
         }
         deferAction(a) {
-            if (this.xw != null) {
-                this.xw.setTimeout(a, 0);
+            if (this.x8 != null) {
+                this.x8.setTimeout(a, 0);
             }
             else {
                 window.setTimeout(a, 0);
             }
         }
-        yc(a) {
-            this.rz(a);
+        yo(a) {
+            this.sa(a);
         }
-        xx() {
+        x9() {
             let a = new ChartVisualData();
-            let b = this.w7.fy();
-            let c = this.w9.fy();
+            let b = this.xj.fy();
+            let c = this.xl.fy();
             a.axes.add1(b);
             a.axes.add1(c);
             for (let d = 0; d < this.series.count; d++) {
@@ -1662,42 +1662,42 @@ let XamGeographicMap = /*@__PURE__*/ (() => {
                 a.series.add1(e);
             }
             a.name = this.name;
-            a.contentArea = RectData.b(this.wz);
-            a.centralArea = RectData.b(this.wz);
-            a.plotArea = RectData.b(this.wz);
+            a.contentArea = RectData.b(this.xb);
+            a.centralArea = RectData.b(this.xb);
+            a.plotArea = RectData.b(this.xb);
             return a;
         }
-        wp(a, b, c) {
+        w1(a, b, c) {
             return a;
         }
-        yg() {
+        ys() {
         }
-        get zj() {
-            return this.y5;
+        get zv() {
+            return this.zh;
         }
-        set zj(a) {
-            this.y5 = a;
+        set zv(a) {
+            this.zh = a;
         }
-        yq(a) {
-            this.zj = a;
-            this.yp();
+        y2(a) {
+            this.zv = a;
+            this.y1();
         }
-        yp() {
-            if (this.xq && !this.zj.isEmpty) {
-                let a = this.getZoomFromGeographicRect(this.zj);
-                this.zj = Rect.empty;
-                this.r6(a, false);
+        y1() {
+            if (this.x2 && !this.zv.isEmpty) {
+                let a = this.getZoomFromGeographicRect(this.zv);
+                this.zv = Rect.empty;
+                this.sh(a, false);
             }
         }
-        get xq() {
-            return !this.wz.isEmpty && !this.wl.isEmpty;
+        get x2() {
+            return !this.xb.isEmpty && !this.wx.isEmpty;
         }
     }
     XamGeographicMap.$t = markType(XamGeographicMap, 'XamGeographicMap', SeriesViewer.$, [IMapRenderDeferralHandler_$type]);
-    XamGeographicMap.xh = 0;
-    XamGeographicMap.y4 = new Rect(2, { $type: Point_$type, x: -180, y: -85.05112878 }, { $type: Point_$type, x: 180, y: 85.05112878 });
-    XamGeographicMap.y7 = new Rect(0, 0, 0, 1, 1);
-    XamGeographicMap.$$p = markDep(DependencyProperty, PropertyMetadata, XamGeographicMap, 'qv', ['BackgroundTilingMode:xe:yr', [MapBackgroundTilingMode_$type, enumGetBox(MapBackgroundTilingMode_$type, 0)], 'IsHorizontalWrappingEnabled:xm:ys', [0, false], 'ResizeBehavior:xi:yt', [MapResizeBehavior_$type, enumGetBox(MapResizeBehavior_$type, XamGeographicMap.xh)], 'SuppressZoomResetOnWorldRectChange:xn:yu', [0, false], 'UseWorldRectForZoomBounds:xo:yv', [0, false], 'WindowScale:xu:yw', [1, NaN], 'WorldRect:zk:yx', [Rect.$, XamGeographicMap.y4], 'Zoomable:xp:yy', [0, true]]);
+    XamGeographicMap.xt = 0;
+    XamGeographicMap.zg = new Rect(2, { $type: Point_$type, x: -180, y: -85.05112878 }, { $type: Point_$type, x: 180, y: 85.05112878 });
+    XamGeographicMap.zj = new Rect(0, 0, 0, 1, 1);
+    XamGeographicMap.$$p = markDep(DependencyProperty, PropertyMetadata, XamGeographicMap, 'q5', ['BackgroundTilingMode:xq:y3', [MapBackgroundTilingMode_$type, enumGetBox(MapBackgroundTilingMode_$type, 0)], 'IsHorizontalWrappingEnabled:xy:y4', [0, false], 'ResizeBehavior:xu:y5', [MapResizeBehavior_$type, enumGetBox(MapResizeBehavior_$type, XamGeographicMap.xt)], 'SuppressZoomResetOnWorldRectChange:xz:y6', [0, false], 'UseWorldRectForZoomBounds:x0:y7', [0, false], 'WindowScale:x6:y8', [1, NaN], 'WorldRect:zw:y9', [Rect.$, XamGeographicMap.zg], 'Zoomable:x1:za', [0, true]]);
     return XamGeographicMap;
 })();
 /**
@@ -1827,14 +1827,14 @@ let GeographicMapImagery = /*@__PURE__*/ (() => {
                 return a;
             }
             let b = new Rect(0, 0, 0, a.width, a.height);
-            let c = this.geographicMap.zd(b);
-            let d = XamGeographicMap.y4;
-            let e = this.geographicMap.y8;
+            let c = this.geographicMap.zp(b);
+            let d = XamGeographicMap.zg;
+            let e = this.geographicMap.zk;
             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.w7;
-            let i = this.geographicMap.w9;
+            let h = this.geographicMap.xj;
+            let i = this.geographicMap.xl;
             let j = new ScalerParams(1, this.windowRect, b, h.ch);
             j.c = c;
             let k = new ScalerParams(1, this.windowRect, b, i.ch);
@@ -1949,8 +1949,8 @@ let GeographicXYTriangulatingSeriesView = /*@__PURE__*/ (() => {
                 a.w4 = null;
                 return;
             }
-            a.w3 = this.cu.dc.w7;
-            a.w4 = this.cu.dc.w9;
+            a.w3 = this.cu.dc.xj;
+            a.w4 = this.cu.dc.xl;
         }
         cw() {
             this.cu.w5.x5 = this.cu.xh;
@@ -2025,15 +2025,15 @@ let XamGeographicMapView = /*@__PURE__*/ (() => {
             this.fp = NaN;
             this.fz = Rect.empty;
             this.fn = a;
-            this.fn.ve = 2;
-            this.fn.iv = 5E-06;
+            this.fn.vq = 2;
+            this.fn.i2 = 5E-06;
         }
         m(a) {
             return 2;
         }
         bk(a) {
             this.j.bw(a);
-            this.fn.yc(a);
+            this.fn.yo(a);
             this.el();
         }
         get_ap() {
@@ -2096,13 +2096,13 @@ let XamGeographicMapView = /*@__PURE__*/ (() => {
             }
         }
         fr(a) {
-            if (this.fn.xc != null) {
-                this.fn.xc.windowRect = a;
+            if (this.fn.xo != null) {
+                this.fn.xo.windowRect = a;
             }
         }
         fu(a, b) {
-            if (this.fn.xc != null) {
-                this.fn.xc.windowRect = this.fn.wh;
+            if (this.fn.xo != null) {
+                this.fn.xo.windowRect = this.fn.wt;
             }
             if (a != null) {
                 let c = a.ao;
@@ -2129,7 +2129,7 @@ let XamGeographicMapView = /*@__PURE__*/ (() => {
             }
         }
         ft(a) {
-            let b = this.fn.hk;
+            let b = this.fn.hp;
             if (b != 1) {
                 a.aa();
                 a.ab(b, b);
@@ -2609,80 +2609,80 @@ let IgxGeographicMapComponent = /*@__PURE__*/ (() => {
      * Gets or sets zoomability of the current control
     */
         get zoomable() {
-            return this.i.xp;
+            return this.i.x1;
         }
         set zoomable(v) {
-            this.i.xp = ensureBool(v);
+            this.i.x1 = ensureBool(v);
         }
         /**
          * Gets or sets the behavior to use during resize.
         */
         get resizeBehavior() {
-            return this.i.xi;
+            return this.i.xu;
         }
         set resizeBehavior(v) {
-            this.i.xi = ensureEnum(MapResizeBehavior_$type, v);
+            this.i.xu = ensureEnum(MapResizeBehavior_$type, v);
         }
         /**
          * Gets or sets if the map should horizontally wrap.
         */
         get isHorizontalWrappingEnabled() {
-            return this.i.xm;
+            return this.i.xy;
         }
         set isHorizontalWrappingEnabled(v) {
-            this.i.xm = ensureBool(v);
+            this.i.xy = ensureBool(v);
         }
         /**
          * Gets or sets if the map should horizontally wrap.
         */
         get backgroundTilingMode() {
-            return this.i.xe;
+            return this.i.xq;
         }
         set backgroundTilingMode(v) {
-            this.i.xe = ensureEnum(MapBackgroundTilingMode_$type, v);
+            this.i.xq = ensureEnum(MapBackgroundTilingMode_$type, v);
         }
         /**
          * Gets or sets whether to use the uncoerced world rect to constrain the zoom bounds.
         */
         get useWorldRectForZoomBounds() {
-            return this.i.xo;
+            return this.i.x0;
         }
         set useWorldRectForZoomBounds(v) {
-            this.i.xo = ensureBool(v);
+            this.i.x0 = ensureBool(v);
         }
         /**
          * Gets or sets whether skip resetting the zoom when the world rect changes.
         */
         get suppressZoomResetOnWorldRectChange() {
-            return this.i.xn;
+            return this.i.xz;
         }
         set suppressZoomResetOnWorldRectChange(v) {
-            this.i.xn = ensureBool(v);
+            this.i.xz = ensureBool(v);
         }
         /**
          * Gets or sets the world bounding rectangle.
         */
         get worldRect() {
-            return fromRect(this.i.zk);
+            return fromRect(this.i.zw);
         }
         set worldRect(v) {
-            this.i.zk = toRect(v);
+            this.i.zw = toRect(v);
         }
         /**
          * Gets the actual value of the WorldRect.
         */
         get actualWorldRect() {
-            return fromRect(this.i.y8);
+            return fromRect(this.i.zk);
         }
         set actualWorldRect(v) {
-            this.i.y8 = toRect(v);
+            this.i.zk = toRect(v);
         }
         /**
          * The X-axis for this IgxGeographicMap.Component
          * Under normal circumstances, this property should not be set in application code.  By default, it will be set to a numeric axis with a spherical mercator scaler.
         */
         get xAxis() {
-            const r = this.i.w7;
+            const r = this.i.xj;
             if (r == null) {
                 return null;
             }
@@ -2698,14 +2698,14 @@ let IgxGeographicMapComponent = /*@__PURE__*/ (() => {
         set xAxis(v) {
             if (v != null && this._stylingContainer && v._styling)
                 v._styling(this._stylingContainer, this, this);
-            v == null ? this.i.w7 = null : this.i.w7 = v.i;
+            v == null ? this.i.xj = null : this.i.xj = v.i;
         }
         /**
          * The Y-axis for this IgxGeographicMap.Component
          * Under normal circumstances, this property should not be set in application code.  By default, it will be set to a numeric axis with a spherical mercator scaler.
         */
         get yAxis() {
-            const r = this.i.w9;
+            const r = this.i.xl;
             if (r == null) {
                 return null;
             }
@@ -2721,39 +2721,39 @@ let IgxGeographicMapComponent = /*@__PURE__*/ (() => {
         set yAxis(v) {
             if (v != null && this._stylingContainer && v._styling)
                 v._styling(this._stylingContainer, this, this);
-            v == null ? this.i.w9 = null : this.i.w9 = v.i;
+            v == null ? this.i.xl = null : this.i.xl = v.i;
         }
         /**
          * Indicates if this SeriesViewer is a map.
         */
         get isMap() {
-            return this.i.fd;
+            return this.i.fh;
         }
         /**
          * A number between 0 and 1 determining the scale of the horizontal/vertical zoom.
          * This property is effectively a shortcut to the Width/Height of the WindowRect property.
         */
         get windowScale() {
-            return this.i.xu;
+            return this.i.x6;
         }
         set windowScale(v) {
-            this.i.xu = +v;
+            this.i.x6 = +v;
         }
         /**
          * A number between 0 and 1 determining the scale of the horizontal/vertical zoom.
          * This property is effectively a shortcut to the Width/Height of the ActualWindowRect property.
         */
         get actualWindowScale() {
-            return this.i.xt;
+            return this.i.x5;
         }
         set actualWindowScale(v) {
-            this.i.xt = +v;
+            this.i.x5 = +v;
         }
         /**
          * Gets whether or not the control is ready for zooming
         */
         get zoomIsReady() {
-            return this.i.xq;
+            return this.i.x2;
         }
         findByName(name) {
             var baseResult = super.findByName(name);
@@ -2781,7 +2781,7 @@ let IgxGeographicMapComponent = /*@__PURE__*/ (() => {
     
     */
         getCurrentActualWorldRect() {
-            let iv = this.i.zc();
+            let iv = this.i.zo();
             return fromRect(iv);
         }
         /**
@@ -2798,14 +2798,14 @@ let IgxGeographicMapComponent = /*@__PURE__*/ (() => {
         
         */
         updateZoomWindow(zoomWindow) {
-            this.i.yo(toRect(zoomWindow));
+            this.i.y0(toRect(zoomWindow));
         }
         /**
          * Updates world rect in geographic coordinates
         
         */
         updateWorldRect(worldRect) {
-            this.i.yn(toRect(worldRect));
+            this.i.yz(toRect(worldRect));
         }
         /**
          * Given the current plot area of the control and a geographic region, get the WindowRect that would encompass that geographic region.
@@ -2817,7 +2817,7 @@ let IgxGeographicMapComponent = /*@__PURE__*/ (() => {
             return fromRect(iv);
         }
         convertGeographicToZoom(geographic, extraPixelPadding) {
-            let iv = this.i.y9(toRect(geographic), extraPixelPadding);
+            let iv = this.i.zl(toRect(geographic), extraPixelPadding);
             return fromRect(iv);
         }
         getZoomFromGeographicPoints(northWest, southEast) {
@@ -2830,7 +2830,7 @@ let IgxGeographicMapComponent = /*@__PURE__*/ (() => {
         * @param windowRect  * The zoom area.
         */
         getGeographicFromZoom(windowRect) {
-            let iv = this.i.ze(toRect(windowRect));
+            let iv = this.i.zq(toRect(windowRect));
             return fromRect(iv);
         }
         /**
@@ -2839,7 +2839,7 @@ let IgxGeographicMapComponent = /*@__PURE__*/ (() => {
         * @param pixelCoordinate  * A pixel-based coordinate
         */
         getGeographicPoint(pixelCoordinate) {
-            let iv = this.i.y0(toPoint(pixelCoordinate));
+            let iv = this.i.zc(toPoint(pixelCoordinate));
             return fromPoint(iv);
         }
         /**
@@ -2848,7 +2848,7 @@ let IgxGeographicMapComponent = /*@__PURE__*/ (() => {
         * @param geographicCoordinate  * A geographic coordinate
         */
         getPixelPoint(geographicCoordinate) {
-            let iv = this.i.y1(toPoint(geographicCoordinate));
+            let iv = this.i.zd(toPoint(geographicCoordinate));
             return fromPoint(iv);
         }
         /**
@@ -2857,7 +2857,7 @@ let IgxGeographicMapComponent = /*@__PURE__*/ (() => {
         * @param geographicCoordinate  * A geographic coordinate
         */
         getWindowPoint(geographicCoordinate) {
-            let iv = this.i.y2(toPoint(geographicCoordinate));
+            let iv = this.i.ze(toPoint(geographicCoordinate));
             return fromPoint(iv);
         }
         /**
@@ -2865,21 +2865,21 @@ let IgxGeographicMapComponent = /*@__PURE__*/ (() => {
         
         */
         clearTileCache() {
-            this.i.yb();
+            this.i.yn();
         }
         /**
          * Notifies the chart that the CSS styles in effect have been updated.
         
         */
         styleUpdated() {
-            this.i.yj();
+            this.i.yv();
         }
         /**
          * Gets actual window scale for horizontal dimension of the control
         
         */
         getActualWindowScaleHorizontal() {
-            let iv = this.i.hu();
+            let iv = this.i.hz();
             return (iv);
         }
         /**
@@ -2887,7 +2887,7 @@ let IgxGeographicMapComponent = /*@__PURE__*/ (() => {
         
         */
         getActualWindowScaleVertical() {
-            let iv = this.i.hv();
+            let iv = this.i.h0();
             return (iv);
         }
         /**
@@ -2902,7 +2902,7 @@ let IgxGeographicMapComponent = /*@__PURE__*/ (() => {
         
         */
         exportVisualData() {
-            let iv = this.i.xx();
+            let iv = this.i.x9();
             return (iv);
         }
         /**
@@ -2911,7 +2911,7 @@ let IgxGeographicMapComponent = /*@__PURE__*/ (() => {
         * @param geographic  * The geographic region to zoom to.
         */
         zoomToGeographic(geographic) {
-            this.i.yq(toRect(geographic));
+            this.i.y2(toRect(geographic));
         }
         /**
          * This event is fired whenever the image tiles transition from a loading state (e.g. some are fading in) to a loaded state.
@@ -5159,8 +5159,8 @@ let GeographicShapeSeriesBaseView = /*@__PURE__*/ (() => {
                 a.xl = null;
                 return;
             }
-            a.xj = this.cu.dc.w7;
-            a.xl = this.cu.dc.w9;
+            a.xj = this.cu.dc.xj;
+            a.xl = this.cu.dc.xl;
         }
         cx() {
             this.cu.w5.zc = this.cu.x4;
@@ -6127,7 +6127,7 @@ let TileSeries = /*@__PURE__*/ (() => {
                     if (f != null && typeCast(XamGeographicMap.$, this.dc) !== null) {
                         f.geographicMap = this.dc;
                         this.aao(this.cw);
-                        this.aac.dr(this.dc.wh);
+                        this.aac.dr(this.dc.wt);
                     }
                     this.qn();
                     break;
@@ -7014,10 +7014,10 @@ let GeographicProportionalSymbolSeriesView = /*@__PURE__*/ (() => {
             this.cu.w5.aae = this.cu.xh;
         }
         db() {
-            this.cu.w5.xAxis = this.cu.dc.w7;
+            this.cu.w5.xAxis = this.cu.dc.xj;
         }
         dc() {
-            this.cu.w5.yAxis = this.cu.dc.w9;
+            this.cu.w5.yAxis = this.cu.dc.xl;
         }
         da() {
             let a = this.cu.w5;
@@ -7026,8 +7026,8 @@ let GeographicProportionalSymbolSeriesView = /*@__PURE__*/ (() => {
                 a.yAxis = null;
                 return;
             }
-            a.xAxis = this.cu.dc.w7;
-            a.yAxis = this.cu.dc.w9;
+            a.xAxis = this.cu.dc.xj;
+            a.yAxis = this.cu.dc.xl;
         }
         c4() {
             this.cu.w5.yo = this.cu.x9;
@@ -7630,10 +7630,10 @@ let GeographicSymbolSeriesView = /*@__PURE__*/ (() => {
             this.cu.w5.aae = this.cu.xh;
         }
         c5() {
-            this.cu.w5.xAxis = this.cu.dc.w7;
+            this.cu.w5.xAxis = this.cu.dc.xj;
         }
         c6() {
-            this.cu.w5.yAxis = this.cu.dc.w9;
+            this.cu.w5.yAxis = this.cu.dc.xl;
         }
         c4() {
             let a = this.cu.w5;
@@ -7642,8 +7642,8 @@ let GeographicSymbolSeriesView = /*@__PURE__*/ (() => {
                 a.yAxis = null;
                 return;
             }
-            a.xAxis = this.cu.dc.w7;
-            a.yAxis = this.cu.dc.w9;
+            a.xAxis = this.cu.dc.xj;
+            a.yAxis = this.cu.dc.xl;
         }
         cy() {
             this.cu.w5.yy = this.cu.yd;
@@ -8368,14 +8368,14 @@ let GeographicHighDensityScatterSeriesView = /*@__PURE__*/ (() => {
                 a.xc = null;
                 return;
             }
-            a.xa = this.cu.dc.w7;
-            a.xc = this.cu.dc.w9;
+            a.xa = this.cu.dc.xj;
+            a.xc = this.cu.dc.xl;
         }
         c6() {
-            this.cu.w5.xa = this.cu.dc.w7;
+            this.cu.w5.xa = this.cu.dc.xj;
         }
         c7() {
-            this.cu.w5.xc = this.cu.dc.w9;
+            this.cu.w5.xc = this.cu.dc.xl;
         }
         cx() {
             this.cu.w5.aak = this.cu.yd;