igniteui-angular-maps 12.1.1

package/esm5/lib/XamGeographicMap_combined.js

@@ -0,0 +1,1555 @@
+/*
+THIS INFRAGISTICS ULTIMATE SOFTWARE LICENSE  AGREEMENT ("AGREEMENT") LOCATED HERE:
+https://www.infragistics.com/legal/license/igultimate-la
+https://www.infragistics.com/legal/license/igultimate-eula
+GOVERNS THE LICENSING, INSTALLATION AND USE OF INFRAGISTICS SOFTWARE. BY DOWNLOADING AND/OR INSTALLING AND USING INFRAGISTICS SOFTWARE:  you are indicating that you have read and understand this Agreement, and agree to be legally bound by it on behalf of the yourself and your company.
+*/
+import * as tslib_1 from "tslib";
+import { SeriesViewer } from "igniteui-angular-charts";
+import { IMapRenderDeferralHandler_$type } from "igniteui-angular-core";
+import { DependencyProperty } from "igniteui-angular-core";
+import { MapResizeBehavior_$type } from "./MapResizeBehavior";
+import { MapBackgroundTilingMode_$type } from "./MapBackgroundTilingMode";
+import { Rect } from "igniteui-angular-core";
+import { Base, Boolean_$type, typeCast, enumGetBox, Point_$type, fromEnum, Number_$type, runOn, delegateRemove, delegateCombine, markType, markDep, INotifyPropertyChanged_$type, PropertyChangedEventArgs, String_$type, IEnumerable_$type } from "igniteui-angular-core";
+import { NumericXAxis } from "igniteui-angular-charts";
+import { NumericYAxis } from "igniteui-angular-charts";
+import { SphericalMercatorVerticalScaler } from "./SphericalMercatorVerticalScaler";
+import { Control } from "igniteui-angular-core";
+import { SphericalMercatorHorizontalScaler } from "./SphericalMercatorHorizontalScaler";
+import { ScalerParams } from "igniteui-angular-charts";
+import { Brush } from "igniteui-angular-core";
+import { SeriesViewerView } from "igniteui-angular-charts";
+import { Tuple$2 } from "igniteui-angular-core";
+import { MathUtil } from "igniteui-angular-core";
+import { ImageTilesReadyEventArgs } from "./ImageTilesReadyEventArgs";
+import { ItfConverter } from "igniteui-angular-core";
+import { ChartVisualData } from "igniteui-angular-charts";
+import { RectData } from "igniteui-angular-core";
+import { PropertyMetadata } from "igniteui-angular-core";
+import { truncate, intDivide, isNaN_ } from "igniteui-angular-core";
+import { XamMultiScaleImage } from "igniteui-angular-core";
+import { Size } from "igniteui-angular-core";
+import { ImagesChangedEventArgs } from "./ImagesChangedEventArgs";
+import { HostSeriesView } from "./HostSeriesView";
+import { GeographicMapSeriesHost } from "./GeographicMapSeriesHost";
+import { ScatterAreaSeries } from "igniteui-angular-charts";
+import { OpenStreetMapTileSource } from "igniteui-angular-core";
+/**
+ * @hidden
+ */
+var XamGeographicMap = /** @class */ (function (_super) {
+    tslib_1.__extends(XamGeographicMap, _super);
+    function XamGeographicMap() {
+        var _this = _super.call(this) || this;
+        _this.p4 = null;
+        _this.pt = false;
+        _this.pl = 1;
+        _this.p0 = 0;
+        _this.rb = null;
+        _this.pi = null;
+        _this.pe = null;
+        _this.pg = null;
+        _this.pk = null;
+        _this.q7 = { $type: Point_$type, x: NaN, y: NaN };
+        _this.re = null;
+        _this.pz = 1;
+        _this.imageTilesReady = null;
+        _this.ps = null;
+        _this.rd = Rect.empty;
+        _this.p0 = SphericalMercatorVerticalScaler.am(XamGeographicMap.rc.bottom) - SphericalMercatorVerticalScaler.am(XamGeographicMap.rc.top);
+        _this.ab = XamGeographicMap.$;
+        _this.backgroundContent = new OpenStreetMapImagery();
+        var a = ((function () {
+            var $ret = new NumericXAxis();
+            $ret.bh = _this;
+            return $ret;
+        })());
+        a.b8 = true;
+        _this.pf = a;
+        _this.pf.lp = new SphericalMercatorHorizontalScaler();
+        var b = ((function () {
+            var $ret = new NumericYAxis();
+            $ret.bh = _this;
+            return $ret;
+        })());
+        b.b8 = true;
+        _this.ph = b;
+        _this.ph.lp = new SphericalMercatorVerticalScaler();
+        _this.qm();
+        _this.qt();
+        _this.i7();
+        return _this;
+    }
+    XamGeographicMap.prototype.provideContainer = function (a) {
+        _super.prototype.provideContainer.call(this, a);
+        this.pf.provideRenderer(a);
+        this.ph.provideRenderer(a);
+    };
+    XamGeographicMap.prototype.i7 = function () {
+        _super.prototype.i7.call(this);
+        this.pr.fq(this.e8);
+    };
+    XamGeographicMap.prototype.dx = function () {
+        return this.px;
+    };
+    XamGeographicMap.prototype.dy = function () {
+        return this.px;
+    };
+    XamGeographicMap.prototype.po = function () {
+        if (this.pm == 0) {
+            if (this.pt) {
+                return 2;
+            }
+        }
+        return 1;
+    };
+    Object.defineProperty(XamGeographicMap.prototype, "pn", {
+        get: function () {
+            return this.pl;
+        },
+        set: function (a) {
+            this.pl = a;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(XamGeographicMap.prototype, "rg", {
+        get: function () {
+            return this.rb;
+        },
+        set: function (a) {
+            var b = Rect.l_op_Inequality(this.rb, a);
+            if (b) {
+                var c = this.rb;
+                this.rb = a;
+                this.k5("ActualWorldRect", c, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    XamGeographicMap.prototype.rk = function () {
+        return this.rg;
+    };
+    XamGeographicMap.prototype.qm = function () {
+        if (this.rs.isEmpty) {
+            return;
+        }
+        this.rg = this.rq(this.rs, this.br == 1);
+    };
+    XamGeographicMap.prototype.rq = function (a, b) {
+        var c = a.top;
+        var d = a.left;
+        var e = a.width;
+        var f = a.height;
+        var g = SphericalMercatorVerticalScaler.am(a.bottom);
+        var h = SphericalMercatorVerticalScaler.am(a.top);
+        var i = g - h;
+        var j = a.width / XamGeographicMap.rc.width;
+        var k = SphericalMercatorVerticalScaler.am(XamGeographicMap.rc.top);
+        var l = i / j;
+        if (i / j > this.p0) {
+            var m = i / this.p0;
+            var n = m - j;
+            d = d - (n / 2) * XamGeographicMap.rc.width;
+            e = m * XamGeographicMap.rc.width;
+            if (b) {
+                if (d < XamGeographicMap.rc.left) {
+                    d += (XamGeographicMap.rc.left - d);
+                }
+                else if ((d + e) > XamGeographicMap.rc.right) {
+                    d -= ((d + e) - XamGeographicMap.rc.right);
+                }
+            }
+        }
+        else if (i / j < this.p0) {
+            var o = this.p0 * j;
+            var p = o - i;
+            var q = h - (p / 2);
+            var r = g + (p / 2);
+            if (b) {
+                if (q < k) {
+                    q += (k - q);
+                    r += (k - q);
+                }
+                else if (r > (k + this.p0)) {
+                    q -= ((r) - (k + this.p0));
+                    r -= ((r) - (k + this.p0));
+                }
+            }
+            c = SphericalMercatorVerticalScaler.aq(q);
+            f = SphericalMercatorVerticalScaler.aq(r) - c;
+        }
+        var s = new Rect(0, d, c, e, f);
+        return s;
+    };
+    Object.defineProperty(XamGeographicMap.prototype, "backgroundContent", {
+        get: function () {
+            return this.pi;
+        },
+        set: function (a) {
+            var b = a != this.backgroundContent;
+            if (b) {
+                var c = this.backgroundContent;
+                this.pi = a;
+                this.k5("BackgroundContent", c, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(XamGeographicMap.prototype, "pf", {
+        get: function () {
+            return this.pe;
+        },
+        set: function (a) {
+            var b = a != this.pf;
+            if (b) {
+                var c = this.pf;
+                this.pe = a;
+                this.k5("XAxis", c, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(XamGeographicMap.prototype, "ph", {
+        get: function () {
+            return this.pg;
+        },
+        set: function (a) {
+            var b = a != this.ph;
+            if (b) {
+                var c = this.ph;
+                this.pg = a;
+                this.k5("YAxis", c, a);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    XamGeographicMap.prototype.getZoomRectFromGeoRect = function (a) {
+        return this.getZoomFromGeographicRect(a);
+    };
+    XamGeographicMap.prototype.qw = function (a) {
+        this.o8 = a;
+    };
+    XamGeographicMap.prototype.qv = function (a) {
+        this.rs = a;
+    };
+    XamGeographicMap.prototype.getZoomFromGeographicRect = function (a) {
+        return this.ri(a, true, 0);
+    };
+    XamGeographicMap.prototype.rh = function (a, b) {
+        return this.ri(a, false, b);
+    };
+    XamGeographicMap.prototype.ri = function (a, b, c) {
+        var d = a;
+        if (b) {
+            d = this.rq(a, false);
+        }
+        var e = this.pf;
+        var f = this.ph;
+        var g = new ScalerParams(1, XamGeographicMap.rf, this.o7, e.ca);
+        g.c = this.ow;
+        var h = new ScalerParams(1, XamGeographicMap.rf, this.o7, f.ca);
+        h.c = this.ow;
+        var i = this.pf.dz(d.left, g);
+        var j = this.pf.dz(d.right, g);
+        var k = this.ph.dz(d.top, h);
+        var l = this.ph.dz(d.bottom, h);
+        var m = (i - c) / this.o7.width;
+        var n = (l - c) / this.o7.height;
+        var o = (j - i + (c * 2)) / this.o7.width;
+        var p = (k - l + (c * 2)) / this.o7.height;
+        var q = new Rect(0, m, n, o, p);
+        q.intersect(XamGeographicMap.rf);
+        if (q.isEmpty) {
+            q = XamGeographicMap.rf;
+        }
+        return q;
+    };
+    XamGeographicMap.prototype.getZoomFromGeographicPoints = function (a, b) {
+        var c = a.x;
+        var d = b.y;
+        var e = b.x - a.x;
+        var f = a.y - b.y;
+        if (e < 0 || f < 0) {
+            return XamGeographicMap.rf;
+        }
+        else {
+            var g = new Rect(0, c, d, e, f);
+            return this.getZoomFromGeographicRect(g);
+        }
+    };
+    XamGeographicMap.prototype.rm = function (a) {
+        var b = this.pf;
+        var c = this.ph;
+        var d = new ScalerParams(1, a, this.o7, b.ca);
+        d.c = this.ow;
+        var e = new ScalerParams(1, a, this.o7, c.ca);
+        e.c = this.ow;
+        var f = this.ov;
+        var g = b.d2(f.left, d);
+        var h = c.d2(f.top, e);
+        var i = b.d2(f.right, d);
+        var j = c.d2(f.bottom, e);
+        var k = i - g;
+        var l = h - j;
+        var m = new Rect(0, g, j, k, l);
+        if (this.br == 1) {
+            m.intersect(XamGeographicMap.rc);
+            if (m.isEmpty) {
+                m = XamGeographicMap.rc;
+            }
+        }
+        return m;
+    };
+    XamGeographicMap.prototype.q8 = function (a) {
+        var b = this.pf.ko(a.x);
+        var c = this.ph.ko(a.y);
+        return { $type: Point_$type, x: b, y: c };
+    };
+    XamGeographicMap.prototype.q9 = function (a) {
+        var b = this.pf.ee(a.x);
+        var c = this.ph.ee(a.y);
+        return { $type: Point_$type, x: b, y: c };
+    };
+    XamGeographicMap.prototype.ra = function (a) {
+        return this.q9(a);
+    };
+    XamGeographicMap.prototype.qj = function () {
+        var a = typeCast(GeographicMapImagery.$, this.backgroundContent);
+        if (a != null) {
+            a.clearTileCache();
+        }
+    };
+    XamGeographicMap.prototype.qp = function (a) {
+    };
+    XamGeographicMap.prototype.oa = function (a) {
+        return this.pr.fu(a);
+    };
+    XamGeographicMap.prototype.ob = function (a) {
+        return this.pr.fv(a);
+    };
+    XamGeographicMap.prototype.eg = function () {
+        return true;
+    };
+    XamGeographicMap.prototype.qr = function () {
+        var e_1, _a;
+        this.pr.eb();
+        try {
+            for (var _b = tslib_1.__values(fromEnum(this.series)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var a = _c.value;
+                a.lc();
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    };
+    XamGeographicMap.prototype.qu = function () {
+        if (this.pq == 2) {
+            if (!this.o7.isEmpty && this.o7.width > 0 && this.o7.height > 0) {
+                var a = this.pf.ko(this.o7.left + (this.o7.width / 2));
+                var b = this.ph.ko(this.o7.top + (this.o7.height / 2));
+                this.q7 = { $type: Point_$type, x: a, y: b };
+            }
+        }
+        else {
+            if (!this.o7.isEmpty && this.o7.width > 0 && this.o7.height > 0) {
+                var c = this.pf.ko(this.o7.left);
+                var d = this.ph.ko(this.o7.top);
+                this.q7 = { $type: Point_$type, x: c, y: d };
+            }
+        }
+    };
+    XamGeographicMap.prototype.qq = function () {
+        if (isNaN_(this.q7.x) || isNaN_(this.q7.y)) {
+            this.qu();
+        }
+        var a = this.q7.x;
+        var b = this.q7.y;
+        if (!isNaN_(a) && !isNaN_(b)) {
+            var c = this.os.left;
+            var d = this.os.top;
+            var e = this.os.width;
+            var f = this.os.height;
+            if (e > this.re.width) {
+            }
+            else {
+                var g = new ScalerParams(1, XamGeographicMap.rf, this.o7, this.pf.ca);
+                g.c = this.ow;
+                var h = this.pf.dz(a, g);
+                if (this.pq == 2) {
+                    var i = h / this.o7.width;
+                    c = i - (e / 2);
+                }
+                else {
+                    c = h / this.o7.width;
+                }
+                if (c + e > this.re.right) {
+                    c = this.re.right - e;
+                }
+                else if (c < this.re.left) {
+                    c = this.re.left;
+                }
+            }
+            if (f > this.re.height) {
+            }
+            else {
+                var j = new ScalerParams(1, XamGeographicMap.rf, this.o7, this.ph.ca);
+                j.c = this.ow;
+                var k = this.ph.dz(b, j);
+                if (this.pq == 2) {
+                    var l = k / this.o7.height;
+                    d = l - (f / 2);
+                }
+                else {
+                    d = k / this.o7.height;
+                }
+                if (d + f > this.re.bottom) {
+                    d = this.re.bottom - f;
+                }
+                else if (d < this.re.top) {
+                    d = this.re.top;
+                }
+            }
+            this.mc(new Rect(0, c, d, e, f), false);
+        }
+    };
+    XamGeographicMap.prototype.get_dq = function () {
+        return true;
+    };
+    XamGeographicMap.prototype.ot = function () {
+        var a = _super.prototype.ot.call(this);
+        if (this.pf == null || this.ph == null) {
+            return a;
+        }
+        this.o3();
+        var b = a.left;
+        var c = a.top;
+        if (this.br == 1) {
+            if (this.o8.width > this.re.width) {
+                b = 0.5 - (this.o8.width / 2);
+            }
+            else if (b + a.width > this.re.right) {
+                b = this.re.right - this.o8.width;
+            }
+            else if (b < this.re.left) {
+                b = this.re.left;
+            }
+            if (this.o8.height > this.re.height) {
+                c = 0.5 - (this.o8.height / 2);
+            }
+            else if (c + this.o8.height > this.re.bottom) {
+                c = this.re.bottom - this.o8.height;
+            }
+            else if (c < this.re.top) {
+                c = this.re.top;
+            }
+        }
+        var d = false;
+        if (!this.pw && this.br == 2 && this.pt) {
+            if (b > 1) {
+                b = (b - Math.floor(b)) + 1;
+            }
+            if (b < 0) {
+                b = 0 - (Math.ceil(b) - b);
+            }
+            if ((a.right - this.re.right) > 0 && ((a.right - this.re.right) / a.width) > 0.8) {
+                b = this.re.left - (a.width - (a.right - this.re.right));
+                d = true;
+            }
+            else if (a.left < this.re.left && (Math.abs(a.left - this.re.left) / a.width) > 0.8) {
+                b = this.re.right - (Math.abs(a.left - this.re.left));
+                d = true;
+            }
+        }
+        var e = new Rect(0, b, c, a.width, a.height);
+        if (this.pw) {
+            var f = this.rh(this.rs, 1);
+            f = this.rj(f);
+            var g = e.left + e.width / 2;
+            var h = e.top + e.height / 2;
+            if (e.width > f.width) {
+                var i = e.height / e.width;
+                var j = f.width;
+                var k = i * j;
+                e = new Rect(0, g - j / 2, h - k / 2, j, k);
+                d = true;
+            }
+            if (e.height > f.height) {
+                var l = e.width / e.height;
+                var m = f.height;
+                var n = l * m;
+                e = new Rect(0, g - n / 2, h - m / 2, n, m);
+                d = true;
+            }
+            if (e.left < f.left) {
+                e = new Rect(0, f.left, e.top, e.width, e.height);
+                d = true;
+            }
+            if (e.top < f.top) {
+                e = new Rect(0, e.left, f.top, e.width, e.height);
+                d = true;
+            }
+            if (e.right > f.right) {
+                e = new Rect(0, f.right - e.width, e.top, e.width, e.height);
+                d = true;
+            }
+            if (e.bottom > f.bottom) {
+                e = new Rect(0, e.left, f.bottom - e.height, e.width, e.height);
+                d = true;
+            }
+        }
+        if (d) {
+            this.dc = true;
+            this.o8 = e;
+            this.dc = false;
+        }
+        return e;
+    };
+    XamGeographicMap.prototype.ik = function (a, b) {
+        var c = true;
+        var d = true;
+        var e = 0;
+        var f = this.o3();
+        var g = 0;
+        var h = 0;
+        if ((a.right - f.right) > 0) {
+            g = ((a.right - f.right) / a.width);
+        }
+        if (a.left < f.left) {
+            h = (Math.abs(a.left - f.left) / a.width);
+        }
+        if (h == 0 && g == 0) {
+            c = false;
+        }
+        if (h > g) {
+            d = false;
+        }
+        if (c) {
+            if (d) {
+                var i = this.pe.dz(-180, b);
+                var j = this.pe.dz(180, b);
+                e = j - i;
+            }
+            else {
+                var k = this.pe.dz(-180, b);
+                var l = this.pe.dz(180, b);
+                e = k - l;
+            }
+        }
+        return new Tuple$2(Boolean_$type, Number_$type, c, e);
+    };
+    XamGeographicMap.prototype.o3 = function () {
+        var a = new ScalerParams(1, XamGeographicMap.rf, this.o7, this.pf.ca);
+        a.c = this.ow;
+        var b = new ScalerParams(1, XamGeographicMap.rf, this.o7, this.ph.ca);
+        b.c = this.ow;
+        var c = this.pf.dz(XamGeographicMap.rc.left, a);
+        var d = this.pf.dz(XamGeographicMap.rc.right, a);
+        var e = this.ph.dz(XamGeographicMap.rc.top, b);
+        var f = this.ph.dz(XamGeographicMap.rc.bottom, b);
+        this.re = new Rect(0, c / this.o7.width, f / this.o7.height, (d - c) / this.o7.width, (e - f) / this.o7.height);
+        return this.re;
+    };
+    XamGeographicMap.prototype.rj = function (a) {
+        var b = this.fw;
+        var c = 0.5 * (a.left + a.right);
+        var d = 0.5 * (a.top + a.bottom);
+        var e = a.width;
+        var f = a.height;
+        var g = MathUtil.b(a.width, b, 1);
+        var h = MathUtil.b(a.height, b, 1);
+        var i = this.o7;
+        var j = i.width / i.height;
+        var k = g * i.width;
+        var l = h * i.height;
+        var m = k / l;
+        if (m != j) {
+            if (l * j > k) {
+                k = l * j;
+                g = k / i.width;
+            }
+            else {
+                l = k / j;
+                h = l / i.height;
+            }
+        }
+        var n = g != e;
+        var o = h != f;
+        var p = n ? c - 0.5 * g : a.left;
+        var q = o ? d - 0.5 * h : a.top;
+        var r = n ? c + 0.5 * g : a.right;
+        var s = o ? d + 0.5 * h : a.bottom;
+        if (p < 0) {
+            p = 0;
+            r = p + g;
+        }
+        if (r > 1) {
+            r = 1;
+            p = r - g;
+        }
+        if (q < 0) {
+            q = 0;
+            s = q + h;
+        }
+        if (s > 1) {
+            s = 1;
+            q = s - h;
+        }
+        return new Rect(0, p, q, r - p, s - q);
+    };
+    XamGeographicMap.prototype.ou = function (a) {
+        _super.prototype.ou.call(this, this.o7);
+        if (a.isEmpty) {
+            return Rect.empty;
+        }
+        var b;
+        if (a.width > a.height) {
+            var c = intDivide(truncate((a.width - a.height)), 2);
+            b = new Rect(0, a.left + c, a.top, a.height, a.height);
+        }
+        else {
+            var d = intDivide(truncate((a.height - a.width)), 2);
+            b = new Rect(0, a.left, a.top + d, a.width, a.width);
+        }
+        return b;
+    };
+    XamGeographicMap.prototype.rl = function (a) {
+        return this.ou(a);
+    };
+    XamGeographicMap.prototype.b7 = function () {
+        return new XamGeographicMapView(this);
+    };
+    XamGeographicMap.prototype.n6 = function (a) {
+        return this.pr.ft(a);
+    };
+    XamGeographicMap.prototype.oc = function (a) {
+        return this.pr.fw(a);
+    };
+    XamGeographicMap.prototype.ql = function (a) {
+        if (a != null) {
+            a.bh = this;
+        }
+    };
+    XamGeographicMap.prototype.kp = function (a) {
+        _super.prototype.kp.call(this, a);
+        this.pr = a;
+    };
+    XamGeographicMap.prototype.k0 = function (a, b) {
+        _super.prototype.k0.call(this, a, b);
+        this.l0(this.pf);
+        this.l0(this.ph);
+        if (Rect.l_op_Inequality(a, b)) {
+            this.qq();
+        }
+        if (this.pw) {
+            this.os = this.ot();
+        }
+        this.qx();
+    };
+    Object.defineProperty(XamGeographicMap.prototype, "p1", {
+        get: function () {
+            return this.pz;
+        },
+        set: function (a) {
+            var b = this.pz;
+            this.pz = a;
+            this.k5("ActualWindowScale", b, this.pz);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    XamGeographicMap.prototype.fe = function () {
+        return this.p1;
+    };
+    XamGeographicMap.prototype.ff = function () {
+        return this.p1;
+    };
+    XamGeographicMap.prototype.lz = function () {
+        _super.prototype.lz.call(this);
+        var a = Math.min(this.os.width, this.os.height);
+        this.p1 = a;
+    };
+    XamGeographicMap.prototype.ea = function () {
+        return this.pt;
+    };
+    XamGeographicMap.prototype.bs = function () {
+        if (this.bt == 0) {
+            if (this.pu) {
+                return 2;
+            }
+        }
+        return this.bt;
+    };
+    XamGeographicMap.prototype.k1 = function (a, b, c, d) {
+        var e_2, _a;
+        _super.prototype.k1.call(this, a, b, c, d);
+        switch (b) {
+            case "ZoomCoercionMode":
+                this.qm();
+                break;
+            case "WindowRect":
+                this.qu();
+                break;
+            case XamGeographicMap.$$p[0]:
+                this.pn = this.po();
+                if (this.pk != null) {
+                    this.pk.isHorizontalWrappingEnabled = this.pn == 2;
+                }
+                break;
+            case XamGeographicMap.$$p[1]:
+                this.pt = this.pu;
+                this.pn = this.po();
+                this.br = this.bs();
+                if (this.pk != null) {
+                    this.pk.isHorizontalWrappingEnabled = this.pn == 2;
+                }
+                break;
+            case XamGeographicMap.$$p[4]:
+                this.os = this.ot();
+                break;
+            case "BackgroundContent":
+                if (this.pk != null) {
+                    var e = this.pk;
+                    e.imageTilesReady = delegateRemove(e.imageTilesReady, runOn(this, this.qn));
+                    this.pk.deferralHandler = null;
+                }
+                this.pk = typeCast(GeographicMapImagery.$, this.backgroundContent);
+                if (this.pk != null) {
+                    var f = this.pk;
+                    f.imageTilesReady = delegateCombine(f.imageTilesReady, runOn(this, this.qn));
+                    this.pk.deferralHandler = this;
+                    this.pk.isHorizontalWrappingEnabled = this.pn == 2;
+                }
+                this.pr.fp(typeCast(GeographicMapImagery.$, c), typeCast(GeographicMapImagery.$, d));
+                if (this.pk != null) {
+                    this.pk.geographicMap = this;
+                    this.pr.fm(this.os);
+                    this.pr.fq(this.e8);
+                }
+                break;
+            case "YAxis":
+            case "XAxis":
+                this.qs(c);
+                this.ql(d);
+                break;
+            case XamGeographicMap.$$p[6]:
+                if (!this.pv) {
+                    this.o8 = XamGeographicMap.rf;
+                }
+                this.qm();
+                this.qt();
+                this.qu();
+                this.os = this.ot();
+                this.pr.fn();
+                break;
+            case "ActualWindowRect":
+                this.pr.fm(this.os);
+                break;
+            case "ActualWorldRect":
+                try {
+                    for (var _b = tslib_1.__values(fromEnum(this.series)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                        var g = _c.value;
+                        g.k3(false);
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+                break;
+            case XamGeographicMap.$$p[5]:
+                this.p1 = this.p2;
+                break;
+            case "ActualWindowScale":
+                if (!this.ef) {
+                    this.mb(this.fe(), this.ff());
+                }
+                break;
+            case "ActualPixelScalingRatio":
+                this.pr.fq(this.e8);
+                break;
+            case XamGeographicMap.$$p[7]:
+                this.l7();
+                break;
+        }
+    };
+    XamGeographicMap.prototype.qn = function (a, b) {
+        if (this.imageTilesReady != null) {
+            this.imageTilesReady(this, new ImageTilesReadyEventArgs());
+        }
+    };
+    XamGeographicMap.prototype.qs = function (a) {
+        if (a != null) {
+            a.bh = null;
+        }
+    };
+    XamGeographicMap.prototype.qt = function () {
+        if (this.pf != null) {
+            this.pf.kl = this.rg.left;
+            this.pf.kk = this.rg.right;
+        }
+        if (this.ph != null) {
+            this.ph.kl = this.rg.top;
+            this.ph.kk = this.rg.bottom;
+        }
+        this.pf.co(true);
+        this.ph.co(true);
+    };
+    XamGeographicMap.prototype.getFontInfo = function () {
+        this.ps = this.pr.fj;
+        return this.ps;
+    };
+    XamGeographicMap.prototype.n5 = function () {
+        return this.pr.fr;
+    };
+    XamGeographicMap.prototype.getFontBrush = function () {
+        return this.pr.fs;
+    };
+    XamGeographicMap.prototype.ls = function (a, b) {
+        if (typeCast(ItfConverter.$, b) !== null) {
+            var c = b;
+            var d = a;
+            d.itemsSource = c.triangulationSource.points;
+            d.ok = c.triangulationSource.triangles;
+        }
+        else {
+            _super.prototype.ls.call(this, a, b);
+        }
+    };
+    XamGeographicMap.prototype.register = function (a, b) {
+        this.li(a, b);
+    };
+    XamGeographicMap.prototype.unRegister = function (a) {
+        this.ly(a);
+    };
+    XamGeographicMap.prototype.deferredRefresh = function () {
+        this.iv();
+    };
+    XamGeographicMap.prototype.deferAction = function (a) {
+        if (this.p4 != null) {
+            this.p4.setTimeout(a, 0);
+        }
+        else {
+            window.setTimeout(a, 0);
+        }
+    };
+    XamGeographicMap.prototype.qk = function (a) {
+        this.l6(a);
+    };
+    XamGeographicMap.prototype.p5 = function () {
+        var a = new ChartVisualData();
+        var b = this.pf.e6();
+        var c = this.ph.e6();
+        a.axes.add1(b);
+        a.axes.add1(c);
+        for (var d = 0; d < this.series.count; d++) {
+            var e = this.series._inner[d].gp();
+            a.series.add1(e);
+        }
+        a.name = this.name;
+        a.contentArea = RectData.b(this.o7);
+        a.centralArea = RectData.b(this.o7);
+        a.plotArea = RectData.b(this.o7);
+        return a;
+    };
+    XamGeographicMap.prototype.oz = function (a, b, c) {
+        return a;
+    };
+    XamGeographicMap.prototype.qo = function () {
+    };
+    Object.defineProperty(XamGeographicMap.prototype, "rr", {
+        get: function () {
+            return this.rd;
+        },
+        set: function (a) {
+            this.rd = a;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    XamGeographicMap.prototype.qy = function (a) {
+        this.rr = a;
+        this.qx();
+    };
+    XamGeographicMap.prototype.qx = function () {
+        if (this.py && !this.rr.isEmpty) {
+            var a = this.getZoomFromGeographicRect(this.rr);
+            this.rr = Rect.empty;
+            this.mc(a, false);
+        }
+    };
+    Object.defineProperty(XamGeographicMap.prototype, "py", {
+        get: function () {
+            return !this.o7.isEmpty && !this.ow.isEmpty;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    XamGeographicMap.$t = markType(XamGeographicMap, 'XamGeographicMap', SeriesViewer.$, [IMapRenderDeferralHandler_$type]);
+    XamGeographicMap.pp = 0;
+    XamGeographicMap.rc = new Rect(2, { $type: Point_$type, x: -180, y: -85.05112878 }, { $type: Point_$type, x: 180, y: 85.05112878 });
+    XamGeographicMap.rf = new Rect(0, 0, 0, 1, 1);
+    XamGeographicMap.$$p = markDep(DependencyProperty, PropertyMetadata, XamGeographicMap, 'k5', ['BackgroundTilingMode:pm:qz', [MapBackgroundTilingMode_$type, enumGetBox(MapBackgroundTilingMode_$type, 0)], 'IsHorizontalWrappingEnabled:pu:q0', [0, false], 'ResizeBehavior:pq:q1', [MapResizeBehavior_$type, enumGetBox(MapResizeBehavior_$type, XamGeographicMap.pp)], 'SuppressZoomResetOnWorldRectChange:pv:q2', [0, false], 'UseWorldRectForZoomBounds:pw:q3', [0, false], 'WindowScale:p2:q4', [1, NaN], 'WorldRect:rs:q5', [Rect.$, XamGeographicMap.rc], 'Zoomable:px:q6', [0, true]]);
+    return XamGeographicMap;
+}(SeriesViewer));
+export { XamGeographicMap };
+/**
+ * @hidden
+ */
+var GeographicMapImagery = /** @class */ (function (_super) {
+    tslib_1.__extends(GeographicMapImagery, _super);
+    function GeographicMapImagery(a) {
+        var _this = _super.call(this) || this;
+        _this.ak = null;
+        _this.imageTilesReady = null;
+        _this.an = null;
+        _this.ap = null;
+        _this.propertyChanged = null;
+        _this.imagesChanged = null;
+        _this.cancellingImage = null;
+        _this.downloadingImage = null;
+        _this.ab = GeographicMapImagery.$;
+        _this.ap = a;
+        _this.aj = _this.ai();
+        _this.bb(_this.aj);
+        return _this;
+    }
+    GeographicMapImagery.prototype.bb = function (a) {
+    };
+    GeographicMapImagery.prototype.ai = function () {
+        return new GeographicMapImageryView(this);
+    };
+    Object.defineProperty(GeographicMapImagery.prototype, "deferralHandler", {
+        get: function () {
+            return this.ak;
+        },
+        set: function (a) {
+            this.ak = a;
+            if (this.ao != null) {
+                this.ao.al = a;
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    GeographicMapImagery.prototype.a5 = function (a, b) {
+        if (this.imageTilesReady != null) {
+            this.imageTilesReady(this, new ImageTilesReadyEventArgs());
+        }
+    };
+    GeographicMapImagery.prototype.a9 = function () {
+        var a = this.ao;
+        a.imageTilesReady = delegateCombine(a.imageTilesReady, runOn(this, this.a5));
+        this.ao.al = this.deferralHandler;
+        var b = this.ao;
+        b.imagesChanged = delegateCombine(b.imagesChanged, runOn(this, this.a4));
+        var c = this.ao;
+        c.downloadingImage = delegateCombine(c.downloadingImage, runOn(this, this.a3));
+        var d = this.ao;
+        d.cancellingImage = delegateCombine(d.cancellingImage, runOn(this, this.a2));
+        this.ao.bf = this.referer;
+        this.ao.bj = this.userAgent;
+        this.ao.av = this.isHorizontalWrappingEnabled;
+    };
+    GeographicMapImagery.prototype.a3 = function (a, b) {
+        if (this.downloadingImage != null) {
+            this.downloadingImage(this, b);
+        }
+    };
+    GeographicMapImagery.prototype.a2 = function (a, b) {
+        if (this.cancellingImage != null) {
+            this.cancellingImage(this, b);
+        }
+    };
+    GeographicMapImagery.prototype.bg = function () {
+        if (this.ao != null) {
+            this.aj.e();
+        }
+    };
+    GeographicMapImagery.prototype.ba = function (a, b, c) {
+        switch (a) {
+            case GeographicMapImagery.$$p[3]:
+                this.bg();
+                break;
+            case "GeographicMap":
+                this.aj.e();
+                break;
+            case GeographicMapImagery.$$p[1]:
+                if (this.ao != null) {
+                    this.ao.bf = this.referer;
+                }
+                break;
+            case GeographicMapImagery.$$p[2]:
+                if (this.ao != null) {
+                    this.ao.bj = this.userAgent;
+                }
+                break;
+            case GeographicMapImagery.$$p[0]:
+                if (this.ao != null) {
+                    this.ao.av = this.isHorizontalWrappingEnabled;
+                }
+                break;
+        }
+        if (this.propertyChanged != null) {
+            this.propertyChanged(this, new PropertyChangedEventArgs(a));
+        }
+    };
+    Object.defineProperty(GeographicMapImagery.prototype, "geographicMap", {
+        get: function () {
+            return this.c(GeographicMapImagery.geographicMapProperty);
+        },
+        set: function (a) {
+            this.h(GeographicMapImagery.geographicMapProperty, a);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    GeographicMapImagery.a8 = function (a, b) {
+        a.a7(b.oldValue, b.newValue);
+    };
+    GeographicMapImagery.prototype.a7 = function (a, b) {
+        this.ba("GeographicMap", a, b);
+    };
+    GeographicMapImagery.prototype.clearTileCache = function () {
+        if (this.ao != null) {
+            this.ao.bs(0, 0, 0, 0);
+        }
+    };
+    Object.defineProperty(GeographicMapImagery.prototype, "ao", {
+        get: function () {
+            return this.an;
+        },
+        set: function (a) {
+            this.an = a;
+            if (this.propertyChanged != null) {
+                this.propertyChanged(this, new PropertyChangedEventArgs("MultiScaleImage"));
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    GeographicMapImagery.prototype.bn = function (a) {
+        if (this.geographicMap == null || a.width < 1 || a.height < 1) {
+            return a;
+        }
+        var b = new Rect(0, 0, 0, a.width, a.height);
+        var c = this.geographicMap.rl(b);
+        var d = XamGeographicMap.rc;
+        var e = this.geographicMap.rg;
+        var f = Math.min(this.windowRect.height, this.windowRect.width);
+        var g = e.width / d.width;
+        this.ao.a5 = (b.width / c.width) * f * g;
+        var h = this.geographicMap.pf;
+        var i = this.geographicMap.ph;
+        var j = new ScalerParams(1, this.windowRect, b, h.ca);
+        j.c = c;
+        var k = new ScalerParams(1, this.windowRect, b, i.ca);
+        k.c = c;
+        var l = h.dz(d.left, j);
+        var m = i.dz(d.bottom, k);
+        var n = (-l / b.width) * this.ao.a5;
+        var o = (-m / b.height) * this.ao.a5 * (b.height / b.width);
+        this.ao.cm = { $type: Point_$type, x: n, y: o };
+        return a;
+    };
+    GeographicMapImagery.prototype.bd = function (a) {
+        this.aj.f(a);
+    };
+    GeographicMapImagery.prototype.bf = function (a) {
+        this.aj.h(a);
+    };
+    GeographicMapImagery.prototype.be = function (a) {
+        this.aj.g(a);
+    };
+    GeographicMapImagery.prototype.a4 = function (a, b) {
+        if (this.imagesChanged != null) {
+            this.imagesChanged(this, new ImagesChangedEventArgs());
+        }
+    };
+    GeographicMapImagery.prototype.a6 = function () {
+        this.aj.e();
+    };
+    GeographicMapImagery.prototype.bc = function (a) {
+        this.aj.i(a);
+    };
+    GeographicMapImagery.prototype.v = function () {
+        _super.prototype.v.call(this);
+        this.ap.o = this._opacity;
+    };
+    GeographicMapImagery.$t = markType(GeographicMapImagery, 'GeographicMapImagery', Control.$, [INotifyPropertyChanged_$type]);
+    GeographicMapImagery.geographicMapProperty = DependencyProperty.i("GeographicMap", XamGeographicMap.$, GeographicMapImagery.$, new PropertyMetadata(2, null, GeographicMapImagery.a8));
+    GeographicMapImagery.$$p = markDep(DependencyProperty, PropertyMetadata, GeographicMapImagery, 'ba', ['IsHorizontalWrappingEnabled', [0, false], 'Referer', [2, null], 'UserAgent', [2, null], 'WindowRect', [Rect.$, Rect.empty]]);
+    return GeographicMapImagery;
+}(Control));
+export { GeographicMapImagery };
+/**
+ * @hidden
+ */
+var GeographicMapImageryView = /** @class */ (function (_super) {
+    tslib_1.__extends(GeographicMapImageryView, _super);
+    function GeographicMapImageryView(a) {
+        var _this = _super.call(this) || this;
+        _this.a = null;
+        _this.j = null;
+        _this.d = null;
+        _this.b = 1;
+        _this.j = Rect.empty;
+        _this.a = a;
+        _this.a.ao = new XamMultiScaleImage();
+        _this.a.ao.ao = _this.a.ap;
+        _this.a.a9();
+        return _this;
+    }
+    GeographicMapImageryView.prototype.e = function () {
+        if (this.j.isEmpty) {
+            return;
+        }
+        this.a.bn(new Size(1, this.j.width, this.j.height));
+    };
+    GeographicMapImageryView.prototype.f = function (a) {
+        this.a.ao.b1(a);
+    };
+    GeographicMapImageryView.prototype.g = function (a) {
+        this.d = a;
+        this.a.ao.b2(a);
+    };
+    GeographicMapImageryView.prototype.h = function (a) {
+        this.j = a;
+        this.a.ao.b3(a);
+        this.a.a6();
+    };
+    Object.defineProperty(GeographicMapImageryView.prototype, "c", {
+        get: function () {
+            return this.b;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    GeographicMapImageryView.prototype.i = function (a) {
+        this.b = a;
+        this.a.ao.bz(a);
+    };
+    GeographicMapImageryView.$t = markType(GeographicMapImageryView, 'GeographicMapImageryView');
+    return GeographicMapImageryView;
+}(Base));
+export { GeographicMapImageryView };
+/**
+ * @hidden
+ */
+var GeographicXYTriangulatingSeriesView = /** @class */ (function (_super) {
+    tslib_1.__extends(GeographicXYTriangulatingSeriesView, _super);
+    function GeographicXYTriangulatingSeriesView(a) {
+        var _this = _super.call(this, a) || this;
+        _this.b3 = null;
+        _this.b3 = a;
+        return _this;
+    }
+    GeographicXYTriangulatingSeriesView.prototype.by = function () {
+        _super.prototype.by.call(this);
+        var a = this.b3.ob;
+        a.o7 = this.b3.on;
+        a.pb = this.b3.ol;
+        a.trianglesSource = this.b3.ok;
+        a.oz = this.b3.oq;
+        a.o1 = this.b3.os;
+        a.o3 = this.b3.ou;
+    };
+    GeographicXYTriangulatingSeriesView.prototype.b6 = function () {
+        var a = this.b3.ob;
+        if (this.b3.b6 == null) {
+            a.n9 = null;
+            a.oa = null;
+            return;
+        }
+        a.n9 = this.b3.b6.pf;
+        a.oa = this.b3.b6.ph;
+    };
+    GeographicXYTriangulatingSeriesView.prototype.b5 = function () {
+        this.b3.ob.o7 = this.b3.on;
+    };
+    GeographicXYTriangulatingSeriesView.prototype.b4 = function () {
+        this.b3.ob.pb = this.b3.ol;
+    };
+    GeographicXYTriangulatingSeriesView.prototype.b7 = function () {
+        this.b3.ob.trianglesSource = this.b3.ok;
+    };
+    GeographicXYTriangulatingSeriesView.prototype.b8 = function () {
+        this.b3.ob.oz = this.b3.oq;
+    };
+    GeographicXYTriangulatingSeriesView.prototype.b9 = function () {
+        this.b3.ob.o1 = this.b3.os;
+    };
+    GeographicXYTriangulatingSeriesView.prototype.ca = function () {
+        this.b3.ob.o3 = this.b3.ou;
+    };
+    GeographicXYTriangulatingSeriesView.$t = markType(GeographicXYTriangulatingSeriesView, 'GeographicXYTriangulatingSeriesView', HostSeriesView.$);
+    return GeographicXYTriangulatingSeriesView;
+}(HostSeriesView));
+export { GeographicXYTriangulatingSeriesView };
+/**
+ * @hidden
+ */
+var GeographicScatterAreaSeriesView = /** @class */ (function (_super) {
+    tslib_1.__extends(GeographicScatterAreaSeriesView, _super);
+    function GeographicScatterAreaSeriesView(a) {
+        var _this = _super.call(this, a) || this;
+        _this.cb = null;
+        _this.cb = a;
+        return _this;
+    }
+    GeographicScatterAreaSeriesView.prototype.by = function () {
+        _super.prototype.by.call(this);
+        if (this.cb.o4 != null) {
+            this.cb.o4.p2 = this.cb.o7;
+            this.cb.o4.pu = this.cb.o3;
+        }
+    };
+    GeographicScatterAreaSeriesView.prototype.cc = function () {
+        if (this.cb.o4 != null) {
+            this.cb.o4.p2 = this.cb.o7;
+        }
+    };
+    GeographicScatterAreaSeriesView.prototype.cd = function () {
+        if (this.cb.o4 != null) {
+            this.cb.o4.pu = this.cb.o3;
+        }
+    };
+    GeographicScatterAreaSeriesView.$t = markType(GeographicScatterAreaSeriesView, 'GeographicScatterAreaSeriesView', GeographicXYTriangulatingSeriesView.$);
+    return GeographicScatterAreaSeriesView;
+}(GeographicXYTriangulatingSeriesView));
+export { GeographicScatterAreaSeriesView };
+/**
+ * @hidden
+ */
+var XamGeographicMapView = /** @class */ (function (_super) {
+    tslib_1.__extends(XamGeographicMapView, _super);
+    function XamGeographicMapView(a) {
+        var _this = _super.call(this, a) || this;
+        _this.fi = null;
+        _this.fy = null;
+        _this.fs = null;
+        _this.fr = null;
+        _this.fj = null;
+        _this.fk = NaN;
+        _this.fy = Rect.empty;
+        _this.fi = a;
+        _this.fi.n0 = 2;
+        _this.fi.fw = 5E-06;
+        return _this;
+    }
+    XamGeographicMapView.prototype.m = function (a) {
+        return 2;
+    };
+    XamGeographicMapView.prototype.bk = function (a) {
+        this.j.bv(a);
+        this.fi.qk(a);
+        this.ei();
+    };
+    XamGeographicMapView.prototype.get_ap = function () {
+        return true;
+    };
+    XamGeographicMapView.prototype.d1 = function () {
+        var a;
+        var b;
+        var c;
+        var d;
+        var e;
+        var f = this.j.a7(a, b, c, d, e);
+        a = f.p0;
+        b = f.p1;
+        c = f.p2;
+        d = f.p3;
+        e = f.p4;
+        this.fs = c;
+        this.fj = d;
+        this.fr = e;
+    };
+    XamGeographicMapView.prototype.fu = function (a) {
+        return ((function () {
+            var $ret = new Brush();
+            $ret.fill = "#8bdc5c";
+            return $ret;
+        })());
+    };
+    XamGeographicMapView.prototype.fv = function (a) {
+        return ((function () {
+            var $ret = new Brush();
+            $ret.fill = "#8bdc5c";
+            return $ret;
+        })());
+    };
+    XamGeographicMapView.prototype.ft = function (a) {
+        return ((function () {
+            var $ret = new Brush();
+            $ret.fill = "rgba(50,50,50,.5)";
+            return $ret;
+        })());
+    };
+    XamGeographicMapView.prototype.fw = function (a) {
+        return ((function () {
+            var $ret = new Brush();
+            $ret.fill = "white";
+            return $ret;
+        })());
+    };
+    XamGeographicMapView.prototype.dr = function (a) {
+        _super.prototype.dr.call(this, a);
+        if (this.fi.backgroundContent != null) {
+            var b = this.fi.backgroundContent;
+            b.be(this.j.ae);
+            b.bd(a);
+        }
+    };
+    XamGeographicMapView.prototype.ds = function (a) {
+        _super.prototype.ds.call(this, a);
+        this.fy = a;
+        if (this.fi.backgroundContent != null) {
+            var b = this.fi.backgroundContent;
+            b.bf(this.fy);
+        }
+    };
+    XamGeographicMapView.prototype.fx = function () {
+        return new Rect(0, 0, 0, this.fy.width, this.fy.height);
+    };
+    XamGeographicMapView.prototype.fn = function () {
+        if (this.fi.backgroundContent != null) {
+            var a = this.fi.backgroundContent;
+            a.a6();
+        }
+    };
+    XamGeographicMapView.prototype.fm = function (a) {
+        if (this.fi.pk != null) {
+            this.fi.pk.windowRect = a;
+        }
+    };
+    XamGeographicMapView.prototype.fp = function (a, b) {
+        if (this.fi.pk != null) {
+            this.fi.pk.windowRect = this.fi.os;
+        }
+        if (a != null) {
+            var c = a.ao;
+            if (c != null) {
+                this.fi.ah.e.remove(c.ag);
+            }
+            a.bd(null);
+            a.be(null);
+        }
+        if (b != null) {
+            var d = b.ao;
+            if (d != null) {
+                this.fi.ah.e.add(d.ag);
+            }
+            if (!this.fy.isEmpty) {
+                this.ds(this.fy);
+            }
+            if (this.w != null) {
+                this.dr(this.w);
+            }
+        }
+        if (b == null) {
+            this.fo(this.w);
+        }
+    };
+    XamGeographicMapView.prototype.fo = function (a) {
+        var b = this.fi.e8;
+        if (b != 1) {
+            a.z();
+            a.aa(b, b);
+        }
+        a.k(this.fy.left, this.fy.top, this.fy.width, this.fy.height);
+        if (b != 1) {
+            a.y();
+        }
+    };
+    XamGeographicMapView.prototype.dy = function () {
+        this.fa.ac = 1;
+        this.fb.ac = 1;
+        this.fa._stroke = this.fs;
+        this.fb._stroke = this.fs;
+        _super.prototype.dy.call(this);
+    };
+    XamGeographicMapView.prototype.fq = function (a) {
+        this.fk = a;
+        if (this.fi.backgroundContent != null) {
+            this.fi.backgroundContent.bc(a);
+        }
+    };
+    Object.defineProperty(XamGeographicMapView.prototype, "fl", {
+        get: function () {
+            return this.fk;
+        },
+        set: function (a) {
+            this.fk = a;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    XamGeographicMapView.$t = markType(XamGeographicMapView, 'XamGeographicMapView', SeriesViewerView.$);
+    return XamGeographicMapView;
+}(SeriesViewerView));
+export { XamGeographicMapView };
+/**
+ * @hidden
+ */
+var OpenStreetMapImagery = /** @class */ (function (_super) {
+    tslib_1.__extends(OpenStreetMapImagery, _super);
+    function OpenStreetMapImagery() {
+        return _super.call(this, new OpenStreetMapTileSource()) || this;
+    }
+    Object.defineProperty(OpenStreetMapImagery.prototype, "tilePath", {
+        get: function () {
+            return this.c(OpenStreetMapImagery.tilePathProperty);
+        },
+        set: function (a) {
+            this.h(OpenStreetMapImagery.tilePathProperty, a);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    OpenStreetMapImagery.br = function (a, b) {
+        a.bq("TilePath", b.oldValue, b.newValue);
+    };
+    OpenStreetMapImagery.prototype.bq = function (a, b, c) {
+        switch (a) {
+            case "TilePath":
+                this.ap.setTilePathUrl(c == null ? null : c);
+                this.aj.e();
+                break;
+        }
+        _super.prototype.ba.call(this, a, b, c);
+    };
+    OpenStreetMapImagery.$t = markType(OpenStreetMapImagery, 'OpenStreetMapImagery', GeographicMapImagery.$);
+    OpenStreetMapImagery.tilePathProperty = DependencyProperty.i("TilePath", String_$type, OpenStreetMapImagery.$, new PropertyMetadata(2, null, OpenStreetMapImagery.br));
+    return OpenStreetMapImagery;
+}(GeographicMapImagery));
+export { OpenStreetMapImagery };
+/**
+ * @hidden
+ */
+var GeographicXYTriangulatingSeries = /** @class */ (function (_super) {
+    tslib_1.__extends(GeographicXYTriangulatingSeries, _super);
+    function GeographicXYTriangulatingSeries() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    GeographicXYTriangulatingSeries.prototype.bp = function () {
+        return new GeographicXYTriangulatingSeriesView(this);
+    };
+    GeographicXYTriangulatingSeries.prototype.kk = function (a) {
+        _super.prototype.kk.call(this, a);
+        this.oj = a;
+    };
+    GeographicXYTriangulatingSeries.prototype.kp = function (a, b, c, d) {
+        _super.prototype.kp.call(this, a, b, c, d);
+        switch (b) {
+            case "SeriesViewer":
+                this.oj.b6();
+                break;
+            case GeographicXYTriangulatingSeries.$$p[1]:
+                this.oj.b5();
+                break;
+            case GeographicXYTriangulatingSeries.$$p[0]:
+                this.oj.b4();
+                break;
+            case GeographicXYTriangulatingSeries.$$p[2]:
+                this.oj.b7();
+                break;
+            case GeographicXYTriangulatingSeries.$$p[3]:
+                this.oj.b8();
+                break;
+            case GeographicXYTriangulatingSeries.$$p[4]:
+                this.oj.b9();
+                break;
+            case GeographicXYTriangulatingSeries.$$p[5]:
+                this.oj.ca();
+                break;
+        }
+    };
+    GeographicXYTriangulatingSeries.$t = markType(GeographicXYTriangulatingSeries, 'GeographicXYTriangulatingSeries', GeographicMapSeriesHost.$);
+    GeographicXYTriangulatingSeries.$$p = markDep(DependencyProperty, PropertyMetadata, GeographicXYTriangulatingSeries, 'raisePropertyChanged', ['LatitudeMemberPath:ol:ow', [2, "pointY"], 'LongitudeMemberPath:on:ox', [2, "pointX"], 'TrianglesSource:ok:oy', [IEnumerable_$type, null], 'TriangleVertexMemberPath1:oq:oz', [2, "v1"], 'TriangleVertexMemberPath2:os:o0', [2, "v2"], 'TriangleVertexMemberPath3:ou:o1', [2, "v3"]]);
+    return GeographicXYTriangulatingSeries;
+}(GeographicMapSeriesHost));
+export { GeographicXYTriangulatingSeries };
+/**
+ * @hidden
+ */
+var GeographicScatterAreaSeries = /** @class */ (function (_super) {
+    tslib_1.__extends(GeographicScatterAreaSeries, _super);
+    function GeographicScatterAreaSeries() {
+        var _this = _super.call(this) || this;
+        _this.o2 = null;
+        _this.triangulationStatusChanged = null;
+        _this.ab = GeographicScatterAreaSeries.$;
+        return _this;
+    }
+    Object.defineProperty(GeographicScatterAreaSeries.prototype, "o3", {
+        get: function () {
+            return this.o2;
+        },
+        set: function (a) {
+            var b = this.o2 != a;
+            if (b) {
+                var c = this.o2;
+                this.o2 = a;
+                this.raisePropertyChanged("ColorScale", c, this.o2);
+                if (this.o4 != null) {
+                    this.o4.pu = a;
+                }
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    GeographicScatterAreaSeries.prototype.oa = function () {
+        this.o4 = new ScatterAreaSeries();
+        var a = this.o4;
+        a.triangulationStatusChanged = delegateCombine(a.triangulationStatusChanged, runOn(this, this.pa));
+        return this.o4;
+    };
+    GeographicScatterAreaSeries.prototype.pa = function (a, b) {
+        if (this.triangulationStatusChanged != null) {
+            this.triangulationStatusChanged(this, b);
+        }
+    };
+    GeographicScatterAreaSeries.prototype.bp = function () {
+        return new GeographicScatterAreaSeriesView(this);
+    };
+    GeographicScatterAreaSeries.prototype.kk = function (a) {
+        _super.prototype.kk.call(this, a);
+        this.o6 = a;
+    };
+    GeographicScatterAreaSeries.prototype.kp = function (a, b, c, d) {
+        _super.prototype.kp.call(this, a, b, c, d);
+        switch (b) {
+            case GeographicScatterAreaSeries.$$p[0]:
+                this.o6.cc();
+                break;
+            case "ColorScale":
+                this.o6.cd();
+                break;
+        }
+    };
+    GeographicScatterAreaSeries.prototype.get_d6 = function () {
+        return true;
+    };
+    GeographicScatterAreaSeries.prototype.set_d6 = function (a) {
+        _super.prototype.set_d6.call(this, a);
+    };
+    GeographicScatterAreaSeries.$t = markType(GeographicScatterAreaSeries, 'GeographicScatterAreaSeries', GeographicXYTriangulatingSeries.$);
+    GeographicScatterAreaSeries.$$p = markDep(DependencyProperty, PropertyMetadata, GeographicScatterAreaSeries, 'raisePropertyChanged', ['ColorMemberPath:o7:pb', [2, "value"]]);
+    return GeographicScatterAreaSeries;
+}(GeographicXYTriangulatingSeries));
+export { GeographicScatterAreaSeries };
+//# sourceMappingURL=XamGeographicMap_combined.js.map