Version 1.0.2 mit node_modules Verzeichnis

node_modules/leaflet.smooth_marker_bouncing/dist/BouncingMotion.js

@@ -0,0 +1,282 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _leaflet = require("leaflet");
+
+var _BouncingOptions = _interopRequireDefault(require("./BouncingOptions"));
+
+var _Cache = _interopRequireDefault(require("./Cache"));
+
+var _Styles = _interopRequireDefault(require("./Styles"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+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; }
+
+var bonceEndEvent = 'bounceend';
+
+var BouncingMotion = /*#__PURE__*/function () {
+  // TODO: check if this cache working right (keys don't need prefix)
+
+  /**
+   * Constructor.
+   *
+   * @param marker {Marker}  marker
+   * @param position {Point}  marker current position on the map canvas
+   * @param bouncingOptions {BouncingOptions}  options of bouncing animation
+   */
+  function BouncingMotion(marker, position, bouncingOptions) {
+    _classCallCheck(this, BouncingMotion);
+
+    _defineProperty(this, "marker", void 0);
+
+    _defineProperty(this, "position", void 0);
+
+    _defineProperty(this, "bouncingOptions", void 0);
+
+    _defineProperty(this, "moveSteps", void 0);
+
+    _defineProperty(this, "moveDelays", void 0);
+
+    _defineProperty(this, "resizeSteps", void 0);
+
+    _defineProperty(this, "resizeDelays", void 0);
+
+    _defineProperty(this, "isBouncing", false);
+
+    _defineProperty(this, "iconStyles", void 0);
+
+    _defineProperty(this, "shadowStyles", void 0);
+
+    _defineProperty(this, "bouncingAnimationPlaying", false);
+
+    this.marker = marker;
+    this.position = position;
+    this.updateBouncingOptions(bouncingOptions);
+  }
+
+  _createClass(BouncingMotion, [{
+    key: "updateBouncingOptions",
+    value: function updateBouncingOptions(options) {
+      this.bouncingOptions = options instanceof _BouncingOptions["default"] ? options : this.bouncingOptions.override(options);
+      var _this$bouncingOptions = this.bouncingOptions,
+          bounceHeight = _this$bouncingOptions.bounceHeight,
+          bounceSpeed = _this$bouncingOptions.bounceSpeed,
+          elastic = _this$bouncingOptions.elastic;
+      this.moveSteps = BouncingMotion.cache.get("moveSteps_".concat(bounceHeight), function () {
+        return BouncingMotion.calculateSteps(bounceHeight);
+      });
+      this.moveDelays = BouncingMotion.cache.get("moveDelays_".concat(bounceHeight, "_").concat(bounceSpeed), function () {
+        return BouncingMotion.calculateDelays(bounceHeight, bounceSpeed);
+      });
+
+      if (elastic) {
+        var _this$bouncingOptions2 = this.bouncingOptions,
+            contractHeight = _this$bouncingOptions2.contractHeight,
+            contractSpeed = _this$bouncingOptions2.contractSpeed;
+        this.resizeSteps = BouncingMotion.cache.get("resizeSteps_".concat(contractHeight), function () {
+          return BouncingMotion.calculateSteps(contractHeight);
+        });
+        this.resizeDelays = BouncingMotion.cache.get("resizeDelays_".concat(contractHeight, "_").concat(contractSpeed), function () {
+          return BouncingMotion.calculateDelays(contractHeight, contractSpeed);
+        });
+      }
+
+      this.recalculateMotion(this.position);
+    }
+  }, {
+    key: "resetStyles",
+    value: function resetStyles(marker) {
+      this.iconStyles = _Styles["default"].ofMarker(marker);
+
+      if (marker._shadow) {
+        this.shadowStyles = _Styles["default"].parse(marker._shadow.style.cssText);
+      }
+    }
+    /**
+     * Recalculates bouncing motion for new marker position.
+     * @param position {Point} new marker position
+     */
+
+  }, {
+    key: "recalculateMotion",
+    value: function recalculateMotion(position) {
+      this.position = position;
+    }
+    /**
+     * @param times {number|null}
+     */
+
+  }, {
+    key: "bounce",
+    value: function bounce() {
+      var times = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+
+      if (this.bouncingAnimationPlaying) {
+        this.isBouncing = true;
+        return;
+      }
+
+      this.isBouncing = true;
+      this.bouncingAnimationPlaying = true;
+      this.move(times);
+    }
+  }, {
+    key: "stopBouncing",
+    value: function stopBouncing() {
+      this.isBouncing = false;
+    }
+    /**
+     * @param times {number|null}
+     */
+
+  }, {
+    key: "move",
+    value: function move() {
+      var _this = this;
+
+      var times = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+
+      if (times !== null) {
+        if (! --times) {
+          this.isBouncing = false; // this is the last bouncing
+
+          this.bouncingAnimationPlaying = false;
+        }
+      }
+      /* Launch timeouts for every step of the movement animation */
+
+
+      var i = this.moveSteps.length;
+
+      while (i--) {
+        setTimeout(function (step) {
+          return _this.makeMoveStep(step);
+        }, this.moveDelays[i], this.moveSteps[i]);
+      }
+
+      setTimeout(function () {
+        return _this.afterMove(times);
+      }, this.moveDelays[this.moveSteps.length - 1]);
+    }
+  }, {
+    key: "afterMove",
+    value: function afterMove(times) {
+      var _this2 = this;
+
+      if (this.isBouncing) {
+        setTimeout(function () {
+          return _this2.move(times);
+        }, this.bouncingOptions.bounceSpeed);
+      } else {
+        this.bouncingAnimationPlaying = false;
+        this.marker.fire(bonceEndEvent);
+      }
+    }
+    /**
+     * @param step {number}
+     */
+
+  }, {
+    key: "makeMoveStep",
+    value: function makeMoveStep(step) {
+      this.marker._icon.style.cssText = this.iconStyles.toString();
+
+      if (this.marker._shadow) {
+        this.marker._shadow.style.cssText = this.shadowStyles.toString();
+      }
+    }
+    /**
+     * Returns calculated array of animation steps. This function used to calculate both movement
+     * and resizing animations.
+     *
+     * @param height {number}  height of movement or resizing (px)
+     *
+     * @return {number[]} array of animation steps
+     */
+
+  }], [{
+    key: "calculateSteps",
+    value: function calculateSteps(height) {
+      /* Calculate the sequence of animation steps:
+       * steps = [1 .. height] concat [height-1 .. 0]
+       */
+      var i = 1;
+      var steps = [];
+
+      while (i <= height) {
+        steps.push(i++);
+      }
+
+      i = height;
+
+      while (i--) {
+        steps.push(i);
+      }
+
+      return steps;
+    }
+    /**
+     * Returns calculated array of delays between animation start and the steps of animation. This
+     * function used to calculate both movement and resizing animations. Element with index i of
+     * this array contains the delay in milliseconds between animation start and the step number i.
+     *
+     * @param height {number}  height of movement or resizing (px)
+     * @param speed {number}  speed coefficient
+     *
+     * @return {number[]} array of delays before steps of animation
+     */
+
+  }, {
+    key: "calculateDelays",
+    value: function calculateDelays(height, speed) {
+      // Calculate delta time for bouncing animation
+      // Delta time to movement in one direction
+      var deltas = []; // time between steps of animation
+
+      deltas[height] = speed;
+      deltas[0] = 0;
+      var i = height;
+
+      while (--i) {
+        deltas[i] = Math.round(speed / (height - i));
+      } // Delta time for movement in two directions
+
+
+      i = height;
+
+      while (i--) {
+        deltas.push(deltas[i]);
+      } // Calculate move delays (cumulated deltas)
+      // TODO: instead of deltas.lenght write bounceHeight * 2 - 1
+
+
+      var delays = []; // delays before steps from beginning of animation
+
+      var totalDelay = 0;
+
+      for (i = 0; i < deltas.length; i++) {
+        totalDelay += deltas[i];
+        delays.push(totalDelay);
+      }
+
+      return delays;
+    }
+  }]);
+
+  return BouncingMotion;
+}();
+
+exports["default"] = BouncingMotion;
+
+_defineProperty(BouncingMotion, "cache", new _Cache["default"]());

node_modules/leaflet.smooth_marker_bouncing/dist/BouncingMotion3D.js

@@ -0,0 +1,258 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _leaflet = require("leaflet");
+
+var _BouncingMotion2 = _interopRequireDefault(require("./BouncingMotion"));
+
+var _Matrix3D = _interopRequireDefault(require("./Matrix3D"));
+
+var _line = require("./line");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
+
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+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; }
+
+var moveMatrixFormat = _Matrix3D["default"].identity().toFormat('d1', 'd2');
+
+var resizeMatrixFormat = _Matrix3D["default"].identity().toFormat('b2', 'd1', 'd2');
+
+var BouncingMotion3D = /*#__PURE__*/function (_BouncingMotion) {
+  _inherits(BouncingMotion3D, _BouncingMotion);
+
+  var _super = _createSuper(BouncingMotion3D);
+
+  /**
+   * Constructor.
+   *
+   * @param marker {Marker}  marker
+   * @param position {Point}  marker current position on the map canvas
+   * @param bouncingOptions {BouncingOptions}  options of bouncing animation
+   */
+  function BouncingMotion3D(marker, position, bouncingOptions) {
+    var _this;
+
+    _classCallCheck(this, BouncingMotion3D);
+
+    _this = _super.call(this, marker, position, bouncingOptions);
+
+    _defineProperty(_assertThisInitialized(_this), "iconMoveTransforms", void 0);
+
+    _defineProperty(_assertThisInitialized(_this), "iconResizeTransforms", void 0);
+
+    _defineProperty(_assertThisInitialized(_this), "shadowMoveTransforms", void 0);
+
+    _defineProperty(_assertThisInitialized(_this), "shadowResizeTransforms", void 0);
+
+    _this.recalculateMotion(position);
+
+    return _this;
+  }
+
+  _createClass(BouncingMotion3D, [{
+    key: "recalculateMotion",
+    value: function recalculateMotion(position) {
+      var _this$marker$getIcon, _this$marker$getIcon$, _this$marker, _this$marker$_iconObj, _this$marker$_iconObj2;
+
+      _get(_getPrototypeOf(BouncingMotion3D.prototype), "recalculateMotion", this).call(this, position);
+
+      var iconHeight = ((_this$marker$getIcon = this.marker.getIcon()) === null || _this$marker$getIcon === void 0 ? void 0 : (_this$marker$getIcon$ = _this$marker$getIcon.options) === null || _this$marker$getIcon$ === void 0 ? void 0 : _this$marker$getIcon$.iconSize[1]) || ((_this$marker = this.marker) === null || _this$marker === void 0 ? void 0 : (_this$marker$_iconObj = _this$marker._iconObj) === null || _this$marker$_iconObj === void 0 ? void 0 : (_this$marker$_iconObj2 = _this$marker$_iconObj.options) === null || _this$marker$_iconObj2 === void 0 ? void 0 : _this$marker$_iconObj2.iconSize[1]);
+      var x = position.x,
+          y = position.y;
+      var _this$bouncingOptions = this.bouncingOptions,
+          bounceHeight = _this$bouncingOptions.bounceHeight,
+          contractHeight = _this$bouncingOptions.contractHeight,
+          shadowAngle = _this$bouncingOptions.shadowAngle;
+      this.iconMoveTransforms = BouncingMotion3D.calculateIconMoveTransforms(x, y, bounceHeight);
+      this.iconResizeTransforms = BouncingMotion3D.calculateResizeTransforms(x, y, iconHeight, contractHeight);
+
+      if (this.marker._shadow) {
+        var _this$marker$getIcon2, _this$marker$getIcon3;
+
+        this.shadowMoveTransforms = BouncingMotion3D.calculateShadowMoveTransforms(x, y, bounceHeight, shadowAngle);
+        var shadowHeight = (_this$marker$getIcon2 = this.marker.getIcon()) === null || _this$marker$getIcon2 === void 0 ? void 0 : (_this$marker$getIcon3 = _this$marker$getIcon2.options) === null || _this$marker$getIcon3 === void 0 ? void 0 : _this$marker$getIcon3.shadowSize[1];
+        this.shadowResizeTransforms = BouncingMotion3D.calculateResizeTransforms(x, y, shadowHeight, contractHeight);
+      }
+    }
+  }, {
+    key: "afterMove",
+    value: function afterMove(times) {
+      if (this.bouncingOptions.elastic) {
+        this.resize(times);
+      } else {
+        _get(_getPrototypeOf(BouncingMotion3D.prototype), "afterMove", this).call(this, times);
+      }
+    }
+  }, {
+    key: "resize",
+    value: function resize(times) {
+      var _this2 = this;
+
+      var nbResizeSteps = this.resizeSteps.length;
+      var i = nbResizeSteps;
+
+      while (i--) {
+        setTimeout(function (step) {
+          return _this2.makeResizeStep(step);
+        }, this.resizeDelays[i], this.resizeSteps[i]);
+      }
+
+      setTimeout(function () {
+        if (!_this2.isBouncing) {
+          _this2.bouncingAnimationPlaying = false;
+        }
+      }, this.resizeDelays[this.resizeSteps.length]);
+      setTimeout(function () {
+        if (_this2.isBouncing) {
+          _this2.move(times);
+        } else {
+          _this2.marker.fire('bounceend');
+        }
+      }, this.resizeDelays[nbResizeSteps - 1]);
+    }
+  }, {
+    key: "makeMoveStep",
+    value: function makeMoveStep(step) {
+      this.marker._icon.style.cssText = this.iconStyles.withTransform(this.iconMoveTransforms[step]).toString();
+
+      if (this.marker._shadow) {
+        this.marker._shadow.style.cssText = this.shadowStyles.withTransform(this.shadowMoveTransforms[step]).toString();
+      }
+    }
+    /**
+     * @param step {number}
+     */
+
+  }, {
+    key: "makeResizeStep",
+    value: function makeResizeStep(step) {
+      this.marker._icon.style.cssText = this.iconStyles.withTransform(this.iconResizeTransforms[step]).toString();
+
+      if (this.marker._shadow && this.bouncingOptions.shadowAngle) {
+        this.marker._shadow.style.cssText = this.shadowStyles.withTransform(this.shadowResizeTransforms[step]).toString();
+      }
+    }
+    /**
+     * Returns calculated array of transformation definitions for the animation of icon movement.
+     * Function defines one transform for every pixel of shift of the icon from it's original y
+     * position.
+     *
+     * @param x {number}  x coordinate of original position of the marker
+     * @param y {number}  y coordinate of original position of the marker
+     * @param bounceHeight {number}  height of bouncing (px)
+     *
+     * @return {string[]} array of transformation definitions
+     */
+
+  }], [{
+    key: "calculateIconMoveTransforms",
+    value: function calculateIconMoveTransforms(x, y, bounceHeight) {
+      var transforms = [];
+      var deltaY = bounceHeight + 1; // Use fast inverse while loop to fill the array
+
+      while (deltaY--) {
+        transforms[deltaY] = moveMatrixFormat(x, y - deltaY);
+      }
+
+      return transforms;
+    }
+    /**
+     * Returns calculated array of transformation definitions for the animation of icon resizing.
+     * Function defines one transform for every pixel of resizing of marker from it's original
+     * height.
+     *
+     * @param x {number}  x coordinate of original position of marker
+     * @param y {number}  y coordinate of original position of marker
+     * @param height {number}  original marker height (px)
+     * @param contractHeight {number}  height of marker contraction (px)
+     *
+     * @return {string[]} array of transformation definitions
+     */
+
+  }, {
+    key: "calculateResizeTransforms",
+    value: function calculateResizeTransforms(x, y, height, contractHeight) {
+      var transforms = [];
+      var deltaHeight = contractHeight + 1; // Use fast inverse while loop to fill the array
+
+      while (deltaHeight--) {
+        transforms[deltaHeight] = resizeMatrixFormat((height - deltaHeight) / height, x, y + deltaHeight);
+      }
+
+      return transforms;
+    }
+    /**
+     * Returns calculated array of transformation definitions for the animation of shadow movement.
+     * Function defines one transform for every pixel of shift of the shadow from it's original
+     * position.
+     *
+     * @param x {number}  x coordinate of original position of marker
+     * @param y {number}  y coordinate of original position of marker
+     * @param bounceHeight {number}  height of bouncing (px)
+     * @param angle {number|null}  shadow inclination angle, if null shadow don't moves from it's
+     *      initial position (radians)
+     *
+     * @return {string[]} array of transformation definitions
+     */
+
+  }, {
+    key: "calculateShadowMoveTransforms",
+    value: function calculateShadowMoveTransforms(x, y, bounceHeight) {
+      var angle = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
+      // TODO: check this method to know if bounceHeight + 1 is normal
+      var transforms = [];
+      var deltaY = bounceHeight + 1;
+      var points = [];
+
+      if (angle != null) {
+        // important: 0 is not null
+        points = (0, _line.calculateLine)(x, y, angle, bounceHeight + 1);
+      } else {
+        for (var i = 0; i <= bounceHeight; i++) {
+          points[i] = [x, y];
+        }
+      } // Use fast inverse while loop to fill the array
+
+
+      while (deltaY--) {
+        transforms[deltaY] = moveMatrixFormat(points[deltaY][0], points[deltaY][1]);
+      }
+
+      return transforms;
+    }
+  }]);
+
+  return BouncingMotion3D;
+}(_BouncingMotion2["default"]);
+
+exports["default"] = BouncingMotion3D;

