function _typeof(t) {
	return (_typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(t) {
		return typeof t
	} : function(t) {
		return t && "function" == typeof Symbol && t.constructor === Symbol && t !== Symbol.prototype ?
			"symbol" : typeof t
	})(t)
}

function _classCallCheck(t, e) {
	if (!(t instanceof e)) throw new TypeError("Cannot call a class as a function")
}

function _defineProperties(t, e) {
	for (var o = 0; o < e.length; o++) {
		var r = e[o];
		r.enumerable = r.enumerable || !1, r.configurable = !0, "value" in r && (r.writable = !0), Object
			.defineProperty(t, r.key, r)
	}
}

function _createClass(t, e, o) {
	return e && _defineProperties(t.prototype, e), o && _defineProperties(t, o), t
}

function _inherits(t, e) {
	if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function");
	t.prototype = Object.create(e && e.prototype, {
		constructor: {
			value: t,
			writable: !0,
			configurable: !0
		}
	}), e && _setPrototypeOf(t, e)
}

function _setPrototypeOf(t, e) {
	return (_setPrototypeOf = Object.setPrototypeOf || function(t, e) {
		return t.__proto__ = e, t
	})(t, e)
}

function _createSuper(o) {
	var r = _isNativeReflectConstruct();
	return function() {
		var t, e = _getPrototypeOf(o);
		return _possibleConstructorReturn(this, r ? (t = _getPrototypeOf(this).constructor, Reflect.construct(e,
			arguments, t)) : e.apply(this, arguments))
	}
}

function _possibleConstructorReturn(t, e) {
	if (e && ("object" === _typeof(e) || "function" == typeof e)) return e;
	if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined");
	return _assertThisInitialized(t)
}

function _assertThisInitialized(t) {
	if (void 0 === t) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
	return t
}

function _isNativeReflectConstruct() {
	if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
	if (Reflect.construct.sham) return !1;
	if ("function" == typeof Proxy) return !0;
	try {
		return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {})), !0
	} catch (t) {
		return !1
	}
}

function _getPrototypeOf(t) {
	return (_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function(t) {
		return t.__proto__ || Object.getPrototypeOf(t)
	})(t)
}! function(o) {
	var t = function() {
		"use strict";
		_inherits(e, o.widget.BaseWidget);
		var t = _createSuper(e);

		function e() {
			return _classCallCheck(this, e), t.apply(this, arguments)
		}
		return _createClass(e, [{
			key: "create",
			value: function() {
				this.zommControl = new o.control.Zoom({
					insertIndex: 1,
					zoomInClass: "fa fa-plus",
					zoomOutClass: "fa fa-minus"
				})
			}
		}, {
			key: "activate",
			value: function() {
				this.map.addControl(this.zommControl)
			}
		}, {
			key: "disable",
			value: function() {
				this.map.removeControl(this.zommControl)
			}
		}]), e
	}();
	o.widget.bindClass(t)
}((window, mars3d));