initialHEADmaster

1 files changed, 2098 insertions, 0 deletions

diff --git a/node_modules/pigeon-maps/lib/index.cjs.js b/node_modules/pigeon-maps/lib/index.cjs.js
new file mode 100644
index 0000000..68c2721
--- /dev/null
+++ b/node_modules/pigeon-maps/lib/index.cjs.js
@@ -0,0 +1,2098 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    enumerableOnly && (symbols = symbols.filter(function (sym) {
+      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+    })), keys.push.apply(keys, symbols);
+  }
+
+  return keys;
+}
+
+function _objectSpread2(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = null != arguments[i] ? arguments[i] : {};
+    i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {
+      _defineProperty(target, key, source[key]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {
+      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
+  }
+
+  return target;
+}
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+
+  return obj;
+}
+
+function _inheritsLoose(subClass, superClass) {
+  subClass.prototype = Object.create(superClass.prototype);
+  subClass.prototype.constructor = subClass;
+
+  _setPrototypeOf(subClass, superClass);
+}
+
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+
+  return _setPrototypeOf(o, p);
+}
+
+function _assertThisInitialized(self) {
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+
+  return self;
+}
+
+function debounce(func, wait) {
+  var timeout;
+  return function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    var context = this;
+    clearTimeout(timeout);
+    timeout = setTimeout(function () {
+      return func.apply(context, args);
+    }, wait);
+  };
+}
+function parentHasClass(element, className) {
+  while (element) {
+    if (element.classList && element.classList.contains(className)) {
+      return true;
+    }
+
+    element = element.parentElement;
+  }
+
+  return false;
+}
+function parentPosition(element) {
+  var rect = element.getBoundingClientRect();
+  return {
+    x: rect.left,
+    y: rect.top
+  };
+}
+
+function osm(x, y, z) {
+  return "https://tile.openstreetmap.org/" + z + "/" + x + "/" + y + ".png";
+}
+
+var ANIMATION_TIME = 300;
+var DIAGONAL_THROW_TIME = 1500;
+var SCROLL_PIXELS_FOR_ZOOM_LEVEL = 150;
+var MIN_DRAG_FOR_THROW = 40;
+var CLICK_TOLERANCE = 2;
+var DOUBLE_CLICK_DELAY = 300;
+var DEBOUNCE_DELAY = 60;
+var PINCH_RELEASE_THROW_DELAY = 300;
+var WARNING_DISPLAY_TIMEOUT = 300;
+
+var NOOP = function NOOP() {
+  return true;
+};
+
+var lng2tile = function lng2tile(lon, zoom) {
+  return (lon + 180) / 360 * Math.pow(2, zoom);
+};
+
+var lat2tile = function lat2tile(lat, zoom) {
+  return (1 - Math.log(Math.tan(lat * Math.PI / 180) + 1 / Math.cos(lat * Math.PI / 180)) / Math.PI) / 2 * Math.pow(2, zoom);
+};
+
+function tile2lng(x, z) {
+  return x / Math.pow(2, z) * 360 - 180;
+}
+
+function tile2lat(y, z) {
+  var n = Math.PI - 2 * Math.PI * y / Math.pow(2, z);
+  return 180 / Math.PI * Math.atan(0.5 * (Math.exp(n) - Math.exp(-n)));
+}
+
+function getMousePixel(dom, event) {
+  var parent = parentPosition(dom);
+  return [event.clientX - parent.x, event.clientY - parent.y];
+}
+
+function easeOutQuad(t) {
+  return t * (2 - t);
+}
+
+var absoluteMinMax = [tile2lat(Math.pow(2, 10), 10), tile2lat(0, 10), tile2lng(0, 10), tile2lng(Math.pow(2, 10), 10)];
+var hasWindow = typeof window !== 'undefined';
+var performanceNow = hasWindow && window.performance && window.performance.now ? function () {
+  return window.performance.now();
+} : function () {
+  var timeStart = new Date().getTime();
+  return function () {
+    return new Date().getTime() - timeStart;
+  };
+}();
+
+var requestAnimationFrame = function requestAnimationFrame(callback) {
+  if (hasWindow) {
+    return (window.requestAnimationFrame || window.setTimeout)(callback);
+  } else {
+    callback(new Date().getTime());
+    return null;
+  }
+};
+
+var cancelAnimationFrame = function cancelAnimationFrame(animFrame) {
+  return hasWindow && animFrame ? (window.cancelAnimationFrame || window.clearTimeout)(animFrame) : false;
+};
+
+function srcSet(dprs, url, x, y, z) {
+  if (!dprs || dprs.length === 0) {
+    return '';
+  }
+
+  return dprs.map(function (dpr) {
+    return url(x, y, z, dpr) + (dpr === 1 ? '' : " " + dpr + "x");
+  }).join(', ');
+}
+
+var ImgTile = function ImgTile(_ref) {
+  var tile = _ref.tile,
+      tileLoaded = _ref.tileLoaded;
+  return /*#__PURE__*/React__default["default"].createElement("img", {
+    src: tile.url,
+    srcSet: tile.srcSet,
+    width: tile.width,
+    height: tile.height,
+    loading: 'lazy',
+    onLoad: tileLoaded,
+    alt: '',
+    style: {
+      position: 'absolute',
+      left: tile.left,
+      top: tile.top,
+      willChange: 'transform',
+      transformOrigin: 'top left',
+      opacity: 1
+    }
+  });
+};
+
+var Map = /*#__PURE__*/function (_Component) {
+  _inheritsLoose(Map, _Component);
+
+  function Map(props) {
+    var _ref2, _props$defaultZoom, _ref3, _props$defaultCenter, _ref4, _props$width, _ref5, _props$height;
+
+    var _this;
+
+    _this = _Component.call(this, props) || this;
+
+    _defineProperty(_assertThisInitialized(_this), "_containerRef", void 0);
+
+    _defineProperty(_assertThisInitialized(_this), "_mousePosition", void 0);
+
+    _defineProperty(_assertThisInitialized(_this), "_loadTracker", void 0);
+
+    _defineProperty(_assertThisInitialized(_this), "_dragStart", null);
+
+    _defineProperty(_assertThisInitialized(_this), "_mouseDown", false);
+
+    _defineProperty(_assertThisInitialized(_this), "_moveEvents", []);
+
+    _defineProperty(_assertThisInitialized(_this), "_lastClick", null);
+
+    _defineProperty(_assertThisInitialized(_this), "_lastTap", null);
+
+    _defineProperty(_assertThisInitialized(_this), "_lastWheel", null);
+
+    _defineProperty(_assertThisInitialized(_this), "_touchStartPixel", null);
+
+    _defineProperty(_assertThisInitialized(_this), "_touchStartMidPoint", null);
+
+    _defineProperty(_assertThisInitialized(_this), "_touchStartDistance", null);
+
+    _defineProperty(_assertThisInitialized(_this), "_secondTouchEnd", null);
+
+    _defineProperty(_assertThisInitialized(_this), "_warningClearTimeout", null);
+
+    _defineProperty(_assertThisInitialized(_this), "_isAnimating", false);
+
+    _defineProperty(_assertThisInitialized(_this), "_animationStart", null);
+
+    _defineProperty(_assertThisInitialized(_this), "_animationEnd", null);
+
+    _defineProperty(_assertThisInitialized(_this), "_zoomStart", null);
+
+    _defineProperty(_assertThisInitialized(_this), "_centerTarget", null);
+
+    _defineProperty(_assertThisInitialized(_this), "_zoomTarget", null);
+
+    _defineProperty(_assertThisInitialized(_this), "_zoomAround", null);
+
+    _defineProperty(_assertThisInitialized(_this), "_animFrame", null);
+
+    _defineProperty(_assertThisInitialized(_this), "_boundsSynced", false);
+
+    _defineProperty(_assertThisInitialized(_this), "_minMaxCache", null);
+
+    _defineProperty(_assertThisInitialized(_this), "_lastZoom", void 0);
+
+    _defineProperty(_assertThisInitialized(_this), "_lastCenter", void 0);
+
+    _defineProperty(_assertThisInitialized(_this), "_centerStart", void 0);
+
+    _defineProperty(_assertThisInitialized(_this), "_resizeObserver", null);
+
+    _defineProperty(_assertThisInitialized(_this), "updateWidthHeight", function () {
+      if (_this._containerRef) {
+        var rect = _this._containerRef.getBoundingClientRect();
+
+        if (rect && rect.width > 0 && rect.height > 0) {
+          _this.setState({
+            width: rect.width,
+            height: rect.height
+          });
+
+          return true;
+        }
+      }
+
+      return false;
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "wa", function () {
+      var _window;
+
+      return (_window = window).addEventListener.apply(_window, arguments);
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "wr", function () {
+      var _window2;
+
+      return (_window2 = window).removeEventListener.apply(_window2, arguments);
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "bindMouseEvents", function () {
+      _this.wa('mousedown', _this.handleMouseDown);
+
+      _this.wa('mouseup', _this.handleMouseUp);
+
+      _this.wa('mousemove', _this.handleMouseMove);
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "bindTouchEvents", function () {
+      _this.wa('touchstart', _this.handleTouchStart, {
+        passive: false
+      });
+
+      _this.wa('touchmove', _this.handleTouchMove, {
+        passive: false
+      });
+
+      _this.wa('touchend', _this.handleTouchEnd, {
+        passive: false
+      });
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "unbindMouseEvents", function () {
+      _this.wr('mousedown', _this.handleMouseDown);
+
+      _this.wr('mouseup', _this.handleMouseUp);
+
+      _this.wr('mousemove', _this.handleMouseMove);
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "unbindTouchEvents", function () {
+      _this.wr('touchstart', _this.handleTouchStart);
+
+      _this.wr('touchmove', _this.handleTouchMove);
+
+      _this.wr('touchend', _this.handleTouchEnd);
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "bindResizeEvent", function () {
+      _this.wa('resize', _this.updateWidthHeight);
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "unbindResizeEvent", function () {
+      _this.wr('resize', _this.updateWidthHeight);
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "bindWheelEvent", function () {
+      if (_this._containerRef) {
+        _this._containerRef.addEventListener('wheel', _this.handleWheel, {
+          passive: false
+        });
+      }
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "unbindWheelEvent", function () {
+      if (_this._containerRef) {
+        _this._containerRef.removeEventListener('wheel', _this.handleWheel);
+      }
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "setCenterZoomTarget", function (center, zoom, fromProps, zoomAround, animationDuration) {
+      if (fromProps === void 0) {
+        fromProps = false;
+      }
+
+      if (zoomAround === void 0) {
+        zoomAround = null;
+      }
+
+      if (animationDuration === void 0) {
+        animationDuration = ANIMATION_TIME;
+      }
+
+      if (_this.props.animate && (!fromProps || _this.distanceInScreens(center, zoom, _this.state.center, _this.state.zoom) <= _this.props.animateMaxScreens)) {
+        if (_this._isAnimating) {
+          cancelAnimationFrame(_this._animFrame);
+
+          var _this$animationStep = _this.animationStep(performanceNow()),
+              centerStep = _this$animationStep.centerStep,
+              zoomStep = _this$animationStep.zoomStep;
+
+          _this._centerStart = centerStep;
+          _this._zoomStart = zoomStep;
+        } else {
+          _this._isAnimating = true;
+          _this._centerStart = _this.limitCenterAtZoom([_this._lastCenter[0], _this._lastCenter[1]], _this._lastZoom);
+          _this._zoomStart = _this._lastZoom;
+
+          _this.onAnimationStart();
+        }
+
+        _this._animationStart = performanceNow();
+        _this._animationEnd = _this._animationStart + animationDuration;
+
+        if (zoomAround) {
+          _this._zoomAround = zoomAround;
+          _this._centerTarget = _this.calculateZoomCenter(_this._lastCenter, zoomAround, _this._lastZoom, zoom);
+        } else {
+          _this._zoomAround = null;
+          _this._centerTarget = center;
+        }
+
+        _this._zoomTarget = zoom;
+        _this._animFrame = requestAnimationFrame(_this.animate);
+      } else {
+        _this.stopAnimating();
+
+        if (zoomAround) {
+          var _center = _this.calculateZoomCenter(_this._lastCenter, zoomAround, _this._lastZoom, zoom);
+
+          _this.setCenterZoom(_center, zoom, fromProps);
+        } else {
+          _this.setCenterZoom(center || _this.state.center, zoom, fromProps);
+        }
+      }
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "setCenterZoomForChildren", function (center, zoom) {
+      _this.setCenterZoomTarget(center || _this.state.center, zoom || _this.state.zoom, true);
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "distanceInScreens", function (centerTarget, zoomTarget, center, zoom) {
+      var _this$state = _this.state,
+          width = _this$state.width,
+          height = _this$state.height;
+
+      var l1 = _this.latLngToPixel(center, center, zoom);
+
+      var l2 = _this.latLngToPixel(centerTarget, center, zoom);
+
+      var z1 = _this.latLngToPixel(center, center, zoomTarget);
+
+      var z2 = _this.latLngToPixel(centerTarget, center, zoomTarget);
+
+      var w = (Math.abs(l1[0] - l2[0]) + Math.abs(z1[0] - z2[0])) / 2 / width;
+      var h = (Math.abs(l1[1] - l2[1]) + Math.abs(z1[1] - z2[1])) / 2 / height;
+      return Math.sqrt(w * w + h * h);
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "animationStep", function (timestamp) {
+      if (!_this._animationEnd || !_this._animationStart || !_this._zoomTarget || !_this._zoomStart || !_this._centerStart || !_this._centerTarget) {
+        return {
+          centerStep: _this.state.center,
+          zoomStep: _this.state.zoom
+        };
+      }
+
+      var length = _this._animationEnd - _this._animationStart;
+      var progress = Math.max(timestamp - _this._animationStart, 0);
+      var percentage = easeOutQuad(progress / length);
+      var zoomDiff = (_this._zoomTarget - _this._zoomStart) * percentage;
+      var zoomStep = _this._zoomStart + zoomDiff;
+
+      if (_this._zoomAround) {
+        var centerStep = _this.calculateZoomCenter(_this._centerStart, _this._zoomAround, _this._zoomStart, zoomStep);
+
+        return {
+          centerStep: centerStep,
+          zoomStep: zoomStep
+        };
+      } else {
+        var _centerStep = [_this._centerStart[0] + (_this._centerTarget[0] - _this._centerStart[0]) * percentage, _this._centerStart[1] + (_this._centerTarget[1] - _this._centerStart[1]) * percentage];
+        return {
+          centerStep: _centerStep,
+          zoomStep: zoomStep
+        };
+      }
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "animate", function (timestamp) {
+      if (!_this._animationEnd || timestamp >= _this._animationEnd) {
+        _this._isAnimating = false;
+
+        _this.setCenterZoom(_this._centerTarget, _this._zoomTarget, true);
+
+        _this.onAnimationStop();
+      } else {
+        var _this$animationStep2 = _this.animationStep(timestamp),
+            centerStep = _this$animationStep2.centerStep,
+            zoomStep = _this$animationStep2.zoomStep;
+
+        _this.setCenterZoom(centerStep, zoomStep);
+
+        _this._animFrame = requestAnimationFrame(_this.animate);
+      }
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "stopAnimating", function () {
+      if (_this._isAnimating) {
+        _this._isAnimating = false;
+
+        _this.onAnimationStop();
+
+        cancelAnimationFrame(_this._animFrame);
+      }
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "limitCenterAtZoom", function (center, zoom) {
+      var minMax = _this.getBoundsMinMax(zoom || _this.state.zoom);
+
+      return [Math.max(Math.min(!center || isNaN(center[0]) ? _this.state.center[0] : center[0], minMax[1]), minMax[0]), Math.max(Math.min(!center || isNaN(center[1]) ? _this.state.center[1] : center[1], minMax[3]), minMax[2])];
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "onAnimationStart", function () {
+      _this.props.onAnimationStart && _this.props.onAnimationStart();
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "onAnimationStop", function () {
+      _this.props.onAnimationStop && _this.props.onAnimationStop();
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "setCenterZoom", function (center, zoom, animationEnded) {
+      if (animationEnded === void 0) {
+        animationEnded = false;
+      }
+
+      var limitedCenter = _this.limitCenterAtZoom(center, zoom);
+
+      if (zoom && Math.round(_this.state.zoom) !== Math.round(zoom)) {
+        var tileValues = _this.tileValues(_this.state);
+
+        var nextValues = _this.tileValues({
+          center: limitedCenter,
+          zoom: zoom,
+          width: _this.state.width,
+          height: _this.state.height
+        });
+
+        var oldTiles = _this.state.oldTiles;
+
+        _this.setState({
+          oldTiles: oldTiles.filter(function (o) {
+            return o.roundedZoom !== tileValues.roundedZoom;
+          }).concat(tileValues)
+        }, NOOP);
+
+        var loadTracker = {};
+
+        for (var x = nextValues.tileMinX; x <= nextValues.tileMaxX; x++) {
+          for (var y = nextValues.tileMinY; y <= nextValues.tileMaxY; y++) {
+            var key = x + "-" + y + "-" + nextValues.roundedZoom;
+            loadTracker[key] = false;
+          }
+        }
+
+        _this._loadTracker = loadTracker;
+      }
+
+      _this.setState({
+        center: limitedCenter,
+        zoom: zoom || _this.state.zoom
+      }, NOOP);
+
+      var maybeZoom = _this.props.zoom ? _this.props.zoom : _this._lastZoom;
+      var maybeCenter = _this.props.center ? _this.props.center : _this._lastCenter;
+
+      if (zoom && (animationEnded || Math.abs(maybeZoom - zoom) > 0.001 || Math.abs(maybeCenter[0] - limitedCenter[0]) > 0.00001 || Math.abs(maybeCenter[1] - limitedCenter[1]) > 0.00001)) {
+        _this._lastZoom = zoom;
+        _this._lastCenter = [].concat(limitedCenter);
+
+        _this.syncToProps(limitedCenter, zoom);
+      }
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "getBoundsMinMax", function (zoom) {
+      if (_this.props.limitBounds === 'center') {
+        return absoluteMinMax;
+      }
+
+      var _this$state2 = _this.state,
+          width = _this$state2.width,
+          height = _this$state2.height;
+
+      if (_this._minMaxCache && _this._minMaxCache[0] === zoom && _this._minMaxCache[1] === width && _this._minMaxCache[2] === height) {
+        return _this._minMaxCache[3];
+      }
+
+      var pixelsAtZoom = Math.pow(2, zoom) * 256;
+      var minLng = width > pixelsAtZoom ? 0 : tile2lng(width / 512, zoom);
+      var minLat = height > pixelsAtZoom ? 0 : tile2lat(Math.pow(2, zoom) - height / 512, zoom);
+      var maxLng = width > pixelsAtZoom ? 0 : tile2lng(Math.pow(2, zoom) - width / 512, zoom);
+      var maxLat = height > pixelsAtZoom ? 0 : tile2lat(height / 512, zoom);
+      var minMax = [minLat, maxLat, minLng, maxLng];
+      _this._minMaxCache = [zoom, width, height, minMax];
+      return minMax;
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "tileLoaded", function (key) {
+      if (_this._loadTracker && key in _this._loadTracker) {
+        _this._loadTracker[key] = true;
+        var unloadedCount = Object.values(_this._loadTracker).filter(function (v) {
+          return !v;
+        }).length;
+
+        if (unloadedCount === 0) {
+          _this.setState({
+            oldTiles: []
+          }, NOOP);
+        }
+      }
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "handleTouchStart", function (event) {
+      if (!_this._containerRef) {
+        return;
+      }
+
+      if (event.target && parentHasClass(event.target, 'pigeon-drag-block')) {
+        return;
+      }
+
+      if (event.touches.length === 1) {
+        var touch = event.touches[0];
+        var pixel = getMousePixel(_this._containerRef, touch);
+
+        if (_this.coordsInside(pixel)) {
+          _this._touchStartPixel = [pixel];
+
+          if (!_this.props.twoFingerDrag) {
+            _this.stopAnimating();
+
+            if (_this._lastTap && performanceNow() - _this._lastTap < DOUBLE_CLICK_DELAY) {
+              event.preventDefault();
+
+              var latLngNow = _this.pixelToLatLng(_this._touchStartPixel[0]);
+
+              _this.setCenterZoomTarget(null, Math.max(_this.props.minZoom, Math.min(_this.state.zoom + 1, _this.props.maxZoom)), false, latLngNow);
+            } else {
+              _this._lastTap = performanceNow();
+
+              _this.trackMoveEvents(pixel);
+            }
+          }
+        }
+      } else if (event.touches.length === 2 && _this._touchStartPixel) {
+        event.preventDefault();
+
+        _this.stopTrackingMoveEvents();
+
+        if (_this.state.pixelDelta || _this.state.zoomDelta) {
+          _this.sendDeltaChange();
+        }
+
+        var t1 = getMousePixel(_this._containerRef, event.touches[0]);
+        var t2 = getMousePixel(_this._containerRef, event.touches[1]);
+        _this._touchStartPixel = [t1, t2];
+        _this._touchStartMidPoint = [(t1[0] + t2[0]) / 2, (t1[1] + t2[1]) / 2];
+        _this._touchStartDistance = Math.sqrt(Math.pow(t1[0] - t2[0], 2) + Math.pow(t1[1] - t2[1], 2));
+      }
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "handleTouchMove", function (event) {
+      if (!_this._containerRef) {
+        _this._touchStartPixel = null;
+        return;
+      }
+
+      if (event.touches.length === 1 && _this._touchStartPixel) {
+        var touch = event.touches[0];
+        var pixel = getMousePixel(_this._containerRef, touch);
+
+        if (_this.props.twoFingerDrag) {
+          if (_this.coordsInside(pixel)) {
+            _this.showWarning('fingers');
+          }
+        } else {
+          event.preventDefault();
+
+          _this.trackMoveEvents(pixel);
+
+          _this.setState({
+            pixelDelta: [pixel[0] - _this._touchStartPixel[0][0], pixel[1] - _this._touchStartPixel[0][1]]
+          }, NOOP);
+        }
+      } else if (event.touches.length === 2 && _this._touchStartPixel && _this._touchStartMidPoint && _this._touchStartDistance) {
+        var _this$state3 = _this.state,
+            width = _this$state3.width,
+            height = _this$state3.height,
+            zoom = _this$state3.zoom;
+        event.preventDefault();
+        var t1 = getMousePixel(_this._containerRef, event.touches[0]);
+        var t2 = getMousePixel(_this._containerRef, event.touches[1]);
+        var midPoint = [(t1[0] + t2[0]) / 2, (t1[1] + t2[1]) / 2];
+        var midPointDiff = [midPoint[0] - _this._touchStartMidPoint[0], midPoint[1] - _this._touchStartMidPoint[1]];
+        var distance = Math.sqrt(Math.pow(t1[0] - t2[0], 2) + Math.pow(t1[1] - t2[1], 2));
+        var zoomDelta = Math.max(_this.props.minZoom, Math.min(_this.props.maxZoom, zoom + Math.log2(distance / _this._touchStartDistance))) - zoom;
+        var scale = Math.pow(2, zoomDelta);
+        var centerDiffDiff = [(width / 2 - midPoint[0]) * (scale - 1), (height / 2 - midPoint[1]) * (scale - 1)];
+
+        _this.setState({
+          zoomDelta: zoomDelta,
+          pixelDelta: [centerDiffDiff[0] + midPointDiff[0] * scale, centerDiffDiff[1] + midPointDiff[1] * scale]
+        }, NOOP);
+      }
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "handleTouchEnd", function (event) {
+      if (!_this._containerRef) {
+        _this._touchStartPixel = null;
+        return;
+      }
+
+      if (_this._touchStartPixel) {
+        var _this$props = _this.props,
+            zoomSnap = _this$props.zoomSnap,
+            twoFingerDrag = _this$props.twoFingerDrag,
+            minZoom = _this$props.minZoom,
+            maxZoom = _this$props.maxZoom;
+        var zoomDelta = _this.state.zoomDelta;
+
+        var _this$sendDeltaChange = _this.sendDeltaChange(),
+            center = _this$sendDeltaChange.center,
+            zoom = _this$sendDeltaChange.zoom;
+
+        if (event.touches.length === 0) {
+          if (twoFingerDrag) {
+            _this.clearWarning();
+          } else {
+            var oldTouchPixel = _this._touchStartPixel[0];
+            var newTouchPixel = getMousePixel(_this._containerRef, event.changedTouches[0]);
+
+            if (Math.abs(oldTouchPixel[0] - newTouchPixel[0]) > CLICK_TOLERANCE || Math.abs(oldTouchPixel[1] - newTouchPixel[1]) > CLICK_TOLERANCE) {
+              if (!_this._secondTouchEnd || performanceNow() - _this._secondTouchEnd > PINCH_RELEASE_THROW_DELAY) {
+                event.preventDefault();
+
+                _this.throwAfterMoving(newTouchPixel, center, zoom);
+              }
+            }
+
+            _this._touchStartPixel = null;
+            _this._secondTouchEnd = null;
+          }
+        } else if (event.touches.length === 1) {
+          event.preventDefault();
+          var touch = getMousePixel(_this._containerRef, event.touches[0]);
+          _this._secondTouchEnd = performanceNow();
+          _this._touchStartPixel = [touch];
+
+          _this.trackMoveEvents(touch);
+
+          if (zoomSnap) {
+            var latLng = _this._touchStartMidPoint ? _this.pixelToLatLng(_this._touchStartMidPoint) : _this.state.center;
+            var zoomTarget;
+
+            if (twoFingerDrag && Math.round(_this.state.zoom) === Math.round(_this.state.zoom + zoomDelta)) {
+              zoomTarget = Math.round(_this.state.zoom);
+            } else {
+              zoomTarget = zoomDelta > 0 ? Math.ceil(_this.state.zoom) : Math.floor(_this.state.zoom);
+            }
+
+            var _zoom = Math.max(minZoom, Math.min(zoomTarget, maxZoom));
+
+            _this.setCenterZoomTarget(latLng, _zoom, false, latLng);
+          }
+        }
+      }
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "handleMouseDown", function (event) {
+      if (!_this._containerRef) {
+        return;
+      }
+
+      var pixel = getMousePixel(_this._containerRef, event);
+
+      if (event.button === 0 && (!event.target || !parentHasClass(event.target, 'pigeon-drag-block')) && _this.coordsInside(pixel)) {
+        _this.stopAnimating();
+
+        event.preventDefault();
+
+        if (_this._lastClick && performanceNow() - _this._lastClick < DOUBLE_CLICK_DELAY) {
+          if (!parentHasClass(event.target, 'pigeon-click-block')) {
+            var latLngNow = _this.pixelToLatLng(_this._mousePosition || pixel);
+
+            _this.setCenterZoomTarget(null, Math.max(_this.props.minZoom, Math.min(_this.state.zoom + 1, _this.props.maxZoom)), false, latLngNow);
+          }
+        } else {
+          _this._lastClick = performanceNow();
+          _this._mouseDown = true;
+          _this._dragStart = pixel;
+
+          _this.trackMoveEvents(pixel);
+        }
+      }
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "handleMouseMove", function (event) {
+      if (!_this._containerRef) {
+        return;
+      }
+
+      _this._mousePosition = getMousePixel(_this._containerRef, event);
+
+      if (_this._mouseDown && _this._dragStart) {
+        _this.trackMoveEvents(_this._mousePosition);
+
+        _this.setState({
+          pixelDelta: [_this._mousePosition[0] - _this._dragStart[0], _this._mousePosition[1] - _this._dragStart[1]]
+        }, NOOP);
+      }
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "handleMouseUp", function (event) {
+      if (!_this._containerRef) {
+        _this._mouseDown = false;
+        return;
+      }
+
+      var pixelDelta = _this.state.pixelDelta;
+
+      if (_this._mouseDown) {
+        _this._mouseDown = false;
+        var pixel = getMousePixel(_this._containerRef, event);
+
+        if (_this.props.onClick && (!event.target || !parentHasClass(event.target, 'pigeon-click-block')) && (!pixelDelta || Math.abs(pixelDelta[0]) + Math.abs(pixelDelta[1]) <= CLICK_TOLERANCE)) {
+          var latLng = _this.pixelToLatLng(pixel);
+
+          _this.props.onClick({
+            event: event,
+            latLng: latLng,
+            pixel: pixel
+          });
+
+          _this.setState({
+            pixelDelta: undefined
+          }, NOOP);
+        } else {
+          var _this$sendDeltaChange2 = _this.sendDeltaChange(),
+              center = _this$sendDeltaChange2.center,
+              zoom = _this$sendDeltaChange2.zoom;
+
+          _this.throwAfterMoving(pixel, center, zoom);
+        }
+      }
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "stopTrackingMoveEvents", function () {
+      _this._moveEvents = [];
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "trackMoveEvents", function (coords) {
+      var timestamp = performanceNow();
+
+      if (_this._moveEvents.length === 0 || timestamp - _this._moveEvents[_this._moveEvents.length - 1].timestamp > 40) {
+        _this._moveEvents.push({
+          timestamp: timestamp,
+          coords: coords
+        });
+
+        if (_this._moveEvents.length > 2) {
+          _this._moveEvents.shift();
+        }
+      }
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "throwAfterMoving", function (coords, center, zoom) {
+      var _this$state4 = _this.state,
+          width = _this$state4.width,
+          height = _this$state4.height;
+      var animate = _this.props.animate;
+      var timestamp = performanceNow();
+
+      var lastEvent = _this._moveEvents.shift();
+
+      if (lastEvent && animate) {
+        var deltaMs = Math.max(timestamp - lastEvent.timestamp, 1);
+        var delta = [(coords[0] - lastEvent.coords[0]) / deltaMs * 120, (coords[1] - lastEvent.coords[1]) / deltaMs * 120];
+        var distance = Math.sqrt(delta[0] * delta[0] + delta[1] * delta[1]);
+
+        if (distance > MIN_DRAG_FOR_THROW) {
+          var diagonal = Math.sqrt(width * width + height * height);
+          var throwTime = DIAGONAL_THROW_TIME * distance / diagonal;
+          var lng = tile2lng(lng2tile(center[1], zoom) - delta[0] / 256.0, zoom);
+          var lat = tile2lat(lat2tile(center[0], zoom) - delta[1] / 256.0, zoom);
+
+          _this.setCenterZoomTarget([lat, lng], zoom, false, null, throwTime);
+        }
+      }
+
+      _this.stopTrackingMoveEvents();
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "sendDeltaChange", function () {
+      var _this$state5 = _this.state,
+          center = _this$state5.center,
+          zoom = _this$state5.zoom,
+          pixelDelta = _this$state5.pixelDelta,
+          zoomDelta = _this$state5.zoomDelta;
+      var lat = center[0];
+      var lng = center[1];
+
+      if (pixelDelta || zoomDelta !== 0) {
+        lng = tile2lng(lng2tile(center[1], zoom + zoomDelta) - (pixelDelta ? pixelDelta[0] / 256.0 : 0), zoom + zoomDelta);
+        lat = tile2lat(lat2tile(center[0], zoom + zoomDelta) - (pixelDelta ? pixelDelta[1] / 256.0 : 0), zoom + zoomDelta);
+
+        _this.setCenterZoom([lat, lng], zoom + zoomDelta);
+      }
+
+      _this.setState({
+        pixelDelta: undefined,
+        zoomDelta: 0
+      }, NOOP);
+
+      return {
+        center: _this.limitCenterAtZoom([lat, lng], zoom + zoomDelta),
+        zoom: zoom + zoomDelta
+      };
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "getBounds", function (center, zoom) {
+      if (center === void 0) {
+        center = _this.state.center;
+      }
+
+      if (zoom === void 0) {
+        zoom = _this.zoomPlusDelta();
+      }
+
+      var _this$state6 = _this.state,
+          width = _this$state6.width,
+          height = _this$state6.height;
+      return {
+        ne: _this.pixelToLatLng([width - 1, 0], center, zoom),
+        sw: _this.pixelToLatLng([0, height - 1], center, zoom)
+      };
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "syncToProps", function (center, zoom) {
+      if (center === void 0) {
+        center = _this.state.center;
+      }
+
+      if (zoom === void 0) {
+        zoom = _this.state.zoom;
+      }
+
+      var onBoundsChanged = _this.props.onBoundsChanged;
+
+      if (onBoundsChanged) {
+        var bounds = _this.getBounds(center, zoom);
+
+        onBoundsChanged({
+          center: center,
+          zoom: zoom,
+          bounds: bounds,
+          initial: !_this._boundsSynced
+        });
+        _this._boundsSynced = true;
+      }
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "handleWheel", function (event) {
+      var _this$props2 = _this.props,
+          mouseEvents = _this$props2.mouseEvents,
+          metaWheelZoom = _this$props2.metaWheelZoom,
+          zoomSnap = _this$props2.zoomSnap,
+          animate = _this$props2.animate;
+
+      if (!mouseEvents) {
+        return;
+      }
+
+      if (!metaWheelZoom || event.metaKey || event.ctrlKey) {
+        event.preventDefault();
+        var addToZoom = -event.deltaY / SCROLL_PIXELS_FOR_ZOOM_LEVEL;
+
+        if (!zoomSnap && _this._zoomTarget) {
+          var stillToAdd = _this._zoomTarget - _this.state.zoom;
+
+          _this.zoomAroundMouse(addToZoom + stillToAdd, event);
+        } else {
+          if (animate) {
+            _this.zoomAroundMouse(addToZoom, event);
+          } else {
+            if (!_this._lastWheel || performanceNow() - _this._lastWheel > ANIMATION_TIME) {
+              _this._lastWheel = performanceNow();
+
+              _this.zoomAroundMouse(addToZoom, event);
+            }
+          }
+        }
+      } else {
+        _this.showWarning('wheel');
+      }
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "showWarning", function (warningType) {
+      if (!_this.state.showWarning || _this.state.warningType !== warningType) {
+        _this.setState({
+          showWarning: true,
+          warningType: warningType
+        });
+      }
+
+      if (_this._warningClearTimeout) {
+        window.clearTimeout(_this._warningClearTimeout);
+      }
+
+      _this._warningClearTimeout = window.setTimeout(_this.clearWarning, WARNING_DISPLAY_TIMEOUT);
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "clearWarning", function () {
+      if (_this.state.showWarning) {
+        _this.setState({
+          showWarning: false
+        });
+      }
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "zoomAroundMouse", function (zoomDiff, event) {
+      if (!_this._containerRef) {
+        return;
+      }
+
+      var zoom = _this.state.zoom;
+      var _this$props3 = _this.props,
+          minZoom = _this$props3.minZoom,
+          maxZoom = _this$props3.maxZoom,
+          zoomSnap = _this$props3.zoomSnap;
+      _this._mousePosition = getMousePixel(_this._containerRef, event);
+
+      if (!_this._mousePosition || zoom === minZoom && zoomDiff < 0 || zoom === maxZoom && zoomDiff > 0) {
+        return;
+      }
+
+      var latLngNow = _this.pixelToLatLng(_this._mousePosition);
+
+      var zoomTarget = zoom + zoomDiff;
+
+      if (zoomSnap) {
+        zoomTarget = zoomDiff < 0 ? Math.floor(zoomTarget) : Math.ceil(zoomTarget);
+      }
+
+      zoomTarget = Math.max(minZoom, Math.min(zoomTarget, maxZoom));
+
+      _this.setCenterZoomTarget(null, zoomTarget, false, latLngNow);
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "zoomPlusDelta", function () {
+      return _this.state.zoom + _this.state.zoomDelta;
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "pixelToLatLng", function (pixel, center, zoom) {
+      if (center === void 0) {
+        center = _this.state.center;
+      }
+
+      if (zoom === void 0) {
+        zoom = _this.zoomPlusDelta();
+      }
+
+      var _this$state7 = _this.state,
+          width = _this$state7.width,
+          height = _this$state7.height,
+          pixelDelta = _this$state7.pixelDelta;
+      var pointDiff = [(pixel[0] - width / 2 - (pixelDelta ? pixelDelta[0] : 0)) / 256.0, (pixel[1] - height / 2 - (pixelDelta ? pixelDelta[1] : 0)) / 256.0];
+      var tileX = lng2tile(center[1], zoom) + pointDiff[0];
+      var tileY = lat2tile(center[0], zoom) + pointDiff[1];
+      return [Math.max(absoluteMinMax[0], Math.min(absoluteMinMax[1], tile2lat(tileY, zoom))), Math.max(absoluteMinMax[2], Math.min(absoluteMinMax[3], tile2lng(tileX, zoom)))];
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "latLngToPixel", function (latLng, center, zoom) {
+      if (center === void 0) {
+        center = _this.state.center;
+      }
+
+      if (zoom === void 0) {
+        zoom = _this.zoomPlusDelta();
+      }
+
+      var _this$state8 = _this.state,
+          width = _this$state8.width,
+          height = _this$state8.height,
+          pixelDelta = _this$state8.pixelDelta;
+      var tileCenterX = lng2tile(center[1], zoom);
+      var tileCenterY = lat2tile(center[0], zoom);
+      var tileX = lng2tile(latLng[1], zoom);
+      var tileY = lat2tile(latLng[0], zoom);
+      return [(tileX - tileCenterX) * 256.0 + width / 2 + (pixelDelta ? pixelDelta[0] : 0), (tileY - tileCenterY) * 256.0 + height / 2 + (pixelDelta ? pixelDelta[1] : 0)];
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "calculateZoomCenter", function (center, coords, oldZoom, newZoom) {
+      var _this$state9 = _this.state,
+          width = _this$state9.width,
+          height = _this$state9.height;
+
+      var pixelBefore = _this.latLngToPixel(coords, center, oldZoom);
+
+      var pixelAfter = _this.latLngToPixel(coords, center, newZoom);
+
+      var newCenter = _this.pixelToLatLng([width / 2 + pixelAfter[0] - pixelBefore[0], height / 2 + pixelAfter[1] - pixelBefore[1]], center, newZoom);
+
+      return _this.limitCenterAtZoom(newCenter, newZoom);
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "setRef", function (dom) {
+      _this._containerRef = dom;
+    });
+
+    _this.syncToProps = debounce(_this.syncToProps, DEBOUNCE_DELAY);
+    _this._lastZoom = (_ref2 = (_props$defaultZoom = props.defaultZoom) !== null && _props$defaultZoom !== void 0 ? _props$defaultZoom : props.zoom) !== null && _ref2 !== void 0 ? _ref2 : 14;
+    _this._lastCenter = (_ref3 = (_props$defaultCenter = props.defaultCenter) !== null && _props$defaultCenter !== void 0 ? _props$defaultCenter : props.center) !== null && _ref3 !== void 0 ? _ref3 : [0, 0];
+    _this.state = {
+      zoom: _this._lastZoom,
+      center: _this._lastCenter,
+      width: (_ref4 = (_props$width = props.width) !== null && _props$width !== void 0 ? _props$width : props.defaultWidth) !== null && _ref4 !== void 0 ? _ref4 : -1,
+      height: (_ref5 = (_props$height = props.height) !== null && _props$height !== void 0 ? _props$height : props.defaultHeight) !== null && _ref5 !== void 0 ? _ref5 : -1,
+      zoomDelta: 0,
+      pixelDelta: undefined,
+      oldTiles: [],
+      showWarning: false,
+      warningType: undefined
+    };
+    return _this;
+  }
+
+  var _proto = Map.prototype;
+
+  _proto.componentDidMount = function componentDidMount() {
+    var _this2 = this;
+
+    this.props.mouseEvents && this.bindMouseEvents();
+    this.props.touchEvents && this.bindTouchEvents();
+
+    if (!this.props.width || !this.props.height) {
+      if (!this.updateWidthHeight()) {
+        requestAnimationFrame(this.updateWidthHeight);
+      }
+
+      this.bindResizeEvent();
+    }
+
+    this.bindWheelEvent();
+    this.syncToProps();
+
+    if (typeof window.ResizeObserver !== 'undefined') {
+      this._resizeObserver = new window.ResizeObserver(function () {
+        _this2.updateWidthHeight();
+      });
+
+      this._resizeObserver.observe(this._containerRef);
+    }
+  };
+
+  _proto.componentWillUnmount = function componentWillUnmount() {
+    this.props.mouseEvents && this.unbindMouseEvents();
+    this.props.touchEvents && this.unbindTouchEvents();
+    this.unbindWheelEvent();
+
+    if (!this.props.width || !this.props.height) {
+      this.unbindResizeEvent();
+    }
+
+    if (this._resizeObserver) {
+      this._resizeObserver.disconnect();
+    }
+  };
+
+  _proto.componentDidUpdate = function componentDidUpdate(prevProps) {
+    var _prevProps$center;
+
+    if (this.props.mouseEvents !== prevProps.mouseEvents) {
+      this.props.mouseEvents ? this.bindMouseEvents() : this.unbindMouseEvents();
+    }
+
+    if (this.props.touchEvents !== prevProps.touchEvents) {
+      this.props.touchEvents ? this.bindTouchEvents() : this.unbindTouchEvents();
+    }
+
+    if (this.props.width && this.props.width !== prevProps.width) {
+      this.setState({
+        width: this.props.width
+      });
+    }
+
+    if (this.props.height && this.props.height !== prevProps.height) {
+      this.setState({
+        height: this.props.height
+      });
+    }
+
+    if (!this.props.center && !this.props.zoom) {
+      return;
+    }
+
+    if ((!this.props.center || this.props.center[0] === (prevProps === null || prevProps === void 0 ? void 0 : (_prevProps$center = prevProps.center) === null || _prevProps$center === void 0 ? void 0 : _prevProps$center[0]) && this.props.center[1] === prevProps.center[1]) && this.props.zoom === prevProps.zoom) {
+      return;
+    }
+
+    var currentCenter = this._isAnimating ? this._centerTarget : this.state.center;
+    var currentZoom = this._isAnimating ? this._zoomTarget : this.state.zoom;
+
+    if (currentCenter && currentZoom) {
+      var _this$props$center, _this$props$zoom;
+
+      var nextCenter = (_this$props$center = this.props.center) !== null && _this$props$center !== void 0 ? _this$props$center : currentCenter;
+      var nextZoom = (_this$props$zoom = this.props.zoom) !== null && _this$props$zoom !== void 0 ? _this$props$zoom : currentZoom;
+
+      if (Math.abs(nextZoom - currentZoom) > 0.001 || Math.abs(nextCenter[0] - currentCenter[0]) > 0.0001 || Math.abs(nextCenter[1] - currentCenter[1]) > 0.0001) {
+        this.setCenterZoomTarget(nextCenter, nextZoom, true);
+      }
+    }
+  };
+
+  _proto.coordsInside = function coordsInside(pixel) {
+    var _this$state10 = this.state,
+        width = _this$state10.width,
+        height = _this$state10.height;
+
+    if (pixel[0] < 0 || pixel[1] < 0 || pixel[0] >= width || pixel[1] >= height) {
+      return false;
+    }
+
+    var parent = this._containerRef;
+
+    if (parent) {
+      var pos = parentPosition(parent);
+      var element = document.elementFromPoint(pixel[0] + pos.x, pixel[1] + pos.y);
+      return parent === element || parent.contains(element);
+    } else {
+      return false;
+    }
+  };
+
+  _proto.tileValues = function tileValues(_ref6) {
+    var center = _ref6.center,
+        zoom = _ref6.zoom,
+        pixelDelta = _ref6.pixelDelta,
+        zoomDelta = _ref6.zoomDelta,
+        width = _ref6.width,
+        height = _ref6.height;
+    var roundedZoom = Math.round(zoom + (zoomDelta || 0));
+    var zoomDiff = zoom + (zoomDelta || 0) - roundedZoom;
+    var scale = Math.pow(2, zoomDiff);
+    var scaleWidth = width / scale;
+    var scaleHeight = height / scale;
+    var tileCenterX = lng2tile(center[1], roundedZoom) - (pixelDelta ? pixelDelta[0] / 256.0 / scale : 0);
+    var tileCenterY = lat2tile(center[0], roundedZoom) - (pixelDelta ? pixelDelta[1] / 256.0 / scale : 0);
+    var halfWidth = scaleWidth / 2 / 256.0;
+    var halfHeight = scaleHeight / 2 / 256.0;
+    var tileMinX = Math.floor(tileCenterX - halfWidth);
+    var tileMaxX = Math.floor(tileCenterX + halfWidth);
+    var tileMinY = Math.floor(tileCenterY - halfHeight);
+    var tileMaxY = Math.floor(tileCenterY + halfHeight);
+    return {
+      tileMinX: tileMinX,
+      tileMaxX: tileMaxX,
+      tileMinY: tileMinY,
+      tileMaxY: tileMaxY,
+      tileCenterX: tileCenterX,
+      tileCenterY: tileCenterY,
+      roundedZoom: roundedZoom,
+      zoomDelta: zoomDelta || 0,
+      scaleWidth: scaleWidth,
+      scaleHeight: scaleHeight,
+      scale: scale
+    };
+  };
+
+  _proto.renderTiles = function renderTiles() {
+    var _this3 = this;
+
+    var _this$state11 = this.state,
+        oldTiles = _this$state11.oldTiles,
+        width = _this$state11.width,
+        height = _this$state11.height;
+    var dprs = this.props.dprs;
+    var mapUrl = this.props.provider || osm;
+
+    var _this$tileValues = this.tileValues(this.state),
+        tileMinX = _this$tileValues.tileMinX,
+        tileMaxX = _this$tileValues.tileMaxX,
+        tileMinY = _this$tileValues.tileMinY,
+        tileMaxY = _this$tileValues.tileMaxY,
+        tileCenterX = _this$tileValues.tileCenterX,
+        tileCenterY = _this$tileValues.tileCenterY,
+        roundedZoom = _this$tileValues.roundedZoom,
+        scaleWidth = _this$tileValues.scaleWidth,
+        scaleHeight = _this$tileValues.scaleHeight,
+        scale = _this$tileValues.scale;
+
+    var tiles = [];
+
+    for (var i = 0; i < oldTiles.length; i++) {
+      var old = oldTiles[i];
+      var zoomDiff = old.roundedZoom - roundedZoom;
+
+      if (Math.abs(zoomDiff) > 4 || zoomDiff === 0) {
+        continue;
+      }
+
+      var pow = 1 / Math.pow(2, zoomDiff);
+      var xDiff = -(tileMinX - old.tileMinX * pow) * 256;
+      var yDiff = -(tileMinY - old.tileMinY * pow) * 256;
+
+      var _xMin = Math.max(old.tileMinX, 0);
+
+      var _yMin = Math.max(old.tileMinY, 0);
+
+      var _xMax = Math.min(old.tileMaxX, Math.pow(2, old.roundedZoom) - 1);
+
+      var _yMax = Math.min(old.tileMaxY, Math.pow(2, old.roundedZoom) - 1);
+
+      for (var x = _xMin; x <= _xMax; x++) {
+        for (var y = _yMin; y <= _yMax; y++) {
+          tiles.push({
+            key: x + "-" + y + "-" + old.roundedZoom,
+            url: mapUrl(x, y, old.roundedZoom),
+            srcSet: srcSet(dprs, mapUrl, x, y, old.roundedZoom),
+            left: xDiff + (x - old.tileMinX) * 256 * pow,
+            top: yDiff + (y - old.tileMinY) * 256 * pow,
+            width: 256 * pow,
+            height: 256 * pow,
+            active: false
+          });
+        }
+      }
+    }
+
+    var xMin = Math.max(tileMinX, 0);
+    var yMin = Math.max(tileMinY, 0);
+    var xMax = Math.min(tileMaxX, Math.pow(2, roundedZoom) - 1);
+    var yMax = Math.min(tileMaxY, Math.pow(2, roundedZoom) - 1);
+
+    for (var _x = xMin; _x <= xMax; _x++) {
+      for (var _y = yMin; _y <= yMax; _y++) {
+        tiles.push({
+          key: _x + "-" + _y + "-" + roundedZoom,
+          url: mapUrl(_x, _y, roundedZoom),
+          srcSet: srcSet(dprs, mapUrl, _x, _y, roundedZoom),
+          left: (_x - tileMinX) * 256,
+          top: (_y - tileMinY) * 256,
+          width: 256,
+          height: 256,
+          active: true
+        });
+      }
+    }
+
+    var boxStyle = {
+      width: scaleWidth,
+      height: scaleHeight,
+      position: 'absolute',
+      top: "calc((100% - " + height + "px) / 2)",
+      left: "calc((100% - " + width + "px) / 2)",
+      overflow: 'hidden',
+      willChange: 'transform',
+      transform: "scale(" + scale + ", " + scale + ")",
+      transformOrigin: 'top left'
+    };
+    var boxClassname = this.props.boxClassname || 'pigeon-tiles-box';
+    var left = -((tileCenterX - tileMinX) * 256 - scaleWidth / 2);
+    var top = -((tileCenterY - tileMinY) * 256 - scaleHeight / 2);
+    var tilesStyle = {
+      position: 'absolute',
+      width: (tileMaxX - tileMinX + 1) * 256,
+      height: (tileMaxY - tileMinY + 1) * 256,
+      willChange: 'transform',
+      transform: "translate(" + left + "px, " + top + "px)"
+    };
+    var Tile = this.props.tileComponent;
+    return /*#__PURE__*/React__default["default"].createElement("div", {
+      style: boxStyle,
+      className: boxClassname
+    }, /*#__PURE__*/React__default["default"].createElement("div", {
+      className: "pigeon-tiles",
+      style: tilesStyle
+    }, tiles.map(function (tile) {
+      return /*#__PURE__*/React__default["default"].createElement(Tile, {
+        key: tile.key,
+        tile: tile,
+        tileLoaded: function tileLoaded() {
+          return _this3.tileLoaded(tile.key);
+        }
+      });
+    })));
+  };
+
+  _proto.renderOverlays = function renderOverlays() {
+    var _this4 = this;
+
+    var _this$state12 = this.state,
+        width = _this$state12.width,
+        height = _this$state12.height,
+        center = _this$state12.center;
+    var mapState = {
+      bounds: this.getBounds(),
+      zoom: this.zoomPlusDelta(),
+      center: center,
+      width: width,
+      height: height
+    };
+    var childrenWithProps = React__default["default"].Children.map(this.props.children, function (child) {
+      if (!child) {
+        return null;
+      }
+
+      if (! /*#__PURE__*/React__default["default"].isValidElement(child)) {
+        return child;
+      }
+
+      var _child$props = child.props,
+          anchor = _child$props.anchor,
+          position = _child$props.position,
+          offset = _child$props.offset;
+
+      var c = _this4.latLngToPixel(anchor || position || center);
+
+      return /*#__PURE__*/React__default["default"].cloneElement(child, {
+        left: c[0] - (offset ? offset[0] : 0),
+        top: c[1] - (offset ? offset[1] : 0),
+        latLngToPixel: _this4.latLngToPixel,
+        pixelToLatLng: _this4.pixelToLatLng,
+        setCenterZoom: _this4.setCenterZoomForChildren,
+        mapProps: _this4.props,
+        mapState: mapState
+      });
+    });
+    var childrenStyle = {
+      position: 'absolute',
+      width: width,
+      height: height,
+      top: "calc((100% - " + height + "px) / 2)",
+      left: "calc((100% - " + width + "px) / 2)"
+    };
+    return /*#__PURE__*/React__default["default"].createElement("div", {
+      className: "pigeon-overlays",
+      style: childrenStyle
+    }, childrenWithProps);
+  };
+
+  _proto.renderAttribution = function renderAttribution() {
+    var _this$props4 = this.props,
+        attribution = _this$props4.attribution,
+        attributionPrefix = _this$props4.attributionPrefix;
+
+    if (attribution === false) {
+      return null;
+    }
+
+    var style = {
+      position: 'absolute',
+      bottom: 0,
+      right: 0,
+      fontSize: '11px',
+      padding: '2px 5px',
+      background: 'rgba(255, 255, 255, 0.7)',
+      fontFamily: "'Helvetica Neue', Helvetica, Arial, sans-serif",
+      color: '#333'
+    };
+    var linkStyle = {
+      color: '#0078A8',
+      textDecoration: 'none'
+    };
+    return /*#__PURE__*/React__default["default"].createElement("div", {
+      key: "attr",
+      className: "pigeon-attribution",
+      style: style
+    }, attributionPrefix === false ? null : /*#__PURE__*/React__default["default"].createElement("span", null, attributionPrefix || /*#__PURE__*/React__default["default"].createElement("a", {
+      href: "https://pigeon-maps.js.org/",
+      style: linkStyle,
+      target: "_blank",
+      rel: "noreferrer noopener"
+    }, "Pigeon"), ' | '), attribution || /*#__PURE__*/React__default["default"].createElement("span", null, ' © ', /*#__PURE__*/React__default["default"].createElement("a", {
+      href: "https://www.openstreetmap.org/copyright",
+      style: linkStyle,
+      target: "_blank",
+      rel: "noreferrer noopener"
+    }, "OpenStreetMap"), ' contributors'));
+  };
+
+  _proto.renderWarning = function renderWarning() {
+    var _this$props5 = this.props,
+        metaWheelZoom = _this$props5.metaWheelZoom,
+        metaWheelZoomWarning = _this$props5.metaWheelZoomWarning,
+        twoFingerDrag = _this$props5.twoFingerDrag,
+        twoFingerDragWarning = _this$props5.twoFingerDragWarning,
+        warningZIndex = _this$props5.warningZIndex;
+    var _this$state13 = this.state,
+        showWarning = _this$state13.showWarning,
+        warningType = _this$state13.warningType,
+        width = _this$state13.width,
+        height = _this$state13.height;
+
+    if (metaWheelZoom && metaWheelZoomWarning || twoFingerDrag && twoFingerDragWarning) {
+      var style = {
+        position: 'absolute',
+        top: 0,
+        left: 0,
+        width: width,
+        height: height,
+        overflow: 'hidden',
+        pointerEvents: 'none',
+        opacity: showWarning ? 100 : 0,
+        transition: 'opacity 300ms',
+        background: 'rgba(0,0,0,0.5)',
+        color: '#fff',
+        display: 'flex',
+        justifyContent: 'center',
+        alignItems: 'center',
+        fontSize: 22,
+        fontFamily: '"Arial", sans-serif',
+        textAlign: 'center',
+        zIndex: warningZIndex
+      };
+      var meta = typeof window !== 'undefined' && window.navigator && window.navigator.platform.toUpperCase().indexOf('MAC') >= 0 ? '⌘' : 'ctrl';
+      var warningText = warningType === 'fingers' ? twoFingerDragWarning : metaWheelZoomWarning;
+      return /*#__PURE__*/React__default["default"].createElement("div", {
+        className: "pigeon-overlay-warning",
+        style: style
+      }, warningText.replace('META', meta));
+    } else {
+      return null;
+    }
+  };
+
+  _proto.render = function render() {
+    var _this$props6 = this.props,
+        touchEvents = _this$props6.touchEvents,
+        twoFingerDrag = _this$props6.twoFingerDrag;
+    var _this$state14 = this.state,
+        width = _this$state14.width,
+        height = _this$state14.height;
+    var containerStyle = {
+      width: this.props.width ? width : '100%',
+      height: this.props.height ? height : '100%',
+      position: 'relative',
+      display: 'inline-block',
+      overflow: 'hidden',
+      background: '#dddddd',
+      touchAction: touchEvents ? twoFingerDrag ? 'pan-x pan-y' : 'none' : 'auto'
+    };
+    var hasSize = !!(width && height);
+    return /*#__PURE__*/React__default["default"].createElement("div", {
+      style: containerStyle,
+      ref: this.setRef,
+      dir: "ltr"
+    }, hasSize && this.renderTiles(), hasSize && this.renderOverlays(), hasSize && this.renderAttribution(), hasSize && this.renderWarning());
+  };
+
+  return Map;
+}(React.Component);
+
+_defineProperty(Map, "defaultProps", {
+  animate: true,
+  metaWheelZoom: false,
+  metaWheelZoomWarning: 'Use META + wheel to zoom!',
+  twoFingerDrag: false,
+  twoFingerDragWarning: 'Use two fingers to move the map',
+  zoomSnap: true,
+  mouseEvents: true,
+  touchEvents: true,
+  warningZIndex: 100,
+  animateMaxScreens: 5,
+  minZoom: 1,
+  maxZoom: 18,
+  limitBounds: 'center',
+  dprs: [],
+  tileComponent: ImgTile
+});
+
+function Marker(props) {
+  var width = typeof props.width !== 'undefined' ? props.width : typeof props.height !== 'undefined' ? props.height * 29 / 34 : 29;
+  var height = typeof props.height !== 'undefined' ? props.height : typeof props.width !== 'undefined' ? props.width * 34 / 29 : 34;
+
+  var _useState = React.useState(props.hover || false),
+      internalHover = _useState[0],
+      setInternalHover = _useState[1];
+
+  var hover = typeof props.hover === 'undefined' ? internalHover : props.hover;
+  var color = props.color || '#93C0D0';
+
+  var eventParameters = function eventParameters(event) {
+    return {
+      event: event,
+      anchor: props.anchor,
+      payload: props.payload
+    };
+  };
+
+  return /*#__PURE__*/React__default["default"].createElement("div", {
+    style: _objectSpread2({
+      position: 'absolute',
+      transform: "translate(" + (props.left - width / 2) + "px, " + (props.top - (height - 1)) + "px)",
+      filter: hover ? 'drop-shadow(0 0 4px rgba(0, 0, 0, .3))' : '',
+      pointerEvents: 'none',
+      cursor: 'pointer'
+    }, props.style || {}),
+    className: props.className ? props.className + " pigeon-click-block" : 'pigeon-click-block',
+    onClick: props.onClick ? function (event) {
+      return props.onClick(eventParameters(event));
+    } : null,
+    onContextMenu: props.onContextMenu ? function (event) {
+      return props.onContextMenu(eventParameters(event));
+    } : null,
+    onMouseOver: function onMouseOver(event) {
+      props.onMouseOver && props.onMouseOver(eventParameters(event));
+      setInternalHover(true);
+    },
+    onMouseOut: function onMouseOut(event) {
+      props.onMouseOut && props.onMouseOut(eventParameters(event));
+      setInternalHover(false);
+    }
+  }, props.children || /*#__PURE__*/React__default["default"].createElement("svg", {
+    width: width,
+    height: height,
+    viewBox: "0 0 61 71",
+    fill: "none",
+    xmlns: "http://www.w3.org/2000/svg"
+  }, /*#__PURE__*/React__default["default"].createElement("g", {
+    style: {
+      pointerEvents: 'auto'
+    }
+  }, /*#__PURE__*/React__default["default"].createElement("path", {
+    d: "M52 31.5C52 36.8395 49.18 42.314 45.0107 47.6094C40.8672 52.872 35.619 57.678 31.1763 61.6922C30.7916 62.0398 30.2084 62.0398 29.8237 61.6922C25.381 57.678 20.1328 52.872 15.9893 47.6094C11.82 42.314 9 36.8395 9 31.5C9 18.5709 18.6801 9 30.5 9C42.3199 9 52 18.5709 52 31.5Z",
+    fill: color,
+    stroke: "white",
+    strokeWidth: "4"
+  }), /*#__PURE__*/React__default["default"].createElement("circle", {
+    cx: "30.5",
+    cy: "30.5",
+    r: "8.5",
+    fill: "white",
+    opacity: hover ? 0.98 : 0.6
+  }))));
+}
+
+function Overlay(props) {
+  return /*#__PURE__*/React__default["default"].createElement("div", {
+    style: _objectSpread2({
+      position: 'absolute',
+      transform: "translate(" + props.left + "px, " + props.top + "px)"
+    }, props.style || {}),
+    className: props.className ? props.className + " pigeon-click-block" : 'pigeon-click-block'
+  }, props.children);
+}
+
+var defaultSvgAttributes = {
+  fill: '#93c0d099',
+  strokeWidth: '2',
+  stroke: 'white',
+  r: '30'
+};
+function PointComponent(props) {
+  var _props$svgAttributes;
+
+  var latLngToPixel = props.latLngToPixel;
+  var _props$coordinates = props.coordinates,
+      y = _props$coordinates[0],
+      x = _props$coordinates[1];
+
+  var _latLngToPixel = latLngToPixel([x, y]),
+      cx = _latLngToPixel[0],
+      cy = _latLngToPixel[1];
+
+  if ((_props$svgAttributes = props.svgAttributes) !== null && _props$svgAttributes !== void 0 && _props$svgAttributes.path) {
+    var path = "M" + cx + "," + cy + "c" + props.svgAttributes.path.split(/[c|C|L|l|v|V|h|H]([\s\S]*)/)[1];
+    return /*#__PURE__*/React__default["default"].createElement("path", _objectSpread2({
+      d: path
+    }, props.svgAttributes));
+  }
+
+  return /*#__PURE__*/React__default["default"].createElement("circle", _objectSpread2({
+    cx: cx,
+    cy: cy
+  }, props.svgAttributes));
+}
+function MultiPoint(props) {
+  return /*#__PURE__*/React__default["default"].createElement(React__default["default"].Fragment, null, props.coordinates.map(function (point, i) {
+    return /*#__PURE__*/React__default["default"].createElement(PointComponent, _objectSpread2(_objectSpread2({}, props), {}, {
+      coordinates: point,
+      key: i
+    }));
+  }));
+}
+function LineString(props) {
+  var latLngToPixel = props.latLngToPixel;
+  var p = 'M' + props.coordinates.reduce(function (a, _ref) {
+    var y = _ref[0],
+        x = _ref[1];
+
+    var _latLngToPixel2 = latLngToPixel([x, y]),
+        v = _latLngToPixel2[0],
+        w = _latLngToPixel2[1];
+
+    return a + ' ' + v + ' ' + w;
+  }, '');
+  return /*#__PURE__*/React__default["default"].createElement("path", _objectSpread2({
+    d: p
+  }, props.svgAttributes));
+}
+function MultiLineString(props) {
+  return /*#__PURE__*/React__default["default"].createElement(React__default["default"].Fragment, null, props.coordinates.map(function (line, i) {
+    return /*#__PURE__*/React__default["default"].createElement(LineString, _objectSpread2(_objectSpread2({}, props), {}, {
+      coordinates: line,
+      key: i
+    }));
+  }));
+}
+function Polygon(props) {
+  var latLngToPixel = props.latLngToPixel;
+  var p = props.coordinates.reduce(function (a, part) {
+    return a + ' M' + part.reduce(function (a, _ref2) {
+      var y = _ref2[0],
+          x = _ref2[1];
+
+      var _latLngToPixel3 = latLngToPixel([x, y]),
+          v = _latLngToPixel3[0],
+          w = _latLngToPixel3[1];
+
+      return a + ' ' + v + ' ' + w;
+    }, '') + 'Z';
+  }, '');
+  return /*#__PURE__*/React__default["default"].createElement("path", _objectSpread2({
+    d: p
+  }, props.svgAttributes));
+}
+function MultiPolygon(props) {
+  return /*#__PURE__*/React__default["default"].createElement(React__default["default"].Fragment, null, props.coordinates.map(function (polygon, i) {
+    return /*#__PURE__*/React__default["default"].createElement(Polygon, _objectSpread2(_objectSpread2({}, props), {}, {
+      coordinates: polygon,
+      key: i
+    }));
+  }));
+}
+function GeometryCollection(props) {
+  var renderer = {
+    Point: PointComponent,
+    MultiPoint: MultiPoint,
+    LineString: LineString,
+    MultiLineString: MultiLineString,
+    Polygon: Polygon,
+    MultiPolygon: MultiPolygon
+  };
+  var _props$geometry = props.geometry,
+      type = _props$geometry.type,
+      coordinates = _props$geometry.coordinates,
+      geometries = _props$geometry.geometries;
+
+  if (type === 'GeometryCollection') {
+    return /*#__PURE__*/React__default["default"].createElement(React__default["default"].Fragment, null, geometries.map(function (geometry, i) {
+      return /*#__PURE__*/React__default["default"].createElement(GeometryCollection, _objectSpread2(_objectSpread2({
+        key: i
+      }, props), {}, {
+        geometry: geometry
+      }));
+    }));
+  }
+
+  var Component = renderer[type];
+
+  if (Component === undefined) {
+    console.warn("The GeoJson Type " + type + " is not known");
+    return null;
+  }
+
+  return /*#__PURE__*/React__default["default"].createElement(Component, {
+    latLngToPixel: props.latLngToPixel,
+    geometry: props.geometry,
+    coordinates: coordinates,
+    svgAttributes: props.svgAttributes
+  });
+}
+function GeoJsonFeature(props) {
+  var _useState = React.useState(props.hover || false),
+      internalHover = _useState[0],
+      setInternalHover = _useState[1];
+
+  var hover = props.hover !== undefined ? props.hover : internalHover;
+  var callbackSvgAttributes = props.styleCallback && props.styleCallback(props.feature, hover);
+  var svgAttributes = callbackSvgAttributes ? props.svgAttributes ? _objectSpread2(_objectSpread2({}, props.svgAttributes), callbackSvgAttributes) : callbackSvgAttributes : props.svgAttributes ? props.svgAttributes : defaultSvgAttributes;
+
+  var eventParameters = function eventParameters(event) {
+    return {
+      event: event,
+      anchor: props.anchor,
+      payload: props.feature
+    };
+  };
+
+  return /*#__PURE__*/React__default["default"].createElement("g", {
+    clipRule: "evenodd",
+    style: {
+      pointerEvents: 'auto'
+    },
+    onClick: props.onClick ? function (event) {
+      return props.onClick(eventParameters(event));
+    } : null,
+    onContextMenu: props.onContextMenu ? function (event) {
+      return props.onContextMenu(eventParameters(event));
+    } : null,
+    onMouseOver: function onMouseOver(event) {
+      props.onMouseOver && props.onMouseOver(eventParameters(event));
+      setInternalHover(true);
+    },
+    onMouseOut: function onMouseOut(event) {
+      props.onMouseOut && props.onMouseOut(eventParameters(event));
+      setInternalHover(false);
+    }
+  }, /*#__PURE__*/React__default["default"].createElement(GeometryCollection, _objectSpread2(_objectSpread2(_objectSpread2({}, props), props.feature), {}, {
+    svgAttributes: svgAttributes
+  })));
+}
+function GeoJson(props) {
+  var _props$mapState = props.mapState,
+      width = _props$mapState.width,
+      height = _props$mapState.height;
+  return /*#__PURE__*/React__default["default"].createElement("div", {
+    style: _objectSpread2({
+      position: 'absolute',
+      left: '0',
+      top: '0',
+      pointerEvents: 'none',
+      cursor: 'pointer'
+    }, props.style || {}),
+    className: props.className ? props.className + " pigeon-click-block" : 'pigeon-click-block'
+  }, /*#__PURE__*/React__default["default"].createElement("svg", {
+    width: width,
+    height: height,
+    viewBox: "0 0 " + width + " " + height,
+    fill: "none",
+    xmlns: "http://www.w3.org/2000/svg"
+  }, props.data && props.data.features.map(function (feature, i) {
+    return /*#__PURE__*/React__default["default"].createElement(GeoJsonFeature, _objectSpread2(_objectSpread2({
+      key: i
+    }, props), {}, {
+      feature: feature
+    }));
+  }), React__default["default"].Children.map(props.children, function (child) {
+    if (!child) {
+      return null;
+    }
+
+    if (! /*#__PURE__*/React__default["default"].isValidElement(child)) {
+      return child;
+    }
+
+    return /*#__PURE__*/React__default["default"].cloneElement(child, props);
+  })));
+}
+function GeoJsonLoader(props) {
+  var _useState2 = React.useState(props.data ? props.data : null),
+      data = _useState2[0],
+      setData = _useState2[1];
+
+  React.useEffect(function () {
+    fetch(props.link).then(function (response) {
+      return response.json();
+    }).then(function (data) {
+      return setData(data);
+    });
+  }, [props.link]);
+  return data ? /*#__PURE__*/React__default["default"].createElement(GeoJson, _objectSpread2({
+    data: data
+  }, props)) : null;
+}
+
+function isDescendentOf(element, ancestor) {
+  while (element) {
+    if (element === ancestor) {
+      return true;
+    }
+
+    element = element.parentElement;
+  }
+
+  return false;
+}
+
+var defaultState = {
+  isDragging: false,
+  startX: undefined,
+  startY: undefined,
+  startLeft: undefined,
+  startTop: undefined,
+  deltaX: 0,
+  deltaY: 0
+};
+function Draggable(props) {
+  var dragRef = React.useRef();
+  var propsRef = React.useRef(props);
+  var stateRef = React.useRef(_objectSpread2({}, defaultState));
+
+  var _useState = React.useState(defaultState),
+      _state = _useState[0],
+      _setState = _useState[1];
+
+  propsRef.current = props;
+
+  var setState = function setState(stateUpdate) {
+    var newState = _objectSpread2(_objectSpread2({}, stateRef.current), stateUpdate);
+
+    stateRef.current = newState;
+
+    _setState(newState);
+  };
+
+  var _props$mapProps = props.mapProps,
+      mouseEvents = _props$mapProps.mouseEvents,
+      touchEvents = _props$mapProps.touchEvents;
+  React.useEffect(function () {
+    var handleDragStart = function handleDragStart(event) {
+      if (isDescendentOf(event.target, dragRef.current)) {
+        event.preventDefault();
+        setState({
+          isDragging: true,
+          startX: ('touches' in event ? event.touches[0] : event).clientX,
+          startY: ('touches' in event ? event.touches[0] : event).clientY,
+          startLeft: propsRef.current.left,
+          startTop: propsRef.current.top,
+          deltaX: 0,
+          deltaY: 0
+        });
+
+        if (propsRef.current.onDragStart) {
+          var _propsRef$current = propsRef.current,
+              _left = _propsRef$current.left,
+              _top = _propsRef$current.top,
+              offset = _propsRef$current.offset,
+              pixelToLatLng = _propsRef$current.pixelToLatLng;
+          propsRef.current.onDragMove(pixelToLatLng([_left + (offset ? offset[0] : 0), _top + (offset ? offset[1] : 0)]));
+        }
+      }
+    };
+
+    var handleDragMove = function handleDragMove(event) {
+      if (!stateRef.current.isDragging) {
+        return;
+      }
+
+      event.preventDefault();
+      var x = ('touches' in event ? event.touches[0] : event).clientX;
+      var y = ('touches' in event ? event.touches[0] : event).clientY;
+      var deltaX = x - stateRef.current.startX;
+      var deltaY = y - stateRef.current.startY;
+      setState({
+        deltaX: deltaX,
+        deltaY: deltaY
+      });
+
+      if (propsRef.current.onDragMove) {
+        var _propsRef$current2 = propsRef.current,
+            offset = _propsRef$current2.offset,
+            pixelToLatLng = _propsRef$current2.pixelToLatLng;
+        var _stateRef$current = stateRef.current,
+            _startLeft = _stateRef$current.startLeft,
+            _startTop = _stateRef$current.startTop;
+        propsRef.current.onDragMove(pixelToLatLng([_startLeft + deltaX + (offset ? offset[0] : 0), _startTop + deltaY + (offset ? offset[1] : 0)]));
+      }
+    };
+
+    var handleDragEnd = function handleDragEnd(event) {
+      var _propsRef$current$onD, _propsRef$current4;
+
+      if (!stateRef.current.isDragging) {
+        return;
+      }
+
+      event.preventDefault();
+      var _propsRef$current3 = propsRef.current,
+          offset = _propsRef$current3.offset,
+          pixelToLatLng = _propsRef$current3.pixelToLatLng;
+      var _stateRef$current2 = stateRef.current,
+          deltaX = _stateRef$current2.deltaX,
+          deltaY = _stateRef$current2.deltaY,
+          startLeft = _stateRef$current2.startLeft,
+          startTop = _stateRef$current2.startTop;
+      (_propsRef$current$onD = (_propsRef$current4 = propsRef.current).onDragEnd) === null || _propsRef$current$onD === void 0 ? void 0 : _propsRef$current$onD.call(_propsRef$current4, pixelToLatLng([startLeft + deltaX + (offset ? offset[0] : 0), startTop + deltaY + (offset ? offset[1] : 0)]));
+      setState({
+        isDragging: false,
+        startX: undefined,
+        startY: undefined,
+        startLeft: undefined,
+        startTop: undefined,
+        deltaX: 0,
+        deltaY: 0
+      });
+    };
+
+    var wa = function wa(e, t, o) {
+      return window.addEventListener(e, t, o);
+    };
+
+    var wr = function wr(e, t) {
+      return window.removeEventListener(e, t);
+    };
+
+    if (mouseEvents) {
+      wa('mousedown', handleDragStart);
+      wa('mousemove', handleDragMove);
+      wa('mouseup', handleDragEnd);
+    }
+
+    if (touchEvents) {
+      wa('touchstart', handleDragStart, {
+        passive: false
+      });
+      wa('touchmove', handleDragMove, {
+        passive: false
+      });
+      wa('touchend', handleDragEnd, {
+        passive: false
+      });
+    }
+
+    return function () {
+      if (mouseEvents) {
+        wr('mousedown', handleDragStart);
+        wr('mousemove', handleDragMove);
+        wr('mouseup', handleDragEnd);
+      }
+
+      if (touchEvents) {
+        wr('touchstart', handleDragStart);
+        wr('touchmove', handleDragMove);
+        wr('touchend', handleDragEnd);
+      }
+    };
+  }, [mouseEvents, touchEvents]);
+  var left = props.left,
+      top = props.top,
+      className = props.className,
+      style = props.style;
+  var deltaX = _state.deltaX,
+      deltaY = _state.deltaY,
+      startLeft = _state.startLeft,
+      startTop = _state.startTop,
+      isDragging = _state.isDragging;
+  return /*#__PURE__*/React__default["default"].createElement("div", {
+    style: _objectSpread2(_objectSpread2({
+      cursor: isDragging ? 'grabbing' : 'grab'
+    }, style || {}), {}, {
+      position: 'absolute',
+      transform: "translate(" + (isDragging ? startLeft + deltaX : left) + "px, " + (isDragging ? startTop + deltaY : top) + "px)"
+    }),
+    ref: dragRef,
+    className: "pigeon-drag-block" + (className ? " " + className : '')
+  }, props.children);
+}
+
+var commonStyle = {
+  position: 'absolute',
+  top: 10,
+  left: 10
+};
+var commonButtonStyle = {
+  width: 28,
+  height: 28,
+  borderRadius: 2,
+  boxShadow: '0 1px 4px -1px rgba(0,0,0,.3)',
+  background: 'white',
+  lineHeight: '26px',
+  fontSize: '20px',
+  fontWeight: 700,
+  color: '#666',
+  marginBottom: 1,
+  cursor: 'pointer',
+  border: 'none',
+  display: 'block',
+  outline: 'none'
+};
+function ZoomControl(_ref) {
+  var style = _ref.style,
+      buttonStyle = _ref.buttonStyle,
+      setCenterZoom = _ref.setCenterZoom,
+      mapState = _ref.mapState,
+      mapProps = _ref.mapProps;
+  return /*#__PURE__*/React__default["default"].createElement("div", {
+    className: "pigeon-zoom-buttons pigeon-drag-block",
+    style: style ? _objectSpread2(_objectSpread2({}, commonStyle), style) : commonStyle
+  }, /*#__PURE__*/React__default["default"].createElement("button", {
+    className: "pigeon-zoom-in",
+    type: "button",
+    style: buttonStyle ? _objectSpread2(_objectSpread2({}, commonButtonStyle), buttonStyle) : commonButtonStyle,
+    onClick: function onClick() {
+      return setCenterZoom(mapState.center, Math.min(mapState.zoom + 1, mapProps.maxZoom));
+    }
+  }, "+"), /*#__PURE__*/React__default["default"].createElement("button", {
+    className: "pigeon-zoom-out",
+    type: "button",
+    style: buttonStyle ? _objectSpread2(_objectSpread2({}, commonButtonStyle), buttonStyle) : commonButtonStyle,
+    onClick: function onClick() {
+      return setCenterZoom(mapState.center, Math.max(mapState.zoom - 1, mapProps.minZoom));
+    }
+  }, "\u2013"));
+}
+
+exports.Draggable = Draggable;
+exports.GeoJson = GeoJson;
+exports.GeoJsonFeature = GeoJsonFeature;
+exports.GeoJsonLoader = GeoJsonLoader;
+exports.Map = Map;
+exports.Marker = Marker;
+exports.Overlay = Overlay;
+exports.ZoomControl = ZoomControl;