node_modules/leaflet.smooth_marker_bouncing/dist/BouncingMotionCss3.js

@@ -0,0 +1,297 @@
+"use strict";
+
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _leaflet = require("leaflet");
+var _line = require("./line");
+require("./bouncing.css");
+var _BouncingOptions = _interopRequireDefault(require("./BouncingOptions"));
+var _Styles = _interopRequireDefault(require("./Styles"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function _classPrivateFieldInitSpec(e, t, a) { _checkPrivateRedeclaration(e, t), t.set(e, a); }
+function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _classPrivateFieldGet(s, a) { return s.get(_assertClassBrand(s, a)); }
+function _classPrivateFieldSet(s, a, r) { return s.set(_assertClassBrand(s, a), r), r; }
+function _assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; throw new TypeError("Private element is not present on this object"); }
+var animationNamePrefix = 'l-smooth-marker-bouncing-';
+var moveAnimationName = animationNamePrefix + 'move';
+var contractAnimationName = animationNamePrefix + 'contract';
+
+/*
+ * CSS3 animation runs faster than transform-based animation. We need to reduce speed in order
+ * to be compatible with old API.
+ */
+var speedCoefficient = 0.8;
+
+/**
+ * Removes and then resets required classes on the HTML element.
+ * Used as hack to restart CSS3 animation.
+ *
+ * @param element {HTMLElement}  HTML element
+ * @param classes {string[]}  names of classes
+ */
+function resetClasses(element, classes) {
+  classes.forEach(function (className) {
+    return _leaflet.DomUtil.removeClass(element, className);
+  });
+  void element.offsetWidth;
+  classes.forEach(function (className) {
+    return _leaflet.DomUtil.addClass(element, className);
+  });
+}
+var _lastAnimationName = /*#__PURE__*/new WeakMap();
+var _classes = /*#__PURE__*/new WeakMap();
+var _eventCounter = /*#__PURE__*/new WeakMap();
+var _times = /*#__PURE__*/new WeakMap();
+var _listener = /*#__PURE__*/new WeakMap();
+var BouncingMotionCss3 = exports["default"] = /*#__PURE__*/function () {
+  /**
+   * Constructor.
+   *
+   * @param marker {Marker}  marker
+   * @param position {Point}  marker current position on the map canvas
+   * @param bouncingOptions {BouncingOptions}  options of bouncing animation
+   */
+  function BouncingMotionCss3(marker, position, bouncingOptions) {
+    var _this = this;
+    _classCallCheck(this, BouncingMotionCss3);
+    _defineProperty(this, "marker", void 0);
+    _defineProperty(this, "position", void 0);
+    _defineProperty(this, "bouncingOptions", void 0);
+    _defineProperty(this, "isBouncing", false);
+    _defineProperty(this, "iconStyles", void 0);
+    _defineProperty(this, "shadowStyles", void 0);
+    _defineProperty(this, "bouncingAnimationPlaying", false);
+    _defineProperty(this, "onMotionEnd", void 0);
+    _classPrivateFieldInitSpec(this, _lastAnimationName, contractAnimationName);
+    _classPrivateFieldInitSpec(this, _classes, ['bouncing']);
+    _classPrivateFieldInitSpec(this, _eventCounter, void 0);
+    _classPrivateFieldInitSpec(this, _times, void 0);
+    _classPrivateFieldInitSpec(this, _listener, function (event) {
+      return _this.onAnimationEnd(event);
+    });
+    this.marker = marker;
+    this.position = position;
+    this.updateBouncingOptions(bouncingOptions);
+  }
+  return _createClass(BouncingMotionCss3, [{
+    key: "updateBouncingOptions",
+    value: function updateBouncingOptions(options) {
+      this.bouncingOptions = options instanceof _BouncingOptions["default"] ? options : this.bouncingOptions.override(options);
+      if (this.bouncingOptions.elastic && this.bouncingOptions.contractHeight) {
+        _classPrivateFieldSet(_lastAnimationName, this, contractAnimationName);
+        var index = _classPrivateFieldGet(_classes, this).indexOf('simple');
+        if (index > -1) {
+          _classPrivateFieldGet(_classes, this).splice(index, 1);
+        }
+        if (this.marker._icon) {
+          _leaflet.DomUtil.removeClass(this.marker._icon, 'simple');
+        }
+      } else {
+        _classPrivateFieldSet(_lastAnimationName, this, moveAnimationName);
+        _classPrivateFieldGet(_classes, this).push('simple');
+      }
+      if (this.marker._icon) {
+        this.resetStyles(this.marker);
+      }
+    }
+  }, {
+    key: "onAnimationEnd",
+    value: function onAnimationEnd(event) {
+      if (event.animationName === _classPrivateFieldGet(_lastAnimationName, this)) {
+        var _this$eventCounter, _this$eventCounter2;
+        _classPrivateFieldSet(_eventCounter, this, (_this$eventCounter = _classPrivateFieldGet(_eventCounter, this), _this$eventCounter2 = _this$eventCounter++, _this$eventCounter)), _this$eventCounter2;
+        _classPrivateFieldSet(_eventCounter, this, _classPrivateFieldGet(_eventCounter, this) % 2);
+        if (!_classPrivateFieldGet(_eventCounter, this)) {
+          var _this$times;
+          if (this.isBouncing && (_classPrivateFieldGet(_times, this) === null || _classPrivateFieldSet(_times, this, (_this$times = _classPrivateFieldGet(_times, this), --_this$times)))) {
+            resetClasses(this.marker._icon, _classPrivateFieldGet(_classes, this));
+            if (this.marker._shadow && this.bouncingOptions.shadowAngle) {
+              resetClasses(this.marker._shadow, _classPrivateFieldGet(_classes, this));
+            }
+          } else {
+            this._stopBouncingAnimation();
+          }
+        }
+      }
+    }
+  }, {
+    key: "resetStyles",
+    value: function resetStyles(marker) {
+      var _this$marker$getIcon,
+        _this$marker,
+        _this2 = this;
+      this.marker = marker;
+      this.iconStyles = _Styles["default"].ofMarker(marker);
+      if (marker._shadow) {
+        this.shadowStyles = _Styles["default"].parse(marker._shadow.style.cssText);
+      }
+      var iconHeight = ((_this$marker$getIcon = this.marker.getIcon()) === null || _this$marker$getIcon === void 0 || (_this$marker$getIcon = _this$marker$getIcon.options) === null || _this$marker$getIcon === void 0 ? void 0 : _this$marker$getIcon.iconSize[1]) || ((_this$marker = this.marker) === null || _this$marker === void 0 || (_this$marker = _this$marker._iconObj) === null || _this$marker === void 0 || (_this$marker = _this$marker.options) === null || _this$marker === void 0 ? void 0 : _this$marker.iconSize[1]);
+      var iconAnimationParams = BouncingMotionCss3.animationParams(this.position, this.bouncingOptions, iconHeight);
+      this.iconStyles = this.iconStyles.withStyles(iconAnimationParams);
+      this.marker._icon.style.cssText = this.iconStyles.toString();
+      if (this.bouncingAnimationPlaying) {
+        resetClasses(this.marker._icon, _classPrivateFieldGet(_classes, this));
+        this.marker._icon.addEventListener('animationend', _classPrivateFieldGet(_listener, this));
+      }
+      var _this$bouncingOptions = this.bouncingOptions,
+        bounceHeight = _this$bouncingOptions.bounceHeight,
+        contractHeight = _this$bouncingOptions.contractHeight,
+        shadowAngle = _this$bouncingOptions.shadowAngle;
+      if (this.marker._shadow) {
+        if (shadowAngle) {
+          var _this$marker$getIcon2;
+          var _this$position = this.position,
+            x = _this$position.x,
+            y = _this$position.y;
+          var points = (0, _line.calculateLine)(x, y, shadowAngle, bounceHeight + 1);
+          var _points$bounceHeight = _slicedToArray(points[bounceHeight], 2),
+            posXJump = _points$bounceHeight[0],
+            posYJump = _points$bounceHeight[1];
+          var shadowHeight = (_this$marker$getIcon2 = this.marker.getIcon()) === null || _this$marker$getIcon2 === void 0 || (_this$marker$getIcon2 = _this$marker$getIcon2.options) === null || _this$marker$getIcon2 === void 0 ? void 0 : _this$marker$getIcon2.shadowSize[1];
+          var shadowScaleContract = BouncingMotionCss3.contractScale(shadowHeight, contractHeight);
+          this.shadowStyles = this.shadowStyles.withStyles(iconAnimationParams).withStyles({
+            '--pos-x-jump': "".concat(posXJump, "px"),
+            '--pos-y-jump': "".concat(posYJump, "px"),
+            '--scale-contract': shadowScaleContract
+          });
+          this.marker._shadow.style.cssText = this.shadowStyles.toString();
+          if (this.bouncingAnimationPlaying) {
+            resetClasses(this.marker._shadow, _classPrivateFieldGet(_classes, this));
+          }
+        } else {
+          _classPrivateFieldGet(_classes, this).forEach(function (className) {
+            _leaflet.DomUtil.removeClass(_this2.marker._shadow, className);
+          });
+        }
+      }
+    }
+  }, {
+    key: "bounce",
+    value: function bounce() {
+      var times = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+      _classPrivateFieldSet(_times, this, times);
+      this.isBouncing = true;
+      if (this.bouncingAnimationPlaying) {
+        return;
+      }
+      _classPrivateFieldSet(_eventCounter, this, 0);
+      this.bouncingAnimationPlaying = true;
+      resetClasses(this.marker._icon, _classPrivateFieldGet(_classes, this));
+      if (this.marker._shadow && this.bouncingOptions.shadowAngle) {
+        resetClasses(this.marker._shadow, _classPrivateFieldGet(_classes, this));
+      }
+      this.marker._icon.addEventListener('animationend', _classPrivateFieldGet(_listener, this));
+    }
+  }, {
+    key: "stopBouncing",
+    value: function stopBouncing() {
+      var immediate = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+      this.isBouncing = false;
+      immediate || (immediate = this.bouncingOptions.immediateStop);
+      if (immediate) {
+        this._stopBouncingAnimation();
+      }
+    }
+  }, {
+    key: "_stopBouncingAnimation",
+    value: function _stopBouncingAnimation() {
+      var _this3 = this;
+      _classPrivateFieldGet(_classes, this).forEach(function (className) {
+        _leaflet.DomUtil.removeClass(_this3.marker._icon, className);
+        if (_this3.marker._shadow) {
+          _leaflet.DomUtil.removeClass(_this3.marker._shadow, className);
+        }
+      });
+      this.bouncingAnimationPlaying = false;
+      if (this.onMotionEnd) {
+        this.onMotionEnd();
+        this.onMotionEnd = null;
+      }
+      this.marker.fire('bounceend');
+    }
+
+    /**
+     * Calculates parameters of CSS3 animation of bouncing.
+     *
+     * @param position {Point}  marker current position on the map canvas
+     * @param bouncingOptions {BouncingOptions}  options of bouncing animation
+     * @param height {number}  icons height
+     * @return {object} CSS3 animation parameters
+     */
+  }], [{
+    key: "animationParams",
+    value: function animationParams(position, bouncingOptions, height) {
+      var x = position.x,
+        y = position.y;
+      var bounceHeight = bouncingOptions.bounceHeight,
+        contractHeight = bouncingOptions.contractHeight,
+        bounceSpeed = bouncingOptions.bounceSpeed,
+        contractSpeed = bouncingOptions.contractSpeed;
+      var scaleContract = BouncingMotionCss3.contractScale(height, contractHeight);
+      var durationJump = BouncingMotionCss3.calculateDuration(bounceHeight, bounceSpeed);
+      var durationContract = BouncingMotionCss3.calculateDuration(contractHeight, contractSpeed);
+      var delays = [0, durationJump, durationJump * 2, durationJump * 2 + durationContract];
+      return {
+        '--pos-x': "".concat(x, "px"),
+        '--pos-y': "".concat(y, "px"),
+        '--pos-y-jump': "".concat(y - bounceHeight, "px"),
+        '--pos-y-contract': "".concat(y + contractHeight, "px"),
+        '--scale-contract': scaleContract,
+        '--duration-jump': "".concat(durationJump, "ms"),
+        '--duration-contract': "".concat(durationContract, "ms"),
+        '--delays': "0ms, ".concat(delays[1], "ms, ").concat(delays[2], "ms, ").concat(delays[3], "ms")
+      };
+    }
+
+    /**
+     * Calculates scale of contracting.
+     *
+     * @param {number} height  original height
+     * @param {number} contractHeight  how much it must contract
+     * @return {number}  contracting scale between 0 and 1
+     */
+  }, {
+    key: "contractScale",
+    value: function contractScale(height, contractHeight) {
+      return (height - contractHeight) / height;
+    }
+
+    /**
+     * Calculates duration of animation.
+     *
+     * @param height {number}  height of movement or resizing (px)
+     * @param speed {number}  speed coefficient
+     *
+     * @return {number} duration of animation (ms)
+     */
+  }, {
+    key: "calculateDuration",
+    value: function calculateDuration(height, speed) {
+      if (height === 0) {
+        return 0;
+      }
+      var duration = Math.round(speed * speedCoefficient);
+      var i = height;
+      while (--i) {
+        duration += Math.round(speed / (height - i));
+      }
+      return duration;
+    }
+  }]);
+}();

node_modules/leaflet.smooth_marker_bouncing/dist/BouncingMotionSimple.js

@@ -0,0 +1,153 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _BouncingMotion2 = _interopRequireDefault(require("./BouncingMotion"));
+
+var _line = require("./line");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
+
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+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; }
+
+var BouncingMotionSimple = /*#__PURE__*/function (_BouncingMotion) {
+  _inherits(BouncingMotionSimple, _BouncingMotion);
+
+  var _super = _createSuper(BouncingMotionSimple);
+
+  /**
+   * Constructor.
+   *
+   * @param marker {Marker}  marker
+   * @param position {Point}  marker current position on the map canvas
+   * @param bouncingOptions {BouncingOptions}  options of bouncing animation
+   */
+  function BouncingMotionSimple(marker, position, bouncingOptions) {
+    var _this;
+
+    _classCallCheck(this, BouncingMotionSimple);
+
+    _this = _super.call(this, marker, position, bouncingOptions);
+
+    _defineProperty(_assertThisInitialized(_this), "iconMovePoints", void 0);
+
+    _defineProperty(_assertThisInitialized(_this), "shadowMovePoints", void 0);
+
+    _this.recalculateMotion(position);
+
+    return _this;
+  }
+
+  _createClass(BouncingMotionSimple, [{
+    key: "recalculateMotion",
+    value: function recalculateMotion(position) {
+      _get(_getPrototypeOf(BouncingMotionSimple.prototype), "recalculateMotion", this).call(this, position);
+
+      var x = position.x,
+          y = position.y;
+      var _this$bouncingOptions = this.bouncingOptions,
+          bounceHeight = _this$bouncingOptions.bounceHeight,
+          shadowAngle = _this$bouncingOptions.shadowAngle;
+      this.iconMovePoints = BouncingMotionSimple.calculateIconMovePoints(x, y, bounceHeight);
+      this.shadowMovePoints = BouncingMotionSimple.calculateShadowMovePoints(x, y, bounceHeight, shadowAngle);
+    }
+  }, {
+    key: "makeMoveStep",
+    value: function makeMoveStep(step) {
+      _get(_getPrototypeOf(BouncingMotionSimple.prototype), "makeMoveStep", this).call(this, step);
+
+      this.marker._icon.style.left = this.iconMovePoints[step][0] + 'px';
+      this.marker._icon.style.top = this.iconMovePoints[step][1] + 'px';
+
+      if (this.marker._shadow) {
+        this.marker._shadow.style.left = this.shadowMovePoints[step][0] + 'px';
+        this.marker._shadow.style.top = this.shadowMovePoints[step][1] + 'px';
+      }
+    }
+    /**
+     * Returns calculated array of points for icon movement. Used to animate markers in browsers
+     * that doesn't support 'transform' attribute.
+     *
+     * @param x {number}  x coordinate of original position of the marker
+     * @param y {number}  y coordinate of original position of the marker
+     * @param bounceHeight {number}  height of bouncing (px)
+     *
+     * @return {[number, number][]} array of points
+     */
+
+  }], [{
+    key: "calculateIconMovePoints",
+    value: function calculateIconMovePoints(x, y, bounceHeight) {
+      var deltaHeight = bounceHeight + 1;
+      var points = []; // Use fast inverse while loop to fill the array
+
+      while (deltaHeight--) {
+        points[deltaHeight] = [x, y - deltaHeight];
+      }
+
+      return points;
+    }
+    /**
+     * Returns calculated array of points for shadow movement. Used to animate markers in browsers
+     * that doesn't support 'transform' attribute.
+     *
+     * @param x {number}  x coordinate of original position of the marker
+     * @param y {number}  y coordinate of original position of the marker
+     * @param bounceHeight {number}  height of bouncing (px)
+     * @param angle {number}  shadow inclination angle, if null shadow don't moves from it's initial
+     *      position (radians)
+     *
+     * @return {[number, number][]} array of points
+     */
+
+  }, {
+    key: "calculateShadowMovePoints",
+    value: function calculateShadowMovePoints(x, y, bounceHeight, angle) {
+      if (angle != null) {
+        // important: 0 is not null
+        return (0, _line.calculateLine)(x, y, angle, bounceHeight + 1);
+      } else {
+        var points = [];
+
+        for (var i = 0; i <= bounceHeight; i++) {
+          points[i] = [x, y];
+        }
+
+        return points;
+      }
+    }
+  }]);
+
+  return BouncingMotionSimple;
+}(_BouncingMotion2["default"]);
+
+exports["default"] = BouncingMotionSimple;

