@theseam/ui-common 0.3.1 → 0.3.4

package/bundles/theseam-ui-common-google-maps.umd.js

@@ -0,0 +1,2202 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/cdk/a11y'), require('@angular/cdk/coercion'), require('@angular/core'), require('@angular/forms'), require('rxjs'), require('rxjs/operators'), require('@agm/core'), require('@fortawesome/free-solid-svg-icons'), require('@theseam/ui-common/core'), require('@theseam/ui-common/menu'), require('@theseam/ui-common/utils'), require('@angular/cdk/keycodes'), require('@turf/boolean-contains'), require('@turf/helpers'), require('@angular/cdk/observers'), require('@angular/common'), require('@theseam/ui-common/form-field'), require('@theseam/ui-common/icon'), require('@theseam/ui-common/shared')) :
+    typeof define === 'function' && define.amd ? define('@theseam/ui-common/google-maps', ['exports', '@angular/cdk/a11y', '@angular/cdk/coercion', '@angular/core', '@angular/forms', 'rxjs', 'rxjs/operators', '@agm/core', '@fortawesome/free-solid-svg-icons', '@theseam/ui-common/core', '@theseam/ui-common/menu', '@theseam/ui-common/utils', '@angular/cdk/keycodes', '@turf/boolean-contains', '@turf/helpers', '@angular/cdk/observers', '@angular/common', '@theseam/ui-common/form-field', '@theseam/ui-common/icon', '@theseam/ui-common/shared'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.theseam = global.theseam || {}, global.theseam["ui-common"] = global.theseam["ui-common"] || {}, global.theseam["ui-common"]["google-maps"] = {}), global.ng.cdk.a11y, global.ng.cdk.coercion, global.ng.core, global.ng.forms, global.rxjs, global.rxjs.operators, global.core$2, global.freeSolidSvgIcons, global.theseam["ui-common"].core, global.theseam["ui-common"].menu, global.theseam["ui-common"].utils, global.ng.cdk.keycodes, global.booleanContains, global.helpers, global.ng.cdk.observers, global.ng.common, global.theseam["ui-common"]["form-field"], global.theseam["ui-common"].icon, global.theseam["ui-common"].shared));
+})(this, (function (exports, a11y, coercion, core, forms, rxjs, operators, core$2, freeSolidSvgIcons, core$1, menu, utils, keycodes, booleanContains, helpers, observers, common, formField, icon, shared) { 'use strict';
+
+    function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+    var booleanContains__default = /*#__PURE__*/_interopDefaultLegacy(booleanContains);
+
+    /*! *****************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */
+    /* global Reflect, Promise */
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b)
+                if (Object.prototype.hasOwnProperty.call(b, p))
+                    d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    function __extends(d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    }
+    var __assign = function () {
+        __assign = Object.assign || function __assign(t) {
+            for (var s, i = 1, n = arguments.length; i < n; i++) {
+                s = arguments[i];
+                for (var p in s)
+                    if (Object.prototype.hasOwnProperty.call(s, p))
+                        t[p] = s[p];
+            }
+            return t;
+        };
+        return __assign.apply(this, arguments);
+    };
+    function __rest(s, e) {
+        var t = {};
+        for (var p in s)
+            if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+                t[p] = s[p];
+        if (s != null && typeof Object.getOwnPropertySymbols === "function")
+            for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+                if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                    t[p[i]] = s[p[i]];
+            }
+        return t;
+    }
+    function __decorate(decorators, target, key, desc) {
+        var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+        if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+            r = Reflect.decorate(decorators, target, key, desc);
+        else
+            for (var i = decorators.length - 1; i >= 0; i--)
+                if (d = decorators[i])
+                    r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+        return c > 3 && r && Object.defineProperty(target, key, r), r;
+    }
+    function __param(paramIndex, decorator) {
+        return function (target, key) { decorator(target, key, paramIndex); };
+    }
+    function __metadata(metadataKey, metadataValue) {
+        if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+            return Reflect.metadata(metadataKey, metadataValue);
+    }
+    function __awaiter(thisArg, _arguments, P, generator) {
+        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+        return new (P || (P = Promise))(function (resolve, reject) {
+            function fulfilled(value) { try {
+                step(generator.next(value));
+            }
+            catch (e) {
+                reject(e);
+            } }
+            function rejected(value) { try {
+                step(generator["throw"](value));
+            }
+            catch (e) {
+                reject(e);
+            } }
+            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+            step((generator = generator.apply(thisArg, _arguments || [])).next());
+        });
+    }
+    function __generator(thisArg, body) {
+        var _ = { label: 0, sent: function () { if (t[0] & 1)
+                throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+        return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function () { return this; }), g;
+        function verb(n) { return function (v) { return step([n, v]); }; }
+        function step(op) {
+            if (f)
+                throw new TypeError("Generator is already executing.");
+            while (_)
+                try {
+                    if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
+                        return t;
+                    if (y = 0, t)
+                        op = [op[0] & 2, t.value];
+                    switch (op[0]) {
+                        case 0:
+                        case 1:
+                            t = op;
+                            break;
+                        case 4:
+                            _.label++;
+                            return { value: op[1], done: false };
+                        case 5:
+                            _.label++;
+                            y = op[1];
+                            op = [0];
+                            continue;
+                        case 7:
+                            op = _.ops.pop();
+                            _.trys.pop();
+                            continue;
+                        default:
+                            if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                                _ = 0;
+                                continue;
+                            }
+                            if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) {
+                                _.label = op[1];
+                                break;
+                            }
+                            if (op[0] === 6 && _.label < t[1]) {
+                                _.label = t[1];
+                                t = op;
+                                break;
+                            }
+                            if (t && _.label < t[2]) {
+                                _.label = t[2];
+                                _.ops.push(op);
+                                break;
+                            }
+                            if (t[2])
+                                _.ops.pop();
+                            _.trys.pop();
+                            continue;
+                    }
+                    op = body.call(thisArg, _);
+                }
+                catch (e) {
+                    op = [6, e];
+                    y = 0;
+                }
+                finally {
+                    f = t = 0;
+                }
+            if (op[0] & 5)
+                throw op[1];
+            return { value: op[0] ? op[1] : void 0, done: true };
+        }
+    }
+    var __createBinding = Object.create ? (function (o, m, k, k2) {
+        if (k2 === undefined)
+            k2 = k;
+        Object.defineProperty(o, k2, { enumerable: true, get: function () { return m[k]; } });
+    }) : (function (o, m, k, k2) {
+        if (k2 === undefined)
+            k2 = k;
+        o[k2] = m[k];
+    });
+    function __exportStar(m, o) {
+        for (var p in m)
+            if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p))
+                __createBinding(o, m, p);
+    }
+    function __values(o) {
+        var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+        if (m)
+            return m.call(o);
+        if (o && typeof o.length === "number")
+            return {
+                next: function () {
+                    if (o && i >= o.length)
+                        o = void 0;
+                    return { value: o && o[i++], done: !o };
+                }
+            };
+        throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+    }
+    function __read(o, n) {
+        var m = typeof Symbol === "function" && o[Symbol.iterator];
+        if (!m)
+            return o;
+        var i = m.call(o), r, ar = [], e;
+        try {
+            while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
+                ar.push(r.value);
+        }
+        catch (error) {
+            e = { error: error };
+        }
+        finally {
+            try {
+                if (r && !r.done && (m = i["return"]))
+                    m.call(i);
+            }
+            finally {
+                if (e)
+                    throw e.error;
+            }
+        }
+        return ar;
+    }
+    /** @deprecated */
+    function __spread() {
+        for (var ar = [], i = 0; i < arguments.length; i++)
+            ar = ar.concat(__read(arguments[i]));
+        return ar;
+    }
+    /** @deprecated */
+    function __spreadArrays() {
+        for (var s = 0, i = 0, il = arguments.length; i < il; i++)
+            s += arguments[i].length;
+        for (var r = Array(s), k = 0, i = 0; i < il; i++)
+            for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+                r[k] = a[j];
+        return r;
+    }
+    function __spreadArray(to, from, pack) {
+        if (pack || arguments.length === 2)
+            for (var i = 0, l = from.length, ar; i < l; i++) {
+                if (ar || !(i in from)) {
+                    if (!ar)
+                        ar = Array.prototype.slice.call(from, 0, i);
+                    ar[i] = from[i];
+                }
+            }
+        return to.concat(ar || Array.prototype.slice.call(from));
+    }
+    function __await(v) {
+        return this instanceof __await ? (this.v = v, this) : new __await(v);
+    }
+    function __asyncGenerator(thisArg, _arguments, generator) {
+        if (!Symbol.asyncIterator)
+            throw new TypeError("Symbol.asyncIterator is not defined.");
+        var g = generator.apply(thisArg, _arguments || []), i, q = [];
+        return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+        function verb(n) { if (g[n])
+            i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+        function resume(n, v) { try {
+            step(g[n](v));
+        }
+        catch (e) {
+            settle(q[0][3], e);
+        } }
+        function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+        function fulfill(value) { resume("next", value); }
+        function reject(value) { resume("throw", value); }
+        function settle(f, v) { if (f(v), q.shift(), q.length)
+            resume(q[0][0], q[0][1]); }
+    }
+    function __asyncDelegator(o) {
+        var i, p;
+        return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
+        function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
+    }
+    function __asyncValues(o) {
+        if (!Symbol.asyncIterator)
+            throw new TypeError("Symbol.asyncIterator is not defined.");
+        var m = o[Symbol.asyncIterator], i;
+        return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+        function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+        function settle(resolve, reject, d, v) { Promise.resolve(v).then(function (v) { resolve({ value: v, done: d }); }, reject); }
+    }
+    function __makeTemplateObject(cooked, raw) {
+        if (Object.defineProperty) {
+            Object.defineProperty(cooked, "raw", { value: raw });
+        }
+        else {
+            cooked.raw = raw;
+        }
+        return cooked;
+    }
+    ;
+    var __setModuleDefault = Object.create ? (function (o, v) {
+        Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function (o, v) {
+        o["default"] = v;
+    };
+    function __importStar(mod) {
+        if (mod && mod.__esModule)
+            return mod;
+        var result = {};
+        if (mod != null)
+            for (var k in mod)
+                if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
+                    __createBinding(result, mod, k);
+        __setModuleDefault(result, mod);
+        return result;
+    }
+    function __importDefault(mod) {
+        return (mod && mod.__esModule) ? mod : { default: mod };
+    }
+    function __classPrivateFieldGet(receiver, state, kind, f) {
+        if (kind === "a" && !f)
+            throw new TypeError("Private accessor was defined without a getter");
+        if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
+            throw new TypeError("Cannot read private member from an object whose class did not declare it");
+        return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+    }
+    function __classPrivateFieldSet(receiver, state, value, kind, f) {
+        if (kind === "m")
+            throw new TypeError("Private method is not writable");
+        if (kind === "a" && !f)
+            throw new TypeError("Private accessor was defined without a setter");
+        if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
+            throw new TypeError("Cannot write private member to an object whose class did not declare it");
+        return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+    }
+
+    exports.AppFeaturePropertyName = void 0;
+    (function (AppFeaturePropertyName) {
+        AppFeaturePropertyName["IsSelected"] = "__app__isSelected";
+    })(exports.AppFeaturePropertyName || (exports.AppFeaturePropertyName = {}));
+    function isAppFeatureProperty(propertyName) {
+        return Object.values(exports.AppFeaturePropertyName)
+            .findIndex(function (value) { return value === propertyName; }) !== -1;
+    }
+    function isFeatureSelected(feature) {
+        var isSelected = feature.getProperty(exports.AppFeaturePropertyName.IsSelected);
+        return coercion.coerceBooleanProperty(isSelected);
+    }
+    function setFeatureSelected(feature, isSelected) {
+        feature.setProperty(exports.AppFeaturePropertyName.IsSelected, isSelected);
+    }
+    // TODO: Check performance of cloning a google.maps.Data instance, so the
+    // properties can be removed with the google maps api, instead of on the
+    // resulting json.
+    function stripAppFeaturePropertiesFromJson(json) {
+        var e_1, _a, e_2, _b;
+        if (utils.notNullOrUndefined(json) && Array.isArray(json === null || json === void 0 ? void 0 : json.features)) {
+            try {
+                for (var _c = __values(json.features), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var feature = _d.value;
+                    if (utils.notNullOrUndefined(feature === null || feature === void 0 ? void 0 : feature.properties)) {
+                        try {
+                            for (var _e = (e_2 = void 0, __values(Object.keys(feature.properties))), _f = _e.next(); !_f.done; _f = _e.next()) {
+                                var k = _f.value;
+                                if (isAppFeatureProperty(k)) {
+                                    feature.properties[k] = undefined;
+                                    delete feature.properties[k];
+                                }
+                            }
+                        }
+                        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                        finally {
+                            try {
+                                if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                            }
+                            finally { if (e_2) throw e_2.error; }
+                        }
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        }
+    }
+    /**
+     * Searches for a Feature in Data that contains the provided Feature and can use
+     * it as a cutout area.
+     */
+    function getPossibleExteriorFeature(data, feature) {
+        var exteriorPolygonFeature;
+        data.forEach(function (f) {
+            if (f !== feature && (f.getGeometry().getType() === 'Polygon' && featureContains(f, feature))) {
+                exteriorPolygonFeature = f;
+            }
+        });
+        return exteriorPolygonFeature;
+    }
+    function addInnerFeatureCutoutToExteriorFeature(exteriorFeature, innerFeature) {
+        // NOTE: Other geometries may support cutouts, but our map shapes editor only
+        // supports polygons currently, so we will need to handle other geometry types
+        // here if we start allowing users to draw shapes other than polygon.
+        if (exteriorFeature.getGeometry().getType() !== 'Polygon' || innerFeature.getGeometry().getType() !== 'Polygon') {
+            throw Error("Inner cutout is only supported by Polygon gemoetry.");
+        }
+        var featurePolygon = innerFeature.getGeometry();
+        var exteriorPolygon = exteriorFeature.getGeometry();
+        exteriorFeature.setGeometry(new google.maps.Data.Polygon(__spreadArray(__spreadArray([], __read(exteriorPolygon.getArray())), [
+            featurePolygon.getAt(0).getArray().reverse()
+        ])));
+    }
+    /**
+     * Google maps paths don't always start and stop at the exact same position, so
+     * this will fix that for turfjs.
+     */
+    function fixPathDifferentStartingAndEndingPoint(coordinates) {
+        if (coordinates.length <= 1) {
+            return;
+        }
+        var start = coordinates[0];
+        var end = coordinates[coordinates.length - 1];
+        if (start[0] === end[0] && start[1] === end[1]) {
+            return;
+        }
+        coordinates.push(coordinates[0]);
+    }
+    function polygonCoordinates(polygon) {
+        return polygon.getArray().map(function (linRing) {
+            var coords = linRing.getArray().map(function (x) { return [x.lng(), x.lat()]; });
+            fixPathDifferentStartingAndEndingPoint(coords);
+            return coords;
+        });
+    }
+    function multiPolygonCoordinates(multiPolygon) {
+        return multiPolygon.getArray().map(function (x) { return polygonCoordinates(x); });
+    }
+    function toTurfJsPolygon(polygon) {
+        return helpers.polygon(polygonCoordinates(polygon));
+    }
+    function toTurfJsMultiPolygon(multiPolygon) {
+        return helpers.multiPolygon(multiPolygonCoordinates(multiPolygon));
+    }
+    function toTurfJsFeature(googleFeature) {
+        if (googleFeature.getGeometry().getType() === 'Polygon') {
+            return toTurfJsPolygon(googleFeature.getGeometry());
+        }
+        else if (googleFeature.getGeometry().getType() === 'MultiPolygon') {
+            return toTurfJsMultiPolygon(googleFeature.getGeometry());
+        }
+        throw Error("Unexpected geometry.");
+    }
+    function featureContains(featureA, featureB) {
+        var polygonA = toTurfJsFeature(featureA);
+        var polygonB = toTurfJsFeature(featureB);
+        return booleanContains__default["default"](polygonA, polygonB);
+    }
+    function createDataFeatureFromPolygon(polygon) {
+        var arr = polygon.getPath().getArray();
+        return new google.maps.Data.Feature({
+            geometry: new google.maps.Data.Polygon([arr])
+        });
+    }
+    function getBoundsWithAllFeatures(data) {
+        var bounds = new google.maps.LatLngBounds();
+        data.forEach(function (feature) {
+            var geometry = feature.getGeometry();
+            geometry.forEachLatLng(function (latLng) {
+                bounds.extend(latLng);
+            });
+        });
+        return bounds;
+    }
+    function getFeatureBounds(feature) {
+        var bounds = new google.maps.LatLngBounds();
+        var geometry = feature.getGeometry();
+        geometry.forEachLatLng(function (latLng) {
+            bounds.extend(latLng);
+        });
+        return bounds;
+    }
+    function getFeatureCenter(feature) {
+        return getFeatureBounds(feature).getCenter();
+    }
+    function removeAllFeatures(data) {
+        data.forEach(function (f) { return data.remove(f); });
+    }
+    function getFeaturesCount(data) {
+        var count = 0;
+        data.forEach(function () { return count++; });
+        return count;
+    }
+    /**
+     * NOTE: Original events are not emitted, because filtering may omit events.
+     */
+    function createFeatureChangeObservable(data, ngZone) {
+        return new rxjs.Observable(function (subscriber) {
+            var listeners = [];
+            ngZone.runOutsideAngular(function () {
+                listeners.push(data.addListener('setgeometry', function (event) {
+                    ngZone.run(function () { subscriber.next(undefined); });
+                }));
+                listeners.push(data.addListener('addfeature', function (event) {
+                    ngZone.run(function () { subscriber.next(undefined); });
+                }));
+                listeners.push(data.addListener('removefeature', function (event) {
+                    ngZone.run(function () { subscriber.next(undefined); });
+                }));
+                listeners.push(data.addListener('setproperty', function (event) {
+                    if (!isAppFeatureProperty(event.name)) {
+                        ngZone.run(function () { subscriber.next(undefined); });
+                    }
+                }));
+                listeners.push(data.addListener('removeproperty', function (event) {
+                    if (!isAppFeatureProperty(event.name)) {
+                        ngZone.run(function () { subscriber.next(undefined); });
+                    }
+                }));
+            });
+            return function () {
+                listeners.forEach(google.maps.event.removeListener);
+            };
+        });
+    }
+
+    // TODO: Close on map losing focus.
+    var GoogleMapsContextMenu = /** @class */ (function () {
+        function GoogleMapsContextMenu(_map, _menu, _position, _vcr, _ngZone, _data, _feature) {
+            var _this = this;
+            this._map = _map;
+            this._menu = _menu;
+            this._vcr = _vcr;
+            this._ngZone = _ngZone;
+            this._data = _data;
+            this._feature = _feature;
+            var tplRef = this._menu.templateRef;
+            if (tplRef === undefined || tplRef === null) {
+                throw Error("Menu template is not defined.");
+            }
+            var ref = this._vcr.createEmbeddedView(tplRef);
+            ref.detectChanges();
+            var listeners = [];
+            var ngUnsubscribe = new rxjs.Subject();
+            // TODO: Fix the initial focus. setTimeout avoids the wrong contextmenu
+            // getting triggered, but the first item flashes and looks off this way.
+            setTimeout(function () {
+                _this._menu.focusFirstItem('program');
+            });
+            this._menu.closed.pipe(operators.takeUntil(ngUnsubscribe)).subscribe(function (v) {
+                _this.close();
+            });
+            rxjs.fromEvent(document, 'keydown').pipe(operators.takeUntil(ngUnsubscribe)).subscribe(function (event) {
+                if (event.keyCode === keycodes.ESCAPE) {
+                    _this.close();
+                }
+            });
+            var __cleanup = function () { return _this._cleanupFn(); };
+            var GoogleMapsContextMenuOverlayView = /** @class */ (function (_super) {
+                __extends(GoogleMapsContextMenuOverlayView, _super);
+                function GoogleMapsContextMenuOverlayView(position, content) {
+                    var _this = _super.call(this) || this;
+                    _this.position = position;
+                    _this.position = position;
+                    _this.containerDiv = document.createElement('div');
+                    _this.containerDiv.style.cursor = 'auto';
+                    _this.containerDiv.style.height = '0',
+                        _this.containerDiv.style.position = 'absolute';
+                    _this.containerDiv.appendChild(content);
+                    // Optionally stop clicks, etc., from bubbling up to the map.
+                    GoogleMapsContextMenuOverlayView.preventMapHitsAndGesturesFrom(_this.containerDiv);
+                    return _this;
+                }
+                /** Called when the view is added to the map. */
+                GoogleMapsContextMenuOverlayView.prototype.onAdd = function () {
+                    // tslint:disable-next-line: no-non-null-assertion
+                    this.getPanes().floatPane.appendChild(this.containerDiv);
+                };
+                /** Called when the view is removed from the map. */
+                GoogleMapsContextMenuOverlayView.prototype.onRemove = function () {
+                    if (this.containerDiv.parentElement) {
+                        this.containerDiv.parentElement.removeChild(this.containerDiv);
+                    }
+                    __cleanup();
+                };
+                /** Called each frame when the view needs to draw itself. */
+                GoogleMapsContextMenuOverlayView.prototype.draw = function () {
+                    // tslint:disable-next-line: no-non-null-assertion
+                    var divPosition = this.getProjection().fromLatLngToDivPixel(this.position);
+                    // Hide the popup when it is far out of view.
+                    var display = Math.abs(divPosition.x) < 4000 && Math.abs(divPosition.y) < 4000
+                        ? 'block'
+                        : 'none';
+                    if (display === 'block') {
+                        this.containerDiv.style.left = divPosition.x + 'px';
+                        this.containerDiv.style.top = divPosition.y + 'px';
+                    }
+                    if (this.containerDiv.style.display !== display) {
+                        this.containerDiv.style.display = display;
+                    }
+                };
+                return GoogleMapsContextMenuOverlayView;
+            }(google.maps.OverlayView));
+            this._overlayView = new GoogleMapsContextMenuOverlayView(_position, ref.rootNodes[0]);
+            this._overlayView.setMap(this._map);
+            this._ngZone.runOutsideAngular(function () {
+                listeners.push(_this._data.addListener('removefeature', function (event) {
+                    if (event.feature === _this._feature) {
+                        _this._ngZone.run(function () { _this.close(); });
+                    }
+                }));
+                listeners.push(_this._data.addListener('setproperty', function (event) {
+                    if (event.feature === _this._feature && !isFeatureSelected(_this._feature)) {
+                        _this._ngZone.run(function () { _this.close(); });
+                    }
+                }));
+                listeners.push(_this._data.addListener('removeproperty', function (event) {
+                    if (event.feature === _this._feature && !isFeatureSelected(_this._feature)) {
+                        _this._ngZone.run(function () { _this.close(); });
+                    }
+                }));
+                listeners.push(_this._map.addListener('click', function (event) {
+                    _this._ngZone.run(function () { _this.close(); });
+                }));
+                listeners.push(_this._data.addListener('click', function (event) {
+                    _this._ngZone.run(function () { _this.close(); });
+                }));
+            });
+            this._cleanupFn = function () {
+                ngUnsubscribe.next();
+                ngUnsubscribe.complete();
+                listeners.forEach(google.maps.event.removeListener);
+            };
+        }
+        GoogleMapsContextMenu.prototype.close = function () {
+            this._overlayView.setMap(null);
+        };
+        return GoogleMapsContextMenu;
+    }());
+
+    exports.MapValueSource = void 0;
+    (function (MapValueSource) {
+        MapValueSource["Input"] = "input";
+        MapValueSource["FeatureChange"] = "featurechange";
+    })(exports.MapValueSource || (exports.MapValueSource = {}));
+    var MapValueManagerService = /** @class */ (function () {
+        function MapValueManagerService() {
+            this._valueChangedSubject = new rxjs.Subject();
+            this.valueChanged = this._valueChangedSubject.asObservable();
+        }
+        MapValueManagerService.prototype.setValue = function (value, source) {
+            if (value === this._value) {
+                return false;
+            }
+            if (value === null || value === undefined) {
+                this._value = value;
+                var _change = {
+                    source: source,
+                    value: this._value,
+                };
+                this._valueChangedSubject.next(_change);
+                return true;
+            }
+            if (JSON.stringify(value) === JSON.stringify(this._value)) {
+                return true;
+            }
+            // TODO: Validate object is valid geojson.
+            this._value = value;
+            var change = {
+                source: source,
+                value: this._value,
+            };
+            this._valueChangedSubject.next(change);
+            return true;
+        };
+        Object.defineProperty(MapValueManagerService.prototype, "value", {
+            get: function () {
+                return this._value;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        return MapValueManagerService;
+    }());
+    MapValueManagerService.decorators = [
+        { type: core.Injectable }
+    ];
+    MapValueManagerService.ctorParameters = function () { return []; };
+
+    var DEFAULT_POLYGON_OPTIONS = {
+        clickable: true,
+        draggable: true,
+        editable: true,
+        // fillColor: 'rgba(60,150,60,1)',
+        // strokeColor: 'rgba(155,255,0,1)'
+    };
+    var DEFAULT_DRAWING_MANAGER_OPTIONS = function () { return ({
+        drawingControl: true,
+        drawingControlOptions: {
+            drawingModes: [
+                google.maps.drawing.OverlayType.POLYGON
+            ]
+        },
+        polygonOptions: DEFAULT_POLYGON_OPTIONS,
+        drawingMode: null
+    }); };
+    var ɵ0 = DEFAULT_DRAWING_MANAGER_OPTIONS;
+    var FEATURE_STYLE_OPTIONS_DEFAULT = {
+        clickable: true,
+        visible: true,
+        // zIndex?: number;
+        // cursor?: string;
+        draggable: false,
+        editable: false,
+        fillColor: 'teal',
+        fillOpacity: 0.3,
+        strokeColor: 'blue',
+        strokeOpacity: 1,
+        strokeWeight: 2,
+    };
+    var FEATURE_STYLE_OPTIONS_SELECTED = Object.assign(Object.assign({}, FEATURE_STYLE_OPTIONS_DEFAULT), { draggable: true, editable: true, fillColor: 'green', fillOpacity: 0.7, strokeColor: 'limegreen', strokeOpacity: 1, strokeWeight: 2 });
+    var GoogleMapsService = /** @class */ (function () {
+        function GoogleMapsService(_mapValueManager, _ngZone, _vcr) {
+            this._mapValueManager = _mapValueManager;
+            this._ngZone = _ngZone;
+            this._vcr = _vcr;
+            this._ngUnsubscribe = new rxjs.Subject();
+            this._mapReadySubject = new rxjs.BehaviorSubject(false);
+            this._featureContextMenu = null;
+            this._activeContextMenu = null;
+            this._allowDrawingHoleInPolygon = false;
+            this.mapReady$ = this._mapReadySubject.asObservable();
+        }
+        Object.defineProperty(GoogleMapsService.prototype, "mapReady", {
+            get: function () { return this._mapReadySubject.value; },
+            enumerable: false,
+            configurable: true
+        });
+        GoogleMapsService.prototype.ngOnDestroy = function () {
+            this._ngUnsubscribe.next();
+            this._ngUnsubscribe.complete();
+        };
+        GoogleMapsService.prototype.setMap = function (map) {
+            this.googleMap = map;
+            this._mapReadySubject.next(true);
+            this._initDrawingManager();
+            this._initFeatureStyling();
+            this._initFeatureChangeListeners();
+        };
+        GoogleMapsService.prototype.setBaseLatLng = function (lat, lng) {
+            this._baseLatLng = { lat: lat, lng: lng };
+        };
+        // TODO: Refactor out of the service meant to just wrap the google maps api.
+        GoogleMapsService.prototype.setFeatureContextMenu = function (menu) {
+            this._featureContextMenu = menu;
+        };
+        GoogleMapsService.prototype.getDiv = function () {
+            this._assertInitialized();
+            return this.googleMap.getDiv();
+        };
+        GoogleMapsService.prototype.fitBounds = function (bounds, padding) {
+            this._assertInitialized();
+            this.googleMap.fitBounds(bounds, padding);
+        };
+        /**
+         * Iterates the map's features and removes any that are selected.
+         */
+        GoogleMapsService.prototype.deleteSelection = function () {
+            this._assertInitialized();
+            var mapData = this.googleMap.data;
+            mapData.forEach(function (f) {
+                if (isFeatureSelected(f)) {
+                    mapData.remove(f);
+                }
+            });
+        };
+        /**
+         * Stops the current drawing.
+         */
+        GoogleMapsService.prototype.stopDrawing = function () {
+            var _this = this;
+            this._ngZone.runOutsideAngular(function () {
+                if (utils.isNullOrUndefined(_this._drawingManager) || _this._drawingManager.getDrawingMode() === null) {
+                    return;
+                }
+                // Listening for the completion event of the overlay currently being drawn
+                // and removing it. I haven't found a way to cancel the current drawing,
+                // without this hack that assumes our listeners will not run into a race
+                // condition.
+                var listener = google.maps.event.addListener(_this._drawingManager, 'overlaycomplete', function (event) {
+                    event.overlay.setMap(null);
+                    listener.remove();
+                });
+                // To fake canceling the current drawing, without disabling the drawing
+                // mode, the drawin mode is being unset then immediately set back. When
+                // the mode is unset the 'overlaycomplete' event will fire, which will
+                // give a reference to the current overlay to remove, then it is set back
+                // to the mode the user was using. To the user is should just seem like
+                // the current drawing was canceled and they can start drawing again.
+                var mode = _this._drawingManager.getDrawingMode();
+                _this._drawingManager.setDrawingMode(null);
+                _this._drawingManager.setDrawingMode(mode);
+                // 'overlaycomplete' should fire immediately, unless an overlay hadn't
+                // started drawing. This timeout will make sure the listener gets removed.
+                setTimeout(function () {
+                    listener.remove();
+                });
+            });
+        };
+        GoogleMapsService.prototype._initDrawingManager = function () {
+            var _this = this;
+            if (utils.notNullOrUndefined(this._drawingManager)) {
+                throw Error("DrawingManager is already initialized.");
+            }
+            this._assertInitialized();
+            var options = DEFAULT_DRAWING_MANAGER_OPTIONS();
+            var drawingManager = new google.maps.drawing.DrawingManager(options);
+            drawingManager.setMap(this.googleMap);
+            this._drawingManager = drawingManager;
+            this._drawingManager.addListener('drawingmode_changed', function (event) {
+                var _a;
+                if (((_a = _this._drawingManager) === null || _a === void 0 ? void 0 : _a.getDrawingMode()) !== null) {
+                    _this._assertInitialized();
+                    _this.googleMap.data.forEach(function (f) {
+                        if (isFeatureSelected(f)) {
+                            setFeatureSelected(f, false);
+                        }
+                    });
+                }
+            });
+        };
+        GoogleMapsService.prototype.addControl = function (element, position) {
+            this._assertInitialized();
+            this.googleMap.controls[position].push(element);
+        };
+        GoogleMapsService.prototype.setData = function (data) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_b) {
+                    this._assertInitialized();
+                    removeAllFeatures(this.googleMap.data);
+                    this.googleMap.data.addGeoJson(data);
+                    this.googleMap.fitBounds(getBoundsWithAllFeatures(this.googleMap.data));
+                    return [2 /*return*/];
+                });
+            });
+        };
+        // TODO: Refactor out of the service meant to just wrap the google maps api.
+        GoogleMapsService.prototype.reCenterOnFeatures = function () {
+            this._assertInitialized();
+            if (getFeaturesCount(this.googleMap.data) === 0) {
+                if (!this._baseLatLng) {
+                    return;
+                }
+                this.googleMap.panTo(this._baseLatLng);
+                return;
+            }
+            this.googleMap.fitBounds(getBoundsWithAllFeatures(this.googleMap.data));
+            // TODO: Fix to pan to center. Currently fitBounds results in the expected
+            // result, but pantToBounds animates.
+            // this.googleMap.panToBounds(getBoundsWithAllFeatures(this.googleMap.data))
+        };
+        GoogleMapsService.prototype.allowDrawingHoleInPolygon = function (allow) {
+            this._allowDrawingHoleInPolygon = allow;
+        };
+        GoogleMapsService.prototype.setFileInputHandler = function (handler) {
+            this._fileInputHandler;
+        };
+        GoogleMapsService.prototype.getFileInputHandler = function () {
+            return this._fileInputHandler;
+        };
+        GoogleMapsService.prototype._initFeatureStyling = function () {
+            var _this = this;
+            this._assertInitialized();
+            // Disable any selection when clicking the map.
+            //
+            // TODO: There may be a better way to do this that would be more accurate or
+            // additional events that should be listened to, such as the disabling
+            // selection when the map looses focus.
+            this.googleMap.addListener('click', function (even) {
+                _this._assertInitialized();
+                _this.googleMap.data.forEach(function (f) { return setFeatureSelected(f, false); });
+            });
+            // Determine what the style of the features are.
+            this.googleMap.data.setStyle(function (feature) {
+                if (isFeatureSelected(feature)) {
+                    return FEATURE_STYLE_OPTIONS_SELECTED;
+                }
+                return FEATURE_STYLE_OPTIONS_DEFAULT;
+            });
+            // Select a feature when clicked.
+            this.googleMap.data.addListener('click', function (event) {
+                _this._assertInitialized();
+                setFeatureSelected(event.feature, true);
+                _this.googleMap.data.forEach(function (f) {
+                    if (f !== event.feature && isFeatureSelected(f)) {
+                        setFeatureSelected(f, false);
+                    }
+                });
+            });
+            // Set a style on hovered features that can be selected.
+            this.googleMap.data.addListener('mouseover', function (event) {
+                _this._assertInitialized();
+                _this.googleMap.data.revertStyle();
+                if (!_this.isDrawing() && !isFeatureSelected(event.feature)) {
+                    _this.googleMap.data.overrideStyle(event.feature, { strokeWeight: 4 });
+                }
+            });
+            // Remove any hover styles when mouse moves away.
+            this.googleMap.data.addListener('mouseout', function (event) {
+                _this._assertInitialized();
+                _this.googleMap.data.revertStyle();
+            });
+        };
+        GoogleMapsService.prototype._initFeatureChangeListeners = function () {
+            var _this = this;
+            this._assertInitialized();
+            createFeatureChangeObservable(this.googleMap.data, this._ngZone).pipe(operators.switchMap(function () { return rxjs.from(_this.getGeoJson()).pipe(operators.tap(function (geoJson) { return _this._mapValueManager.setValue(geoJson, exports.MapValueSource.FeatureChange); })); }), operators.takeUntil(this._ngUnsubscribe)).subscribe();
+            this.googleMap.data.addListener('contextmenu', function (event) {
+                if (!isFeatureSelected(event.feature)) {
+                    return;
+                }
+                _this._openContextMenuForFeature(event.feature, event.latLng);
+            });
+            if (utils.notNullOrUndefined(this._drawingManager)) {
+                google.maps.event.addListener(this._drawingManager, 'polygoncomplete', function (polygon) {
+                    var _a;
+                    // The DrawingManager doesn't seem to have a way to access the overlays,
+                    // so if the map is not set then it shouldn'y be considered a successful
+                    // completion. I am canceling the active drawing by disabling drawing
+                    // mode and setting the map null in the 'overlaycomplete' event, which
+                    // fires before the 'polygoncomplete' event.
+                    if (utils.isNullOrUndefined(polygon.getMap())) {
+                        return;
+                    }
+                    _this._assertInitialized();
+                    // Create a map feature of the drawn polygon.
+                    var feature = createDataFeatureFromPolygon(polygon);
+                    // Remove the drawn polygon.
+                    polygon.setMap(null);
+                    // Stop drawing.
+                    (_a = _this._drawingManager) === null || _a === void 0 ? void 0 : _a.setDrawingMode(null);
+                    // Check if the feature should be used as a cutout to an existing
+                    // feature or added as it's own feature.
+                    var exteriorPolygonFeature = _this._allowDrawingHoleInPolygon
+                        ? getPossibleExteriorFeature(_this.googleMap.data, feature)
+                        : undefined;
+                    if (exteriorPolygonFeature) {
+                        addInnerFeatureCutoutToExteriorFeature(exteriorPolygonFeature, feature);
+                        setFeatureSelected(exteriorPolygonFeature, true);
+                    }
+                    else {
+                        _this.googleMap.data.add(feature);
+                        setFeatureSelected(feature, true);
+                    }
+                });
+            }
+        };
+        GoogleMapsService.prototype.isDrawing = function () {
+            if (utils.isNullOrUndefined(this._drawingManager)) {
+                return true;
+            }
+            return this._drawingManager.getDrawingMode() !== null;
+        };
+        // TODO: Refactor out of the service meant to just wrap the google maps api.
+        GoogleMapsService.prototype.hasSelectedFeature = function () {
+            this._assertInitialized();
+            var isSelected = false;
+            this.googleMap.data.forEach(function (f) {
+                if (isFeatureSelected(f)) {
+                    isSelected = true;
+                }
+            });
+            return isSelected;
+        };
+        // TODO: Refactor out of the service meant to just wrap the google maps api.
+        GoogleMapsService.prototype.getSelectedFeature = function () {
+            this._assertInitialized();
+            var feature = null;
+            this.googleMap.data.forEach(function (f) {
+                if (isFeatureSelected(f)) {
+                    feature = f;
+                }
+            });
+            return feature;
+        };
+        // TODO: Refactor out of the service meant to just wrap the google maps api.
+        GoogleMapsService.prototype.openContextMenu = function () {
+            var feature = this.getSelectedFeature();
+            if (feature) {
+                this._openContextMenuForFeature(feature);
+            }
+        };
+        // TODO: Refactor out of the service meant to just wrap the google maps api.
+        GoogleMapsService.prototype._openContextMenuForFeature = function (feature, position) {
+            if (this._activeContextMenu) {
+                this._activeContextMenu.close();
+                this._activeContextMenu = null;
+            }
+            this._assertInitialized();
+            var _position = position;
+            if (!_position) {
+                _position = getFeatureCenter(feature);
+            }
+            if (this._featureContextMenu) {
+                this._activeContextMenu = new GoogleMapsContextMenu(this.googleMap, this._featureContextMenu, _position, this._vcr, this._ngZone, this.googleMap.data, feature);
+            }
+        };
+        GoogleMapsService.prototype.getGeoJson = function (removeAppProperties) {
+            var _this = this;
+            if (removeAppProperties === void 0) { removeAppProperties = true; }
+            return new Promise(function (resolve, reject) {
+                _this._assertInitialized();
+                _this.googleMap.data.toGeoJson(function (f) {
+                    if (removeAppProperties) {
+                        stripAppFeaturePropertiesFromJson(f);
+                    }
+                    resolve(f);
+                });
+            });
+        };
+        /** Asserts that the map has been initialized. */
+        GoogleMapsService.prototype._assertInitialized = function () {
+            if (!this.googleMap && (typeof ngDevMode === 'undefined' || ngDevMode)) {
+                throw Error('Cannot access Google Map information before the API has been initialized. ' +
+                    'Please wait for the API to load before trying to interact with it.');
+            }
+        };
+        return GoogleMapsService;
+    }());
+    GoogleMapsService.decorators = [
+        { type: core.Injectable }
+    ];
+    GoogleMapsService.ctorParameters = function () { return [
+        { type: MapValueManagerService },
+        { type: core.NgZone },
+        { type: core.ViewContainerRef }
+    ]; };
+
+    var MAP_CONTROLS_SERVICE = new core.InjectionToken('MAP_CONTROLS_SERVICE');
+    var MAP_CONTROL_DATA = new core.InjectionToken('MAP_CONTROL_DATA');
+
+    var MapControlRef = /** @class */ (function () {
+        function MapControlRef(_googleMaps, _componentFactoryResolver, _injector, _controlDef) {
+            var _a;
+            this._googleMaps = _googleMaps;
+            this._componentFactoryResolver = _componentFactoryResolver;
+            this._injector = _injector;
+            this._controlDef = _controlDef;
+            this._destroyedSubject = new rxjs.Subject();
+            this.destroyed = this._destroyedSubject.asObservable();
+            var component = this._controlDef.component;
+            var factory = this._componentFactoryResolver.resolveComponentFactory(component);
+            var providers = [];
+            if (this._controlDef.data) {
+                providers.push({
+                    provide: MAP_CONTROL_DATA,
+                    useValue: this._controlDef.data
+                });
+            }
+            var injector = core.Injector.create({
+                providers: providers,
+                parent: this._injector,
+            });
+            this._componentRef = factory.create(injector);
+            this._componentRef.changeDetectorRef.detectChanges();
+            var position = (_a = this._controlDef.position) !== null && _a !== void 0 ? _a : google.maps.ControlPosition.LEFT_BOTTOM;
+            this._googleMaps.addControl(this._componentRef.location.nativeElement, position);
+            this._addedAtPosition = position;
+        }
+        MapControlRef.prototype.destroy = function () {
+            var _this = this;
+            var googleMaps = this._googleMaps.googleMap;
+            if (googleMaps !== undefined) {
+                var idx_1 = -1;
+                googleMaps.controls[this._addedAtPosition].forEach(function (elem, index) {
+                    if (elem === _this._componentRef.location.nativeElement) {
+                        idx_1 = index;
+                    }
+                });
+                if (idx_1 === -1) {
+                    throw Error("Unable to destroy control. Control not found.");
+                }
+                googleMaps.controls[this._addedAtPosition].removeAt(idx_1);
+            }
+            this._componentRef.destroy();
+            this._destroyedSubject.next();
+            this._destroyedSubject.complete();
+        };
+        return MapControlRef;
+    }());
+    var GoogleMapsControlsService = /** @class */ (function () {
+        function GoogleMapsControlsService(_googleMaps, _componentFactoryResolver, _injector) {
+            this._googleMaps = _googleMaps;
+            this._componentFactoryResolver = _componentFactoryResolver;
+            this._injector = _injector;
+        }
+        GoogleMapsControlsService.prototype.add = function (control) {
+            return new MapControlRef(this._googleMaps, this._componentFactoryResolver, this._injector, control);
+        };
+        return GoogleMapsControlsService;
+    }());
+    GoogleMapsControlsService.decorators = [
+        { type: core.Injectable }
+    ];
+    GoogleMapsControlsService.ctorParameters = function () { return [
+        { type: GoogleMapsService },
+        { type: core.ComponentFactoryResolver },
+        { type: core.Injector }
+    ]; };
+
+    /**
+     *
+     */
+    var TheSeamGoogleMapsRecenterButtonControlComponent = /** @class */ (function () {
+        function TheSeamGoogleMapsRecenterButtonControlComponent(_googleMaps, _data) {
+            this._googleMaps = _googleMaps;
+            this._ngUnsubscribe = new rxjs.Subject();
+            this._listeners = [];
+            if (_data) {
+                if (_data.hasOwnProperty('label')) {
+                    this.label = _data.label;
+                }
+                if (_data.hasOwnProperty('icon')) {
+                    this.icon = _data.icon;
+                }
+            }
+        }
+        TheSeamGoogleMapsRecenterButtonControlComponent.prototype._onClick = function (event) {
+            this._googleMaps.reCenterOnFeatures();
+        };
+        /** @ignore */
+        TheSeamGoogleMapsRecenterButtonControlComponent.prototype.ngOnDestroy = function () {
+            this._listeners.forEach(function (l) { return l(); });
+            this._ngUnsubscribe.next();
+            this._ngUnsubscribe.complete();
+        };
+        return TheSeamGoogleMapsRecenterButtonControlComponent;
+    }());
+    TheSeamGoogleMapsRecenterButtonControlComponent.decorators = [
+        { type: core.Component, args: [{
+                    // tslint:disable-next-line: component-selector
+                    selector: 'button[seam-google-maps-recenter-button-control]',
+                    template: "<seam-icon [icon]=\"icon\" iconType=\"image-fill\"></seam-icon>\n",
+                    host: {
+                        '[attr.draggable]': 'false',
+                        '[attr.aria-label]': 'label',
+                        '[attr.title]': 'label',
+                        'type': 'button',
+                        'class': 'gmnoprint gm-control-active'
+                    },
+                    changeDetection: core.ChangeDetectionStrategy.OnPush,
+                    styles: [":host{background:none white;border:0px;margin:10px;padding:11px;text-transform:none;-webkit-appearance:none;-moz-appearance:none;appearance:none;position:absolute;cursor:pointer;-webkit-user-select:none;-moz-user-select:none;user-select:none;border-radius:2px;height:40px;width:40px;box-shadow:#0000004d 0 1px 4px -1px;overflow:hidden}\n"]
+                },] }
+    ];
+    TheSeamGoogleMapsRecenterButtonControlComponent.ctorParameters = function () { return [
+        { type: GoogleMapsService },
+        { type: undefined, decorators: [{ type: core.Optional }, { type: core.Inject, args: [MAP_CONTROL_DATA,] }] }
+    ]; };
+    TheSeamGoogleMapsRecenterButtonControlComponent.propDecorators = {
+        label: [{ type: core.Input }],
+        icon: [{ type: core.Input }],
+        _onClick: [{ type: core.HostListener, args: ['click', ['event'],] }]
+    };
+
+    /**
+     *
+     */
+    var TheSeamGoogleMapsUploadButtonControlComponent = /** @class */ (function () {
+        function TheSeamGoogleMapsUploadButtonControlComponent(_elementRef, _mapValueManager, _renderer, _googleMaps, _data) {
+            this._elementRef = _elementRef;
+            this._mapValueManager = _mapValueManager;
+            this._renderer = _renderer;
+            this._googleMaps = _googleMaps;
+            this._ngUnsubscribe = new rxjs.Subject();
+            this._listeners = [];
+            if (_data) {
+                if (_data.hasOwnProperty('label')) {
+                    this.label = _data.label;
+                }
+                if (_data.hasOwnProperty('icon')) {
+                    this.icon = _data.icon;
+                }
+            }
+            this._fileInputElement = this._createHiddenInput();
+            this._renderer.appendChild(this._elementRef.nativeElement, this._fileInputElement);
+        }
+        TheSeamGoogleMapsUploadButtonControlComponent.prototype._onClick = function (event) {
+            this._fileInputElement.click();
+        };
+        /** @ignore */
+        TheSeamGoogleMapsUploadButtonControlComponent.prototype.ngOnDestroy = function () {
+            this._listeners.forEach(function (l) { return l(); });
+            this._ngUnsubscribe.next();
+            this._ngUnsubscribe.complete();
+        };
+        TheSeamGoogleMapsUploadButtonControlComponent.prototype._getFile = function (throwIfInvalidFiles) {
+            if (throwIfInvalidFiles === void 0) { throwIfInvalidFiles = true; }
+            var files = this._fileInputElement.files;
+            if (files === null || files.length === 0) {
+                return null;
+            }
+            if (throwIfInvalidFiles) {
+                if (files.length > 1) {
+                    throw Error("Only one file can be imported at a time.");
+                }
+            }
+            return files[0];
+        };
+        TheSeamGoogleMapsUploadButtonControlComponent.prototype._importFile = function (file) {
+            return __awaiter(this, void 0, void 0, function () {
+                var json;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, utils.readGeoFile(file)];
+                        case 1:
+                            json = _a.sent();
+                            this._mapValueManager.setValue(json, exports.MapValueSource.Input);
+                            this._resetInput();
+                            return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        TheSeamGoogleMapsUploadButtonControlComponent.prototype._createHiddenInput = function () {
+            var _this = this;
+            var fileInputElement = this._renderer.createElement('input');
+            this._renderer.setAttribute(fileInputElement, 'type', 'file');
+            this._renderer.setAttribute(fileInputElement, 'hidden', '');
+            this._renderer.setAttribute(fileInputElement, 'accept', '.json,.geojson,.shp,.zip');
+            this._listeners.push(this._renderer.listen(fileInputElement, 'change', function (event) {
+                var file = _this._getFile();
+                if (file === null) {
+                    return;
+                }
+                var fileImportHandler = _this._googleMaps.getFileInputHandler();
+                if (fileImportHandler) {
+                    fileImportHandler(file);
+                }
+                else {
+                    _this._importFile(file);
+                }
+            }));
+            return fileInputElement;
+        };
+        TheSeamGoogleMapsUploadButtonControlComponent.prototype._createTemporaryFormElement = function () {
+            return this._renderer.createElement('form');
+        };
+        /**
+         * Reset input element, so that the same file can be added again.
+         */
+        TheSeamGoogleMapsUploadButtonControlComponent.prototype._resetInput = function () {
+            var formElement = this._createTemporaryFormElement();
+            this._renderer.appendChild(formElement, this._fileInputElement);
+            formElement.reset();
+            this._renderer.appendChild(this._elementRef.nativeElement, this._fileInputElement);
+        };
+        return TheSeamGoogleMapsUploadButtonControlComponent;
+    }());
+    TheSeamGoogleMapsUploadButtonControlComponent.decorators = [
+        { type: core.Component, args: [{
+                    // tslint:disable-next-line: component-selector
+                    selector: 'button[seam-google-maps-upload-button-control]',
+                    template: "<seam-icon [icon]=\"icon\" iconType=\"image-fill\"></seam-icon>\n",
+                    host: {
+                        '[attr.draggable]': 'false',
+                        '[attr.aria-label]': 'label',
+                        '[attr.title]': 'label',
+                        'type': 'button',
+                        'class': 'gmnoprint gm-control-active'
+                    },
+                    changeDetection: core.ChangeDetectionStrategy.OnPush,
+                    styles: [":host{background:none white;border:0px;margin:10px;padding:11px;text-transform:none;-webkit-appearance:none;-moz-appearance:none;appearance:none;position:absolute;cursor:pointer;-webkit-user-select:none;-moz-user-select:none;user-select:none;border-radius:2px;height:40px;width:40px;box-shadow:#0000004d 0 1px 4px -1px;overflow:hidden}\n"]
+                },] }
+    ];
+    TheSeamGoogleMapsUploadButtonControlComponent.ctorParameters = function () { return [
+        { type: core.ElementRef },
+        { type: MapValueManagerService },
+        { type: core.Renderer2 },
+        { type: GoogleMapsService },
+        { type: undefined, decorators: [{ type: core.Optional }, { type: core.Inject, args: [MAP_CONTROL_DATA,] }] }
+    ]; };
+    TheSeamGoogleMapsUploadButtonControlComponent.propDecorators = {
+        label: [{ type: core.Input }],
+        icon: [{ type: core.Input }],
+        _onClick: [{ type: core.HostListener, args: ['click', ['event'],] }]
+    };
+
+    var TheSeamGoogleMapsComponentBase = /** @class */ (function () {
+        function TheSeamGoogleMapsComponentBase(_elementRef) {
+            this._elementRef = _elementRef;
+        }
+        return TheSeamGoogleMapsComponentBase;
+    }());
+    var _TheSeamGoogleMapsMixinBase = core$1.mixinDisabled(TheSeamGoogleMapsComponentBase);
+    /**
+     * A wrapper for googlemap.
+     */
+    var TheSeamGoogleMapsComponent = /** @class */ (function (_super) {
+        __extends(TheSeamGoogleMapsComponent, _super);
+        function TheSeamGoogleMapsComponent(elementRef, _focusMonitor, _googleMaps, _mapValueManager) {
+            var _this = _super.call(this, elementRef) || this;
+            _this._focusMonitor = _focusMonitor;
+            _this._googleMaps = _googleMaps;
+            _this._mapValueManager = _mapValueManager;
+            _this._ngUnsubscribe = new rxjs.Subject();
+            _this._fileUploadControlDef = {
+                component: TheSeamGoogleMapsUploadButtonControlComponent,
+                data: { label: 'Import Geo File', icon: freeSolidSvgIcons.faFileImport },
+                position: 6 /* google.maps.ControlPosition.LEFT_BOTTOM */,
+            };
+            _this._reCenterControlDef = {
+                component: TheSeamGoogleMapsRecenterButtonControlComponent,
+                data: { label: 'Center on Field', icon: freeSolidSvgIcons.faCrosshairs },
+                position: 9 /* google.maps.ControlPosition.RIGHT_BOTTOM */,
+            };
+            _this._focusOrigin = null;
+            /**
+             * Set the tab index to `-1` to allow the root element of the
+             * component to receive `focus` event from javascript, but not get focused by
+             * keyboard navigation.
+             */
+            _this._tabIndex = -1;
+            _this.fileDropEnabled = true;
+            _this.fileUploadControlEnabled = false;
+            _this.fullscreenControlEnabled = true;
+            _this.reCenterControlEnabled = true;
+            _this.mapTypeControlEnabled = true;
+            _this.streetViewControlEnabled = false;
+            _this.allowDrawingHoleInPolygon = false;
+            _this.zoom = 14;
+            _this.longitude = -98.570209;
+            _this.latitude = 37.633814;
+            _this.mapReady = new core.EventEmitter();
+            _this._focusMonitor.monitor(_this._elementRef, true).pipe(operators.tap(function (origin) { return _this._focusOrigin = origin; }), operators.takeUntil(_this._ngUnsubscribe)).subscribe();
+            _this._mapValueManager.valueChanged.pipe(operators.tap(function (change) {
+                if (_this.onChange) {
+                    _this.onChange(change.value);
+                }
+                if (_this.onTouched) {
+                    _this.onTouched();
+                }
+            }), operators.tap(function (changed) {
+                if (_this._googleMaps.mapReady && changed.source !== exports.MapValueSource.FeatureChange) {
+                    _this._googleMaps.setData(changed.value);
+                }
+            }), operators.takeUntil(_this._ngUnsubscribe)).subscribe();
+            _this._googleMaps.setBaseLatLng(_this.latitude, _this.longitude);
+            return _this;
+        }
+        Object.defineProperty(TheSeamGoogleMapsComponent.prototype, "value", {
+            get: function () {
+                return this._mapValueManager.value;
+            },
+            set: function (value) {
+                this._mapValueManager.setValue(value, exports.MapValueSource.Input);
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(TheSeamGoogleMapsComponent.prototype, "tabIndex", {
+            get: function () { return this._tabIndex; },
+            set: function (value) { this._tabIndex = coercion.coerceNumberProperty(value); },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(TheSeamGoogleMapsComponent.prototype, "fileImportHandler", {
+            set: function (value) {
+                this._googleMaps.setFileInputHandler(value);
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(TheSeamGoogleMapsComponent.prototype, "_attrDisabled", {
+            get: function () { return this.disabled || null; },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(TheSeamGoogleMapsComponent.prototype, "_attrTabIndex", {
+            get: function () { return this.disabled ? -1 : (this.tabIndex || 0); },
+            enumerable: false,
+            configurable: true
+        });
+        /** @ignore */
+        TheSeamGoogleMapsComponent.prototype.ngOnInit = function () {
+            var _this = this;
+            this._googleMaps.setFeatureContextMenu(this.featureContextMenu);
+            rxjs.fromEvent(window, 'keydown').pipe(operators.tap(function (event) {
+                switch (event.code) {
+                    case 'Delete':
+                        _this._googleMaps.deleteSelection();
+                        event.preventDefault();
+                        event.stopPropagation();
+                        break;
+                    case 'Escape':
+                        _this._googleMaps.stopDrawing();
+                        event.preventDefault();
+                        event.stopPropagation();
+                        break;
+                    case 'ContextMenu':
+                        _this._googleMaps.openContextMenu();
+                        event.preventDefault();
+                        event.stopPropagation();
+                        break;
+                }
+            }), operators.takeUntil(this._ngUnsubscribe)).subscribe();
+        };
+        /** @ignore */
+        TheSeamGoogleMapsComponent.prototype.ngOnDestroy = function () {
+            this._focusMonitor.stopMonitoring(this._elementRef);
+            this._ngUnsubscribe.next();
+            this._ngUnsubscribe.complete();
+        };
+        /** @ignore */
+        TheSeamGoogleMapsComponent.prototype.ngAfterViewInit = function () { };
+        TheSeamGoogleMapsComponent.prototype.ngOnChanges = function (changes) {
+            var updateBase = false;
+            if (changes.hasOwnProperty('latitude')) {
+                this.latitude = changes['latitude'].currentValue;
+                updateBase = true;
+            }
+            if (changes.hasOwnProperty('longitude')) {
+                this.longitude = changes['longitude'].currentValue;
+                updateBase = true;
+            }
+            if (updateBase) {
+                this._googleMaps.setBaseLatLng(this.latitude, this.longitude);
+            }
+            if (changes.hasOwnProperty('allowDrawingHoleInPolygon')) {
+                this._googleMaps.allowDrawingHoleInPolygon(this.allowDrawingHoleInPolygon);
+            }
+        };
+        TheSeamGoogleMapsComponent.prototype.writeValue = function (value) {
+            this.value = value;
+        };
+        TheSeamGoogleMapsComponent.prototype.registerOnChange = function (fn) {
+            this.onChange = fn;
+        };
+        TheSeamGoogleMapsComponent.prototype.registerOnTouched = function (fn) {
+            this.onTouched = fn;
+        };
+        TheSeamGoogleMapsComponent.prototype.setDisabledState = function (isDisabled) {
+            this.disabled = isDisabled;
+        };
+        TheSeamGoogleMapsComponent.prototype.fitBounds = function (bounds, padding) {
+            this._googleMaps.fitBounds(bounds, padding);
+        };
+        TheSeamGoogleMapsComponent.prototype.getGeoJson = function () {
+            return this._googleMaps.getGeoJson();
+        };
+        TheSeamGoogleMapsComponent.prototype.hasFocus = function () {
+            return this._focusOrigin !== null && this._focusOrigin !== undefined;
+        };
+        /** Focuses the button. */
+        TheSeamGoogleMapsComponent.prototype.focus = function () {
+            this._getHostElement().focus();
+        };
+        TheSeamGoogleMapsComponent.prototype._getHostElement = function () {
+            return this._elementRef.nativeElement;
+        };
+        TheSeamGoogleMapsComponent.prototype._onMapReady = function (theMap) {
+            var _a;
+            this._googleMaps.setMap(theMap);
+            this._googleMaps.setData(this._mapValueManager.value);
+            // NOTE: AgmMap has a race condition problem that causes the input latitude,
+            // longitude, and zoom to get ignored, before googlemaps emits
+            // 'center_changed'. This should avoid the issue, until we stop using AgmMap
+            // or upgrade to a more recent version that may not have the issue anymore.
+            this._googleMaps.reCenterOnFeatures();
+            (_a = this._googleMaps.googleMap) === null || _a === void 0 ? void 0 : _a.setZoom(this.zoom);
+        };
+        TheSeamGoogleMapsComponent.prototype._onClickDeleteFeature = function () {
+            this._googleMaps.deleteSelection();
+        };
+        return TheSeamGoogleMapsComponent;
+    }(_TheSeamGoogleMapsMixinBase));
+    TheSeamGoogleMapsComponent.decorators = [
+        { type: core.Component, args: [{
+                    selector: 'seam-google-maps',
+                    template: "<agm-map\n  [latitude]=\"latitude\"\n  [longitude]=\"longitude\"\n  [zoom]=\"zoom\"\n  [mapTypeControl]=\"true\"\n  mapTypeId=\"hybrid\"\n  [streetViewControl]=\"false\"\n  (mapReady)=\"_onMapReady($event)\"\n  [fullscreenControl]=\"$any(fullscreenControlEnabled)\">\n</agm-map>\n<seam-menu #featureContextMenu>\n  <button seamMenuItem (click)=\"_onClickDeleteFeature()\">Delete</button>\n</seam-menu>\n<seam-map-file-drop *ngIf=\"fileDropEnabled\"></seam-map-file-drop>\n\n<seam-map-control *ngIf=\"fileUploadControlEnabled\" [def]=\"_fileUploadControlDef\"></seam-map-control>\n<seam-map-control *ngIf=\"reCenterControlEnabled\" [def]=\"_reCenterControlDef\"></seam-map-control>\n",
+                    inputs: [
+                        'disabled'
+                    ],
+                    providers: [
+                        MapValueManagerService,
+                        GoogleMapsService,
+                        { provide: MAP_CONTROLS_SERVICE, useClass: GoogleMapsControlsService },
+                        {
+                            provide: forms.NG_VALUE_ACCESSOR,
+                            // tslint:disable-next-line: no-use-before-declare
+                            useExisting: core.forwardRef(function () { return TheSeamGoogleMapsComponent; }),
+                            multi: true
+                        }
+                    ],
+                    changeDetection: core.ChangeDetectionStrategy.OnPush,
+                    exportAs: 'seamGoogleMaps',
+                    styles: [":host{display:block;position:relative;height:400px;width:100%}:host.show-focus-border.cdk-focused{outline:0;box-shadow:0 0 0 .2rem #357ebd40}:host.show-focus-border[disabled]{opacity:.65}agm-map{height:inherit;width:inherit}\n"]
+                },] }
+    ];
+    TheSeamGoogleMapsComponent.ctorParameters = function () { return [
+        { type: core.ElementRef },
+        { type: a11y.FocusMonitor },
+        { type: GoogleMapsService },
+        { type: MapValueManagerService }
+    ]; };
+    TheSeamGoogleMapsComponent.propDecorators = {
+        value: [{ type: core.Input }],
+        tabIndex: [{ type: core.Input }],
+        fileDropEnabled: [{ type: core.Input }],
+        fileUploadControlEnabled: [{ type: core.Input }],
+        fullscreenControlEnabled: [{ type: core.Input }],
+        reCenterControlEnabled: [{ type: core.Input }],
+        mapTypeControlEnabled: [{ type: core.Input }],
+        streetViewControlEnabled: [{ type: core.Input }],
+        allowDrawingHoleInPolygon: [{ type: core.Input }],
+        fileImportHandler: [{ type: core.Input }],
+        _attrDisabled: [{ type: core.HostBinding, args: ['attr.disabled',] }],
+        _attrTabIndex: [{ type: core.HostBinding, args: ['attr.tabindex',] }],
+        zoom: [{ type: core.Input }],
+        longitude: [{ type: core.Input }],
+        latitude: [{ type: core.Input }],
+        mapReady: [{ type: core.Output }],
+        agmMap: [{ type: core.ViewChild, args: [core$2.AgmMap, { static: true },] }],
+        featureContextMenu: [{ type: core.ViewChild, args: ['featureContextMenu', { static: true, read: menu.MenuComponent },] }],
+        agmMapTpl: [{ type: core.ViewChild, args: [core$2.AgmMap, { static: true, read: core.ElementRef },] }]
+    };
+    __decorate([
+        core$1.InputBoolean()
+    ], TheSeamGoogleMapsComponent.prototype, "fileDropEnabled", void 0);
+    __decorate([
+        core$1.InputBoolean()
+    ], TheSeamGoogleMapsComponent.prototype, "fileUploadControlEnabled", void 0);
+    __decorate([
+        core$1.InputBoolean()
+    ], TheSeamGoogleMapsComponent.prototype, "fullscreenControlEnabled", void 0);
+    __decorate([
+        core$1.InputBoolean()
+    ], TheSeamGoogleMapsComponent.prototype, "reCenterControlEnabled", void 0);
+    __decorate([
+        core$1.InputBoolean()
+    ], TheSeamGoogleMapsComponent.prototype, "mapTypeControlEnabled", void 0);
+    __decorate([
+        core$1.InputBoolean()
+    ], TheSeamGoogleMapsComponent.prototype, "streetViewControlEnabled", void 0);
+    __decorate([
+        core$1.InputBoolean()
+    ], TheSeamGoogleMapsComponent.prototype, "allowDrawingHoleInPolygon", void 0);
+    __decorate([
+        core$1.InputNumber()
+    ], TheSeamGoogleMapsComponent.prototype, "zoom", void 0);
+    __decorate([
+        core$1.InputNumber()
+    ], TheSeamGoogleMapsComponent.prototype, "longitude", void 0);
+    __decorate([
+        core$1.InputNumber()
+    ], TheSeamGoogleMapsComponent.prototype, "latitude", void 0);
+
+    var SEAM_GOOGLE_PLACES_AUTOCOMPLETE_DEFAULT_OPTIONS = {
+        componentRestrictions: { country: 'US' }
+    };
+    var TheSeamGoogleMapsPlacesAutocompleteDirective = /** @class */ (function () {
+        function TheSeamGoogleMapsPlacesAutocompleteDirective(_elementRef, _ngZone) {
+            var _this = this;
+            this._elementRef = _elementRef;
+            this._ngZone = _ngZone;
+            this._autoCompleteReadySubject = new rxjs.Subject();
+            this._ngUnsubscribe = new rxjs.Subject();
+            this._placeChangedPending = [];
+            this._listeners = [];
+            this._options = SEAM_GOOGLE_PLACES_AUTOCOMPLETE_DEFAULT_OPTIONS;
+            this._attrType = 'text';
+            this.placeChanged = this._autoCompleteReadySubject.pipe(operators.startWith(undefined), operators.switchMap(function () { return _this._createPlaceChangedObservable(); }));
+        }
+        Object.defineProperty(TheSeamGoogleMapsPlacesAutocompleteDirective.prototype, "options", {
+            set: function (value) {
+                this._options = value || SEAM_GOOGLE_PLACES_AUTOCOMPLETE_DEFAULT_OPTIONS;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        TheSeamGoogleMapsPlacesAutocompleteDirective.prototype.ngOnInit = function () {
+            var _this = this;
+            this._ngZone.runOutsideAngular(function () {
+                _this._untilGoogleMapsApiLoaded().pipe(operators.takeUntil(_this._ngUnsubscribe)).subscribe(function () {
+                    _this.autoComplete = new google.maps.places.Autocomplete(_this.getHostElement(), _this._options);
+                    _this._placeChangedPending.forEach(function (pending) { return pending.observable.subscribe(pending.subscriber); });
+                    _this._autoCompleteReadySubject.next();
+                });
+            });
+        };
+        TheSeamGoogleMapsPlacesAutocompleteDirective.prototype.ngOnDestroy = function () {
+            this._listeners.forEach(function (l) { return l.remove(); });
+            this._listeners = [];
+            this._ngUnsubscribe.next();
+            this._ngUnsubscribe.complete();
+        };
+        TheSeamGoogleMapsPlacesAutocompleteDirective.prototype.ngOnChanges = function (changes) {
+            if (this.autoComplete && changes['options']) {
+                this.autoComplete.setOptions(this._options);
+            }
+        };
+        TheSeamGoogleMapsPlacesAutocompleteDirective.prototype._untilGoogleMapsApiLoaded = function () {
+            return rxjs.interval(500).pipe(operators.filter(function () { return !!(window.google && window.google.maps && window.google.maps.version); }), operators.take(1), operators.mapTo(undefined));
+        };
+        /**
+         * Returns the bounds to which predictions are biased.
+         */
+        TheSeamGoogleMapsPlacesAutocompleteDirective.prototype.getBounds = function () {
+            this._assertInitialized();
+            return this.autoComplete.getBounds();
+        };
+        /**
+         * Returns the fields to be included for the Place in the details response
+         * when the details are successfully retrieved. For a list of fields see
+         * [PlaceResult](https://developers.google.com/maps/documentation/javascript/reference/places-service#PlaceResult).
+         */
+        TheSeamGoogleMapsPlacesAutocompleteDirective.prototype.getFields = function () {
+            this._assertInitialized();
+            return this.autoComplete.getFields();
+        };
+        /**
+         * Returns the details of the Place selected by user if the details were
+         * successfully retrieved. Otherwise returns a stub Place object, with the
+         * name property set to the current value of the input field.
+         */
+        TheSeamGoogleMapsPlacesAutocompleteDirective.prototype.getPlace = function () {
+            this._assertInitialized();
+            return this.autoComplete.getPlace();
+        };
+        /**
+         * Sets the preferred area within which to return Place results. Results are
+         * biased towards, but not restricted to, this area.
+         */
+        TheSeamGoogleMapsPlacesAutocompleteDirective.prototype.setBounds = function (bounds) {
+            this._assertInitialized();
+            // tslint:disable-next-line: no-non-null-assertion
+            return this.autoComplete.setBounds(bounds);
+        };
+        /**
+         * Sets the component restrictions. Component restrictions are used to
+         * restrict predictions to only those within the parent component. For
+         * example, the country.
+         */
+        TheSeamGoogleMapsPlacesAutocompleteDirective.prototype.setComponentRestrictions = function (restrictions) {
+            this._assertInitialized();
+            // tslint:disable-next-line: no-non-null-assertion
+            return this.autoComplete.setComponentRestrictions(restrictions);
+        };
+        /**
+         * Sets the fields to be included for the Place in the details response when
+         * the details are successfully retrieved. For a list of fields see
+         * [PlaceResult](https://developers.google.com/maps/documentation/javascript/reference/places-service#PlaceResult).
+         */
+        TheSeamGoogleMapsPlacesAutocompleteDirective.prototype.setFields = function (fields) {
+            this._assertInitialized();
+            // tslint:disable-next-line: no-non-null-assertion
+            return this.autoComplete.setFields(fields);
+        };
+        /** */
+        TheSeamGoogleMapsPlacesAutocompleteDirective.prototype.setOptions = function (options) {
+            this._assertInitialized();
+            // tslint:disable-next-line: no-non-null-assertion
+            return this.autoComplete.setOptions(options);
+        };
+        /**
+         * Sets the types of predictions to be returned. For supported types, see the
+         * [developer's guide](https://developers.google.com/maps/documentation/javascript/places-autocomplete#constrain-place-types).
+         * If no types are specified, all types will be returned.
+         */
+        TheSeamGoogleMapsPlacesAutocompleteDirective.prototype.setTypes = function (types) {
+            this._assertInitialized();
+            // tslint:disable-next-line: no-non-null-assertion
+            return this.autoComplete.setTypes(types);
+        };
+        /** Focuses the input. */
+        TheSeamGoogleMapsPlacesAutocompleteDirective.prototype.focus = function () {
+            this._elementRef.nativeElement.focus();
+        };
+        /** Unfocuses the input. */
+        TheSeamGoogleMapsPlacesAutocompleteDirective.prototype.blur = function () {
+            this._elementRef.nativeElement.blur();
+        };
+        TheSeamGoogleMapsPlacesAutocompleteDirective.prototype.getHostElement = function () {
+            return this._elementRef.nativeElement;
+        };
+        TheSeamGoogleMapsPlacesAutocompleteDirective.prototype._createPlaceChangedObservable = function () {
+            var _this = this;
+            var observable = new rxjs.Observable(function (subscriber) {
+                if (!_this.autoComplete) {
+                    _this._placeChangedPending.push({ observable: observable, subscriber: subscriber });
+                    return undefined;
+                }
+                var listener = _this.autoComplete.addListener('place_changed', function (event) {
+                    _this._ngZone.run(function () { return subscriber.next(event); });
+                });
+                _this._listeners.push(listener);
+                return function () { return listener.remove(); };
+            });
+            return observable;
+        };
+        /** Asserts that the map has been initialized. */
+        TheSeamGoogleMapsPlacesAutocompleteDirective.prototype._assertInitialized = function () {
+            if (!this.autoComplete && (typeof ngDevMode === 'undefined' || ngDevMode)) {
+                throw Error('Cannot access Google Map Places information before the API has been initialized. ' +
+                    'Please wait for the API to load before trying to interact with it.');
+            }
+        };
+        return TheSeamGoogleMapsPlacesAutocompleteDirective;
+    }());
+    TheSeamGoogleMapsPlacesAutocompleteDirective.decorators = [
+        { type: core.Directive, args: [{
+                    selector: 'input[seamGoogleMapsPlacesAutocomplete]',
+                    exportAs: 'seamGoogleMapsPlacesAutocomplete'
+                },] }
+    ];
+    TheSeamGoogleMapsPlacesAutocompleteDirective.ctorParameters = function () { return [
+        { type: core.ElementRef },
+        { type: core.NgZone }
+    ]; };
+    TheSeamGoogleMapsPlacesAutocompleteDirective.propDecorators = {
+        options: [{ type: core.Input }],
+        placeChanged: [{ type: core.Output }],
+        _attrType: [{ type: core.HostBinding, args: ['attr.type',] }]
+    };
+
+    /**
+     *
+     */
+    var TheSeamGoogleMapsPlacesAutoCompleteComponent = /** @class */ (function () {
+        function TheSeamGoogleMapsPlacesAutoCompleteComponent(_elementRef) {
+            var _this = this;
+            this._elementRef = _elementRef;
+            this._ngUnsubscribe = new rxjs.Subject();
+            this._autoCompleteReadySubject = new rxjs.Subject();
+            this._placeChangedPending = [];
+            this.label = 'Search by address, place or name';
+            this.icon = freeSolidSvgIcons.faSearchLocation;
+            this.disabled = false;
+            this.placeholder = 'Enter address, place or name';
+            this.autocorrect = 'off';
+            this.autocapitalize = 'off';
+            this._tabIndex = -1;
+            this._options = SEAM_GOOGLE_PLACES_AUTOCOMPLETE_DEFAULT_OPTIONS;
+            this.placeChanged = this._autoCompleteReadySubject.pipe(operators.startWith(undefined), operators.switchMap(function () { return _this._createPlaceChangedObservable(); }));
+        }
+        Object.defineProperty(TheSeamGoogleMapsPlacesAutoCompleteComponent.prototype, "tabIndex", {
+            get: function () { return this._tabIndex; },
+            /**
+             * Set the tab index to `-1` to allow the root element of the
+             * component to receive `focus` event from javascript, but not get focused by
+             * keyboard navigation.
+             */
+            set: function (value) { this._tabIndex = coercion.coerceNumberProperty(value); },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(TheSeamGoogleMapsPlacesAutoCompleteComponent.prototype, "options", {
+            set: function (value) {
+                this._options = value || SEAM_GOOGLE_PLACES_AUTOCOMPLETE_DEFAULT_OPTIONS;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(TheSeamGoogleMapsPlacesAutoCompleteComponent.prototype, "__autocompleteDirective", {
+            set: function (value) {
+                var _this = this;
+                this._autoCompleteDirective = value;
+                this._untilAutoCompleteReady().pipe(operators.takeUntil(this._ngUnsubscribe)).subscribe(function () {
+                    _this.autoComplete = _this._autoCompleteDirective.autoComplete;
+                    _this._placeChangedPending.forEach(function (pending) { return pending.observable.subscribe(pending.subscriber); });
+                    _this._placeChangedPending = [];
+                });
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(TheSeamGoogleMapsPlacesAutoCompleteComponent.prototype, "_attrTabIndex", {
+            get: function () { return this.disabled ? -1 : (this.tabIndex || 0); },
+            enumerable: false,
+            configurable: true
+        });
+        TheSeamGoogleMapsPlacesAutoCompleteComponent.prototype._onClick = function (event) {
+            this._inputDirective.focus();
+        };
+        TheSeamGoogleMapsPlacesAutoCompleteComponent.prototype._onFocus = function () {
+            var _a;
+            (_a = this._inputDirective) === null || _a === void 0 ? void 0 : _a.focus();
+        };
+        TheSeamGoogleMapsPlacesAutoCompleteComponent.prototype.ngOnInit = function () { };
+        /** @ignore */
+        TheSeamGoogleMapsPlacesAutoCompleteComponent.prototype.ngOnDestroy = function () {
+            this._ngUnsubscribe.next();
+            this._ngUnsubscribe.complete();
+        };
+        TheSeamGoogleMapsPlacesAutoCompleteComponent.prototype._untilAutoCompleteReady = function () {
+            var _this = this;
+            return rxjs.interval(500).pipe(operators.filter(function () { return !!_this._autoCompleteDirective.autoComplete; }), operators.take(1), operators.mapTo(undefined));
+        };
+        /**
+         * Returns the bounds to which predictions are biased.
+         */
+        TheSeamGoogleMapsPlacesAutoCompleteComponent.prototype.getBounds = function () {
+            this._assertInitialized();
+            return this.autoComplete.getBounds();
+        };
+        /**
+         * Returns the fields to be included for the Place in the details response
+         * when the details are successfully retrieved. For a list of fields see
+         * [PlaceResult](https://developers.google.com/maps/documentation/javascript/reference/places-service#PlaceResult).
+         */
+        TheSeamGoogleMapsPlacesAutoCompleteComponent.prototype.getFields = function () {
+            this._assertInitialized();
+            return this.autoComplete.getFields();
+        };
+        /**
+         * Returns the details of the Place selected by user if the details were
+         * successfully retrieved. Otherwise returns a stub Place object, with the
+         * name property set to the current value of the input field.
+         */
+        TheSeamGoogleMapsPlacesAutoCompleteComponent.prototype.getPlace = function () {
+            this._assertInitialized();
+            return this.autoComplete.getPlace();
+        };
+        /**
+         * Sets the preferred area within which to return Place results. Results are
+         * biased towards, but not restricted to, this area.
+         */
+        TheSeamGoogleMapsPlacesAutoCompleteComponent.prototype.setBounds = function (bounds) {
+            this._assertInitialized();
+            // tslint:disable-next-line: no-non-null-assertion
+            return this.autoComplete.setBounds(bounds);
+        };
+        /**
+         * Sets the component restrictions. Component restrictions are used to
+         * restrict predictions to only those within the parent component. For
+         * example, the country.
+         */
+        TheSeamGoogleMapsPlacesAutoCompleteComponent.prototype.setComponentRestrictions = function (restrictions) {
+            this._assertInitialized();
+            // tslint:disable-next-line: no-non-null-assertion
+            return this.autoComplete.setComponentRestrictions(restrictions);
+        };
+        /**
+         * Sets the fields to be included for the Place in the details response when
+         * the details are successfully retrieved. For a list of fields see
+         * [PlaceResult](https://developers.google.com/maps/documentation/javascript/reference/places-service#PlaceResult).
+         */
+        TheSeamGoogleMapsPlacesAutoCompleteComponent.prototype.setFields = function (fields) {
+            this._assertInitialized();
+            // tslint:disable-next-line: no-non-null-assertion
+            return this.autoComplete.setFields(fields);
+        };
+        /** */
+        TheSeamGoogleMapsPlacesAutoCompleteComponent.prototype.setOptions = function (options) {
+            this._assertInitialized();
+            // tslint:disable-next-line: no-non-null-assertion
+            return this.autoComplete.setOptions(options);
+        };
+        /**
+         * Sets the types of predictions to be returned. For supported types, see the
+         * [developer's guide](https://developers.google.com/maps/documentation/javascript/places-autocomplete#constrain-place-types).
+         * If no types are specified, all types will be returned.
+         */
+        TheSeamGoogleMapsPlacesAutoCompleteComponent.prototype.setTypes = function (types) {
+            this._assertInitialized();
+            // tslint:disable-next-line: no-non-null-assertion
+            return this.autoComplete.setTypes(types);
+        };
+        /** Focuses the input. */
+        TheSeamGoogleMapsPlacesAutoCompleteComponent.prototype.focus = function () {
+            this._elementRef.nativeElement.focus();
+        };
+        /** Unfocuses the input. */
+        TheSeamGoogleMapsPlacesAutoCompleteComponent.prototype.blur = function () {
+            this._elementRef.nativeElement.blur();
+        };
+        TheSeamGoogleMapsPlacesAutoCompleteComponent.prototype.getHostElement = function () {
+            return this._elementRef.nativeElement;
+        };
+        TheSeamGoogleMapsPlacesAutoCompleteComponent.prototype._createPlaceChangedObservable = function () {
+            var _this = this;
+            var observable = new rxjs.Observable(function (subscriber) {
+                if (!_this.autoComplete) {
+                    _this._placeChangedPending.push({ observable: observable, subscriber: subscriber });
+                    return undefined;
+                }
+                var sub = _this._autoCompleteDirective.placeChanged.subscribe(subscriber);
+                return function () { return sub.unsubscribe(); };
+            });
+            return observable;
+        };
+        /** Asserts that the map has been initialized. */
+        TheSeamGoogleMapsPlacesAutoCompleteComponent.prototype._assertInitialized = function () {
+            if (!this.autoComplete && (typeof ngDevMode === 'undefined' || ngDevMode)) {
+                throw Error('Cannot access Google Map Places information before the API has been initialized. ' +
+                    'Please wait for the API to load before trying to interact with it.');
+            }
+        };
+        return TheSeamGoogleMapsPlacesAutoCompleteComponent;
+    }());
+    TheSeamGoogleMapsPlacesAutoCompleteComponent.decorators = [
+        { type: core.Component, args: [{
+                    selector: 'seam-google-maps-places-autocomplete',
+                    template: "<div *ngIf=\"icon\" class=\"search-container--icon-wrapper\">\n  <seam-icon [icon]=\"icon\" class=\"text-muted\" size=\"lg\"></seam-icon>\n</div>\n<label *ngIf=\"label || placeholder\" [attr.for]=\"inp.id\" class=\"sr-only\">{{ label || placeholder }}</label>\n<input #inp=\"seamInput\"\n  seamInput\n  seamGoogleMapsPlacesAutocomplete\n  [disabled]=\"disabled\"\n  [attr.placeholder]=\"placeholder\"\n  [attr.autocorrect]=\"autocorrect\"\n  [attr.autocapitalize]=\"autocapitalize\"\n  [options]=\"_options\"\n/>\n",
+                    changeDetection: core.ChangeDetectionStrategy.OnPush,
+                    exportAs: 'seamGoogleMapsPlacesAutoComplete',
+                    styles: [":host{position:relative;width:100%}:host>input{padding-left:40px}:host .search-container--icon-wrapper{position:absolute;top:6px;left:10px;bottom:0px}:host .search-container--icon-wrapper ::ng-deep .svg-inline--fa{vertical-align:middle}\n"]
+                },] }
+    ];
+    TheSeamGoogleMapsPlacesAutoCompleteComponent.ctorParameters = function () { return [
+        { type: core.ElementRef }
+    ]; };
+    TheSeamGoogleMapsPlacesAutoCompleteComponent.propDecorators = {
+        label: [{ type: core.Input }],
+        icon: [{ type: core.Input }],
+        disabled: [{ type: core.Input }],
+        placeholder: [{ type: core.Input }],
+        autocorrect: [{ type: core.Input }],
+        autocapitalize: [{ type: core.Input }],
+        tabIndex: [{ type: core.Input }],
+        options: [{ type: core.Input }],
+        placeChanged: [{ type: core.Output }],
+        _inputDirective: [{ type: core.ViewChild, args: ['inp', { read: formField.InputDirective, static: true },] }],
+        __autocompleteDirective: [{ type: core.ViewChild, args: [TheSeamGoogleMapsPlacesAutocompleteDirective, { static: true },] }],
+        _attrTabIndex: [{ type: core.HostBinding, args: ['attr.tabindex',] }],
+        _onClick: [{ type: core.HostListener, args: ['click', ['event'],] }],
+        _onFocus: [{ type: core.HostListener, args: ['focus', ['$event'],] }]
+    };
+    __decorate([
+        core$1.InputBoolean()
+    ], TheSeamGoogleMapsPlacesAutoCompleteComponent.prototype, "disabled", void 0);
+
+    var TheSeamMapsControlComponent = /** @class */ (function () {
+        function TheSeamMapsControlComponent(_googleMaps, _googleMapsControls) {
+            this._googleMaps = _googleMaps;
+            this._googleMapsControls = _googleMapsControls;
+            this._ngUnsubscribe = new rxjs.Subject();
+        }
+        Object.defineProperty(TheSeamMapsControlComponent.prototype, "def", {
+            set: function (value) {
+                if (value !== this._def) {
+                    this._remove();
+                    this._def = value;
+                }
+            },
+            enumerable: false,
+            configurable: true
+        });
+        /** @ignore */
+        TheSeamMapsControlComponent.prototype.ngOnInit = function () {
+            var _this = this;
+            this._googleMaps.mapReady$.pipe(operators.tap(function (ready) {
+                if (ready) {
+                    _this._add();
+                }
+                else {
+                    _this._remove();
+                }
+            }), operators.takeUntil(this._ngUnsubscribe)).subscribe();
+        };
+        /** @ignore */
+        TheSeamMapsControlComponent.prototype.ngOnDestroy = function () {
+            this._remove();
+            this._ngUnsubscribe.next();
+            this._ngUnsubscribe.complete();
+        };
+        TheSeamMapsControlComponent.prototype._add = function () {
+            if (this._controlRef) {
+                return;
+            }
+            if (this._def === null || this._def === undefined) {
+                return;
+            }
+            this._controlRef = this._googleMapsControls.add(this._def);
+        };
+        TheSeamMapsControlComponent.prototype._remove = function () {
+            var _a;
+            (_a = this._controlRef) === null || _a === void 0 ? void 0 : _a.destroy();
+            this._controlRef = undefined;
+        };
+        return TheSeamMapsControlComponent;
+    }());
+    TheSeamMapsControlComponent.decorators = [
+        { type: core.Component, args: [{
+                    selector: 'seam-map-control',
+                    template: '',
+                    changeDetection: core.ChangeDetectionStrategy.OnPush
+                },] }
+    ];
+    TheSeamMapsControlComponent.ctorParameters = function () { return [
+        { type: GoogleMapsService },
+        { type: GoogleMapsControlsService, decorators: [{ type: core.Inject, args: [MAP_CONTROLS_SERVICE,] }] }
+    ]; };
+    TheSeamMapsControlComponent.propDecorators = {
+        def: [{ type: core.Input }]
+    };
+
+    /**
+     *
+     */
+    var TheSeamMapFileDropComponent = /** @class */ (function () {
+        function TheSeamMapFileDropComponent(_elementRef, _ngZone, _googleMaps, _mapValueManager, _renderer) {
+            var _this = this;
+            this._elementRef = _elementRef;
+            this._ngZone = _ngZone;
+            this._googleMaps = _googleMaps;
+            this._mapValueManager = _mapValueManager;
+            this._renderer = _renderer;
+            this._ngUnsubscribe = new rxjs.Subject();
+            this._listeners = [];
+            this._globalDragInProgress = false;
+            this._handleDragOverEvent = function (event) {
+                if (!_this._dropAllowed()) {
+                    return;
+                }
+                if (!_this._isSupportedDataTransferTypes(event.dataTransfer)) {
+                    return;
+                }
+                event.preventDefault();
+                event.dataTransfer.dropEffect = 'copy';
+            };
+            this._handleDropEvent = function (event) {
+                if (!_this._dropAllowed()) {
+                    return;
+                }
+                event.preventDefault();
+                event.stopPropagation();
+                _this._renderer.setStyle(_this._elementRef.nativeElement, 'display', 'none');
+                // TODO: Show error if multiple files?
+                if (!_this._isSupportedDataTransfer(event.dataTransfer)) {
+                    return;
+                }
+                var item = event.dataTransfer.items[0];
+                var file = item.getAsFile();
+                utils.readGeoFile(file).then(function (json) {
+                    _this._mapValueManager.setValue(json, exports.MapValueSource.Input);
+                });
+            };
+            this._handleDragEnterEvent = function (event) {
+                if (!_this._dropAllowed()) {
+                    return;
+                }
+                if (!_this._isSupportedDataTransferTypes(event.dataTransfer)) {
+                    return;
+                }
+                _this._renderer.setStyle(_this._elementRef.nativeElement, 'display', 'block');
+            };
+            this._handleDragLeaveEvent = function (event) {
+                if (!_this._dropAllowed()) {
+                    return;
+                }
+                _this._renderer.setStyle(_this._elementRef.nativeElement, 'display', 'none');
+            };
+        }
+        /** @ignore */
+        TheSeamMapFileDropComponent.prototype.ngOnInit = function () {
+            var _this = this;
+            this._googleMaps.mapReady$.pipe(operators.tap(function (ready) {
+                if (ready) {
+                    _this._enableFileDrop();
+                }
+                else {
+                    _this._disableFileDrop();
+                }
+            }), operators.takeUntil(this._ngUnsubscribe)).subscribe();
+        };
+        /** @ignore */
+        TheSeamMapFileDropComponent.prototype.ngOnDestroy = function () {
+            this._disableFileDrop();
+            this._ngUnsubscribe.next();
+            this._ngUnsubscribe.complete();
+        };
+        TheSeamMapFileDropComponent.prototype._enableFileDrop = function () {
+            var _this = this;
+            var divElement = this._googleMaps.getDiv();
+            if (this._mapDiv === divElement) {
+                return;
+            }
+            if (this._mapDiv !== undefined) {
+                // Disable file drop on previous map div.
+                this._disableFileDrop();
+            }
+            this._mapDiv = divElement;
+            this._ngZone.runOutsideAngular(function () {
+                _this._listeners.push(_this._renderer.listen('document', 'dragstart', function (event) {
+                    _this._globalDragInProgress = true;
+                }));
+                _this._listeners.push(_this._renderer.listen('document', 'dragend', function (event) {
+                    _this._globalDragInProgress = false;
+                }));
+                _this._listeners.push(_this._renderer.listen(divElement, 'dragover', _this._handleDragOverEvent));
+                _this._listeners.push(_this._renderer.listen(_this._elementRef.nativeElement, 'dragover', _this._handleDragOverEvent));
+                _this._listeners.push(_this._renderer.listen(_this._elementRef.nativeElement, 'drop', _this._handleDropEvent));
+                _this._listeners.push(_this._renderer.listen(divElement, 'dragenter', _this._handleDragEnterEvent));
+                _this._listeners.push(_this._renderer.listen(_this._elementRef.nativeElement, 'dragleave', _this._handleDragLeaveEvent));
+            });
+        };
+        TheSeamMapFileDropComponent.prototype._disableFileDrop = function () {
+            if (this._listeners.length > 0) {
+                this._listeners.forEach(function (l) { return l(); });
+                this._listeners = [];
+            }
+        };
+        TheSeamMapFileDropComponent.prototype._dropAllowed = function () {
+            return !this._globalDragInProgress;
+        };
+        TheSeamMapFileDropComponent.prototype._isSupportedDataTransfer = function (dataTransfer) {
+            return dataTransfer.files.length === 1 && dataTransfer.types[0] === 'Files';
+        };
+        TheSeamMapFileDropComponent.prototype._isSupportedDataTransferTypes = function (dataTransfer) {
+            return dataTransfer.types[0] === 'Files';
+        };
+        return TheSeamMapFileDropComponent;
+    }());
+    TheSeamMapFileDropComponent.decorators = [
+        { type: core.Component, args: [{
+                    selector: 'seam-map-file-drop',
+                    template: "",
+                    changeDetection: core.ChangeDetectionStrategy.OnPush,
+                    styles: [":host{display:none;position:absolute;top:0;left:0;width:100%;height:100%;z-index:9999!important;background-color:#1e1e1eb3}\n"]
+                },] }
+    ];
+    TheSeamMapFileDropComponent.ctorParameters = function () { return [
+        { type: core.ElementRef },
+        { type: core.NgZone },
+        { type: GoogleMapsService },
+        { type: MapValueManagerService },
+        { type: core.Renderer2 }
+    ]; };
+
+    var TheSeamGoogleMapsModule = /** @class */ (function () {
+        function TheSeamGoogleMapsModule() {
+        }
+        return TheSeamGoogleMapsModule;
+    }());
+    TheSeamGoogleMapsModule.decorators = [
+        { type: core.NgModule, args: [{
+                    declarations: [
+                        TheSeamGoogleMapsComponent,
+                        TheSeamMapFileDropComponent,
+                        TheSeamGoogleMapsUploadButtonControlComponent,
+                        TheSeamGoogleMapsRecenterButtonControlComponent,
+                        TheSeamMapsControlComponent,
+                        TheSeamGoogleMapsPlacesAutocompleteDirective,
+                        TheSeamGoogleMapsPlacesAutoCompleteComponent,
+                    ],
+                    imports: [
+                        common.CommonModule,
+                        observers.ObserversModule,
+                        shared.TheSeamSharedModule,
+                        menu.TheSeamMenuModule,
+                        icon.TheSeamIconModule,
+                        formField.TheSeamFormFieldModule,
+                        core$2.AgmCoreModule,
+                    ],
+                    exports: [
+                        TheSeamGoogleMapsComponent,
+                        TheSeamGoogleMapsPlacesAutocompleteDirective,
+                        TheSeamGoogleMapsPlacesAutoCompleteComponent
+                    ]
+                },] }
+    ];
+
+    /**
+     * Generated bundle index. Do not edit.
+     */
+
+    exports.GoogleMapsContextMenu = GoogleMapsContextMenu;
+    exports.GoogleMapsControlsService = GoogleMapsControlsService;
+    exports.GoogleMapsService = GoogleMapsService;
+    exports.MapControlRef = MapControlRef;
+    exports.MapValueManagerService = MapValueManagerService;
+    exports.SEAM_GOOGLE_PLACES_AUTOCOMPLETE_DEFAULT_OPTIONS = SEAM_GOOGLE_PLACES_AUTOCOMPLETE_DEFAULT_OPTIONS;
+    exports.TheSeamGoogleMapsComponent = TheSeamGoogleMapsComponent;
+    exports.TheSeamGoogleMapsModule = TheSeamGoogleMapsModule;
+    exports.TheSeamGoogleMapsPlacesAutoCompleteComponent = TheSeamGoogleMapsPlacesAutoCompleteComponent;
+    exports.TheSeamGoogleMapsPlacesAutocompleteDirective = TheSeamGoogleMapsPlacesAutocompleteDirective;
+    exports.TheSeamGoogleMapsRecenterButtonControlComponent = TheSeamGoogleMapsRecenterButtonControlComponent;
+    exports.TheSeamGoogleMapsUploadButtonControlComponent = TheSeamGoogleMapsUploadButtonControlComponent;
+    exports.TheSeamMapFileDropComponent = TheSeamMapFileDropComponent;
+    exports.TheSeamMapsControlComponent = TheSeamMapsControlComponent;
+    exports.addInnerFeatureCutoutToExteriorFeature = addInnerFeatureCutoutToExteriorFeature;
+    exports.createDataFeatureFromPolygon = createDataFeatureFromPolygon;
+    exports.createFeatureChangeObservable = createFeatureChangeObservable;
+    exports.featureContains = featureContains;
+    exports.fixPathDifferentStartingAndEndingPoint = fixPathDifferentStartingAndEndingPoint;
+    exports.getBoundsWithAllFeatures = getBoundsWithAllFeatures;
+    exports.getFeatureBounds = getFeatureBounds;
+    exports.getFeatureCenter = getFeatureCenter;
+    exports.getFeaturesCount = getFeaturesCount;
+    exports.getPossibleExteriorFeature = getPossibleExteriorFeature;
+    exports.isAppFeatureProperty = isAppFeatureProperty;
+    exports.isFeatureSelected = isFeatureSelected;
+    exports.multiPolygonCoordinates = multiPolygonCoordinates;
+    exports.polygonCoordinates = polygonCoordinates;
+    exports.removeAllFeatures = removeAllFeatures;
+    exports.setFeatureSelected = setFeatureSelected;
+    exports.stripAppFeaturePropertiesFromJson = stripAppFeaturePropertiesFromJson;
+    exports.toTurfJsFeature = toTurfJsFeature;
+    exports.toTurfJsMultiPolygon = toTurfJsMultiPolygon;
+    exports.toTurfJsPolygon = toTurfJsPolygon;
+    exports["ɵ0"] = ɵ0;
+    exports["ɵb"] = MAP_CONTROLS_SERVICE;
+    exports["ɵc"] = MAP_CONTROL_DATA;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+//# sourceMappingURL=theseam-ui-common-google-maps.umd.js.map