igniteui-angular-maps 17.0.0-beta.0 → 17.1.0

package/fesm2015/igniteui-angular-maps.js

@@ -590,10 +590,10 @@ let GeographicMapSeriesHost = /*@__PURE__*/ (() => {
                 case "SeriesViewer":
                     this.qe.ce = this.ce;
                     if (c != null) {
-                        c.oz(this.qe);
+                        c.o0(this.qe);
                     }
                     if (d != null) {
-                        this.ce.lo(this.qe);
+                        this.ce.lp(this.qe);
                     }
                     this.qe.mc(this.p7);
                     this.qe.index = this.index;
@@ -692,7 +692,7 @@ let GeographicMapSeriesHost = /*@__PURE__*/ (() => {
                 return;
             }
             if (!isNaN_(this.qg)) {
-                if (this.ce.tj.width > this.qg) {
+                if (this.ce.tk.width > this.qg) {
                     let hs_ = this.qe;
                     let v_ = 1;
                     hs_.visibility = v_;
@@ -855,22 +855,22 @@ let XamGeographicMap = /*@__PURE__*/ (() => {
     class XamGeographicMap extends SeriesViewer {
         constructor() {
             super();
-            this.uv = null;
-            this.uk = false;
-            this.uc = 1;
-            this.ur = 0;
-            this.v2 = null;
-            this.t9 = null;
-            this.t5 = null;
-            this.t7 = null;
-            this.ub = null;
-            this.vy = { $type: Point_$type, x: NaN, y: NaN };
-            this.v5 = null;
-            this.uq = 1;
+            this.uw = null;
+            this.ul = false;
+            this.ud = 1;
+            this.us = 0;
+            this.v3 = null;
+            this.ua = null;
+            this.t6 = null;
+            this.t8 = null;
+            this.uc = null;
+            this.vz = { $type: Point_$type, x: NaN, y: NaN };
+            this.v6 = null;
+            this.ur = 1;
             this.imageTilesReady = null;
-            this.uj = null;
-            this.v4 = Rect.empty;
-            this.ur = SphericalMercatorVerticalScaler.am(XamGeographicMap.v3.bottom) - SphericalMercatorVerticalScaler.am(XamGeographicMap.v3.top);
+            this.uk = null;
+            this.v5 = Rect.empty;
+            this.us = SphericalMercatorVerticalScaler.am(XamGeographicMap.v4.bottom) - SphericalMercatorVerticalScaler.am(XamGeographicMap.v4.top);
             this.ab = XamGeographicMap.$;
             this.backgroundContent = new OpenStreetMapImagery();
             let a = ((() => {
@@ -879,70 +879,70 @@ let XamGeographicMap = /*@__PURE__*/ (() => {
                 return $ret;
             })());
             a.cf = true;
-            this.t6 = a;
-            this.t6.nl = new SphericalMercatorHorizontalScaler();
+            this.t7 = a;
+            this.t7.nl = new SphericalMercatorHorizontalScaler();
             let b = ((() => {
                 let $ret = new NumericYAxis();
                 $ret.bi = this;
                 return $ret;
             })());
             b.cf = true;
-            this.t8 = b;
-            this.t8.nl = new SphericalMercatorVerticalScaler();
-            this.vd();
-            this.vk();
-            this.ma();
+            this.t9 = b;
+            this.t9.nl = new SphericalMercatorVerticalScaler();
+            this.ve();
+            this.vl();
+            this.mb();
         }
         provideContainer(a) {
             super.provideContainer(a);
-            this.t6.provideRenderer(a);
-            this.t8.provideRenderer(a);
+            this.t7.provideRenderer(a);
+            this.t9.provideRenderer(a);
         }
-        ma() {
-            super.ma();
-            this.ui.fv(this.gf);
-        }
-        es() {
-            return this.uo;
+        mb() {
+            super.mb();
+            this.uj.fv(this.gg);
         }
         et() {
-            return this.uo;
+            return this.up;
+        }
+        eu() {
+            return this.up;
         }
-        uf() {
-            if (this.ud == 0) {
-                if (this.uk) {
+        ug() {
+            if (this.ue == 0) {
+                if (this.ul) {
                     return 2;
                 }
             }
             return 1;
         }
-        get ue() {
-            return this.uc;
+        get uf() {
+            return this.ud;
         }
-        set ue(a) {
-            this.uc = a;
+        set uf(a) {
+            this.ud = a;
         }
-        get v7() {
-            return this.v2;
+        get v8() {
+            return this.v3;
         }
-        set v7(a) {
-            let b = Rect.l_op_Inequality(this.v2, a);
+        set v8(a) {
+            let b = Rect.l_op_Inequality(this.v3, a);
             if (b) {
-                let c = this.v2;
-                this.v2 = a;
-                this.oi("ActualWorldRect", c, a);
+                let c = this.v3;
+                this.v3 = a;
+                this.oj("ActualWorldRect", c, a);
             }
         }
-        wb() {
-            return this.v7;
+        wc() {
+            return this.v8;
         }
-        vd() {
-            if (this.wj.isEmpty) {
+        ve() {
+            if (this.wk.isEmpty) {
                 return;
             }
-            this.v7 = this.wh(this.wj, this.cd == 1);
+            this.v8 = this.wi(this.wk, this.cd == 1);
         }
-        wh(a, b) {
+        wi(a, b) {
             let c = a.top;
             let d = a.left;
             let e = a.width;
@@ -950,25 +950,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.v3.width;
-            let k = SphericalMercatorVerticalScaler.am(XamGeographicMap.v3.top);
+            let j = a.width / XamGeographicMap.v4.width;
+            let k = SphericalMercatorVerticalScaler.am(XamGeographicMap.v4.top);
             let l = i / j;
-            if (i / j > this.ur) {
-                let m = i / this.ur;
+            if (i / j > this.us) {
+                let m = i / this.us;
                 let n = m - j;
-                d = d - (n / 2) * XamGeographicMap.v3.width;
-                e = m * XamGeographicMap.v3.width;
+                d = d - (n / 2) * XamGeographicMap.v4.width;
+                e = m * XamGeographicMap.v4.width;
                 if (b) {
-                    if (d < XamGeographicMap.v3.left) {
-                        d += (XamGeographicMap.v3.left - d);
+                    if (d < XamGeographicMap.v4.left) {
+                        d += (XamGeographicMap.v4.left - d);
                     }
-                    else if ((d + e) > XamGeographicMap.v3.right) {
-                        d -= ((d + e) - XamGeographicMap.v3.right);
+                    else if ((d + e) > XamGeographicMap.v4.right) {
+                        d -= ((d + e) - XamGeographicMap.v4.right);
                     }
                 }
             }
-            else if (i / j < this.ur) {
-                let o = this.ur * j;
+            else if (i / j < this.us) {
+                let o = this.us * j;
                 let p = o - i;
                 let q = h - (p / 2);
                 let r = g + (p / 2);
@@ -977,9 +977,9 @@ let XamGeographicMap = /*@__PURE__*/ (() => {
                         q += (k - q);
                         r += (k - q);
                     }
-                    else if (r > (k + this.ur)) {
-                        q -= ((r) - (k + this.ur));
-                        r -= ((r) - (k + this.ur));
+                    else if (r > (k + this.us)) {
+                        q -= ((r) - (k + this.us));
+                        r -= ((r) - (k + this.us));
                     }
                 }
                 c = SphericalMercatorVerticalScaler.aq(q);
@@ -989,76 +989,76 @@ let XamGeographicMap = /*@__PURE__*/ (() => {
             return s;
         }
         get backgroundContent() {
-            return this.t9;
+            return this.ua;
         }
         set backgroundContent(a) {
             let b = a != this.backgroundContent;
             if (b) {
                 let c = this.backgroundContent;
-                this.t9 = a;
-                this.oi("BackgroundContent", c, a);
+                this.ua = a;
+                this.oj("BackgroundContent", c, a);
             }
         }
-        get t6() {
-            return this.t5;
+        get t7() {
+            return this.t6;
         }
-        set t6(a) {
-            let b = a != this.t6;
+        set t7(a) {
+            let b = a != this.t7;
             if (b) {
-                let c = this.t6;
-                this.t5 = a;
-                this.oi("XAxis", c, a);
+                let c = this.t7;
+                this.t6 = a;
+                this.oj("XAxis", c, a);
             }
         }
-        get t8() {
-            return this.t7;
+        get t9() {
+            return this.t8;
         }
-        set t8(a) {
-            let b = a != this.t8;
+        set t9(a) {
+            let b = a != this.t9;
             if (b) {
-                let c = this.t8;
-                this.t7 = a;
-                this.oi("YAxis", c, a);
+                let c = this.t9;
+                this.t8 = a;
+                this.oj("YAxis", c, a);
             }
         }
         getZoomRectFromGeoRect(a) {
             return this.getZoomFromGeographicRect(a);
         }
-        vn(a) {
-            this.tz = a;
+        vo(a) {
+            this.t0 = a;
         }
-        vm(a) {
-            this.wj = a;
+        vn(a) {
+            this.wk = a;
         }
         getZoomFromGeographicRect(a) {
-            return this.v9(a, true, 0);
+            return this.wa(a, true, 0);
         }
-        v8(a, b) {
-            return this.v9(a, false, b);
+        v9(a, b) {
+            return this.wa(a, false, b);
         }
-        v9(a, b, c) {
+        wa(a, b, c) {
             let d = a;
             if (b) {
-                d = this.wh(a, false);
-            }
-            let e = this.t6;
-            let f = this.t8;
-            let g = new ScalerParams(1, XamGeographicMap.v6, this.ty, e.ch);
-            g.c = this.tn;
-            let h = new ScalerParams(1, XamGeographicMap.v6, this.ty, f.ch);
-            h.c = this.tn;
-            let i = this.t6.ej(d.left, g);
-            let j = this.t6.ej(d.right, g);
-            let k = this.t8.ej(d.top, h);
-            let l = this.t8.ej(d.bottom, h);
-            let m = (i - c) / this.ty.width;
-            let n = (l - c) / this.ty.height;
-            let o = (j - i + (c * 2)) / this.ty.width;
-            let p = (k - l + (c * 2)) / this.ty.height;
+                d = this.wi(a, false);
+            }
+            let e = this.t7;
+            let f = this.t9;
+            let g = new ScalerParams(1, XamGeographicMap.v7, this.tz, e.ch);
+            g.c = this.to;
+            let h = new ScalerParams(1, XamGeographicMap.v7, this.tz, f.ch);
+            h.c = this.to;
+            let i = this.t7.ej(d.left, g);
+            let j = this.t7.ej(d.right, g);
+            let k = this.t9.ej(d.top, h);
+            let l = this.t9.ej(d.bottom, h);
+            let m = (i - c) / this.tz.width;
+            let n = (l - c) / this.tz.height;
+            let o = (j - i + (c * 2)) / this.tz.width;
+            let p = (k - l + (c * 2)) / this.tz.height;
             let q = new Rect(0, m, n, o, p);
-            q.intersect(XamGeographicMap.v6);
+            q.intersect(XamGeographicMap.v7);
             if (q.isEmpty) {
-                q = XamGeographicMap.v6;
+                q = XamGeographicMap.v7;
             }
             return q;
         }
@@ -1068,21 +1068,21 @@ let XamGeographicMap = /*@__PURE__*/ (() => {
             let e = b.x - a.x;
             let f = a.y - b.y;
             if (e < 0 || f < 0) {
-                return XamGeographicMap.v6;
+                return XamGeographicMap.v7;
             }
             else {
                 let g = new Rect(0, c, d, e, f);
                 return this.getZoomFromGeographicRect(g);
             }
         }
-        wd(a) {
-            let b = this.t6;
-            let c = this.t8;
-            let d = new ScalerParams(1, a, this.ty, b.ch);
-            d.c = this.tn;
-            let e = new ScalerParams(1, a, this.ty, c.ch);
-            e.c = this.tn;
-            let f = this.tm;
+        we(a) {
+            let b = this.t7;
+            let c = this.t9;
+            let d = new ScalerParams(1, a, this.tz, b.ch);
+            d.c = this.to;
+            let e = new ScalerParams(1, a, this.tz, c.ch);
+            e.c = this.to;
+            let f = this.tn;
             let g = b.em(f.left, d);
             let h = c.em(f.top, e);
             let i = b.em(f.right, d);
@@ -1091,165 +1091,165 @@ let XamGeographicMap = /*@__PURE__*/ (() => {
             let l = h - j;
             let m = new Rect(0, g, j, k, l);
             if (this.cd == 1) {
-                m.intersect(XamGeographicMap.v3);
+                m.intersect(XamGeographicMap.v4);
                 if (m.isEmpty) {
-                    m = XamGeographicMap.v3;
+                    m = XamGeographicMap.v4;
                 }
             }
             return m;
         }
-        vz(a) {
-            let b = this.t6.l8(a.x);
-            let c = this.t8.l8(a.y);
-            return { $type: Point_$type, x: b, y: c };
-        }
         v0(a) {
-            let b = this.t6.e4(a.x);
-            let c = this.t8.e4(a.y);
+            let b = this.t7.l8(a.x);
+            let c = this.t9.l8(a.y);
             return { $type: Point_$type, x: b, y: c };
         }
         v1(a) {
-            return this.v0(a);
+            let b = this.t7.e4(a.x);
+            let c = this.t9.e4(a.y);
+            return { $type: Point_$type, x: b, y: c };
+        }
+        v2(a) {
+            return this.v1(a);
         }
-        va() {
+        vb() {
             let a = typeCast(GeographicMapImagery.$, this.backgroundContent);
             if (a != null) {
                 a.clearTileCache();
             }
         }
-        vg(a) {
+        vh(a) {
         }
-        fh() {
+        fi() {
             return true;
         }
-        vi() {
-            this.ui.ee();
+        vj() {
+            this.uj.ee();
             for (let a of fromEnum(this.series)) {
                 a.mx();
             }
         }
-        vl() {
-            if (this.uh == 2) {
-                if (!this.ty.isEmpty && this.ty.width > 0 && this.ty.height > 0) {
-                    let a = this.t6.l8(this.ty.left + (this.ty.width / 2));
-                    let b = this.t8.l8(this.ty.top + (this.ty.height / 2));
-                    this.vy = { $type: Point_$type, x: a, y: b };
+        vm() {
+            if (this.ui == 2) {
+                if (!this.tz.isEmpty && this.tz.width > 0 && this.tz.height > 0) {
+                    let a = this.t7.l8(this.tz.left + (this.tz.width / 2));
+                    let b = this.t9.l8(this.tz.top + (this.tz.height / 2));
+                    this.vz = { $type: Point_$type, x: a, y: b };
                 }
             }
             else {
-                if (!this.ty.isEmpty && this.ty.width > 0 && this.ty.height > 0) {
-                    let c = this.t6.l8(this.ty.left);
-                    let d = this.t8.l8(this.ty.top);
-                    this.vy = { $type: Point_$type, x: c, y: d };
+                if (!this.tz.isEmpty && this.tz.width > 0 && this.tz.height > 0) {
+                    let c = this.t7.l8(this.tz.left);
+                    let d = this.t9.l8(this.tz.top);
+                    this.vz = { $type: Point_$type, x: c, y: d };
                 }
             }
         }
-        vh() {
-            if (isNaN_(this.vy.x) || isNaN_(this.vy.y)) {
-                this.vl();
+        vi() {
+            if (isNaN_(this.vz.x) || isNaN_(this.vz.y)) {
+                this.vm();
             }
-            let a = this.vy.x;
-            let b = this.vy.y;
+            let a = this.vz.x;
+            let b = this.vz.y;
             if (!isNaN_(a) && !isNaN_(b)) {
-                let c = this.tj.left;
-                let d = this.tj.top;
-                let e = this.tj.width;
-                let f = this.tj.height;
-                if (e > this.v5.width) {
+                let c = this.tk.left;
+                let d = this.tk.top;
+                let e = this.tk.width;
+                let f = this.tk.height;
+                if (e > this.v6.width) {
                 }
                 else {
-                    let g = new ScalerParams(1, XamGeographicMap.v6, this.ty, this.t6.ch);
-                    g.c = this.tn;
-                    let h = this.t6.ej(a, g);
-                    if (this.uh == 2) {
-                        let i = h / this.ty.width;
+                    let g = new ScalerParams(1, XamGeographicMap.v7, this.tz, this.t7.ch);
+                    g.c = this.to;
+                    let h = this.t7.ej(a, g);
+                    if (this.ui == 2) {
+                        let i = h / this.tz.width;
                         c = i - (e / 2);
                     }
                     else {
-                        c = h / this.ty.width;
+                        c = h / this.tz.width;
                     }
-                    if (c + e > this.v5.right) {
-                        c = this.v5.right - e;
+                    if (c + e > this.v6.right) {
+                        c = this.v6.right - e;
                     }
-                    else if (c < this.v5.left) {
-                        c = this.v5.left;
+                    else if (c < this.v6.left) {
+                        c = this.v6.left;
                     }
                 }
-                if (f > this.v5.height) {
+                if (f > this.v6.height) {
                 }
                 else {
-                    let j = new ScalerParams(1, XamGeographicMap.v6, this.ty, this.t8.ch);
-                    j.c = this.tn;
-                    let k = this.t8.ej(b, j);
-                    if (this.uh == 2) {
-                        let l = k / this.ty.height;
+                    let j = new ScalerParams(1, XamGeographicMap.v7, this.tz, this.t9.ch);
+                    j.c = this.to;
+                    let k = this.t9.ej(b, j);
+                    if (this.ui == 2) {
+                        let l = k / this.tz.height;
                         d = l - (f / 2);
                     }
                     else {
-                        d = k / this.ty.height;
+                        d = k / this.tz.height;
                     }
-                    if (d + f > this.v5.bottom) {
-                        d = this.v5.bottom - f;
+                    if (d + f > this.v6.bottom) {
+                        d = this.v6.bottom - f;
                     }
-                    else if (d < this.v5.top) {
-                        d = this.v5.top;
+                    else if (d < this.v6.top) {
+                        d = this.v6.top;
                     }
                 }
-                this.pr(new Rect(0, c, d, e, f), false);
+                this.ps(new Rect(0, c, d, e, f), false);
             }
         }
-        get_ek() {
+        get_el() {
             return true;
         }
-        tk() {
-            let a = super.tk();
-            if (this.t6 == null || this.t8 == null) {
+        tl() {
+            let a = super.tl();
+            if (this.t7 == null || this.t9 == null) {
                 return a;
             }
-            this.tu();
+            this.tv();
             let b = a.left;
             let c = a.top;
             if (this.cd == 1) {
-                if (this.tz.width > this.v5.width) {
-                    b = 0.5 - (this.tz.width / 2);
+                if (this.t0.width > this.v6.width) {
+                    b = 0.5 - (this.t0.width / 2);
                 }
-                else if (b + a.width > this.v5.right) {
-                    b = this.v5.right - this.tz.width;
+                else if (b + a.width > this.v6.right) {
+                    b = this.v6.right - this.t0.width;
                 }
-                else if (b < this.v5.left) {
-                    b = this.v5.left;
+                else if (b < this.v6.left) {
+                    b = this.v6.left;
                 }
-                if (this.tz.height > this.v5.height) {
-                    c = 0.5 - (this.tz.height / 2);
+                if (this.t0.height > this.v6.height) {
+                    c = 0.5 - (this.t0.height / 2);
                 }
-                else if (c + this.tz.height > this.v5.bottom) {
-                    c = this.v5.bottom - this.tz.height;
+                else if (c + this.t0.height > this.v6.bottom) {
+                    c = this.v6.bottom - this.t0.height;
                 }
-                else if (c < this.v5.top) {
-                    c = this.v5.top;
+                else if (c < this.v6.top) {
+                    c = this.v6.top;
                 }
             }
             let d = false;
-            if (!this.un && this.cd == 2 && this.uk) {
+            if (!this.uo && this.cd == 2 && this.ul) {
                 if (b > 1) {
                     b = (b - Math.floor(b)) + 1;
                 }
                 if (b < 0) {
                     b = 0 - (Math.ceil(b) - b);
                 }
-                if ((a.right - this.v5.right) > 0 && ((a.right - this.v5.right) / a.width) > 0.8) {
-                    b = this.v5.left - (a.width - (a.right - this.v5.right));
+                if ((a.right - this.v6.right) > 0 && ((a.right - this.v6.right) / a.width) > 0.8) {
+                    b = this.v6.left - (a.width - (a.right - this.v6.right));
                     d = true;
                 }
-                else if (a.left < this.v5.left && (Math.abs(a.left - this.v5.left) / a.width) > 0.8) {
-                    b = this.v5.right - (Math.abs(a.left - this.v5.left));
+                else if (a.left < this.v6.left && (Math.abs(a.left - this.v6.left) / a.width) > 0.8) {
+                    b = this.v6.right - (Math.abs(a.left - this.v6.left));
                     d = true;
                 }
             }
             let e = new Rect(0, b, c, a.width, a.height);
-            if (this.un) {
-                let f = this.v8(this.wj, 1);
-                f = this.wa(f);
+            if (this.uo) {
+                let f = this.v9(this.wk, 1);
+                f = this.wb(f);
                 let g = e.left + e.width / 2;
                 let h = e.top + e.height / 2;
                 if (e.width > f.width) {
@@ -1284,17 +1284,17 @@ let XamGeographicMap = /*@__PURE__*/ (() => {
                 }
             }
             if (d) {
-                this.d7 = true;
-                this.tz = e;
-                this.d7 = false;
+                this.d8 = true;
+                this.t0 = e;
+                this.d8 = false;
             }
             return e;
         }
-        ll(a, b) {
+        lm(a, b) {
             let c = true;
             let d = true;
             let e = 0;
-            let f = this.tu();
+            let f = this.tv();
             let g = 0;
             let h = 0;
             if ((a.right - f.right) > 0) {
@@ -1311,39 +1311,39 @@ let XamGeographicMap = /*@__PURE__*/ (() => {
             }
             if (c) {
                 if (d) {
-                    let i = this.t5.ej(-180, b);
-                    let j = this.t5.ej(180, b);
+                    let i = this.t6.ej(-180, b);
+                    let j = this.t6.ej(180, b);
                     e = j - i;
                 }
                 else {
-                    let k = this.t5.ej(-180, b);
-                    let l = this.t5.ej(180, b);
+                    let k = this.t6.ej(-180, b);
+                    let l = this.t6.ej(180, b);
                     e = k - l;
                 }
             }
             return new Tuple$2(Boolean_$type, Number_$type, c, e);
         }
-        tu() {
-            let a = new ScalerParams(1, XamGeographicMap.v6, this.ty, this.t6.ch);
-            a.c = this.tn;
-            let b = new ScalerParams(1, XamGeographicMap.v6, this.ty, this.t8.ch);
-            b.c = this.tn;
-            let c = this.t6.ej(XamGeographicMap.v3.left, a);
-            let d = this.t6.ej(XamGeographicMap.v3.right, a);
-            let e = this.t8.ej(XamGeographicMap.v3.top, b);
-            let f = this.t8.ej(XamGeographicMap.v3.bottom, b);
-            this.v5 = new Rect(0, c / this.ty.width, f / this.ty.height, (d - c) / this.ty.width, (e - f) / this.ty.height);
-            return this.v5;
-        }
-        wa(a) {
-            let b = this.gj;
+        tv() {
+            let a = new ScalerParams(1, XamGeographicMap.v7, this.tz, this.t7.ch);
+            a.c = this.to;
+            let b = new ScalerParams(1, XamGeographicMap.v7, this.tz, this.t9.ch);
+            b.c = this.to;
+            let c = this.t7.ej(XamGeographicMap.v4.left, a);
+            let d = this.t7.ej(XamGeographicMap.v4.right, a);
+            let e = this.t9.ej(XamGeographicMap.v4.top, b);
+            let f = this.t9.ej(XamGeographicMap.v4.bottom, b);
+            this.v6 = new Rect(0, c / this.tz.width, f / this.tz.height, (d - c) / this.tz.width, (e - f) / this.tz.height);
+            return this.v6;
+        }
+        wb(a) {
+            let b = this.gk;
             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.ty;
+            let i = this.tz;
             let j = i.width / i.height;
             let k = g * i.width;
             let l = h * i.height;
@@ -1382,8 +1382,8 @@ let XamGeographicMap = /*@__PURE__*/ (() => {
             }
             return new Rect(0, p, q, r - p, s - q);
         }
-        tl(a) {
-            super.tl(this.ty);
+        tm(a) {
+            super.tm(this.tz);
             if (a.isEmpty) {
                 return Rect.empty;
             }
@@ -1398,126 +1398,126 @@ let XamGeographicMap = /*@__PURE__*/ (() => {
             }
             return b;
         }
-        wc(a) {
-            return this.tl(a);
+        wd(a) {
+            return this.tm(a);
         }
         ct() {
             return new XamGeographicMapView(this);
         }
-        vc(a) {
+        vd(a) {
             if (a != null) {
                 a.bi = this;
             }
         }
-        n1(a) {
-            super.n1(a);
-            this.ui = a;
+        n2(a) {
+            super.n2(a);
+            this.uj = a;
         }
-        oc(a, b) {
-            super.oc(a, b);
-            this.pe(this.t6);
-            this.pe(this.t8);
+        od(a, b) {
+            super.od(a, b);
+            this.pf(this.t7);
+            this.pf(this.t9);
             if (Rect.l_op_Inequality(a, b)) {
-                this.vh();
+                this.vi();
             }
-            if (this.un) {
-                this.tj = this.tk();
+            if (this.uo) {
+                this.tk = this.tl();
             }
-            this.vo();
-        }
-        get us() {
-            return this.uq;
+            this.vp();
         }
-        set us(a) {
-            let b = this.uq;
-            this.uq = a;
-            this.oi("ActualWindowScale", b, this.uq);
+        get ut() {
+            return this.ur;
         }
-        gp() {
-            return this.us;
+        set ut(a) {
+            let b = this.ur;
+            this.ur = a;
+            this.oj("ActualWindowScale", b, this.ur);
         }
         gq() {
-            return this.us;
+            return this.ut;
         }
-        pd() {
-            super.pd();
-            let a = Math.min(this.tj.width, this.tj.height);
-            this.us = a;
+        gr() {
+            return this.ut;
         }
-        e9() {
-            return this.uk;
+        pe() {
+            super.pe();
+            let a = Math.min(this.tk.width, this.tk.height);
+            this.ut = a;
+        }
+        fa() {
+            return this.ul;
         }
         ce() {
             if (this.cf == 0) {
-                if (this.ul) {
+                if (this.um) {
                     return 2;
                 }
             }
             return this.cf;
         }
-        od(a, b, c, d) {
-            super.od(a, b, c, d);
+        oe(a, b, c, d) {
+            super.oe(a, b, c, d);
             switch (b) {
                 case "ZoomCoercionMode":
-                    this.vd();
+                    this.ve();
                     break;
                 case "WindowRect":
-                    this.vl();
+                    this.vm();
                     break;
                 case XamGeographicMap.$$p[0]:
-                    this.ue = this.uf();
-                    if (this.ub != null) {
-                        this.ub.isHorizontalWrappingEnabled = this.ue == 2;
+                    this.uf = this.ug();
+                    if (this.uc != null) {
+                        this.uc.isHorizontalWrappingEnabled = this.uf == 2;
                     }
                     break;
                 case XamGeographicMap.$$p[1]:
-                    this.uk = this.ul;
-                    this.ue = this.uf();
+                    this.ul = this.um;
+                    this.uf = this.ug();
                     this.cd = this.ce();
-                    if (this.ub != null) {
-                        this.ub.isHorizontalWrappingEnabled = this.ue == 2;
+                    if (this.uc != null) {
+                        this.uc.isHorizontalWrappingEnabled = this.uf == 2;
                     }
                     break;
                 case XamGeographicMap.$$p[4]:
-                    this.tj = this.tk();
+                    this.tk = this.tl();
                     break;
                 case "BackgroundContent":
-                    if (this.ub != null) {
-                        let e = this.ub;
-                        e.imageTilesReady = delegateRemove(e.imageTilesReady, runOn(this, this.ve));
-                        this.ub.deferralHandler = null;
+                    if (this.uc != null) {
+                        let e = this.uc;
+                        e.imageTilesReady = delegateRemove(e.imageTilesReady, runOn(this, this.vf));
+                        this.uc.deferralHandler = null;
                     }
-                    this.ub = typeCast(GeographicMapImagery.$, this.backgroundContent);
-                    if (this.ub != null) {
-                        let f = this.ub;
-                        f.imageTilesReady = delegateCombine(f.imageTilesReady, runOn(this, this.ve));
-                        this.ub.deferralHandler = this;
-                        this.ub.isHorizontalWrappingEnabled = this.ue == 2;
+                    this.uc = typeCast(GeographicMapImagery.$, this.backgroundContent);
+                    if (this.uc != null) {
+                        let f = this.uc;
+                        f.imageTilesReady = delegateCombine(f.imageTilesReady, runOn(this, this.vf));
+                        this.uc.deferralHandler = this;
+                        this.uc.isHorizontalWrappingEnabled = this.uf == 2;
                     }
-                    this.ui.fu(typeCast(GeographicMapImagery.$, c), typeCast(GeographicMapImagery.$, d));
-                    if (this.ub != null) {
-                        this.ub.geographicMap = this;
-                        this.ui.fr(this.tj);
-                        this.ui.fv(this.gf);
+                    this.uj.fu(typeCast(GeographicMapImagery.$, c), typeCast(GeographicMapImagery.$, d));
+                    if (this.uc != null) {
+                        this.uc.geographicMap = this;
+                        this.uj.fr(this.tk);
+                        this.uj.fv(this.gg);
                     }
                     break;
                 case "YAxis":
                 case "XAxis":
-                    this.vj(c);
-                    this.vc(d);
+                    this.vk(c);
+                    this.vd(d);
                     break;
                 case XamGeographicMap.$$p[6]:
-                    if (!this.um) {
-                        this.tz = XamGeographicMap.v6;
+                    if (!this.un) {
+                        this.t0 = XamGeographicMap.v7;
                     }
-                    this.vd();
-                    this.vk();
+                    this.ve();
                     this.vl();
-                    this.tj = this.tk();
-                    this.ui.fs();
+                    this.vm();
+                    this.tk = this.tl();
+                    this.uj.fs();
                     break;
                 case "ActualWindowRect":
-                    this.ui.fr(this.tj);
+                    this.uj.fr(this.tk);
                     break;
                 case "ActualWorldRect":
                     for (let g of fromEnum(this.series)) {
@@ -1525,30 +1525,30 @@ let XamGeographicMap = /*@__PURE__*/ (() => {
                     }
                     break;
                 case XamGeographicMap.$$p[5]:
-                    this.us = this.ut;
+                    this.ut = this.uu;
                     break;
                 case "ActualWindowScale":
-                    if (!this.fg) {
-                        this.pp(this.gp(), this.gq());
+                    if (!this.fh) {
+                        this.pq(this.gq(), this.gr());
                     }
                     break;
                 case "ActualPixelScalingRatio":
-                    this.ui.fv(this.gf);
+                    this.uj.fv(this.gg);
                     break;
                 case "WindowRectMinWidth":
                 case "WindowRectMinHeight":
                     let h = d;
                     if (isNaN_(h) || isInfinity(h)) {
+                        this.gk = 5E-06;
                         this.gj = 5E-06;
-                        this.gi = 5E-06;
                     }
                     else {
+                        this.gk = h;
                         this.gj = h;
-                        this.gi = h;
                     }
                     break;
                 case XamGeographicMap.$$p[7]:
-                    this.pl();
+                    this.pm();
                     break;
                 case "MarkerAutomaticBehavior":
                     for (let i of fromEnum(this.series)) {
@@ -1557,39 +1557,39 @@ let XamGeographicMap = /*@__PURE__*/ (() => {
                     break;
             }
         }
-        ve(a, b) {
+        vf(a, b) {
             if (this.imageTilesReady != null) {
                 this.imageTilesReady(this, new ImageTilesReadyEventArgs());
             }
         }
-        vj(a) {
+        vk(a) {
             if (a != null) {
                 a.bi = null;
             }
         }
-        vk() {
-            if (this.t6 != null) {
-                this.t6.l5 = this.v7.left;
-                this.t6.l4 = this.v7.right;
+        vl() {
+            if (this.t7 != null) {
+                this.t7.l5 = this.v8.left;
+                this.t7.l4 = this.v8.right;
             }
-            if (this.t8 != null) {
-                this.t8.l5 = this.v7.top;
-                this.t8.l4 = this.v7.bottom;
+            if (this.t9 != null) {
+                this.t9.l5 = this.v8.top;
+                this.t9.l4 = this.v8.bottom;
             }
-            this.t6.c2(true);
-            this.t8.c2(true);
+            this.t7.c2(true);
+            this.t9.c2(true);
         }
         getFontInfo() {
-            this.uj = this.ui.fo;
-            return this.uj;
+            this.uk = this.uj.fo;
+            return this.uk;
         }
-        so() {
-            return this.ui.fw;
+        sp() {
+            return this.uj.fw;
         }
         getFontBrush() {
-            return this.ui.fx;
+            return this.uj.fx;
         }
-        o6(a, b) {
+        o7(a, b) {
             if (typeCast(ItfConverter.$, b) !== null) {
                 let c = b;
                 let d = a;
@@ -1597,33 +1597,33 @@ let XamGeographicMap = /*@__PURE__*/ (() => {
                 d.qn = c.triangulationSource.triangles;
             }
             else {
-                super.o6(a, b);
+                super.o7(a, b);
             }
         }
         register(a, b) {
-            this.ow(a, b);
+            this.ox(a, b);
         }
         unRegister(a) {
-            this.pc(a);
+            this.pd(a);
         }
         deferredRefresh() {
-            this.ly();
+            this.lz();
         }
         deferAction(a) {
-            if (this.uv != null) {
-                this.uv.setTimeout(a, 0);
+            if (this.uw != null) {
+                this.uw.setTimeout(a, 0);
             }
             else {
                 window.setTimeout(a, 0);
             }
         }
-        vb(a) {
-            this.pk(a);
+        vc(a) {
+            this.pl(a);
         }
-        uw() {
+        ux() {
             let a = new ChartVisualData();
-            let b = this.t6.fw();
-            let c = this.t8.fw();
+            let b = this.t7.fw();
+            let c = this.t9.fw();
             a.axes.add1(b);
             a.axes.add1(c);
             for (let d = 0; d < this.series.count; d++) {
@@ -1631,42 +1631,42 @@ let XamGeographicMap = /*@__PURE__*/ (() => {
                 a.series.add1(e);
             }
             a.name = this.name;
-            a.contentArea = RectData.b(this.ty);
-            a.centralArea = RectData.b(this.ty);
-            a.plotArea = RectData.b(this.ty);
+            a.contentArea = RectData.b(this.tz);
+            a.centralArea = RectData.b(this.tz);
+            a.plotArea = RectData.b(this.tz);
             return a;
         }
-        tq(a, b, c) {
+        tr(a, b, c) {
             return a;
         }
-        vf() {
+        vg() {
         }
-        get wi() {
-            return this.v4;
+        get wj() {
+            return this.v5;
         }
-        set wi(a) {
-            this.v4 = a;
+        set wj(a) {
+            this.v5 = a;
         }
-        vp(a) {
-            this.wi = a;
-            this.vo();
+        vq(a) {
+            this.wj = a;
+            this.vp();
         }
-        vo() {
-            if (this.up && !this.wi.isEmpty) {
-                let a = this.getZoomFromGeographicRect(this.wi);
-                this.wi = Rect.empty;
-                this.pr(a, false);
+        vp() {
+            if (this.uq && !this.wj.isEmpty) {
+                let a = this.getZoomFromGeographicRect(this.wj);
+                this.wj = Rect.empty;
+                this.ps(a, false);
             }
         }
-        get up() {
-            return !this.ty.isEmpty && !this.tn.isEmpty;
+        get uq() {
+            return !this.tz.isEmpty && !this.to.isEmpty;
         }
     }
     XamGeographicMap.$t = markType(XamGeographicMap, 'XamGeographicMap', SeriesViewer.$, [IMapRenderDeferralHandler_$type]);
-    XamGeographicMap.ug = 0;
-    XamGeographicMap.v3 = new Rect(2, { $type: Point_$type, x: -180, y: -85.05112878 }, { $type: Point_$type, x: 180, y: 85.05112878 });
-    XamGeographicMap.v6 = new Rect(0, 0, 0, 1, 1);
-    XamGeographicMap.$$p = markDep(DependencyProperty, PropertyMetadata, XamGeographicMap, 'oi', ['BackgroundTilingMode:ud:vq', [MapBackgroundTilingMode_$type, enumGetBox(MapBackgroundTilingMode_$type, 0)], 'IsHorizontalWrappingEnabled:ul:vr', [0, false], 'ResizeBehavior:uh:vs', [MapResizeBehavior_$type, enumGetBox(MapResizeBehavior_$type, XamGeographicMap.ug)], 'SuppressZoomResetOnWorldRectChange:um:vt', [0, false], 'UseWorldRectForZoomBounds:un:vu', [0, false], 'WindowScale:ut:vv', [1, NaN], 'WorldRect:wj:vw', [Rect.$, XamGeographicMap.v3], 'Zoomable:uo:vx', [0, true]]);
+    XamGeographicMap.uh = 0;
+    XamGeographicMap.v4 = new Rect(2, { $type: Point_$type, x: -180, y: -85.05112878 }, { $type: Point_$type, x: 180, y: 85.05112878 });
+    XamGeographicMap.v7 = new Rect(0, 0, 0, 1, 1);
+    XamGeographicMap.$$p = markDep(DependencyProperty, PropertyMetadata, XamGeographicMap, 'oj', ['BackgroundTilingMode:ue:vr', [MapBackgroundTilingMode_$type, enumGetBox(MapBackgroundTilingMode_$type, 0)], 'IsHorizontalWrappingEnabled:um:vs', [0, false], 'ResizeBehavior:ui:vt', [MapResizeBehavior_$type, enumGetBox(MapResizeBehavior_$type, XamGeographicMap.uh)], 'SuppressZoomResetOnWorldRectChange:un:vu', [0, false], 'UseWorldRectForZoomBounds:uo:vv', [0, false], 'WindowScale:uu:vw', [1, NaN], 'WorldRect:wk:vx', [Rect.$, XamGeographicMap.v4], 'Zoomable:up:vy', [0, true]]);
     return XamGeographicMap;
 })();
 /**
@@ -1796,14 +1796,14 @@ let GeographicMapImagery = /*@__PURE__*/ (() => {
                 return a;
             }
             let b = new Rect(0, 0, 0, a.width, a.height);
-            let c = this.geographicMap.wc(b);
-            let d = XamGeographicMap.v3;
-            let e = this.geographicMap.v7;
+            let c = this.geographicMap.wd(b);
+            let d = XamGeographicMap.v4;
+            let e = this.geographicMap.v8;
             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.t6;
-            let i = this.geographicMap.t8;
+            let h = this.geographicMap.t7;
+            let i = this.geographicMap.t9;
             let j = new ScalerParams(1, this.windowRect, b, h.ch);
             j.c = c;
             let k = new ScalerParams(1, this.windowRect, b, i.ch);
@@ -1918,8 +1918,8 @@ let GeographicXYTriangulatingSeriesView = /*@__PURE__*/ (() => {
                 a.qd = null;
                 return;
             }
-            a.qc = this.ce.ce.t6;
-            a.qd = this.ce.ce.t8;
+            a.qc = this.ce.ce.t7;
+            a.qd = this.ce.ce.t9;
         }
         cg() {
             this.ce.qe.re = this.ce.qq;
@@ -1994,15 +1994,15 @@ let XamGeographicMapView = /*@__PURE__*/ (() => {
             this.fp = NaN;
             this.fz = Rect.empty;
             this.fn = a;
-            this.fn.sj = 2;
-            this.fn.ho = 5E-06;
+            this.fn.sk = 2;
+            this.fn.hp = 5E-06;
         }
         m(a) {
             return 2;
         }
         bk(a) {
             this.j.bw(a);
-            this.fn.vb(a);
+            this.fn.vc(a);
             this.el();
         }
         get_ap() {
@@ -2065,13 +2065,13 @@ let XamGeographicMapView = /*@__PURE__*/ (() => {
             }
         }
         fr(a) {
-            if (this.fn.ub != null) {
-                this.fn.ub.windowRect = a;
+            if (this.fn.uc != null) {
+                this.fn.uc.windowRect = a;
             }
         }
         fu(a, b) {
-            if (this.fn.ub != null) {
-                this.fn.ub.windowRect = this.fn.tj;
+            if (this.fn.uc != null) {
+                this.fn.uc.windowRect = this.fn.tk;
             }
             if (a != null) {
                 let c = a.ao;
@@ -2098,7 +2098,7 @@ let XamGeographicMapView = /*@__PURE__*/ (() => {
             }
         }
         ft(a) {
-            let b = this.fn.gf;
+            let b = this.fn.gg;
             if (b != 1) {
                 a.aa();
                 a.ab(b, b);
@@ -2575,80 +2575,80 @@ let IgxGeographicMapComponent = /*@__PURE__*/ (() => {
      * Gets or sets zoomability of the current control
     */
         get zoomable() {
-            return this.i.uo;
+            return this.i.up;
         }
         set zoomable(v) {
-            this.i.uo = ensureBool(v);
+            this.i.up = ensureBool(v);
         }
         /**
          * Gets or sets the behavior to use during resize.
         */
         get resizeBehavior() {
-            return this.i.uh;
+            return this.i.ui;
         }
         set resizeBehavior(v) {
-            this.i.uh = ensureEnum(MapResizeBehavior_$type, v);
+            this.i.ui = ensureEnum(MapResizeBehavior_$type, v);
         }
         /**
          * Gets or sets if the map should horizontally wrap.
         */
         get isHorizontalWrappingEnabled() {
-            return this.i.ul;
+            return this.i.um;
         }
         set isHorizontalWrappingEnabled(v) {
-            this.i.ul = ensureBool(v);
+            this.i.um = ensureBool(v);
         }
         /**
          * Gets or sets if the map should horizontally wrap.
         */
         get backgroundTilingMode() {
-            return this.i.ud;
+            return this.i.ue;
         }
         set backgroundTilingMode(v) {
-            this.i.ud = ensureEnum(MapBackgroundTilingMode_$type, v);
+            this.i.ue = ensureEnum(MapBackgroundTilingMode_$type, v);
         }
         /**
          * Gets or sets whether to use the uncoerced world rect to constrain the zoom bounds.
         */
         get useWorldRectForZoomBounds() {
-            return this.i.un;
+            return this.i.uo;
         }
         set useWorldRectForZoomBounds(v) {
-            this.i.un = ensureBool(v);
+            this.i.uo = ensureBool(v);
         }
         /**
          * Gets or sets whether skip resetting the zoom when the world rect changes.
         */
         get suppressZoomResetOnWorldRectChange() {
-            return this.i.um;
+            return this.i.un;
         }
         set suppressZoomResetOnWorldRectChange(v) {
-            this.i.um = ensureBool(v);
+            this.i.un = ensureBool(v);
         }
         /**
          * Gets or sets the world bounding rectangle.
         */
         get worldRect() {
-            return fromRect(this.i.wj);
+            return fromRect(this.i.wk);
         }
         set worldRect(v) {
-            this.i.wj = toRect(v);
+            this.i.wk = toRect(v);
         }
         /**
          * Gets the actual value of the WorldRect.
         */
         get actualWorldRect() {
-            return fromRect(this.i.v7);
+            return fromRect(this.i.v8);
         }
         set actualWorldRect(v) {
-            this.i.v7 = toRect(v);
+            this.i.v8 = 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.t6;
+            const r = this.i.t7;
             if (r == null) {
                 return null;
             }
@@ -2664,14 +2664,14 @@ let IgxGeographicMapComponent = /*@__PURE__*/ (() => {
         set xAxis(v) {
             if (v != null && this._stylingContainer && v._styling)
                 v._styling(this._stylingContainer, this, this);
-            v == null ? this.i.t6 = null : this.i.t6 = v.i;
+            v == null ? this.i.t7 = null : this.i.t7 = 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.t8;
+            const r = this.i.t9;
             if (r == null) {
                 return null;
             }
@@ -2687,39 +2687,39 @@ let IgxGeographicMapComponent = /*@__PURE__*/ (() => {
         set yAxis(v) {
             if (v != null && this._stylingContainer && v._styling)
                 v._styling(this._stylingContainer, this, this);
-            v == null ? this.i.t8 = null : this.i.t8 = v.i;
+            v == null ? this.i.t9 = null : this.i.t9 = v.i;
         }
         /**
          * Indicates if this SeriesViewer is a map.
         */
         get isMap() {
-            return this.i.ek;
+            return this.i.el;
         }
         /**
          * 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.ut;
+            return this.i.uu;
         }
         set windowScale(v) {
-            this.i.ut = +v;
+            this.i.uu = +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.us;
+            return this.i.ut;
         }
         set actualWindowScale(v) {
-            this.i.us = +v;
+            this.i.ut = +v;
         }
         /**
          * Gets whether or not the control is ready for zooming
         */
         get zoomIsReady() {
-            return this.i.up;
+            return this.i.uq;
         }
         findByName(name) {
             var baseResult = super.findByName(name);
@@ -2747,7 +2747,7 @@ let IgxGeographicMapComponent = /*@__PURE__*/ (() => {
     
     */
         getCurrentActualWorldRect() {
-            let iv = this.i.wb();
+            let iv = this.i.wc();
             return fromRect(iv);
         }
         /**
@@ -2764,14 +2764,14 @@ let IgxGeographicMapComponent = /*@__PURE__*/ (() => {
         
         */
         updateZoomWindow(zoomWindow) {
-            this.i.vn(toRect(zoomWindow));
+            this.i.vo(toRect(zoomWindow));
         }
         /**
          * Updates world rect in geographic coordinates
         
         */
         updateWorldRect(worldRect) {
-            this.i.vm(toRect(worldRect));
+            this.i.vn(toRect(worldRect));
         }
         /**
          * Given the current plot area of the control and a geographic region, get the WindowRect that would encompass that geographic region.
@@ -2783,7 +2783,7 @@ let IgxGeographicMapComponent = /*@__PURE__*/ (() => {
             return fromRect(iv);
         }
         convertGeographicToZoom(geographic, extraPixelPadding) {
-            let iv = this.i.v8(toRect(geographic), extraPixelPadding);
+            let iv = this.i.v9(toRect(geographic), extraPixelPadding);
             return fromRect(iv);
         }
         getZoomFromGeographicPoints(northWest, southEast) {
@@ -2796,7 +2796,7 @@ let IgxGeographicMapComponent = /*@__PURE__*/ (() => {
         * @param windowRect  * The zoom area.
         */
         getGeographicFromZoom(windowRect) {
-            let iv = this.i.wd(toRect(windowRect));
+            let iv = this.i.we(toRect(windowRect));
             return fromRect(iv);
         }
         /**
@@ -2805,7 +2805,7 @@ let IgxGeographicMapComponent = /*@__PURE__*/ (() => {
         * @param pixelCoordinate  * A pixel-based coordinate
         */
         getGeographicPoint(pixelCoordinate) {
-            let iv = this.i.vz(toPoint(pixelCoordinate));
+            let iv = this.i.v0(toPoint(pixelCoordinate));
             return fromPoint(iv);
         }
         /**
@@ -2814,7 +2814,7 @@ let IgxGeographicMapComponent = /*@__PURE__*/ (() => {
         * @param geographicCoordinate  * A geographic coordinate
         */
         getPixelPoint(geographicCoordinate) {
-            let iv = this.i.v0(toPoint(geographicCoordinate));
+            let iv = this.i.v1(toPoint(geographicCoordinate));
             return fromPoint(iv);
         }
         /**
@@ -2823,7 +2823,7 @@ let IgxGeographicMapComponent = /*@__PURE__*/ (() => {
         * @param geographicCoordinate  * A geographic coordinate
         */
         getWindowPoint(geographicCoordinate) {
-            let iv = this.i.v1(toPoint(geographicCoordinate));
+            let iv = this.i.v2(toPoint(geographicCoordinate));
             return fromPoint(iv);
         }
         /**
@@ -2831,21 +2831,21 @@ let IgxGeographicMapComponent = /*@__PURE__*/ (() => {
         
         */
         clearTileCache() {
-            this.i.va();
+            this.i.vb();
         }
         /**
          * Notifies the chart that the CSS styles in effect have been updated.
         
         */
         styleUpdated() {
-            this.i.vi();
+            this.i.vj();
         }
         /**
          * Gets actual window scale for horizontal dimension of the control
         
         */
         getActualWindowScaleHorizontal() {
-            let iv = this.i.gp();
+            let iv = this.i.gq();
             return (iv);
         }
         /**
@@ -2853,7 +2853,7 @@ let IgxGeographicMapComponent = /*@__PURE__*/ (() => {
         
         */
         getActualWindowScaleVertical() {
-            let iv = this.i.gq();
+            let iv = this.i.gr();
             return (iv);
         }
         /**
@@ -2868,7 +2868,7 @@ let IgxGeographicMapComponent = /*@__PURE__*/ (() => {
         
         */
         exportVisualData() {
-            let iv = this.i.uw();
+            let iv = this.i.ux();
             return (iv);
         }
         /**
@@ -2877,7 +2877,7 @@ let IgxGeographicMapComponent = /*@__PURE__*/ (() => {
         * @param geographic  * The geographic region to zoom to.
         */
         zoomToGeographic(geographic) {
-            this.i.vp(toRect(geographic));
+            this.i.vq(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.
@@ -5057,8 +5057,8 @@ let GeographicShapeSeriesBaseView = /*@__PURE__*/ (() => {
                 a.qv = null;
                 return;
             }
-            a.qt = this.ce.ce.t6;
-            a.qv = this.ce.ce.t8;
+            a.qt = this.ce.ce.t7;
+            a.qv = this.ce.ce.t9;
         }
         ch() {
             this.ce.qe.r5 = this.ce.q7;
@@ -6016,7 +6016,7 @@ let TileSeries = /*@__PURE__*/ (() => {
                     if (f != null && typeCast(XamGeographicMap.$, this.ce) !== null) {
                         f.geographicMap = this.ce;
                         this.tb(this.b1);
-                        this.sz.da(this.ce.tj);
+                        this.sz.da(this.ce.tk);
                     }
                     this.lu();
                     break;
@@ -6900,10 +6900,10 @@ let GeographicProportionalSymbolSeriesView = /*@__PURE__*/ (() => {
             this.ce.qe.tb = this.ce.qq;
         }
         cv() {
-            this.ce.qe.xAxis = this.ce.ce.t6;
+            this.ce.qe.xAxis = this.ce.ce.t7;
         }
         cw() {
-            this.ce.qe.yAxis = this.ce.ce.t8;
+            this.ce.qe.yAxis = this.ce.ce.t9;
         }
         cu() {
             let a = this.ce.qe;
@@ -6912,8 +6912,8 @@ let GeographicProportionalSymbolSeriesView = /*@__PURE__*/ (() => {
                 a.yAxis = null;
                 return;
             }
-            a.xAxis = this.ce.ce.t6;
-            a.yAxis = this.ce.ce.t8;
+            a.xAxis = this.ce.ce.t7;
+            a.yAxis = this.ce.ce.t9;
         }
         co() {
             this.ce.qe.rn = this.ce.ri;
@@ -7513,10 +7513,10 @@ let GeographicSymbolSeriesView = /*@__PURE__*/ (() => {
             this.ce.qe.tb = this.ce.qq;
         }
         cp() {
-            this.ce.qe.xAxis = this.ce.ce.t6;
+            this.ce.qe.xAxis = this.ce.ce.t7;
         }
         cq() {
-            this.ce.qe.yAxis = this.ce.ce.t8;
+            this.ce.qe.yAxis = this.ce.ce.t9;
         }
         co() {
             let a = this.ce.qe;
@@ -7525,8 +7525,8 @@ let GeographicSymbolSeriesView = /*@__PURE__*/ (() => {
                 a.yAxis = null;
                 return;
             }
-            a.xAxis = this.ce.ce.t6;
-            a.yAxis = this.ce.ce.t8;
+            a.xAxis = this.ce.ce.t7;
+            a.yAxis = this.ce.ce.t9;
         }
         ci() {
             this.ce.qe.rx = this.ce.rm;
@@ -8248,14 +8248,14 @@ let GeographicHighDensityScatterSeriesView = /*@__PURE__*/ (() => {
                 a.ql = null;
                 return;
             }
-            a.qj = this.ce.ce.t6;
-            a.ql = this.ce.ce.t8;
+            a.qj = this.ce.ce.t7;
+            a.ql = this.ce.ce.t9;
         }
         cq() {
-            this.ce.qe.qj = this.ce.ce.t6;
+            this.ce.qe.qj = this.ce.ce.t7;
         }
         cr() {
-            this.ce.qe.ql = this.ce.ce.t8;
+            this.ce.qe.ql = this.ce.ce.t9;
         }
         ch() {
             this.ce.qe.ts = this.ce.rm;