node_modules/leaflet.smooth_marker_bouncing/dist/BouncingOptions.js

@@ -0,0 +1,66 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+var BouncingOptions = exports["default"] = /*#__PURE__*/function () {
+  function BouncingOptions(options) {
+    _classCallCheck(this, BouncingOptions);
+    /**
+     * How high marker can bounce (px)
+     * @type {number}
+     */
+    _defineProperty(this, "bounceHeight", 15);
+    /**
+     * How much marker can contract (px)
+     * @type {number}
+     */
+    _defineProperty(this, "contractHeight", 12);
+    /**
+     * Bouncing speed coefficient
+     * @type {number}
+     */
+    _defineProperty(this, "bounceSpeed", 52);
+    /**
+     * Contracting speed coefficient
+     * @type {number}
+     */
+    _defineProperty(this, "contractSpeed", 52);
+    /**
+     * Shadow inclination angle(radians); null to cancel shadow movement
+     * @type {number}
+     */
+    _defineProperty(this, "shadowAngle", -Math.PI / 4);
+    /**
+     * Activate contract animation
+     * @type {boolean}
+     */
+    _defineProperty(this, "elastic", true);
+    /**
+     * Many markers can bounce in the same time
+     * @type {boolean}
+     */
+    _defineProperty(this, "exclusive", false);
+    /**
+     * If true, when marker stops, it does not execute animation until its end, but instead stops
+     * abruptly.
+     * @type {boolean}
+     */
+    _defineProperty(this, "immediateStop", false);
+    options && Object.assign(this, options);
+  }
+  return _createClass(BouncingOptions, [{
+    key: "override",
+    value: function override(options) {
+      return Object.assign(new BouncingOptions(this), options);
+    }
+  }]);
+}();

node_modules/leaflet.smooth_marker_bouncing/dist/Cache.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+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; }
+
+var Cache = /*#__PURE__*/function () {
+  function Cache() {
+    _classCallCheck(this, Cache);
+
+    _defineProperty(this, "cache", {});
+  }
+
+  _createClass(Cache, [{
+    key: "get",
+
+    /**
+     * If item with supplied {@code key} is present in cache, returns it, otherwise executes
+     * {@code supplier} function and caches the result.
+     *
+     * @param key {String}  key of the cache
+     * @param supplier {function}  item supplier
+     * @return {Object}  item
+     */
+    value: function get(key, supplier) {
+      return this.cache[key] || (this.cache[key] = supplier.apply());
+    }
+  }]);
+
+  return Cache;
+}();
+
+exports["default"] = Cache;

node_modules/leaflet.smooth_marker_bouncing/dist/MarkerPrototypeExt.js

@@ -0,0 +1,107 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = MarkerPrototypeExt;
+var _BouncingOptions = _interopRequireDefault(require("./BouncingOptions"));
+var _Orchestration = _interopRequireDefault(require("./Orchestration"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+function MarkerPrototypeExt(Leaflet) {
+  var oldSetPos = Leaflet.Marker.prototype._setPos;
+  var oldOnAdd = Leaflet.Marker.prototype.onAdd;
+  var oldSetIcon = Leaflet.Marker.prototype.setIcon;
+  return {
+    /** Bouncing options shared by all markers. */
+    _bouncingOptions: new _BouncingOptions["default"](),
+    _orchestration: new _Orchestration["default"](),
+    _realMarker: true,
+    /**
+     * Registers options of bouncing animation for this marker. After registration of options for
+     * this marker, it will ignore changes of default options. Function automatically recalculates
+     * animation steps and delays.
+     *
+     * @param options {BouncingOptions}  options object
+     * @return {Marker} this marker
+     */
+    setBouncingOptions: function setBouncingOptions(options) {
+      this._bouncingMotion.updateBouncingOptions(options);
+      return this;
+    },
+    /**
+     * Returns true if this marker is bouncing. If this marker is not bouncing returns false.
+     * @return {boolean} true if marker is bouncing, false if not
+     */
+    isBouncing: function isBouncing() {
+      return this._bouncingMotion.isBouncing;
+    },
+    /**
+     * Starts bouncing of this marker.
+     * @param times {number|null}  number of times the marker must to bounce
+     * @return {Marker} this marker
+     */
+    bounce: function bounce() {
+      var _this = this;
+      var times = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+      if (times) {
+        this._bouncingMotion.onMotionEnd = function () {
+          Leaflet.Marker.prototype._orchestration.removeBouncingMarker(_this);
+        };
+      }
+      this._bouncingMotion.bounce(times);
+      var exclusive = this._bouncingMotion.bouncingOptions.exclusive;
+      Leaflet.Marker.prototype._orchestration.addBouncingMarker(this, exclusive);
+      return this;
+    },
+    /**
+     * Stops bouncing of this marker.
+     * Note: unless 'immediate' flag is set to true, by the call to this method or in marker options,
+     * the bouncing will not stop immediately after the call of this method. Instead, the animation
+     * is executed until marker returns to its original position and takes its full size.
+     *
+     * @param immediate {boolean}  if true, marker stop to bounce immediately, without waiting
+     *      animation to end
+     * @return {Marker} this marker
+     */
+    stopBouncing: function stopBouncing() {
+      var immediate = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+      this._bouncingMotion.stopBouncing(immediate);
+      Leaflet.Marker.prototype._orchestration.removeBouncingMarker(this);
+      return this;
+    },
+    /**
+     * Starts/stops bouncing of this marker.
+     * @return {Marker} marker
+     */
+    toggleBouncing: function toggleBouncing() {
+      if (this._bouncingMotion.isBouncing) {
+        this.stopBouncing();
+      } else {
+        this.bounce();
+      }
+      return this;
+    },
+    isRealMarker: function isRealMarker() {
+      return Object.hasOwn(this.__proto__, '_realMarker');
+    },
+    _setPos: function _setPos(position) {
+      oldSetPos.call(this, position);
+      if (this.isRealMarker()) {
+        this._bouncingMotion.position = position;
+        this._bouncingMotion.resetStyles(this);
+      }
+    },
+    onAdd: function onAdd(map) {
+      oldOnAdd.call(this, map);
+      if (this.isRealMarker()) {
+        this._bouncingMotion.resetStyles(this);
+      }
+    },
+    setIcon: function setIcon(icon) {
+      oldSetIcon.call(this, icon);
+      if (this.isRealMarker() && this._icon) {
+        this._bouncingMotion.resetStyles(this);
+      }
+    }
+  };
+}

node_modules/leaflet.smooth_marker_bouncing/dist/Matrix3D.js

@@ -0,0 +1,106 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _classPrivateFieldGet(receiver, privateMap) { var descriptor = privateMap.get(receiver); if (!descriptor) { throw new TypeError("attempted to get private field on non-instance"); } if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
+
+function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = privateMap.get(receiver); if (!descriptor) { throw new TypeError("attempted to set private field on non-instance"); } if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } return value; }
+
+var rowMap = {
+  'a': 0,
+  'b': 1,
+  'c': 2,
+  'd': 3
+};
+var zeros = Array(16).fill(0);
+var _identity = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+/**
+ * @see https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/matrix3d
+ */
+
+var _matrix = new WeakMap();
+
+var Matrix3D = /*#__PURE__*/function () {
+  function Matrix3D() {
+    var matrix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : zeros;
+
+    _classCallCheck(this, Matrix3D);
+
+    _matrix.set(this, {
+      writable: true,
+      value: void 0
+    });
+
+    _classPrivateFieldSet(this, _matrix, _toConsumableArray(matrix));
+  }
+
+  _createClass(Matrix3D, [{
+    key: "toFormat",
+    value: function toFormat() {
+      for (var _len = arguments.length, placeholders = new Array(_len), _key = 0; _key < _len; _key++) {
+        placeholders[_key] = arguments[_key];
+      }
+
+      placeholders = placeholders.map(Matrix3D.valueNameToIndex);
+      var nextPlaceholderIndex = 0;
+
+      var fnBody = _classPrivateFieldGet(this, _matrix).map(function (value, index) {
+        return index === placeholders[nextPlaceholderIndex] ? "'+arguments[".concat(nextPlaceholderIndex++, "]+'") : value;
+      }).join(',');
+
+      fnBody = "return ' matrix3d(".concat(fnBody, ") ';");
+
+      function formatFn() {
+        return Function.apply(this, [fnBody]);
+      }
+
+      formatFn.prototype = Function.prototype;
+      return new formatFn();
+    }
+  }, {
+    key: "toString",
+    value: function toString() {
+      return " matrix3d(".concat(_classPrivateFieldGet(this, _matrix).join(','), ") ");
+    }
+  }], [{
+    key: "zeros",
+    value: function zeros() {
+      return new Matrix3D();
+    }
+  }, {
+    key: "identity",
+    value: function identity() {
+      return new Matrix3D(_identity);
+    }
+  }, {
+    key: "valueNameToIndex",
+    value: function valueNameToIndex(valueName) {
+      return rowMap[valueName[0]] * 4 + parseInt(valueName[1]) - 1;
+    }
+  }]);
+
+  return Matrix3D;
+}();
+
+exports["default"] = Matrix3D;

node_modules/leaflet.smooth_marker_bouncing/dist/Orchestration.js

@@ -0,0 +1,91 @@
+"use strict";
+
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _classPrivateFieldInitSpec(e, t, a) { _checkPrivateRedeclaration(e, t), t.set(e, a); }
+function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
+function _classPrivateFieldGet(s, a) { return s.get(_assertClassBrand(s, a)); }
+function _assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; throw new TypeError("Private element is not present on this object"); }
+var _bouncingMarkers = /*#__PURE__*/new WeakMap();
+var Orchestration = exports["default"] = /*#__PURE__*/function () {
+  function Orchestration() {
+    _classCallCheck(this, Orchestration);
+    _classPrivateFieldInitSpec(this, _bouncingMarkers, []);
+  }
+  return _createClass(Orchestration, [{
+    key: "getBouncingMarkers",
+    value: function getBouncingMarkers() {
+      return _classPrivateFieldGet(_bouncingMarkers, this);
+    }
+
+    /**
+     * Adds the marker to the list of bouncing markers.
+     * If flag 'exclusive' is set to true, stops all bouncing markers before.
+     *
+     * @param marker {Marker}  marker object
+     * @param exclusive {boolean}  flag of exclusive bouncing. If set to true, stops the bouncing
+     *      of all other markers.
+     */
+  }, {
+    key: "addBouncingMarker",
+    value: function addBouncingMarker(marker, exclusive) {
+      if (exclusive || marker._bouncingMotion.bouncingOptions.exclusive) {
+        this.stopAllBouncingMarkers();
+      } else {
+        this.stopExclusiveMarkerBouncing();
+      }
+      _classPrivateFieldGet(_bouncingMarkers, this).push(marker);
+    }
+
+    /**
+     * Stops the bouncing of exclusive marker.
+     */
+  }, {
+    key: "stopExclusiveMarkerBouncing",
+    value: function stopExclusiveMarkerBouncing() {
+      var exclusiveMarker = _classPrivateFieldGet(_bouncingMarkers, this).find(function (marker) {
+        return marker._bouncingMotion.bouncingOptions.exclusive;
+      });
+      if (exclusiveMarker) {
+        exclusiveMarker.stopBouncing();
+      }
+    }
+
+    /**
+     * Removes the marker from the list of bouncing markers.
+     * @param marker {Marker}  marker
+     */
+  }, {
+    key: "removeBouncingMarker",
+    value: function removeBouncingMarker(marker) {
+      var i = _classPrivateFieldGet(_bouncingMarkers, this).indexOf(marker);
+      if (~i) {
+        _classPrivateFieldGet(_bouncingMarkers, this).splice(i, 1);
+      }
+    }
+
+    /**
+     * Stops the bouncing of all currently bouncing markers. Purge the array of bouncing markers.
+     *
+     * @param immediate {boolean} if true, markers stop to bounce immediately, without waiting
+     *      animation to end
+     */
+  }, {
+    key: "stopAllBouncingMarkers",
+    value: function stopAllBouncingMarkers() {
+      var immediate = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+      var marker;
+      while (marker = _classPrivateFieldGet(_bouncingMarkers, this).shift()) {
+        marker.stopBouncing(immediate);
+      }
+    }
+  }]);
+}();

node_modules/leaflet.smooth_marker_bouncing/dist/SmoothMarkerBouncing.js

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = SmoothMarkerBouncing;
+var _BouncingOptions = _interopRequireDefault(require("./BouncingOptions"));
+var _MarkerPrototypeExt = _interopRequireDefault(require("./MarkerPrototypeExt"));
+var _BouncingMotionCss = _interopRequireDefault(require("./BouncingMotionCss3"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+function SmoothMarkerBouncing(Leaflet) {
+  Leaflet.Marker.include((0, _MarkerPrototypeExt["default"])(Leaflet));
+
+  /**
+   * Registers default options of bouncing animation.
+   * @param options {BouncingOptions|object}  object with options
+   */
+  Leaflet.Marker.setBouncingOptions = function (options) {
+    Leaflet.Marker.prototype._bouncingOptions = options instanceof _BouncingOptions["default"] ? options : new _BouncingOptions["default"](options);
+  };
+
+  /**
+   * Returns array of currently bouncing markers.
+   * @return {Marker[]} array of bouncing markers
+   */
+  Leaflet.Marker.getBouncingMarkers = function () {
+    return Leaflet.Marker.prototype._orchestration.getBouncingMarkers();
+  };
+
+  /**
+   * Stops the bouncing of all currently bouncing markers. Purge the array of bouncing markers.
+   *
+   * @param immediate {boolean}  if true, markers stop to bounce immediately, without waiting
+   *      animation to end
+   */
+  Leaflet.Marker.stopAllBouncingMarkers = function () {
+    var immediate = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+    Leaflet.Marker.prototype._orchestration.stopAllBouncingMarkers(immediate);
+  };
+  Leaflet.Marker.addInitHook(function () {
+    if (this.isRealMarker()) {
+      var bouncingOptions = new _BouncingOptions["default"](Leaflet.Marker.prototype._bouncingOptions);
+      this._bouncingMotion = new _BouncingMotionCss["default"](this, new Leaflet.Point(0, 0), bouncingOptions);
+    }
+  });
+  return Leaflet;
+}

node_modules/leaflet.smooth_marker_bouncing/dist/Styles.js

@@ -0,0 +1,79 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+/** Regex to parse style definitions. */
+var regStyle = /([\w-]+): ([^;]+);/g;
+var Styles = exports["default"] = /*#__PURE__*/function () {
+  function Styles(styles) {
+    _classCallCheck(this, Styles);
+    styles && Object.assign(this, styles);
+  }
+  return _createClass(Styles, [{
+    key: "findOpacity",
+    value: function findOpacity(options) {
+      this.opacity = (options === null || options === void 0 ? void 0 : options.opacityWhenUnclustered // used by cluster plugin
+      ) || (options === null || options === void 0 ? void 0 : options.opacity) || 1;
+    }
+
+    /**
+     * Creates a copy of styles merged with provided 'styles'.
+     * @param {Object} styles  object with styles to merge
+     * @return {Styles} copy of styles
+     */
+  }, {
+    key: "withStyles",
+    value: function withStyles(styles) {
+      var copy = new Styles(this);
+      copy && Object.assign(copy, styles);
+      return copy;
+    }
+  }, {
+    key: "toString",
+    value: function toString() {
+      return Object.entries(this).map(function (entry) {
+        return "".concat(entry[0], ": ").concat(entry[1], ";");
+      }).join(' ');
+    }
+
+    /**
+     * Parses cssText attribute into Styles object.
+     * @param cssText {string}  cssText string
+     * @return {Styles} Styles object
+     */
+  }], [{
+    key: "parse",
+    value: function parse(cssText) {
+      var styles = {};
+      var match = regStyle.exec(cssText);
+      while (match) {
+        styles[match[1]] = match[2];
+        match = regStyle.exec(cssText);
+      }
+      delete styles['z-index'];
+      delete styles['opacity'];
+      styles['outline'] = 'none';
+      return new Styles(styles);
+    }
+
+    /**
+     * @param marker {Marker}
+     */
+  }, {
+    key: "ofMarker",
+    value: function ofMarker(marker) {
+      var styles = Styles.parse(marker._icon.style.cssText);
+      styles.findOpacity(marker.options);
+      styles['z-index'] = marker._zIndex;
+      return styles;
+    }
+  }]);
+}();

node_modules/leaflet.smooth_marker_bouncing/dist/bundle.js

@@ -0,0 +1,780 @@
+(function (L) {
+  'use strict';
+
+  function _arrayLikeToArray(r, a) {
+    (null == a || a > r.length) && (a = r.length);
+    for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+    return n;
+  }
+  function _arrayWithHoles(r) {
+    if (Array.isArray(r)) return r;
+  }
+  function _assertClassBrand(e, t, n) {
+    if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n;
+    throw new TypeError("Private element is not present on this object");
+  }
+  function _checkPrivateRedeclaration(e, t) {
+    if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+  }
+  function _classCallCheck(a, n) {
+    if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
+  }
+  function _classPrivateFieldGet2(s, a) {
+    return s.get(_assertClassBrand(s, a));
+  }
+  function _classPrivateFieldInitSpec(e, t, a) {
+    _checkPrivateRedeclaration(e, t), t.set(e, a);
+  }
+  function _classPrivateFieldSet2(s, a, r) {
+    return s.set(_assertClassBrand(s, a), r), r;
+  }
+  function _defineProperties(e, r) {
+    for (var t = 0; t < r.length; t++) {
+      var o = r[t];
+      o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o);
+    }
+  }
+  function _createClass(e, r, t) {
+    return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", {
+      writable: !1
+    }), e;
+  }
+  function _defineProperty(e, r, t) {
+    return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+      value: t,
+      enumerable: !0,
+      configurable: !0,
+      writable: !0
+    }) : e[r] = t, e;
+  }
+  function _iterableToArrayLimit(r, l) {
+    var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+    if (null != t) {
+      var e,
+        n,
+        i,
+        u,
+        a = [],
+        f = !0,
+        o = !1;
+      try {
+        if (i = (t = t.call(r)).next, 0 === l) ; else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
+      } catch (r) {
+        o = !0, n = r;
+      } finally {
+        try {
+          if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
+        } finally {
+          if (o) throw n;
+        }
+      }
+      return a;
+    }
+  }
+  function _nonIterableRest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  function _slicedToArray(r, e) {
+    return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
+  }
+  function _toPrimitive(t, r) {
+    if ("object" != typeof t || !t) return t;
+    var e = t[Symbol.toPrimitive];
+    if (void 0 !== e) {
+      var i = e.call(t, r);
+      if ("object" != typeof i) return i;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return (String )(t);
+  }
+  function _toPropertyKey(t) {
+    var i = _toPrimitive(t, "string");
+    return "symbol" == typeof i ? i : i + "";
+  }
+  function _unsupportedIterableToArray(r, a) {
+    if (r) {
+      if ("string" == typeof r) return _arrayLikeToArray(r, a);
+      var t = {}.toString.call(r).slice(8, -1);
+      return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
+    }
+  }
+
+  var BouncingOptions = /*#__PURE__*/function () {
+    function BouncingOptions(options) {
+      _classCallCheck(this, BouncingOptions);
+      /**
+       * How high marker can bounce (px)
+       * @type {number}
+       */
+      _defineProperty(this, "bounceHeight", 15);
+      /**
+       * How much marker can contract (px)
+       * @type {number}
+       */
+      _defineProperty(this, "contractHeight", 12);
+      /**
+       * Bouncing speed coefficient
+       * @type {number}
+       */
+      _defineProperty(this, "bounceSpeed", 52);
+      /**
+       * Contracting speed coefficient
+       * @type {number}
+       */
+      _defineProperty(this, "contractSpeed", 52);
+      /**
+       * Shadow inclination angle(radians); null to cancel shadow movement
+       * @type {number}
+       */
+      _defineProperty(this, "shadowAngle", -Math.PI / 4);
+      /**
+       * Activate contract animation
+       * @type {boolean}
+       */
+      _defineProperty(this, "elastic", true);
+      /**
+       * Many markers can bounce in the same time
+       * @type {boolean}
+       */
+      _defineProperty(this, "exclusive", false);
+      /**
+       * If true, when marker stops, it does not execute animation until its end, but instead stops
+       * abruptly.
+       * @type {boolean}
+       */
+      _defineProperty(this, "immediateStop", false);
+      options && Object.assign(this, options);
+    }
+    return _createClass(BouncingOptions, [{
+      key: "override",
+      value: function override(options) {
+        return Object.assign(new BouncingOptions(this), options);
+      }
+    }]);
+  }();
+
+  var _bouncingMarkers = /*#__PURE__*/new WeakMap();
+  var Orchestration = /*#__PURE__*/function () {
+    function Orchestration() {
+      _classCallCheck(this, Orchestration);
+      _classPrivateFieldInitSpec(this, _bouncingMarkers, []);
+    }
+    return _createClass(Orchestration, [{
+      key: "getBouncingMarkers",
+      value: function getBouncingMarkers() {
+        return _classPrivateFieldGet2(_bouncingMarkers, this);
+      }
+
+      /**
+       * Adds the marker to the list of bouncing markers.
+       * If flag 'exclusive' is set to true, stops all bouncing markers before.
+       *
+       * @param marker {Marker}  marker object
+       * @param exclusive {boolean}  flag of exclusive bouncing. If set to true, stops the bouncing
+       *      of all other markers.
+       */
+    }, {
+      key: "addBouncingMarker",
+      value: function addBouncingMarker(marker, exclusive) {
+        if (exclusive || marker._bouncingMotion.bouncingOptions.exclusive) {
+          this.stopAllBouncingMarkers();
+        } else {
+          this.stopExclusiveMarkerBouncing();
+        }
+        _classPrivateFieldGet2(_bouncingMarkers, this).push(marker);
+      }
+
+      /**
+       * Stops the bouncing of exclusive marker.
+       */
+    }, {
+      key: "stopExclusiveMarkerBouncing",
+      value: function stopExclusiveMarkerBouncing() {
+        var exclusiveMarker = _classPrivateFieldGet2(_bouncingMarkers, this).find(function (marker) {
+          return marker._bouncingMotion.bouncingOptions.exclusive;
+        });
+        if (exclusiveMarker) {
+          exclusiveMarker.stopBouncing();
+        }
+      }
+
+      /**
+       * Removes the marker from the list of bouncing markers.
+       * @param marker {Marker}  marker
+       */
+    }, {
+      key: "removeBouncingMarker",
+      value: function removeBouncingMarker(marker) {
+        var i = _classPrivateFieldGet2(_bouncingMarkers, this).indexOf(marker);
+        if (~i) {
+          _classPrivateFieldGet2(_bouncingMarkers, this).splice(i, 1);
+        }
+      }
+
+      /**
+       * Stops the bouncing of all currently bouncing markers. Purge the array of bouncing markers.
+       *
+       * @param immediate {boolean} if true, markers stop to bounce immediately, without waiting
+       *      animation to end
+       */
+    }, {
+      key: "stopAllBouncingMarkers",
+      value: function stopAllBouncingMarkers() {
+        var immediate = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+        var marker;
+        while (marker = _classPrivateFieldGet2(_bouncingMarkers, this).shift()) {
+          marker.stopBouncing(immediate);
+        }
+      }
+    }]);
+  }();
+
+  function MarkerPrototypeExt(Leaflet) {
+    var oldSetPos = Leaflet.Marker.prototype._setPos;
+    var oldOnAdd = Leaflet.Marker.prototype.onAdd;
+    var oldSetIcon = Leaflet.Marker.prototype.setIcon;
+    return {
+      /** Bouncing options shared by all markers. */
+      _bouncingOptions: new BouncingOptions(),
+      _orchestration: new Orchestration(),
+      _realMarker: true,
+      /**
+       * Registers options of bouncing animation for this marker. After registration of options for
+       * this marker, it will ignore changes of default options. Function automatically recalculates
+       * animation steps and delays.
+       *
+       * @param options {BouncingOptions}  options object
+       * @return {Marker} this marker
+       */
+      setBouncingOptions: function setBouncingOptions(options) {
+        this._bouncingMotion.updateBouncingOptions(options);
+        return this;
+      },
+      /**
+       * Returns true if this marker is bouncing. If this marker is not bouncing returns false.
+       * @return {boolean} true if marker is bouncing, false if not
+       */
+      isBouncing: function isBouncing() {
+        return this._bouncingMotion.isBouncing;
+      },
+      /**
+       * Starts bouncing of this marker.
+       * @param times {number|null}  number of times the marker must to bounce
+       * @return {Marker} this marker
+       */
+      bounce: function bounce() {
+        var _this = this;
+        var times = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+        if (times) {
+          this._bouncingMotion.onMotionEnd = function () {
+            Leaflet.Marker.prototype._orchestration.removeBouncingMarker(_this);
+          };
+        }
+        this._bouncingMotion.bounce(times);
+        var exclusive = this._bouncingMotion.bouncingOptions.exclusive;
+        Leaflet.Marker.prototype._orchestration.addBouncingMarker(this, exclusive);
+        return this;
+      },
+      /**
+       * Stops bouncing of this marker.
+       * Note: unless 'immediate' flag is set to true, by the call to this method or in marker options,
+       * the bouncing will not stop immediately after the call of this method. Instead, the animation
+       * is executed until marker returns to its original position and takes its full size.
+       *
+       * @param immediate {boolean}  if true, marker stop to bounce immediately, without waiting
+       *      animation to end
+       * @return {Marker} this marker
+       */
+      stopBouncing: function stopBouncing() {
+        var immediate = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+        this._bouncingMotion.stopBouncing(immediate);
+        Leaflet.Marker.prototype._orchestration.removeBouncingMarker(this);
+        return this;
+      },
+      /**
+       * Starts/stops bouncing of this marker.
+       * @return {Marker} marker
+       */
+      toggleBouncing: function toggleBouncing() {
+        if (this._bouncingMotion.isBouncing) {
+          this.stopBouncing();
+        } else {
+          this.bounce();
+        }
+        return this;
+      },
+      isRealMarker: function isRealMarker() {
+        return Object.hasOwn(this.__proto__, '_realMarker');
+      },
+      _setPos: function _setPos(position) {
+        oldSetPos.call(this, position);
+        if (this.isRealMarker()) {
+          this._bouncingMotion.position = position;
+          this._bouncingMotion.resetStyles(this);
+        }
+      },
+      onAdd: function onAdd(map) {
+        oldOnAdd.call(this, map);
+        if (this.isRealMarker()) {
+          this._bouncingMotion.resetStyles(this);
+        }
+      },
+      setIcon: function setIcon(icon) {
+        oldSetIcon.call(this, icon);
+        if (this.isRealMarker() && this._icon) {
+          this._bouncingMotion.resetStyles(this);
+        }
+      }
+    };
+  }
+
+  /**
+   * Calculates the points to draw the continous line on the screen. Returns the array of ordered
+   * point coordinates. Uses Bresenham algorithm.
+   *
+   * @param x {number}  x coordinate of origin
+   * @param y {number}  y coordinate of origin
+   * @param angle {number}  angle (radians)
+   * @param length {number}  length of line (px)
+   *
+   * @return {[number, number][]} array of ordered point coordinates
+   *
+   * @see http://rosettacode.org/wiki/Bitmap/Bresenham's_line_algorithm#JavaScript
+   */
+  function calculateLine(x, y, angle, length) {
+    // TODO: use something else than multiply length by 2 to calculate the line with defined
+    // length
+    var xD = Math.round(x + Math.cos(angle) * (length * 2)),
+      yD = Math.round(y + Math.sin(angle) * (length * 2)),
+      dx = Math.abs(xD - x),
+      sx = x < xD ? 1 : -1,
+      dy = Math.abs(yD - y),
+      sy = y < yD ? 1 : -1,
+      err = (dx > dy ? dx : -dy) / 2,
+      e2,
+      p = [],
+      i = 0;
+    while (true) {
+      p.push([x, y]);
+      i++;
+      if (i === length) break;
+      e2 = err;
+      if (e2 > -dx) {
+        err -= dy;
+        x += sx;
+      }
+      if (e2 < dy) {
+        err += dx;
+        y += sy;
+      }
+    }
+    return p;
+  }
+
+  function styleInject(css, ref) {
+    if ( ref === void 0 ) ref = {};
+    var insertAt = ref.insertAt;
+
+    if (typeof document === 'undefined') { return; }
+
+    var head = document.head || document.getElementsByTagName('head')[0];
+    var style = document.createElement('style');
+    style.type = 'text/css';
+
+    if (insertAt === 'top') {
+      if (head.firstChild) {
+        head.insertBefore(style, head.firstChild);
+      } else {
+        head.appendChild(style);
+      }
+    } else {
+      head.appendChild(style);
+    }
+
+    if (style.styleSheet) {
+      style.styleSheet.cssText = css;
+    } else {
+      style.appendChild(document.createTextNode(css));
+    }
+  }
+
+  var css_248z = "@keyframes l-smooth-marker-bouncing-move {\n    from {\n        transform: translate(var(--pos-x), var(--pos-y))\n    }\n    to {\n        transform: translate(var(--pos-x-jump, var(--pos-x)), var(--pos-y-jump))\n    }\n}\n\n@keyframes l-smooth-marker-bouncing-contract {\n    from {\n        transform: translate(var(--pos-x), var(--pos-y))\n    }\n    to {\n        transform: translate(var(--pos-x), var(--pos-y-contract)) scaleY(var(--scale-contract))\n    }\n}\n\n.bouncing {\n    animation-name: l-smooth-marker-bouncing-move, l-smooth-marker-bouncing-move, l-smooth-marker-bouncing-contract, l-smooth-marker-bouncing-contract;\n    animation-direction: normal, reverse, normal, reverse;\n    animation-duration: var(--duration-jump), var(--duration-jump), var(--duration-contract), var(--duration-contract);\n    animation-delay: var(--delays)\n}\n\n.bouncing.simple {\n    animation-name: l-smooth-marker-bouncing-move, l-smooth-marker-bouncing-move;\n    animation-direction: normal, reverse;\n    animation-duration: var(--duration-jump), var(--duration-jump);\n    animation-delay: var(--delays)\n}\n";
+  styleInject(css_248z);
+
+  /** Regex to parse style definitions. */
+  var regStyle = /([\w-]+): ([^;]+);/g;
+  var Styles = /*#__PURE__*/function () {
+    function Styles(styles) {
+      _classCallCheck(this, Styles);
+      styles && Object.assign(this, styles);
+    }
+    return _createClass(Styles, [{
+      key: "findOpacity",
+      value: function findOpacity(options) {
+        this.opacity = (options === null || options === void 0 ? void 0 : options.opacityWhenUnclustered // used by cluster plugin
+        ) || (options === null || options === void 0 ? void 0 : options.opacity) || 1;
+      }
+
+      /**
+       * Creates a copy of styles merged with provided 'styles'.
+       * @param {Object} styles  object with styles to merge
+       * @return {Styles} copy of styles
+       */
+    }, {
+      key: "withStyles",
+      value: function withStyles(styles) {
+        var copy = new Styles(this);
+        copy && Object.assign(copy, styles);
+        return copy;
+      }
+    }, {
+      key: "toString",
+      value: function toString() {
+        return Object.entries(this).map(function (entry) {
+          return "".concat(entry[0], ": ").concat(entry[1], ";");
+        }).join(' ');
+      }
+
+      /**
+       * Parses cssText attribute into Styles object.
+       * @param cssText {string}  cssText string
+       * @return {Styles} Styles object
+       */
+    }], [{
+      key: "parse",
+      value: function parse(cssText) {
+        var styles = {};
+        var match = regStyle.exec(cssText);
+        while (match) {
+          styles[match[1]] = match[2];
+          match = regStyle.exec(cssText);
+        }
+        delete styles['z-index'];
+        delete styles['opacity'];
+        styles['outline'] = 'none';
+        return new Styles(styles);
+      }
+
+      /**
+       * @param marker {Marker}
+       */
+    }, {
+      key: "ofMarker",
+      value: function ofMarker(marker) {
+        var styles = Styles.parse(marker._icon.style.cssText);
+        styles.findOpacity(marker.options);
+        styles['z-index'] = marker._zIndex;
+        return styles;
+      }
+    }]);
+  }();
+
+  var animationNamePrefix = 'l-smooth-marker-bouncing-';
+  var moveAnimationName = animationNamePrefix + 'move';
+  var contractAnimationName = animationNamePrefix + 'contract';
+
+  /*
+   * CSS3 animation runs faster than transform-based animation. We need to reduce speed in order
+   * to be compatible with old API.
+   */
+  var speedCoefficient = 0.8;
+
+  /**
+   * Removes and then resets required classes on the HTML element.
+   * Used as hack to restart CSS3 animation.
+   *
+   * @param element {HTMLElement}  HTML element
+   * @param classes {string[]}  names of classes
+   */
+  function resetClasses(element, classes) {
+    classes.forEach(function (className) {
+      return L.DomUtil.removeClass(element, className);
+    });
+    void element.offsetWidth;
+    classes.forEach(function (className) {
+      return L.DomUtil.addClass(element, className);
+    });
+  }
+  var _lastAnimationName = /*#__PURE__*/new WeakMap();
+  var _classes = /*#__PURE__*/new WeakMap();
+  var _eventCounter = /*#__PURE__*/new WeakMap();
+  var _times = /*#__PURE__*/new WeakMap();
+  var _listener = /*#__PURE__*/new WeakMap();
+  var BouncingMotionCss3 = /*#__PURE__*/function () {
+    /**
+     * Constructor.
+     *
+     * @param marker {Marker}  marker
+     * @param position {Point}  marker current position on the map canvas
+     * @param bouncingOptions {BouncingOptions}  options of bouncing animation
+     */
+    function BouncingMotionCss3(marker, position, bouncingOptions) {
+      var _this = this;
+      _classCallCheck(this, BouncingMotionCss3);
+      _defineProperty(this, "marker", void 0);
+      _defineProperty(this, "position", void 0);
+      _defineProperty(this, "bouncingOptions", void 0);
+      _defineProperty(this, "isBouncing", false);
+      _defineProperty(this, "iconStyles", void 0);
+      _defineProperty(this, "shadowStyles", void 0);
+      _defineProperty(this, "bouncingAnimationPlaying", false);
+      _defineProperty(this, "onMotionEnd", void 0);
+      _classPrivateFieldInitSpec(this, _lastAnimationName, contractAnimationName);
+      _classPrivateFieldInitSpec(this, _classes, ['bouncing']);
+      _classPrivateFieldInitSpec(this, _eventCounter, void 0);
+      _classPrivateFieldInitSpec(this, _times, void 0);
+      _classPrivateFieldInitSpec(this, _listener, function (event) {
+        return _this.onAnimationEnd(event);
+      });
+      this.marker = marker;
+      this.position = position;
+      this.updateBouncingOptions(bouncingOptions);
+    }
+    return _createClass(BouncingMotionCss3, [{
+      key: "updateBouncingOptions",
+      value: function updateBouncingOptions(options) {
+        this.bouncingOptions = options instanceof BouncingOptions ? options : this.bouncingOptions.override(options);
+        if (this.bouncingOptions.elastic && this.bouncingOptions.contractHeight) {
+          _classPrivateFieldSet2(_lastAnimationName, this, contractAnimationName);
+          var index = _classPrivateFieldGet2(_classes, this).indexOf('simple');
+          if (index > -1) {
+            _classPrivateFieldGet2(_classes, this).splice(index, 1);
+          }
+          if (this.marker._icon) {
+            L.DomUtil.removeClass(this.marker._icon, 'simple');
+          }
+        } else {
+          _classPrivateFieldSet2(_lastAnimationName, this, moveAnimationName);
+          _classPrivateFieldGet2(_classes, this).push('simple');
+        }
+        if (this.marker._icon) {
+          this.resetStyles(this.marker);
+        }
+      }
+    }, {
+      key: "onAnimationEnd",
+      value: function onAnimationEnd(event) {
+        if (event.animationName === _classPrivateFieldGet2(_lastAnimationName, this)) {
+          var _this$eventCounter;
+          _classPrivateFieldSet2(_eventCounter, this, (_this$eventCounter = _classPrivateFieldGet2(_eventCounter, this), _this$eventCounter++, _this$eventCounter));
+          _classPrivateFieldSet2(_eventCounter, this, _classPrivateFieldGet2(_eventCounter, this) % 2);
+          if (!_classPrivateFieldGet2(_eventCounter, this)) {
+            var _this$times;
+            if (this.isBouncing && (_classPrivateFieldGet2(_times, this) === null || _classPrivateFieldSet2(_times, this, (_this$times = _classPrivateFieldGet2(_times, this), --_this$times)))) {
+              resetClasses(this.marker._icon, _classPrivateFieldGet2(_classes, this));
+              if (this.marker._shadow && this.bouncingOptions.shadowAngle) {
+                resetClasses(this.marker._shadow, _classPrivateFieldGet2(_classes, this));
+              }
+            } else {
+              this._stopBouncingAnimation();
+            }
+          }
+        }
+      }
+    }, {
+      key: "resetStyles",
+      value: function resetStyles(marker) {
+        var _this$marker$getIcon,
+          _this$marker,
+          _this2 = this;
+        this.marker = marker;
+        this.iconStyles = Styles.ofMarker(marker);
+        if (marker._shadow) {
+          this.shadowStyles = Styles.parse(marker._shadow.style.cssText);
+        }
+        var iconHeight = ((_this$marker$getIcon = this.marker.getIcon()) === null || _this$marker$getIcon === void 0 || (_this$marker$getIcon = _this$marker$getIcon.options) === null || _this$marker$getIcon === void 0 ? void 0 : _this$marker$getIcon.iconSize[1]) || ((_this$marker = this.marker) === null || _this$marker === void 0 || (_this$marker = _this$marker._iconObj) === null || _this$marker === void 0 || (_this$marker = _this$marker.options) === null || _this$marker === void 0 ? void 0 : _this$marker.iconSize[1]);
+        var iconAnimationParams = BouncingMotionCss3.animationParams(this.position, this.bouncingOptions, iconHeight);
+        this.iconStyles = this.iconStyles.withStyles(iconAnimationParams);
+        this.marker._icon.style.cssText = this.iconStyles.toString();
+        if (this.bouncingAnimationPlaying) {
+          resetClasses(this.marker._icon, _classPrivateFieldGet2(_classes, this));
+          this.marker._icon.addEventListener('animationend', _classPrivateFieldGet2(_listener, this));
+        }
+        var _this$bouncingOptions = this.bouncingOptions,
+          bounceHeight = _this$bouncingOptions.bounceHeight,
+          contractHeight = _this$bouncingOptions.contractHeight,
+          shadowAngle = _this$bouncingOptions.shadowAngle;
+        if (this.marker._shadow) {
+          if (shadowAngle) {
+            var _this$marker$getIcon2;
+            var _this$position = this.position,
+              x = _this$position.x,
+              y = _this$position.y;
+            var points = calculateLine(x, y, shadowAngle, bounceHeight + 1);
+            var _points$bounceHeight = _slicedToArray(points[bounceHeight], 2),
+              posXJump = _points$bounceHeight[0],
+              posYJump = _points$bounceHeight[1];
+            var shadowHeight = (_this$marker$getIcon2 = this.marker.getIcon()) === null || _this$marker$getIcon2 === void 0 || (_this$marker$getIcon2 = _this$marker$getIcon2.options) === null || _this$marker$getIcon2 === void 0 ? void 0 : _this$marker$getIcon2.shadowSize[1];
+            var shadowScaleContract = BouncingMotionCss3.contractScale(shadowHeight, contractHeight);
+            this.shadowStyles = this.shadowStyles.withStyles(iconAnimationParams).withStyles({
+              '--pos-x-jump': "".concat(posXJump, "px"),
+              '--pos-y-jump': "".concat(posYJump, "px"),
+              '--scale-contract': shadowScaleContract
+            });
+            this.marker._shadow.style.cssText = this.shadowStyles.toString();
+            if (this.bouncingAnimationPlaying) {
+              resetClasses(this.marker._shadow, _classPrivateFieldGet2(_classes, this));
+            }
+          } else {
+            _classPrivateFieldGet2(_classes, this).forEach(function (className) {
+              L.DomUtil.removeClass(_this2.marker._shadow, className);
+            });
+          }
+        }
+      }
+    }, {
+      key: "bounce",
+      value: function bounce() {
+        var times = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+        _classPrivateFieldSet2(_times, this, times);
+        this.isBouncing = true;
+        if (this.bouncingAnimationPlaying) {
+          return;
+        }
+        _classPrivateFieldSet2(_eventCounter, this, 0);
+        this.bouncingAnimationPlaying = true;
+        resetClasses(this.marker._icon, _classPrivateFieldGet2(_classes, this));
+        if (this.marker._shadow && this.bouncingOptions.shadowAngle) {
+          resetClasses(this.marker._shadow, _classPrivateFieldGet2(_classes, this));
+        }
+        this.marker._icon.addEventListener('animationend', _classPrivateFieldGet2(_listener, this));
+      }
+    }, {
+      key: "stopBouncing",
+      value: function stopBouncing() {
+        var immediate = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+        this.isBouncing = false;
+        immediate || (immediate = this.bouncingOptions.immediateStop);
+        if (immediate) {
+          this._stopBouncingAnimation();
+        }
+      }
+    }, {
+      key: "_stopBouncingAnimation",
+      value: function _stopBouncingAnimation() {
+        var _this3 = this;
+        _classPrivateFieldGet2(_classes, this).forEach(function (className) {
+          L.DomUtil.removeClass(_this3.marker._icon, className);
+          if (_this3.marker._shadow) {
+            L.DomUtil.removeClass(_this3.marker._shadow, className);
+          }
+        });
+        this.bouncingAnimationPlaying = false;
+        if (this.onMotionEnd) {
+          this.onMotionEnd();
+          this.onMotionEnd = null;
+        }
+        this.marker.fire('bounceend');
+      }
+
+      /**
+       * Calculates parameters of CSS3 animation of bouncing.
+       *
+       * @param position {Point}  marker current position on the map canvas
+       * @param bouncingOptions {BouncingOptions}  options of bouncing animation
+       * @param height {number}  icons height
+       * @return {object} CSS3 animation parameters
+       */
+    }], [{
+      key: "animationParams",
+      value: function animationParams(position, bouncingOptions, height) {
+        var x = position.x,
+          y = position.y;
+        var bounceHeight = bouncingOptions.bounceHeight,
+          contractHeight = bouncingOptions.contractHeight,
+          bounceSpeed = bouncingOptions.bounceSpeed,
+          contractSpeed = bouncingOptions.contractSpeed;
+        var scaleContract = BouncingMotionCss3.contractScale(height, contractHeight);
+        var durationJump = BouncingMotionCss3.calculateDuration(bounceHeight, bounceSpeed);
+        var durationContract = BouncingMotionCss3.calculateDuration(contractHeight, contractSpeed);
+        var delays = [0, durationJump, durationJump * 2, durationJump * 2 + durationContract];
+        return {
+          '--pos-x': "".concat(x, "px"),
+          '--pos-y': "".concat(y, "px"),
+          '--pos-y-jump': "".concat(y - bounceHeight, "px"),
+          '--pos-y-contract': "".concat(y + contractHeight, "px"),
+          '--scale-contract': scaleContract,
+          '--duration-jump': "".concat(durationJump, "ms"),
+          '--duration-contract': "".concat(durationContract, "ms"),
+          '--delays': "0ms, ".concat(delays[1], "ms, ").concat(delays[2], "ms, ").concat(delays[3], "ms")
+        };
+      }
+
+      /**
+       * Calculates scale of contracting.
+       *
+       * @param {number} height  original height
+       * @param {number} contractHeight  how much it must contract
+       * @return {number}  contracting scale between 0 and 1
+       */
+    }, {
+      key: "contractScale",
+      value: function contractScale(height, contractHeight) {
+        return (height - contractHeight) / height;
+      }
+
+      /**
+       * Calculates duration of animation.
+       *
+       * @param height {number}  height of movement or resizing (px)
+       * @param speed {number}  speed coefficient
+       *
+       * @return {number} duration of animation (ms)
+       */
+    }, {
+      key: "calculateDuration",
+      value: function calculateDuration(height, speed) {
+        if (height === 0) {
+          return 0;
+        }
+        var duration = Math.round(speed * speedCoefficient);
+        var i = height;
+        while (--i) {
+          duration += Math.round(speed / (height - i));
+        }
+        return duration;
+      }
+    }]);
+  }();
+
+  function SmoothMarkerBouncing(Leaflet) {
+    Leaflet.Marker.include(MarkerPrototypeExt(Leaflet));
+
+    /**
+     * Registers default options of bouncing animation.
+     * @param options {BouncingOptions|object}  object with options
+     */
+    Leaflet.Marker.setBouncingOptions = function (options) {
+      Leaflet.Marker.prototype._bouncingOptions = options instanceof BouncingOptions ? options : new BouncingOptions(options);
+    };
+
+    /**
+     * Returns array of currently bouncing markers.
+     * @return {Marker[]} array of bouncing markers
+     */
+    Leaflet.Marker.getBouncingMarkers = function () {
+      return Leaflet.Marker.prototype._orchestration.getBouncingMarkers();
+    };
+
+    /**
+     * Stops the bouncing of all currently bouncing markers. Purge the array of bouncing markers.
+     *
+     * @param immediate {boolean}  if true, markers stop to bounce immediately, without waiting
+     *      animation to end
+     */
+    Leaflet.Marker.stopAllBouncingMarkers = function () {
+      var immediate = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+      Leaflet.Marker.prototype._orchestration.stopAllBouncingMarkers(immediate);
+    };
+    Leaflet.Marker.addInitHook(function () {
+      if (this.isRealMarker()) {
+        var bouncingOptions = new BouncingOptions(Leaflet.Marker.prototype._bouncingOptions);
+        this._bouncingMotion = new BouncingMotionCss3(this, new Leaflet.Point(0, 0), bouncingOptions);
+      }
+    });
+    return Leaflet;
+  }
+
+  SmoothMarkerBouncing(L);
+
+})(L);

node_modules/leaflet.smooth_marker_bouncing/dist/index.esm.js

@@ -0,0 +1,777 @@
+import { DomUtil } from 'leaflet';
+
+function _arrayLikeToArray(r, a) {
+  (null == a || a > r.length) && (a = r.length);
+  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+  return n;
+}
+function _arrayWithHoles(r) {
+  if (Array.isArray(r)) return r;
+}
+function _assertClassBrand(e, t, n) {
+  if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n;
+  throw new TypeError("Private element is not present on this object");
+}
+function _checkPrivateRedeclaration(e, t) {
+  if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+}
+function _classCallCheck(a, n) {
+  if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
+}
+function _classPrivateFieldGet2(s, a) {
+  return s.get(_assertClassBrand(s, a));
+}
+function _classPrivateFieldInitSpec(e, t, a) {
+  _checkPrivateRedeclaration(e, t), t.set(e, a);
+}
+function _classPrivateFieldSet2(s, a, r) {
+  return s.set(_assertClassBrand(s, a), r), r;
+}
+function _defineProperties(e, r) {
+  for (var t = 0; t < r.length; t++) {
+    var o = r[t];
+    o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o);
+  }
+}
+function _createClass(e, r, t) {
+  return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", {
+    writable: !1
+  }), e;
+}
+function _defineProperty(e, r, t) {
+  return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+    value: t,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : e[r] = t, e;
+}
+function _iterableToArrayLimit(r, l) {
+  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (null != t) {
+    var e,
+      n,
+      i,
+      u,
+      a = [],
+      f = !0,
+      o = !1;
+    try {
+      if (i = (t = t.call(r)).next, 0 === l) ; else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
+    } catch (r) {
+      o = !0, n = r;
+    } finally {
+      try {
+        if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
+      } finally {
+        if (o) throw n;
+      }
+    }
+    return a;
+  }
+}
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _slicedToArray(r, e) {
+  return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
+}
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r);
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (String )(t);
+}
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : i + "";
+}
+function _unsupportedIterableToArray(r, a) {
+  if (r) {
+    if ("string" == typeof r) return _arrayLikeToArray(r, a);
+    var t = {}.toString.call(r).slice(8, -1);
+    return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
+  }
+}
+
+var BouncingOptions = /*#__PURE__*/function () {
+  function BouncingOptions(options) {
+    _classCallCheck(this, BouncingOptions);
+    /**
+     * How high marker can bounce (px)
+     * @type {number}
+     */
+    _defineProperty(this, "bounceHeight", 15);
+    /**
+     * How much marker can contract (px)
+     * @type {number}
+     */
+    _defineProperty(this, "contractHeight", 12);
+    /**
+     * Bouncing speed coefficient
+     * @type {number}
+     */
+    _defineProperty(this, "bounceSpeed", 52);
+    /**
+     * Contracting speed coefficient
+     * @type {number}
+     */
+    _defineProperty(this, "contractSpeed", 52);
+    /**
+     * Shadow inclination angle(radians); null to cancel shadow movement
+     * @type {number}
+     */
+    _defineProperty(this, "shadowAngle", -Math.PI / 4);
+    /**
+     * Activate contract animation
+     * @type {boolean}
+     */
+    _defineProperty(this, "elastic", true);
+    /**
+     * Many markers can bounce in the same time
+     * @type {boolean}
+     */
+    _defineProperty(this, "exclusive", false);
+    /**
+     * If true, when marker stops, it does not execute animation until its end, but instead stops
+     * abruptly.
+     * @type {boolean}
+     */
+    _defineProperty(this, "immediateStop", false);
+    options && Object.assign(this, options);
+  }
+  return _createClass(BouncingOptions, [{
+    key: "override",
+    value: function override(options) {
+      return Object.assign(new BouncingOptions(this), options);
+    }
+  }]);
+}();
+
+var _bouncingMarkers = /*#__PURE__*/new WeakMap();
+var Orchestration = /*#__PURE__*/function () {
+  function Orchestration() {
+    _classCallCheck(this, Orchestration);
+    _classPrivateFieldInitSpec(this, _bouncingMarkers, []);
+  }
+  return _createClass(Orchestration, [{
+    key: "getBouncingMarkers",
+    value: function getBouncingMarkers() {
+      return _classPrivateFieldGet2(_bouncingMarkers, this);
+    }
+
+    /**
+     * Adds the marker to the list of bouncing markers.
+     * If flag 'exclusive' is set to true, stops all bouncing markers before.
+     *
+     * @param marker {Marker}  marker object
+     * @param exclusive {boolean}  flag of exclusive bouncing. If set to true, stops the bouncing
+     *      of all other markers.
+     */
+  }, {
+    key: "addBouncingMarker",
+    value: function addBouncingMarker(marker, exclusive) {
+      if (exclusive || marker._bouncingMotion.bouncingOptions.exclusive) {
+        this.stopAllBouncingMarkers();
+      } else {
+        this.stopExclusiveMarkerBouncing();
+      }
+      _classPrivateFieldGet2(_bouncingMarkers, this).push(marker);
+    }
+
+    /**
+     * Stops the bouncing of exclusive marker.
+     */
+  }, {
+    key: "stopExclusiveMarkerBouncing",
+    value: function stopExclusiveMarkerBouncing() {
+      var exclusiveMarker = _classPrivateFieldGet2(_bouncingMarkers, this).find(function (marker) {
+        return marker._bouncingMotion.bouncingOptions.exclusive;
+      });
+      if (exclusiveMarker) {
+        exclusiveMarker.stopBouncing();
+      }
+    }
+
+    /**
+     * Removes the marker from the list of bouncing markers.
+     * @param marker {Marker}  marker
+     */
+  }, {
+    key: "removeBouncingMarker",
+    value: function removeBouncingMarker(marker) {
+      var i = _classPrivateFieldGet2(_bouncingMarkers, this).indexOf(marker);
+      if (~i) {
+        _classPrivateFieldGet2(_bouncingMarkers, this).splice(i, 1);
+      }
+    }
+
+    /**
+     * Stops the bouncing of all currently bouncing markers. Purge the array of bouncing markers.
+     *
+     * @param immediate {boolean} if true, markers stop to bounce immediately, without waiting
+     *      animation to end
+     */
+  }, {
+    key: "stopAllBouncingMarkers",
+    value: function stopAllBouncingMarkers() {
+      var immediate = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+      var marker;
+      while (marker = _classPrivateFieldGet2(_bouncingMarkers, this).shift()) {
+        marker.stopBouncing(immediate);
+      }
+    }
+  }]);
+}();
+
+function MarkerPrototypeExt(Leaflet) {
+  var oldSetPos = Leaflet.Marker.prototype._setPos;
+  var oldOnAdd = Leaflet.Marker.prototype.onAdd;
+  var oldSetIcon = Leaflet.Marker.prototype.setIcon;
+  return {
+    /** Bouncing options shared by all markers. */
+    _bouncingOptions: new BouncingOptions(),
+    _orchestration: new Orchestration(),
+    _realMarker: true,
+    /**
+     * Registers options of bouncing animation for this marker. After registration of options for
+     * this marker, it will ignore changes of default options. Function automatically recalculates
+     * animation steps and delays.
+     *
+     * @param options {BouncingOptions}  options object
+     * @return {Marker} this marker
+     */
+    setBouncingOptions: function setBouncingOptions(options) {
+      this._bouncingMotion.updateBouncingOptions(options);
+      return this;
+    },
+    /**
+     * Returns true if this marker is bouncing. If this marker is not bouncing returns false.
+     * @return {boolean} true if marker is bouncing, false if not
+     */
+    isBouncing: function isBouncing() {
+      return this._bouncingMotion.isBouncing;
+    },
+    /**
+     * Starts bouncing of this marker.
+     * @param times {number|null}  number of times the marker must to bounce
+     * @return {Marker} this marker
+     */
+    bounce: function bounce() {
+      var _this = this;
+      var times = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+      if (times) {
+        this._bouncingMotion.onMotionEnd = function () {
+          Leaflet.Marker.prototype._orchestration.removeBouncingMarker(_this);
+        };
+      }
+      this._bouncingMotion.bounce(times);
+      var exclusive = this._bouncingMotion.bouncingOptions.exclusive;
+      Leaflet.Marker.prototype._orchestration.addBouncingMarker(this, exclusive);
+      return this;
+    },
+    /**
+     * Stops bouncing of this marker.
+     * Note: unless 'immediate' flag is set to true, by the call to this method or in marker options,
+     * the bouncing will not stop immediately after the call of this method. Instead, the animation
+     * is executed until marker returns to its original position and takes its full size.
+     *
+     * @param immediate {boolean}  if true, marker stop to bounce immediately, without waiting
+     *      animation to end
+     * @return {Marker} this marker
+     */
+    stopBouncing: function stopBouncing() {
+      var immediate = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+      this._bouncingMotion.stopBouncing(immediate);
+      Leaflet.Marker.prototype._orchestration.removeBouncingMarker(this);
+      return this;
+    },
+    /**
+     * Starts/stops bouncing of this marker.
+     * @return {Marker} marker
+     */
+    toggleBouncing: function toggleBouncing() {
+      if (this._bouncingMotion.isBouncing) {
+        this.stopBouncing();
+      } else {
+        this.bounce();
+      }
+      return this;
+    },
+    isRealMarker: function isRealMarker() {
+      return Object.hasOwn(this.__proto__, '_realMarker');
+    },
+    _setPos: function _setPos(position) {
+      oldSetPos.call(this, position);
+      if (this.isRealMarker()) {
+        this._bouncingMotion.position = position;
+        this._bouncingMotion.resetStyles(this);
+      }
+    },
+    onAdd: function onAdd(map) {
+      oldOnAdd.call(this, map);
+      if (this.isRealMarker()) {
+        this._bouncingMotion.resetStyles(this);
+      }
+    },
+    setIcon: function setIcon(icon) {
+      oldSetIcon.call(this, icon);
+      if (this.isRealMarker() && this._icon) {
+        this._bouncingMotion.resetStyles(this);
+      }
+    }
+  };
+}
+
+/**
+ * Calculates the points to draw the continous line on the screen. Returns the array of ordered
+ * point coordinates. Uses Bresenham algorithm.
+ *
+ * @param x {number}  x coordinate of origin
+ * @param y {number}  y coordinate of origin
+ * @param angle {number}  angle (radians)
+ * @param length {number}  length of line (px)
+ *
+ * @return {[number, number][]} array of ordered point coordinates
+ *
+ * @see http://rosettacode.org/wiki/Bitmap/Bresenham's_line_algorithm#JavaScript
+ */
+function calculateLine(x, y, angle, length) {
+  // TODO: use something else than multiply length by 2 to calculate the line with defined
+  // length
+  var xD = Math.round(x + Math.cos(angle) * (length * 2)),
+    yD = Math.round(y + Math.sin(angle) * (length * 2)),
+    dx = Math.abs(xD - x),
+    sx = x < xD ? 1 : -1,
+    dy = Math.abs(yD - y),
+    sy = y < yD ? 1 : -1,
+    err = (dx > dy ? dx : -dy) / 2,
+    e2,
+    p = [],
+    i = 0;
+  while (true) {
+    p.push([x, y]);
+    i++;
+    if (i === length) break;
+    e2 = err;
+    if (e2 > -dx) {
+      err -= dy;
+      x += sx;
+    }
+    if (e2 < dy) {
+      err += dx;
+      y += sy;
+    }
+  }
+  return p;
+}
+
+function styleInject(css, ref) {
+  if ( ref === void 0 ) ref = {};
+  var insertAt = ref.insertAt;
+
+  if (typeof document === 'undefined') { return; }
+
+  var head = document.head || document.getElementsByTagName('head')[0];
+  var style = document.createElement('style');
+  style.type = 'text/css';
+
+  if (insertAt === 'top') {
+    if (head.firstChild) {
+      head.insertBefore(style, head.firstChild);
+    } else {
+      head.appendChild(style);
+    }
+  } else {
+    head.appendChild(style);
+  }
+
+  if (style.styleSheet) {
+    style.styleSheet.cssText = css;
+  } else {
+    style.appendChild(document.createTextNode(css));
+  }
+}
+
+var css_248z = "@keyframes l-smooth-marker-bouncing-move {\n    from {\n        transform: translate(var(--pos-x), var(--pos-y))\n    }\n    to {\n        transform: translate(var(--pos-x-jump, var(--pos-x)), var(--pos-y-jump))\n    }\n}\n\n@keyframes l-smooth-marker-bouncing-contract {\n    from {\n        transform: translate(var(--pos-x), var(--pos-y))\n    }\n    to {\n        transform: translate(var(--pos-x), var(--pos-y-contract)) scaleY(var(--scale-contract))\n    }\n}\n\n.bouncing {\n    animation-name: l-smooth-marker-bouncing-move, l-smooth-marker-bouncing-move, l-smooth-marker-bouncing-contract, l-smooth-marker-bouncing-contract;\n    animation-direction: normal, reverse, normal, reverse;\n    animation-duration: var(--duration-jump), var(--duration-jump), var(--duration-contract), var(--duration-contract);\n    animation-delay: var(--delays)\n}\n\n.bouncing.simple {\n    animation-name: l-smooth-marker-bouncing-move, l-smooth-marker-bouncing-move;\n    animation-direction: normal, reverse;\n    animation-duration: var(--duration-jump), var(--duration-jump);\n    animation-delay: var(--delays)\n}\n";
+styleInject(css_248z);
+
+/** Regex to parse style definitions. */
+var regStyle = /([\w-]+): ([^;]+);/g;
+var Styles = /*#__PURE__*/function () {
+  function Styles(styles) {
+    _classCallCheck(this, Styles);
+    styles && Object.assign(this, styles);
+  }
+  return _createClass(Styles, [{
+    key: "findOpacity",
+    value: function findOpacity(options) {
+      this.opacity = (options === null || options === void 0 ? void 0 : options.opacityWhenUnclustered // used by cluster plugin
+      ) || (options === null || options === void 0 ? void 0 : options.opacity) || 1;
+    }
+
+    /**
+     * Creates a copy of styles merged with provided 'styles'.
+     * @param {Object} styles  object with styles to merge
+     * @return {Styles} copy of styles
+     */
+  }, {
+    key: "withStyles",
+    value: function withStyles(styles) {
+      var copy = new Styles(this);
+      copy && Object.assign(copy, styles);
+      return copy;
+    }
+  }, {
+    key: "toString",
+    value: function toString() {
+      return Object.entries(this).map(function (entry) {
+        return "".concat(entry[0], ": ").concat(entry[1], ";");
+      }).join(' ');
+    }
+
+    /**
+     * Parses cssText attribute into Styles object.
+     * @param cssText {string}  cssText string
+     * @return {Styles} Styles object
+     */
+  }], [{
+    key: "parse",
+    value: function parse(cssText) {
+      var styles = {};
+      var match = regStyle.exec(cssText);
+      while (match) {
+        styles[match[1]] = match[2];
+        match = regStyle.exec(cssText);
+      }
+      delete styles['z-index'];
+      delete styles['opacity'];
+      styles['outline'] = 'none';
+      return new Styles(styles);
+    }
+
+    /**
+     * @param marker {Marker}
+     */
+  }, {
+    key: "ofMarker",
+    value: function ofMarker(marker) {
+      var styles = Styles.parse(marker._icon.style.cssText);
+      styles.findOpacity(marker.options);
+      styles['z-index'] = marker._zIndex;
+      return styles;
+    }
+  }]);
+}();
+
+var animationNamePrefix = 'l-smooth-marker-bouncing-';
+var moveAnimationName = animationNamePrefix + 'move';
+var contractAnimationName = animationNamePrefix + 'contract';
+
+/*
+ * CSS3 animation runs faster than transform-based animation. We need to reduce speed in order
+ * to be compatible with old API.
+ */
+var speedCoefficient = 0.8;
+
+/**
+ * Removes and then resets required classes on the HTML element.
+ * Used as hack to restart CSS3 animation.
+ *
+ * @param element {HTMLElement}  HTML element
+ * @param classes {string[]}  names of classes
+ */
+function resetClasses(element, classes) {
+  classes.forEach(function (className) {
+    return DomUtil.removeClass(element, className);
+  });
+  void element.offsetWidth;
+  classes.forEach(function (className) {
+    return DomUtil.addClass(element, className);
+  });
+}
+var _lastAnimationName = /*#__PURE__*/new WeakMap();
+var _classes = /*#__PURE__*/new WeakMap();
+var _eventCounter = /*#__PURE__*/new WeakMap();
+var _times = /*#__PURE__*/new WeakMap();
+var _listener = /*#__PURE__*/new WeakMap();
+var BouncingMotionCss3 = /*#__PURE__*/function () {
+  /**
+   * Constructor.
+   *
+   * @param marker {Marker}  marker
+   * @param position {Point}  marker current position on the map canvas
+   * @param bouncingOptions {BouncingOptions}  options of bouncing animation
+   */
+  function BouncingMotionCss3(marker, position, bouncingOptions) {
+    var _this = this;
+    _classCallCheck(this, BouncingMotionCss3);
+    _defineProperty(this, "marker", void 0);
+    _defineProperty(this, "position", void 0);
+    _defineProperty(this, "bouncingOptions", void 0);
+    _defineProperty(this, "isBouncing", false);
+    _defineProperty(this, "iconStyles", void 0);
+    _defineProperty(this, "shadowStyles", void 0);
+    _defineProperty(this, "bouncingAnimationPlaying", false);
+    _defineProperty(this, "onMotionEnd", void 0);
+    _classPrivateFieldInitSpec(this, _lastAnimationName, contractAnimationName);
+    _classPrivateFieldInitSpec(this, _classes, ['bouncing']);
+    _classPrivateFieldInitSpec(this, _eventCounter, void 0);
+    _classPrivateFieldInitSpec(this, _times, void 0);
+    _classPrivateFieldInitSpec(this, _listener, function (event) {
+      return _this.onAnimationEnd(event);
+    });
+    this.marker = marker;
+    this.position = position;
+    this.updateBouncingOptions(bouncingOptions);
+  }
+  return _createClass(BouncingMotionCss3, [{
+    key: "updateBouncingOptions",
+    value: function updateBouncingOptions(options) {
+      this.bouncingOptions = options instanceof BouncingOptions ? options : this.bouncingOptions.override(options);
+      if (this.bouncingOptions.elastic && this.bouncingOptions.contractHeight) {
+        _classPrivateFieldSet2(_lastAnimationName, this, contractAnimationName);
+        var index = _classPrivateFieldGet2(_classes, this).indexOf('simple');
+        if (index > -1) {
+          _classPrivateFieldGet2(_classes, this).splice(index, 1);
+        }
+        if (this.marker._icon) {
+          DomUtil.removeClass(this.marker._icon, 'simple');
+        }
+      } else {
+        _classPrivateFieldSet2(_lastAnimationName, this, moveAnimationName);
+        _classPrivateFieldGet2(_classes, this).push('simple');
+      }
+      if (this.marker._icon) {
+        this.resetStyles(this.marker);
+      }
+    }
+  }, {
+    key: "onAnimationEnd",
+    value: function onAnimationEnd(event) {
+      if (event.animationName === _classPrivateFieldGet2(_lastAnimationName, this)) {
+        var _this$eventCounter;
+        _classPrivateFieldSet2(_eventCounter, this, (_this$eventCounter = _classPrivateFieldGet2(_eventCounter, this), _this$eventCounter++, _this$eventCounter));
+        _classPrivateFieldSet2(_eventCounter, this, _classPrivateFieldGet2(_eventCounter, this) % 2);
+        if (!_classPrivateFieldGet2(_eventCounter, this)) {
+          var _this$times;
+          if (this.isBouncing && (_classPrivateFieldGet2(_times, this) === null || _classPrivateFieldSet2(_times, this, (_this$times = _classPrivateFieldGet2(_times, this), --_this$times)))) {
+            resetClasses(this.marker._icon, _classPrivateFieldGet2(_classes, this));
+            if (this.marker._shadow && this.bouncingOptions.shadowAngle) {
+              resetClasses(this.marker._shadow, _classPrivateFieldGet2(_classes, this));
+            }
+          } else {
+            this._stopBouncingAnimation();
+          }
+        }
+      }
+    }
+  }, {
+    key: "resetStyles",
+    value: function resetStyles(marker) {
+      var _this$marker$getIcon,
+        _this$marker,
+        _this2 = this;
+      this.marker = marker;
+      this.iconStyles = Styles.ofMarker(marker);
+      if (marker._shadow) {
+        this.shadowStyles = Styles.parse(marker._shadow.style.cssText);
+      }
+      var iconHeight = ((_this$marker$getIcon = this.marker.getIcon()) === null || _this$marker$getIcon === void 0 || (_this$marker$getIcon = _this$marker$getIcon.options) === null || _this$marker$getIcon === void 0 ? void 0 : _this$marker$getIcon.iconSize[1]) || ((_this$marker = this.marker) === null || _this$marker === void 0 || (_this$marker = _this$marker._iconObj) === null || _this$marker === void 0 || (_this$marker = _this$marker.options) === null || _this$marker === void 0 ? void 0 : _this$marker.iconSize[1]);
+      var iconAnimationParams = BouncingMotionCss3.animationParams(this.position, this.bouncingOptions, iconHeight);
+      this.iconStyles = this.iconStyles.withStyles(iconAnimationParams);
+      this.marker._icon.style.cssText = this.iconStyles.toString();
+      if (this.bouncingAnimationPlaying) {
+        resetClasses(this.marker._icon, _classPrivateFieldGet2(_classes, this));
+        this.marker._icon.addEventListener('animationend', _classPrivateFieldGet2(_listener, this));
+      }
+      var _this$bouncingOptions = this.bouncingOptions,
+        bounceHeight = _this$bouncingOptions.bounceHeight,
+        contractHeight = _this$bouncingOptions.contractHeight,
+        shadowAngle = _this$bouncingOptions.shadowAngle;
+      if (this.marker._shadow) {
+        if (shadowAngle) {
+          var _this$marker$getIcon2;
+          var _this$position = this.position,
+            x = _this$position.x,
+            y = _this$position.y;
+          var points = calculateLine(x, y, shadowAngle, bounceHeight + 1);
+          var _points$bounceHeight = _slicedToArray(points[bounceHeight], 2),
+            posXJump = _points$bounceHeight[0],
+            posYJump = _points$bounceHeight[1];
+          var shadowHeight = (_this$marker$getIcon2 = this.marker.getIcon()) === null || _this$marker$getIcon2 === void 0 || (_this$marker$getIcon2 = _this$marker$getIcon2.options) === null || _this$marker$getIcon2 === void 0 ? void 0 : _this$marker$getIcon2.shadowSize[1];
+          var shadowScaleContract = BouncingMotionCss3.contractScale(shadowHeight, contractHeight);
+          this.shadowStyles = this.shadowStyles.withStyles(iconAnimationParams).withStyles({
+            '--pos-x-jump': "".concat(posXJump, "px"),
+            '--pos-y-jump': "".concat(posYJump, "px"),
+            '--scale-contract': shadowScaleContract
+          });
+          this.marker._shadow.style.cssText = this.shadowStyles.toString();
+          if (this.bouncingAnimationPlaying) {
+            resetClasses(this.marker._shadow, _classPrivateFieldGet2(_classes, this));
+          }
+        } else {
+          _classPrivateFieldGet2(_classes, this).forEach(function (className) {
+            DomUtil.removeClass(_this2.marker._shadow, className);
+          });
+        }
+      }
+    }
+  }, {
+    key: "bounce",
+    value: function bounce() {
+      var times = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+      _classPrivateFieldSet2(_times, this, times);
+      this.isBouncing = true;
+      if (this.bouncingAnimationPlaying) {
+        return;
+      }
+      _classPrivateFieldSet2(_eventCounter, this, 0);
+      this.bouncingAnimationPlaying = true;
+      resetClasses(this.marker._icon, _classPrivateFieldGet2(_classes, this));
+      if (this.marker._shadow && this.bouncingOptions.shadowAngle) {
+        resetClasses(this.marker._shadow, _classPrivateFieldGet2(_classes, this));
+      }
+      this.marker._icon.addEventListener('animationend', _classPrivateFieldGet2(_listener, this));
+    }
+  }, {
+    key: "stopBouncing",
+    value: function stopBouncing() {
+      var immediate = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+      this.isBouncing = false;
+      immediate || (immediate = this.bouncingOptions.immediateStop);
+      if (immediate) {
+        this._stopBouncingAnimation();
+      }
+    }
+  }, {
+    key: "_stopBouncingAnimation",
+    value: function _stopBouncingAnimation() {
+      var _this3 = this;
+      _classPrivateFieldGet2(_classes, this).forEach(function (className) {
+        DomUtil.removeClass(_this3.marker._icon, className);
+        if (_this3.marker._shadow) {
+          DomUtil.removeClass(_this3.marker._shadow, className);
+        }
+      });
+      this.bouncingAnimationPlaying = false;
+      if (this.onMotionEnd) {
+        this.onMotionEnd();
+        this.onMotionEnd = null;
+      }
+      this.marker.fire('bounceend');
+    }
+
+    /**
+     * Calculates parameters of CSS3 animation of bouncing.
+     *
+     * @param position {Point}  marker current position on the map canvas
+     * @param bouncingOptions {BouncingOptions}  options of bouncing animation
+     * @param height {number}  icons height
+     * @return {object} CSS3 animation parameters
+     */
+  }], [{
+    key: "animationParams",
+    value: function animationParams(position, bouncingOptions, height) {
+      var x = position.x,
+        y = position.y;
+      var bounceHeight = bouncingOptions.bounceHeight,
+        contractHeight = bouncingOptions.contractHeight,
+        bounceSpeed = bouncingOptions.bounceSpeed,
+        contractSpeed = bouncingOptions.contractSpeed;
+      var scaleContract = BouncingMotionCss3.contractScale(height, contractHeight);
+      var durationJump = BouncingMotionCss3.calculateDuration(bounceHeight, bounceSpeed);
+      var durationContract = BouncingMotionCss3.calculateDuration(contractHeight, contractSpeed);
+      var delays = [0, durationJump, durationJump * 2, durationJump * 2 + durationContract];
+      return {
+        '--pos-x': "".concat(x, "px"),
+        '--pos-y': "".concat(y, "px"),
+        '--pos-y-jump': "".concat(y - bounceHeight, "px"),
+        '--pos-y-contract': "".concat(y + contractHeight, "px"),
+        '--scale-contract': scaleContract,
+        '--duration-jump': "".concat(durationJump, "ms"),
+        '--duration-contract': "".concat(durationContract, "ms"),
+        '--delays': "0ms, ".concat(delays[1], "ms, ").concat(delays[2], "ms, ").concat(delays[3], "ms")
+      };
+    }
+
+    /**
+     * Calculates scale of contracting.
+     *
+     * @param {number} height  original height
+     * @param {number} contractHeight  how much it must contract
+     * @return {number}  contracting scale between 0 and 1
+     */
+  }, {
+    key: "contractScale",
+    value: function contractScale(height, contractHeight) {
+      return (height - contractHeight) / height;
+    }
+
+    /**
+     * Calculates duration of animation.
+     *
+     * @param height {number}  height of movement or resizing (px)
+     * @param speed {number}  speed coefficient
+     *
+     * @return {number} duration of animation (ms)
+     */
+  }, {
+    key: "calculateDuration",
+    value: function calculateDuration(height, speed) {
+      if (height === 0) {
+        return 0;
+      }
+      var duration = Math.round(speed * speedCoefficient);
+      var i = height;
+      while (--i) {
+        duration += Math.round(speed / (height - i));
+      }
+      return duration;
+    }
+  }]);
+}();
+
+function SmoothMarkerBouncing(Leaflet) {
+  Leaflet.Marker.include(MarkerPrototypeExt(Leaflet));
+
+  /**
+   * Registers default options of bouncing animation.
+   * @param options {BouncingOptions|object}  object with options
+   */
+  Leaflet.Marker.setBouncingOptions = function (options) {
+    Leaflet.Marker.prototype._bouncingOptions = options instanceof BouncingOptions ? options : new BouncingOptions(options);
+  };
+
+  /**
+   * Returns array of currently bouncing markers.
+   * @return {Marker[]} array of bouncing markers
+   */
+  Leaflet.Marker.getBouncingMarkers = function () {
+    return Leaflet.Marker.prototype._orchestration.getBouncingMarkers();
+  };
+
+  /**
+   * Stops the bouncing of all currently bouncing markers. Purge the array of bouncing markers.
+   *
+   * @param immediate {boolean}  if true, markers stop to bounce immediately, without waiting
+   *      animation to end
+   */
+  Leaflet.Marker.stopAllBouncingMarkers = function () {
+    var immediate = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+    Leaflet.Marker.prototype._orchestration.stopAllBouncingMarkers(immediate);
+  };
+  Leaflet.Marker.addInitHook(function () {
+    if (this.isRealMarker()) {
+      var bouncingOptions = new BouncingOptions(Leaflet.Marker.prototype._bouncingOptions);
+      this._bouncingMotion = new BouncingMotionCss3(this, new Leaflet.Point(0, 0), bouncingOptions);
+    }
+  });
+  return Leaflet;
+}
+
+export { SmoothMarkerBouncing as default };

node_modules/leaflet.smooth_marker_bouncing/dist/index.js

@@ -0,0 +1,8 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _SmoothMarkerBouncing = require("./SmoothMarkerBouncing");
+var _default = exports["default"] = _SmoothMarkerBouncing.SmoothMarkerBouncing;

node_modules/leaflet.smooth_marker_bouncing/dist/line.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.calculateLine = calculateLine;
+/**
+ * Calculates the points to draw the continous line on the screen. Returns the array of ordered
+ * point coordinates. Uses Bresenham algorithm.
+ *
+ * @param x {number}  x coordinate of origin
+ * @param y {number}  y coordinate of origin
+ * @param angle {number}  angle (radians)
+ * @param length {number}  length of line (px)
+ *
+ * @return {[number, number][]} array of ordered point coordinates
+ *
+ * @see http://rosettacode.org/wiki/Bitmap/Bresenham's_line_algorithm#JavaScript
+ */
+function calculateLine(x, y, angle, length) {
+  // TODO: use something else than multiply length by 2 to calculate the line with defined
+  // length
+  var xD = Math.round(x + Math.cos(angle) * (length * 2)),
+    yD = Math.round(y + Math.sin(angle) * (length * 2)),
+    dx = Math.abs(xD - x),
+    sx = x < xD ? 1 : -1,
+    dy = Math.abs(yD - y),
+    sy = y < yD ? 1 : -1,
+    err = (dx > dy ? dx : -dy) / 2,
+    e2,
+    p = [],
+    i = 0;
+  while (true) {
+    p.push([x, y]);
+    i++;
+    if (i === length) break;
+    e2 = err;
+    if (e2 > -dx) {
+      err -= dy;
+      x += sx;
+    }
+    if (e2 < dy) {
+      err += dx;
+      y += sy;
+    }
+  }
+  return p;
+}

node_modules/leaflet.smooth_marker_bouncing/dist/standalone.js

@@ -0,0 +1,6 @@
+"use strict";
+
+var _leaflet = _interopRequireDefault(require("leaflet"));
+var _SmoothMarkerBouncing = _interopRequireDefault(require("./SmoothMarkerBouncing"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+(0, _SmoothMarkerBouncing["default"])(_leaflet["default"]);