@nextgis/leaflet-map-adapter 3.0.0 → 4.0.0-alpha.0

package/lib/leaflet-map-adapter.esm-browser.js

@@ -1,474 +1,599 @@
-/** Bundle of @nextgis/leaflet-map-adapter; version: 3.0.0; author: NextGIS */
-var domain;
-
-// This constructor is used to store event handlers. Instantiating this is
-// faster than explicitly calling `Object.create(null)` to get a "clean" empty
-// object (tested with v8 v4.9).
-function EventHandlers() {}
-EventHandlers.prototype = Object.create(null);
-
-function EventEmitter() {
-  EventEmitter.init.call(this);
+/** Bundle of @nextgis/leaflet-map-adapter; version: 4.0.0-alpha.0; author: NextGIS */
+function getElement(el) {
+  if (typeof el === "string") {
+    let el_ = document.getElementById(el);
+    if (!el_) {
+      try {
+        el_ = document.querySelector(el);
+      } catch (e) {
+      }
+    }
+    return el_ || void 0;
+  }
+  return el;
 }
 
-// nodejs oddity
-// require('events') === require('events').EventEmitter
-EventEmitter.EventEmitter = EventEmitter;
-
-EventEmitter.usingDomains = false;
-
-EventEmitter.prototype.domain = undefined;
-EventEmitter.prototype._events = undefined;
-EventEmitter.prototype._maxListeners = undefined;
-
-// By default EventEmitters will print a warning if more than 10 listeners are
-// added to it. This is a useful default which helps finding memory leaks.
-EventEmitter.defaultMaxListeners = 10;
+var __defProp$g = Object.defineProperty;
+var __defProps$8 = Object.defineProperties;
+var __getOwnPropDescs$8 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$b = Object.getOwnPropertySymbols;
+var __hasOwnProp$b = Object.prototype.hasOwnProperty;
+var __propIsEnum$b = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$g = (obj, key, value) => key in obj ? __defProp$g(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$b = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$b.call(b, prop))
+      __defNormalProp$g(a, prop, b[prop]);
+  if (__getOwnPropSymbols$b)
+    for (var prop of __getOwnPropSymbols$b(b)) {
+      if (__propIsEnum$b.call(b, prop))
+        __defNormalProp$g(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$8 = (a, b) => __defProps$8(a, __getOwnPropDescs$8(b));
+const controlOptions = /* @__PURE__ */ new WeakMap();
+function resolveControlOptions(options = {}) {
+  var _a;
+  return __spreadProps$8(__spreadValues$b({}, options), {
+    margin: (_a = options.margin) != null ? _a : options.bar
+  });
+}
+function setControlOptions(control, options = {}) {
+  controlOptions.set(control, resolveControlOptions(options));
+}
+function getControlOptions(control) {
+  return control ? controlOptions.get(control) : void 0;
+}
 
-EventEmitter.init = function() {
-  this.domain = null;
-  if (EventEmitter.usingDomains) {
-    // if there is an active domain, then attach to it.
-    if (domain.active) ;
+var __defProp$f = Object.defineProperty;
+var __defNormalProp$f = (obj, key, value) => key in obj ? __defProp$f(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$a = (obj, key, value) => __defNormalProp$f(obj, typeof key !== "symbol" ? key + "" : key, value);
+class ControlContainer {
+  constructor(opt = {}) {
+    __publicField$a(this, "classPrefix", "webmap");
+    __publicField$a(this, "addClass");
+    __publicField$a(this, "map");
+    __publicField$a(this, "wrapperClass");
+    __publicField$a(this, "ownsContainer");
+    __publicField$a(this, "_container");
+    __publicField$a(this, "_positionsContainers");
+    __publicField$a(this, "_targets", /* @__PURE__ */ new Set());
+    __publicField$a(this, "_idContainers", /* @__PURE__ */ new Map());
+    __publicField$a(this, "_pendingChildren", /* @__PURE__ */ new Map());
+    __publicField$a(this, "_orders", /* @__PURE__ */ new WeakMap());
+    __publicField$a(this, "_targetOptions", /* @__PURE__ */ new WeakMap());
+    __publicField$a(this, "_switchGroups", /* @__PURE__ */ new WeakMap());
+    __publicField$a(this, "_switchBindings", /* @__PURE__ */ new WeakMap());
+    this.classPrefix = opt.classPrefix || this.classPrefix;
+    this.addClass = opt.addClass;
+    this.map = opt.map;
+    this.wrapperClass = opt.wrapperClass;
+    const externalPositions = [
+      "top-right",
+      "top-left",
+      "bottom-right",
+      "bottom-left"
+    ];
+    const positionContainers = externalPositions.some(
+      (position) => {
+        var _a;
+        return !!((_a = opt.positionContainers) == null ? void 0 : _a[position]);
+      }
+    ) ? opt.positionContainers : void 0;
+    this.ownsContainer = !opt.container && !positionContainers;
+    const { element, positionsContainers } = this.createContainerElement(
+      opt.container,
+      positionContainers
+    );
+    this._container = element;
+    this._positionsContainers = positionsContainers;
   }
-
-  if (!this._events || this._events === Object.getPrototypeOf(this)._events) {
-    this._events = new EventHandlers();
-    this._eventsCount = 0;
+  addTo(el) {
+    if (!this.ownsContainer) {
+      return this;
+    }
+    const el_ = getElement(el);
+    if (el_) {
+      el_.appendChild(this._container);
+    }
+    return this;
+  }
+  detach() {
+    if (!this.ownsContainer) {
+      Array.from(this._targets).forEach((target) => this.removeTarget(target));
+      this._pendingChildren.clear();
+      return;
+    }
+    const parent = this._container.parentElement;
+    if (parent) {
+      parent.removeChild(this._container);
+    }
+  }
+  getContainer() {
+    return this._container;
+  }
+  getPositionContainer(position) {
+    return this._positionsContainers[position];
+  }
+  newPositionContainer(position, order = 0, control) {
+    var _a;
+    const newContainer = document.createElement("div");
+    newContainer.className = `${this.classPrefix}-ctrl-wrapper` + (this.wrapperClass ? " " + this.wrapperClass : "");
+    if ((_a = getControlOptions(control)) == null ? void 0 : _a.margin) {
+      newContainer.classList.add(`${this.classPrefix}-ctrl-margin`);
+    }
+    this.append(newContainer, position, order, control);
+    return newContainer;
+  }
+  addControl(control, position, options = {}) {
+    const controlContainer = control.onAdd(this.map);
+    if (controlContainer instanceof HTMLElement) {
+      const target = this.newPositionContainer(
+        position,
+        options.order,
+        control
+      );
+      if (target) {
+        target.appendChild(controlContainer);
+        if (options.id) {
+          this.registerIDContainer(options.id, controlContainer, control);
+        }
+        return target;
+      }
+    }
+  }
+  append(element, position, order = 0, control) {
+    const node = this._normalizeElement(element);
+    if (!node) return;
+    const positionContainer = this._resolveTargetContainer(position);
+    if (positionContainer) {
+      this._insertSorted(positionContainer, node, order);
+      this._registerSwitchControl(node, control, positionContainer);
+      return positionContainer;
+    } else if (typeof position !== "string") {
+      this._appendPending(position.inside, node, order, control);
+    }
+  }
+  registerIDContainer(id, controlRoot, control) {
+    this._idContainers.set(id, controlRoot);
+    this._registerTargetOptions(controlRoot, control);
+    this._flushPending(id, controlRoot);
+  }
+  unregisterIDContainer(id) {
+    const controlRoot = this._idContainers.get(id);
+    if (controlRoot) {
+      this._targetOptions.delete(controlRoot);
+    }
+    this._idContainers.delete(id);
+    this._pendingChildren.delete(id);
+  }
+  removeTarget(target) {
+    const parent = target.parentElement;
+    if (parent) {
+      parent.removeChild(target);
+    }
+    this._unregisterSwitchControl(target);
+    this._removePending(target);
+    this._targets.delete(target);
+  }
+  createContainerElement(container, positionContainers) {
+    const element = container || document.createElement("div");
+    if (!container) {
+      element.className = `${this.classPrefix}-control-container` + (this.addClass ? " " + this.addClass : "");
+    }
+    const positionsContainers = {};
+    const positions = [
+      "top-right",
+      "top-left",
+      "bottom-right",
+      "bottom-left"
+    ];
+    positions.forEach((x) => {
+      const positionContainer = (positionContainers == null ? void 0 : positionContainers[x]) || this._createPositionContainer(x);
+      positionsContainers[x] = positionContainer;
+      if (!(positionContainers == null ? void 0 : positionContainers[x])) {
+        element.appendChild(positionContainer);
+      }
+    });
+    return { element, positionsContainers };
+  }
+  _createPositionContainer(position) {
+    const positionContainer = document.createElement("div");
+    positionContainer.className = `${this.classPrefix}-ctrl-${position}`;
+    return positionContainer;
+  }
+  _resolveTargetContainer(position) {
+    return typeof position === "string" ? this._positionsContainers[position] : this._idContainers.get(position.inside);
+  }
+  _normalizeElement(element) {
+    if (typeof element !== "string") {
+      return element;
+    }
+    const template = document.createElement("template");
+    template.innerHTML = element.trim();
+    return template.content.firstElementChild;
+  }
+  _insertSorted(positionContainer, element, order) {
+    this._orders.set(element, order);
+    element.style.order = String(order);
+    const isBottomPosition = this._isBottomPositionContainer(positionContainer);
+    const children = Array.from(positionContainer.children);
+    const before = children.find((child) => {
+      var _a;
+      if (child === element) {
+        return false;
+      }
+      const value = (_a = this._orders.get(child)) != null ? _a : Number.POSITIVE_INFINITY;
+      return isBottomPosition ? value <= order : value > order;
+    });
+    if (before) {
+      positionContainer.insertBefore(element, before);
+    } else if (element.parentElement === positionContainer) {
+      return;
+    } else {
+      positionContainer.appendChild(element);
+    }
+    this._targets.add(element);
+  }
+  _isBottomPositionContainer(element) {
+    return element === this._positionsContainers["bottom-left"] || element === this._positionsContainers["bottom-right"];
+  }
+  _appendPending(parentId, element, order, control) {
+    const parent = element.parentElement;
+    if (parent) {
+      parent.removeChild(element);
+    }
+    const pending = this._pendingChildren.get(parentId) || [];
+    pending.push({ element, order, control });
+    pending.sort((a, b) => a.order - b.order);
+    this._pendingChildren.set(parentId, pending);
+    this._targets.add(element);
+  }
+  _flushPending(parentId, target) {
+    const pending = this._pendingChildren.get(parentId);
+    if (!pending) return;
+    for (const { element, order, control } of pending) {
+      this._insertSorted(target, element, order);
+      this._registerSwitchControl(element, control, target);
+    }
+    this._pendingChildren.delete(parentId);
+  }
+  _removePending(target) {
+    this._pendingChildren.forEach((children, parentId) => {
+      const filtered = children.filter(({ element }) => element !== target);
+      if (filtered.length) {
+        this._pendingChildren.set(parentId, filtered);
+      } else {
+        this._pendingChildren.delete(parentId);
+      }
+    });
+  }
+  _registerSwitchControl(element, control, target) {
+    if (!this._isSwitchToggleControl(control)) return;
+    this._unregisterSwitchControl(element);
+    const groupName = typeof control.switch === "string" ? control.switch : "default";
+    const group = this._getSwitchGroup(target, groupName);
+    const hadDisableOnSecondClick = Object.prototype.hasOwnProperty.call(
+      control,
+      "disableOnSecondClick"
+    );
+    const previousDisableOnSecondClick = control.disableOnSecondClick;
+    const targetDisableOnSecondClick = control.disableOnSecondClick === void 0 ? this._getTargetDisableOnSecondClick(target) : void 0;
+    if (targetDisableOnSecondClick !== void 0) {
+      control.disableOnSecondClick = targetDisableOnSecondClick;
+    }
+    group.add(control);
+    const unsubscribe = control.onStatusChange((status) => {
+      if (status) {
+        this._disableSwitchSiblings(control, group);
+      }
+    });
+    this._switchBindings.set(element, {
+      control,
+      group,
+      unsubscribe,
+      hadDisableOnSecondClick,
+      previousDisableOnSecondClick
+    });
+    if (control.getStatus()) {
+      this._disableSwitchSiblings(control, group);
+    }
+  }
+  _unregisterSwitchControl(element) {
+    const binding = this._switchBindings.get(element);
+    if (binding) {
+      binding.unsubscribe();
+      binding.group.delete(binding.control);
+      if (binding.hadDisableOnSecondClick) {
+        binding.control.disableOnSecondClick = binding.previousDisableOnSecondClick;
+      } else {
+        delete binding.control.disableOnSecondClick;
+      }
+      this._switchBindings.delete(element);
+    }
+    Array.from(element.children).forEach((child) => {
+      if (child instanceof HTMLElement) {
+        this._unregisterSwitchControl(child);
+      }
+    });
+  }
+  _getSwitchGroup(target, groupName) {
+    let targetGroups = this._switchGroups.get(target);
+    if (!targetGroups) {
+      targetGroups = /* @__PURE__ */ new Map();
+      this._switchGroups.set(target, targetGroups);
+    }
+    let group = targetGroups.get(groupName);
+    if (!group) {
+      group = /* @__PURE__ */ new Set();
+      targetGroups.set(groupName, group);
+    }
+    return group;
+  }
+  _disableSwitchSiblings(activeControl, group) {
+    group.forEach((control) => {
+      if (control !== activeControl && control.getStatus()) {
+        control.onClick(false);
+      }
+    });
+  }
+  _getTargetDisableOnSecondClick(target) {
+    var _a;
+    return (_a = this._targetOptions.get(target)) == null ? void 0 : _a.disableOnSecondClick;
+  }
+  _isSwitchToggleControl(control) {
+    const toggle = control;
+    return !!((toggle == null ? void 0 : toggle.switch) && typeof toggle.onStatusChange === "function" && typeof toggle.getStatus === "function" && typeof toggle.onClick === "function");
+  }
+  _registerTargetOptions(target, control) {
+    const options = getControlOptions(control) || getControlOptions(target);
+    if (options) {
+      this._targetOptions.set(target, options);
+    } else {
+      this._targetOptions.delete(target);
+    }
   }
-
-  this._maxListeners = this._maxListeners || undefined;
-};
-
-// Obviously not all Emitters should be limited to 10. This function allows
-// that to be increased. Set to zero for unlimited.
-EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
-  if (typeof n !== 'number' || n < 0 || isNaN(n))
-    throw new TypeError('"n" argument must be a positive number');
-  this._maxListeners = n;
-  return this;
-};
-
-function $getMaxListeners(that) {
-  if (that._maxListeners === undefined)
-    return EventEmitter.defaultMaxListeners;
-  return that._maxListeners;
 }
 
-EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
-  return $getMaxListeners(this);
-};
-
-// These standalone emit* functions are used to optimize calling of event
-// handlers for fast cases because emit() itself often has a variable number of
-// arguments and can be deoptimized because of that. These functions always have
-// the same number of arguments and thus do not get deoptimized, so the code
-// inside them can execute faster.
-function emitNone(handler, isFn, self) {
-  if (isFn)
-    handler.call(self);
-  else {
-    var len = handler.length;
-    var listeners = arrayClone(handler, len);
-    for (var i = 0; i < len; ++i)
-      listeners[i].call(self);
+const STOP_PROPAGATION_EVENTS = [
+  "wheel",
+  "click",
+  "mouseup",
+  "touchend",
+  "dblclick",
+  "pointerup",
+  "mousedown",
+  "touchstart",
+  "pointerdown"
+];
+function addClasses(element, classes) {
+  if (classes) {
+    classes.split(" ").filter(Boolean).forEach((x) => element.classList.add(x));
   }
 }
-function emitOne(handler, isFn, self, arg1) {
-  if (isFn)
-    handler.call(self, arg1);
-  else {
-    var len = handler.length;
-    var listeners = arrayClone(handler, len);
-    for (var i = 0; i < len; ++i)
-      listeners[i].call(self, arg1);
+function removeElement(element) {
+  if (element == null ? void 0 : element.parentNode) {
+    element.parentNode.removeChild(element);
   }
 }
-function emitTwo(handler, isFn, self, arg1, arg2) {
-  if (isFn)
-    handler.call(self, arg1, arg2);
-  else {
-    var len = handler.length;
-    var listeners = arrayClone(handler, len);
-    for (var i = 0; i < len; ++i)
-      listeners[i].call(self, arg1, arg2);
+function stopPropagation(event) {
+  event.stopPropagation();
+}
+function preventMapEventPropagation(element) {
+  STOP_PROPAGATION_EVENTS.forEach((eventName) => {
+    element.addEventListener(eventName, stopPropagation);
+  });
+}
+function getAlignValue(align) {
+  if (align === "start") return "flex-start";
+  if (align === "end") return "flex-end";
+  return align;
+}
+function isZeroGap(gap) {
+  if (typeof gap === "number") {
+    return gap === 0;
   }
+  if (typeof gap === "string") {
+    return gap.trim().split(/\s+/).every((x) => /^0(?:\.0+)?(?:[a-z%]+)?$/i.test(x));
+  }
+  return false;
 }
-function emitThree(handler, isFn, self, arg1, arg2, arg3) {
-  if (isFn)
-    handler.call(self, arg1, arg2, arg3);
-  else {
-    var len = handler.length;
-    var listeners = arrayClone(handler, len);
-    for (var i = 0; i < len; ++i)
-      listeners[i].call(self, arg1, arg2, arg3);
+function createControlContainer(options = {}) {
+  const resolvedOptions = resolveControlOptions(options);
+  const element = document.createElement("div");
+  element.className = "webmap-ctrl";
+  if (resolvedOptions.bar) {
+    element.classList.add("webmap-ctrl-group");
+  }
+  if (resolvedOptions.margin) {
+    element.classList.add("webmap-ctrl-margin");
+  }
+  const orientation = resolvedOptions.orientation || resolvedOptions.direction;
+  if (orientation) {
+    element.classList.add(`webmap-ctrl-${orientation}`);
   }
+  if (resolvedOptions.gap !== void 0) {
+    const gap = typeof resolvedOptions.gap === "number" ? `${resolvedOptions.gap}px` : resolvedOptions.gap;
+    element.style.setProperty("--webmap-ctrl-gap", gap);
+    if (isZeroGap(resolvedOptions.gap)) {
+      element.classList.add("webmap-ctrl-gapless");
+    }
+  }
+  const align = getAlignValue(resolvedOptions.align);
+  if (align) {
+    element.style.setProperty("--webmap-ctrl-align", align);
+  }
+  addClasses(element, resolvedOptions.addClass);
+  preventMapEventPropagation(element);
+  return element;
 }
-
-function emitMany(handler, isFn, self, args) {
-  if (isFn)
-    handler.apply(self, args);
-  else {
-    var len = handler.length;
-    var listeners = arrayClone(handler, len);
-    for (var i = 0; i < len; ++i)
-      listeners[i].apply(self, args);
+function appendHtml(element, html) {
+  if (html instanceof HTMLElement) {
+    element.appendChild(html);
+  } else if (typeof html === "string") {
+    element.innerHTML = html;
   }
 }
-
-EventEmitter.prototype.emit = function emit(type) {
-  var er, handler, len, args, i, events, domain;
-  var doError = (type === 'error');
-
-  events = this._events;
-  if (events)
-    doError = (doError && events.error == null);
-  else if (!doError)
-    return false;
-
-  domain = this.domain;
-
-  // If there is no 'error' event listener then throw.
-  if (doError) {
-    er = arguments[1];
-    if (domain) {
-      if (!er)
-        er = new Error('Uncaught, unspecified "error" event');
-      er.domainEmitter = this;
-      er.domain = domain;
-      er.domainThrown = false;
-      domain.emit('error', er);
-    } else if (er instanceof Error) {
-      throw er; // Unhandled 'error' event
-    } else {
-      // At least give some kind of context to the user
-      var err = new Error('Uncaught, unspecified "error" event. (' + er + ')');
-      err.context = er;
-      throw err;
+function createControlElement(control, options = {}, map) {
+  const element = createControlContainer(options);
+  setControlOptions(element, options);
+  const content = control.onAdd(map);
+  if (content) {
+    element.appendChild(content);
+  }
+  return element;
+}
+function createButtonControlContent(options) {
+  let button;
+  const onClick = (event) => {
+    event.preventDefault();
+    event.stopPropagation();
+    options.onClick();
+  };
+  const buttonControl = {
+    onAdd() {
+      button = document.createElement("button");
+      button.type = "button";
+      button.className = "webmap-ctrl-button";
+      addClasses(button, options.addClass);
+      if (options.title) {
+        button.title = options.title;
+        button.setAttribute("aria-label", options.title);
+      }
+      appendHtml(button, options.html);
+      button.addEventListener("click", onClick);
+      return button;
+    },
+    onRemove() {
+      if (button) {
+        button.removeEventListener("click", onClick);
+        removeElement(button);
+        button = void 0;
+      }
+    },
+    getContainer() {
+      return button;
     }
-    return false;
+  };
+  buttonControl.remove = () => {
+    buttonControl.onRemove();
+  };
+  return buttonControl;
+}
+function createToggleControlContent(options) {
+  const link = document.createElement("div");
+  const statusListeners = /* @__PURE__ */ new Set();
+  let status = false;
+  if (options.getStatus) {
+    status = options.getStatus();
+  } else if (options.status) {
+    status = options.status;
   }
-
-  handler = events[type];
-
-  if (!handler)
-    return false;
-
-  var isFn = typeof handler === 'function';
-  len = arguments.length;
-  switch (len) {
-    // fast cases
-    case 1:
-      emitNone(handler, isFn, this);
-      break;
-    case 2:
-      emitOne(handler, isFn, this, arguments[1]);
-      break;
-    case 3:
-      emitTwo(handler, isFn, this, arguments[1], arguments[2]);
-      break;
-    case 4:
-      emitThree(handler, isFn, this, arguments[1], arguments[2], arguments[3]);
-      break;
-    // slower
-    default:
-      args = new Array(len - 1);
-      for (i = 1; i < len; i++)
-        args[i - 1] = arguments[i];
-      emitMany(handler, isFn, this, args);
+  const title = options.title || "";
+  const html = options.html;
+  function notifyStatusChange(control) {
+    statusListeners.forEach((listener) => listener(status, control));
   }
-
-  return true;
-};
-
-function _addListener(target, type, listener, prepend) {
-  var m;
-  var events;
-  var existing;
-
-  if (typeof listener !== 'function')
-    throw new TypeError('"listener" argument must be a function');
-
-  events = target._events;
-  if (!events) {
-    events = target._events = new EventHandlers();
-    target._eventsCount = 0;
-  } else {
-    // To avoid recursion in the case that type === "newListener"! Before
-    // adding it to the listeners, first emit "newListener".
-    if (events.newListener) {
-      target.emit('newListener', type,
-                  listener.listener ? listener.listener : listener);
-
-      // Re-assign `events` because a newListener handler could have caused the
-      // this._events to be assigned to a new object
-      events = target._events;
+  function setTitle() {
+    if (title) {
+      if (typeof title === "string") {
+        link.title = title;
+      } else {
+        link.title = status ? title.on : title.off;
+      }
+      link.setAttribute("aria-label", link.title);
     }
-    existing = events[type];
   }
-
-  if (!existing) {
-    // Optimize the case of one listener. Don't need the extra array object.
-    existing = events[type] = listener;
-    ++target._eventsCount;
-  } else {
-    if (typeof existing === 'function') {
-      // Adding the second element, need to change to array.
-      existing = events[type] = prepend ? [listener, existing] :
-                                          [existing, listener];
-    } else {
-      // If we've already got an array, just append.
-      if (prepend) {
-        existing.unshift(listener);
+  function setHtml() {
+    if (html) {
+      link.innerHTML = "";
+      if (typeof html === "string" || html instanceof HTMLElement) {
+        appendHtml(link, html);
       } else {
-        existing.push(listener);
+        appendHtml(link, status ? html.on : html.off);
       }
     }
-
-    // Check for listener leak
-    if (!existing.warned) {
-      m = $getMaxListeners(target);
-      if (m && m > 0 && existing.length > m) {
-        existing.warned = true;
-        var w = new Error('Possible EventEmitter memory leak detected. ' +
-                            existing.length + ' ' + type + ' listeners added. ' +
-                            'Use emitter.setMaxListeners() to increase limit');
-        w.name = 'MaxListenersExceededWarning';
-        w.emitter = target;
-        w.type = type;
-        w.count = existing.length;
-        emitWarning(w);
+  }
+  function setClasses(classes, impact) {
+    classes.split(" ").filter(Boolean).forEach((x) => {
+      if (impact) {
+        link.classList.add(x);
+      } else {
+        link.classList.remove(x);
       }
-    }
+    });
   }
-
-  return target;
-}
-function emitWarning(e) {
-  typeof console.warn === 'function' ? console.warn(e) : console.log(e);
-}
-EventEmitter.prototype.addListener = function addListener(type, listener) {
-  return _addListener(this, type, listener, false);
-};
-
-EventEmitter.prototype.on = EventEmitter.prototype.addListener;
-
-EventEmitter.prototype.prependListener =
-    function prependListener(type, listener) {
-      return _addListener(this, type, listener, true);
-    };
-
-function _onceWrap(target, type, listener) {
-  var fired = false;
-  function g() {
-    target.removeListener(type, g);
-    if (!fired) {
-      fired = true;
-      listener.apply(target, arguments);
+  function setStatusClasses() {
+    if (options.addClassOn) {
+      setClasses(options.addClassOn, status);
+    }
+    if (options.addClassOff) {
+      setClasses(options.addClassOff, !status);
     }
   }
-  g.listener = listener;
-  return g;
-}
-
-EventEmitter.prototype.once = function once(type, listener) {
-  if (typeof listener !== 'function')
-    throw new TypeError('"listener" argument must be a function');
-  this.on(type, _onceWrap(this, type, listener));
-  return this;
-};
-
-EventEmitter.prototype.prependOnceListener =
-    function prependOnceListener(type, listener) {
-      if (typeof listener !== 'function')
-        throw new TypeError('"listener" argument must be a function');
-      this.prependListener(type, _onceWrap(this, type, listener));
-      return this;
-    };
-
-// emits a 'removeListener' event iff the listener was removed
-EventEmitter.prototype.removeListener =
-    function removeListener(type, listener) {
-      var list, events, position, i, originalListener;
-
-      if (typeof listener !== 'function')
-        throw new TypeError('"listener" argument must be a function');
-
-      events = this._events;
-      if (!events)
-        return this;
-
-      list = events[type];
-      if (!list)
-        return this;
-
-      if (list === listener || (list.listener && list.listener === listener)) {
-        if (--this._eventsCount === 0)
-          this._events = new EventHandlers();
-        else {
-          delete events[type];
-          if (events.removeListener)
-            this.emit('removeListener', type, list.listener || listener);
-        }
-      } else if (typeof list !== 'function') {
-        position = -1;
-
-        for (i = list.length; i-- > 0;) {
-          if (list[i] === listener ||
-              (list[i].listener && list[i].listener === listener)) {
-            originalListener = list[i].listener;
-            position = i;
-            break;
-          }
-        }
-
-        if (position < 0)
-          return this;
-
-        if (list.length === 1) {
-          list[0] = undefined;
-          if (--this._eventsCount === 0) {
-            this._events = new EventHandlers();
-            return this;
-          } else {
-            delete events[type];
-          }
-        } else {
-          spliceOne(list, position);
-        }
-
-        if (events.removeListener)
-          this.emit('removeListener', type, originalListener || listener);
-      }
-
-      return this;
-    };
-    
-// Alias for removeListener added in NodeJS 10.0
-// https://nodejs.org/api/events.html#events_emitter_off_eventname_listener
-EventEmitter.prototype.off = function(type, listener){
-    return this.removeListener(type, listener);
-};
-
-EventEmitter.prototype.removeAllListeners =
-    function removeAllListeners(type) {
-      var listeners, events;
-
-      events = this._events;
-      if (!events)
-        return this;
-
-      // not listening for removeListener, no need to emit
-      if (!events.removeListener) {
-        if (arguments.length === 0) {
-          this._events = new EventHandlers();
-          this._eventsCount = 0;
-        } else if (events[type]) {
-          if (--this._eventsCount === 0)
-            this._events = new EventHandlers();
-          else
-            delete events[type];
-        }
-        return this;
+  setTitle();
+  setHtml();
+  if (options.addClass) {
+    setClasses(options.addClass, true);
+  }
+  setStatusClasses();
+  const changeStatus = (status_) => {
+    if (status_ !== void 0) {
+      status = status_;
+    }
+    setHtml();
+    setTitle();
+    setStatusClasses();
+  };
+  const getStatus = () => status;
+  const onClick = (status_) => {
+    if (status_ === void 0 && status && buttonControl.disableOnSecondClick) {
+      return;
+    }
+    const previousStatus = status;
+    status = status_ !== void 0 ? status_ : !status;
+    if (options.onClick) {
+      let afterClick;
+      try {
+        afterClick = options.onClick(status);
+      } catch (er) {
+        status = previousStatus;
+        changeStatus();
+        throw er;
       }
-
-      // emit removeListener for all listeners on all events
-      if (arguments.length === 0) {
-        var keys = Object.keys(events);
-        for (var i = 0, key; i < keys.length; ++i) {
-          key = keys[i];
-          if (key === 'removeListener') continue;
-          this.removeAllListeners(key);
+      Promise.resolve(afterClick).then(() => {
+        changeStatus();
+        if (previousStatus !== status) {
+          notifyStatusChange(buttonControl);
         }
-        this.removeAllListeners('removeListener');
-        this._events = new EventHandlers();
-        this._eventsCount = 0;
-        return this;
-      }
-
-      listeners = events[type];
-
-      if (typeof listeners === 'function') {
-        this.removeListener(type, listeners);
-      } else if (listeners) {
-        // LIFO order
-        do {
-          this.removeListener(type, listeners[listeners.length - 1]);
-        } while (listeners[0]);
+      }).catch(() => {
+        status = previousStatus;
+        changeStatus();
+      });
+    } else {
+      changeStatus();
+      if (previousStatus !== status) {
+        notifyStatusChange(buttonControl);
       }
-
-      return this;
-    };
-
-EventEmitter.prototype.listeners = function listeners(type) {
-  var evlistener;
-  var ret;
-  var events = this._events;
-
-  if (!events)
-    ret = [];
-  else {
-    evlistener = events[type];
-    if (!evlistener)
-      ret = [];
-    else if (typeof evlistener === 'function')
-      ret = [evlistener.listener || evlistener];
-    else
-      ret = unwrapListeners(evlistener);
-  }
-
-  return ret;
-};
-
-EventEmitter.listenerCount = function(emitter, type) {
-  if (typeof emitter.listenerCount === 'function') {
-    return emitter.listenerCount(type);
-  } else {
-    return listenerCount.call(emitter, type);
-  }
-};
-
-EventEmitter.prototype.listenerCount = listenerCount;
-function listenerCount(type) {
-  var events = this._events;
-
-  if (events) {
-    var evlistener = events[type];
-
-    if (typeof evlistener === 'function') {
-      return 1;
-    } else if (evlistener) {
-      return evlistener.length;
-    }
-  }
-
-  return 0;
-}
-
-EventEmitter.prototype.eventNames = function eventNames() {
-  return this._eventsCount > 0 ? Reflect.ownKeys(this._events) : [];
-};
-
-// About 1.5x faster than the two-arg version of Array#splice().
-function spliceOne(list, index) {
-  for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1)
-    list[i] = list[k];
-  list.pop();
-}
-
-function arrayClone(arr, i) {
-  var copy = new Array(i);
-  while (i--)
-    copy[i] = arr[i];
-  return copy;
-}
-
-function unwrapListeners(arr) {
-  var ret = new Array(arr.length);
-  for (var i = 0; i < ret.length; ++i) {
-    ret[i] = arr[i].listener || arr[i];
+    }
+  };
+  const buttonControl = createButtonControlContent({
+    html: link,
+    onClick
+  });
+  buttonControl.onClick = onClick;
+  buttonControl.changeStatus = changeStatus;
+  buttonControl.getStatus = getStatus;
+  buttonControl.switch = options.switch;
+  if (options.disableOnSecondClick !== void 0) {
+    buttonControl.disableOnSecondClick = options.disableOnSecondClick;
   }
-  return ret;
+  buttonControl.onStatusChange = (listener) => {
+    statusListeners.add(listener);
+    return () => statusListeners.delete(listener);
+  };
+  return buttonControl;
 }
 
 var leafletSrc$1 = {exports: {}};
@@ -13925,625 +14050,1279 @@ function requireLeafletSrc () {
 		  });
 
 		  // @section Handlers
-		  // @property dragging: Handler
-		  // Map dragging handler (by both mouse and touch).
-		  Map.addInitHook('addHandler', 'dragging', Drag);
+		  // @property dragging: Handler
+		  // Map dragging handler (by both mouse and touch).
+		  Map.addInitHook('addHandler', 'dragging', Drag);
+
+		  /*
+		   * L.Map.Keyboard is handling keyboard interaction with the map, enabled by default.
+		   */
+
+		  // @namespace Map
+		  // @section Keyboard Navigation Options
+		  Map.mergeOptions({
+		  	// @option keyboard: Boolean = true
+		  	// Makes the map focusable and allows users to navigate the map with keyboard
+		  	// arrows and `+`/`-` keys.
+		  	keyboard: true,
+
+		  	// @option keyboardPanDelta: Number = 80
+		  	// Amount of pixels to pan when pressing an arrow key.
+		  	keyboardPanDelta: 80
+		  });
+
+		  var Keyboard = Handler.extend({
+
+		  	keyCodes: {
+		  		left:    [37],
+		  		right:   [39],
+		  		down:    [40],
+		  		up:      [38],
+		  		zoomIn:  [187, 107, 61, 171],
+		  		zoomOut: [189, 109, 54, 173]
+		  	},
+
+		  	initialize: function (map) {
+		  		this._map = map;
+
+		  		this._setPanDelta(map.options.keyboardPanDelta);
+		  		this._setZoomDelta(map.options.zoomDelta);
+		  	},
+
+		  	addHooks: function () {
+		  		var container = this._map._container;
+
+		  		// make the container focusable by tabbing
+		  		if (container.tabIndex <= 0) {
+		  			container.tabIndex = '0';
+		  		}
+
+		  		on(container, {
+		  			focus: this._onFocus,
+		  			blur: this._onBlur,
+		  			mousedown: this._onMouseDown
+		  		}, this);
+
+		  		this._map.on({
+		  			focus: this._addHooks,
+		  			blur: this._removeHooks
+		  		}, this);
+		  	},
+
+		  	removeHooks: function () {
+		  		this._removeHooks();
+
+		  		off(this._map._container, {
+		  			focus: this._onFocus,
+		  			blur: this._onBlur,
+		  			mousedown: this._onMouseDown
+		  		}, this);
+
+		  		this._map.off({
+		  			focus: this._addHooks,
+		  			blur: this._removeHooks
+		  		}, this);
+		  	},
+
+		  	_onMouseDown: function () {
+		  		if (this._focused) { return; }
+
+		  		var body = document.body,
+		  		    docEl = document.documentElement,
+		  		    top = body.scrollTop || docEl.scrollTop,
+		  		    left = body.scrollLeft || docEl.scrollLeft;
+
+		  		this._map._container.focus();
+
+		  		window.scrollTo(left, top);
+		  	},
+
+		  	_onFocus: function () {
+		  		this._focused = true;
+		  		this._map.fire('focus');
+		  	},
+
+		  	_onBlur: function () {
+		  		this._focused = false;
+		  		this._map.fire('blur');
+		  	},
+
+		  	_setPanDelta: function (panDelta) {
+		  		var keys = this._panKeys = {},
+		  		    codes = this.keyCodes,
+		  		    i, len;
+
+		  		for (i = 0, len = codes.left.length; i < len; i++) {
+		  			keys[codes.left[i]] = [-1 * panDelta, 0];
+		  		}
+		  		for (i = 0, len = codes.right.length; i < len; i++) {
+		  			keys[codes.right[i]] = [panDelta, 0];
+		  		}
+		  		for (i = 0, len = codes.down.length; i < len; i++) {
+		  			keys[codes.down[i]] = [0, panDelta];
+		  		}
+		  		for (i = 0, len = codes.up.length; i < len; i++) {
+		  			keys[codes.up[i]] = [0, -1 * panDelta];
+		  		}
+		  	},
+
+		  	_setZoomDelta: function (zoomDelta) {
+		  		var keys = this._zoomKeys = {},
+		  		    codes = this.keyCodes,
+		  		    i, len;
+
+		  		for (i = 0, len = codes.zoomIn.length; i < len; i++) {
+		  			keys[codes.zoomIn[i]] = zoomDelta;
+		  		}
+		  		for (i = 0, len = codes.zoomOut.length; i < len; i++) {
+		  			keys[codes.zoomOut[i]] = -zoomDelta;
+		  		}
+		  	},
+
+		  	_addHooks: function () {
+		  		on(document, 'keydown', this._onKeyDown, this);
+		  	},
+
+		  	_removeHooks: function () {
+		  		off(document, 'keydown', this._onKeyDown, this);
+		  	},
+
+		  	_onKeyDown: function (e) {
+		  		if (e.altKey || e.ctrlKey || e.metaKey) { return; }
+
+		  		var key = e.keyCode,
+		  		    map = this._map,
+		  		    offset;
+
+		  		if (key in this._panKeys) {
+		  			if (!map._panAnim || !map._panAnim._inProgress) {
+		  				offset = this._panKeys[key];
+		  				if (e.shiftKey) {
+		  					offset = toPoint(offset).multiplyBy(3);
+		  				}
+
+		  				map.panBy(offset);
+
+		  				if (map.options.maxBounds) {
+		  					map.panInsideBounds(map.options.maxBounds);
+		  				}
+		  			}
+		  		} else if (key in this._zoomKeys) {
+		  			map.setZoom(map.getZoom() + (e.shiftKey ? 3 : 1) * this._zoomKeys[key]);
+
+		  		} else if (key === 27 && map._popup && map._popup.options.closeOnEscapeKey) {
+		  			map.closePopup();
+
+		  		} else {
+		  			return;
+		  		}
+
+		  		stop(e);
+		  	}
+		  });
+
+		  // @section Handlers
+		  // @section Handlers
+		  // @property keyboard: Handler
+		  // Keyboard navigation handler.
+		  Map.addInitHook('addHandler', 'keyboard', Keyboard);
+
+		  /*
+		   * L.Handler.ScrollWheelZoom is used by L.Map to enable mouse scroll wheel zoom on the map.
+		   */
+
+		  // @namespace Map
+		  // @section Interaction Options
+		  Map.mergeOptions({
+		  	// @section Mouse wheel options
+		  	// @option scrollWheelZoom: Boolean|String = true
+		  	// Whether the map can be zoomed by using the mouse wheel. If passed `'center'`,
+		  	// it will zoom to the center of the view regardless of where the mouse was.
+		  	scrollWheelZoom: true,
+
+		  	// @option wheelDebounceTime: Number = 40
+		  	// Limits the rate at which a wheel can fire (in milliseconds). By default
+		  	// user can't zoom via wheel more often than once per 40 ms.
+		  	wheelDebounceTime: 40,
+
+		  	// @option wheelPxPerZoomLevel: Number = 60
+		  	// How many scroll pixels (as reported by [L.DomEvent.getWheelDelta](#domevent-getwheeldelta))
+		  	// mean a change of one full zoom level. Smaller values will make wheel-zooming
+		  	// faster (and vice versa).
+		  	wheelPxPerZoomLevel: 60
+		  });
+
+		  var ScrollWheelZoom = Handler.extend({
+		  	addHooks: function () {
+		  		on(this._map._container, 'wheel', this._onWheelScroll, this);
+
+		  		this._delta = 0;
+		  	},
+
+		  	removeHooks: function () {
+		  		off(this._map._container, 'wheel', this._onWheelScroll, this);
+		  	},
+
+		  	_onWheelScroll: function (e) {
+		  		var delta = getWheelDelta(e);
+
+		  		var debounce = this._map.options.wheelDebounceTime;
+
+		  		this._delta += delta;
+		  		this._lastMousePos = this._map.mouseEventToContainerPoint(e);
+
+		  		if (!this._startTime) {
+		  			this._startTime = +new Date();
+		  		}
+
+		  		var left = Math.max(debounce - (+new Date() - this._startTime), 0);
+
+		  		clearTimeout(this._timer);
+		  		this._timer = setTimeout(bind(this._performZoom, this), left);
+
+		  		stop(e);
+		  	},
+
+		  	_performZoom: function () {
+		  		var map = this._map,
+		  		    zoom = map.getZoom(),
+		  		    snap = this._map.options.zoomSnap || 0;
+
+		  		map._stop(); // stop panning and fly animations if any
+
+		  		// map the delta with a sigmoid function to -4..4 range leaning on -1..1
+		  		var d2 = this._delta / (this._map.options.wheelPxPerZoomLevel * 4),
+		  		    d3 = 4 * Math.log(2 / (1 + Math.exp(-Math.abs(d2)))) / Math.LN2,
+		  		    d4 = snap ? Math.ceil(d3 / snap) * snap : d3,
+		  		    delta = map._limitZoom(zoom + (this._delta > 0 ? d4 : -d4)) - zoom;
+
+		  		this._delta = 0;
+		  		this._startTime = null;
+
+		  		if (!delta) { return; }
+
+		  		if (map.options.scrollWheelZoom === 'center') {
+		  			map.setZoom(zoom + delta);
+		  		} else {
+		  			map.setZoomAround(this._lastMousePos, zoom + delta);
+		  		}
+		  	}
+		  });
+
+		  // @section Handlers
+		  // @property scrollWheelZoom: Handler
+		  // Scroll wheel zoom handler.
+		  Map.addInitHook('addHandler', 'scrollWheelZoom', ScrollWheelZoom);
 
 		  /*
-		   * L.Map.Keyboard is handling keyboard interaction with the map, enabled by default.
+		   * L.Map.Tap is used to enable mobile hacks like quick taps and long hold.
 		   */
 
 		  // @namespace Map
-		  // @section Keyboard Navigation Options
+		  // @section Interaction Options
 		  Map.mergeOptions({
-		  	// @option keyboard: Boolean = true
-		  	// Makes the map focusable and allows users to navigate the map with keyboard
-		  	// arrows and `+`/`-` keys.
-		  	keyboard: true,
+		  	// @section Touch interaction options
+		  	// @option tap: Boolean = true
+		  	// Enables mobile hacks for supporting instant taps (fixing 200ms click
+		  	// delay on iOS/Android) and touch holds (fired as `contextmenu` events).
+		  	tap: true,
 
-		  	// @option keyboardPanDelta: Number = 80
-		  	// Amount of pixels to pan when pressing an arrow key.
-		  	keyboardPanDelta: 80
+		  	// @option tapTolerance: Number = 15
+		  	// The max number of pixels a user can shift his finger during touch
+		  	// for it to be considered a valid tap.
+		  	tapTolerance: 15
 		  });
 
-		  var Keyboard = Handler.extend({
+		  var Tap = Handler.extend({
+		  	addHooks: function () {
+		  		on(this._map._container, 'touchstart', this._onDown, this);
+		  	},
 
-		  	keyCodes: {
-		  		left:    [37],
-		  		right:   [39],
-		  		down:    [40],
-		  		up:      [38],
-		  		zoomIn:  [187, 107, 61, 171],
-		  		zoomOut: [189, 109, 54, 173]
+		  	removeHooks: function () {
+		  		off(this._map._container, 'touchstart', this._onDown, this);
 		  	},
 
-		  	initialize: function (map) {
-		  		this._map = map;
+		  	_onDown: function (e) {
+		  		if (!e.touches) { return; }
 
-		  		this._setPanDelta(map.options.keyboardPanDelta);
-		  		this._setZoomDelta(map.options.zoomDelta);
-		  	},
+		  		preventDefault(e);
 
-		  	addHooks: function () {
-		  		var container = this._map._container;
+		  		this._fireClick = true;
 
-		  		// make the container focusable by tabbing
-		  		if (container.tabIndex <= 0) {
-		  			container.tabIndex = '0';
+		  		// don't simulate click or track longpress if more than 1 touch
+		  		if (e.touches.length > 1) {
+		  			this._fireClick = false;
+		  			clearTimeout(this._holdTimeout);
+		  			return;
 		  		}
 
-		  		on(container, {
-		  			focus: this._onFocus,
-		  			blur: this._onBlur,
-		  			mousedown: this._onMouseDown
-		  		}, this);
+		  		var first = e.touches[0],
+		  		    el = first.target;
 
-		  		this._map.on({
-		  			focus: this._addHooks,
-		  			blur: this._removeHooks
+		  		this._startPos = this._newPos = new Point(first.clientX, first.clientY);
+
+		  		// if touching a link, highlight it
+		  		if (el.tagName && el.tagName.toLowerCase() === 'a') {
+		  			addClass(el, 'leaflet-active');
+		  		}
+
+		  		// simulate long hold but setting a timeout
+		  		this._holdTimeout = setTimeout(bind(function () {
+		  			if (this._isTapValid()) {
+		  				this._fireClick = false;
+		  				this._onUp();
+		  				this._simulateEvent('contextmenu', first);
+		  			}
+		  		}, this), 1000);
+
+		  		this._simulateEvent('mousedown', first);
+
+		  		on(document, {
+		  			touchmove: this._onMove,
+		  			touchend: this._onUp
 		  		}, this);
 		  	},
 
-		  	removeHooks: function () {
-		  		this._removeHooks();
+		  	_onUp: function (e) {
+		  		clearTimeout(this._holdTimeout);
 
-		  		off(this._map._container, {
-		  			focus: this._onFocus,
-		  			blur: this._onBlur,
-		  			mousedown: this._onMouseDown
+		  		off(document, {
+		  			touchmove: this._onMove,
+		  			touchend: this._onUp
 		  		}, this);
 
-		  		this._map.off({
-		  			focus: this._addHooks,
-		  			blur: this._removeHooks
-		  		}, this);
-		  	},
+		  		if (this._fireClick && e && e.changedTouches) {
 
-		  	_onMouseDown: function () {
-		  		if (this._focused) { return; }
+		  			var first = e.changedTouches[0],
+		  			    el = first.target;
 
-		  		var body = document.body,
-		  		    docEl = document.documentElement,
-		  		    top = body.scrollTop || docEl.scrollTop,
-		  		    left = body.scrollLeft || docEl.scrollLeft;
+		  			if (el && el.tagName && el.tagName.toLowerCase() === 'a') {
+		  				removeClass(el, 'leaflet-active');
+		  			}
 
-		  		this._map._container.focus();
+		  			this._simulateEvent('mouseup', first);
 
-		  		window.scrollTo(left, top);
+		  			// simulate click if the touch didn't move too much
+		  			if (this._isTapValid()) {
+		  				this._simulateEvent('click', first);
+		  			}
+		  		}
 		  	},
 
-		  	_onFocus: function () {
-		  		this._focused = true;
-		  		this._map.fire('focus');
+		  	_isTapValid: function () {
+		  		return this._newPos.distanceTo(this._startPos) <= this._map.options.tapTolerance;
 		  	},
 
-		  	_onBlur: function () {
-		  		this._focused = false;
-		  		this._map.fire('blur');
+		  	_onMove: function (e) {
+		  		var first = e.touches[0];
+		  		this._newPos = new Point(first.clientX, first.clientY);
+		  		this._simulateEvent('mousemove', first);
 		  	},
 
-		  	_setPanDelta: function (panDelta) {
-		  		var keys = this._panKeys = {},
-		  		    codes = this.keyCodes,
-		  		    i, len;
+		  	_simulateEvent: function (type, e) {
+		  		var simulatedEvent = document.createEvent('MouseEvents');
 
-		  		for (i = 0, len = codes.left.length; i < len; i++) {
-		  			keys[codes.left[i]] = [-1 * panDelta, 0];
-		  		}
-		  		for (i = 0, len = codes.right.length; i < len; i++) {
-		  			keys[codes.right[i]] = [panDelta, 0];
-		  		}
-		  		for (i = 0, len = codes.down.length; i < len; i++) {
-		  			keys[codes.down[i]] = [0, panDelta];
-		  		}
-		  		for (i = 0, len = codes.up.length; i < len; i++) {
-		  			keys[codes.up[i]] = [0, -1 * panDelta];
-		  		}
-		  	},
+		  		simulatedEvent._simulated = true;
+		  		e.target._simulatedClick = true;
 
-		  	_setZoomDelta: function (zoomDelta) {
-		  		var keys = this._zoomKeys = {},
-		  		    codes = this.keyCodes,
-		  		    i, len;
+		  		simulatedEvent.initMouseEvent(
+		  		        type, true, true, window, 1,
+		  		        e.screenX, e.screenY,
+		  		        e.clientX, e.clientY,
+		  		        false, false, false, false, 0, null);
 
-		  		for (i = 0, len = codes.zoomIn.length; i < len; i++) {
-		  			keys[codes.zoomIn[i]] = zoomDelta;
-		  		}
-		  		for (i = 0, len = codes.zoomOut.length; i < len; i++) {
-		  			keys[codes.zoomOut[i]] = -zoomDelta;
-		  		}
-		  	},
+		  		e.target.dispatchEvent(simulatedEvent);
+		  	}
+		  });
 
-		  	_addHooks: function () {
-		  		on(document, 'keydown', this._onKeyDown, this);
-		  	},
+		  // @section Handlers
+		  // @property tap: Handler
+		  // Mobile touch hacks (quick tap and touch hold) handler.
+		  if (touch && (!pointer || safari)) {
+		  	Map.addInitHook('addHandler', 'tap', Tap);
+		  }
 
-		  	_removeHooks: function () {
-		  		off(document, 'keydown', this._onKeyDown, this);
+		  /*
+		   * L.Handler.TouchZoom is used by L.Map to add pinch zoom on supported mobile browsers.
+		   */
+
+		  // @namespace Map
+		  // @section Interaction Options
+		  Map.mergeOptions({
+		  	// @section Touch interaction options
+		  	// @option touchZoom: Boolean|String = *
+		  	// Whether the map can be zoomed by touch-dragging with two fingers. If
+		  	// passed `'center'`, it will zoom to the center of the view regardless of
+		  	// where the touch events (fingers) were. Enabled for touch-capable web
+		  	// browsers except for old Androids.
+		  	touchZoom: touch && !android23,
+
+		  	// @option bounceAtZoomLimits: Boolean = true
+		  	// Set it to false if you don't want the map to zoom beyond min/max zoom
+		  	// and then bounce back when pinch-zooming.
+		  	bounceAtZoomLimits: true
+		  });
+
+		  var TouchZoom = Handler.extend({
+		  	addHooks: function () {
+		  		addClass(this._map._container, 'leaflet-touch-zoom');
+		  		on(this._map._container, 'touchstart', this._onTouchStart, this);
 		  	},
 
-		  	_onKeyDown: function (e) {
-		  		if (e.altKey || e.ctrlKey || e.metaKey) { return; }
+		  	removeHooks: function () {
+		  		removeClass(this._map._container, 'leaflet-touch-zoom');
+		  		off(this._map._container, 'touchstart', this._onTouchStart, this);
+		  	},
 
-		  		var key = e.keyCode,
-		  		    map = this._map,
-		  		    offset;
+		  	_onTouchStart: function (e) {
+		  		var map = this._map;
+		  		if (!e.touches || e.touches.length !== 2 || map._animatingZoom || this._zooming) { return; }
 
-		  		if (key in this._panKeys) {
-		  			if (!map._panAnim || !map._panAnim._inProgress) {
-		  				offset = this._panKeys[key];
-		  				if (e.shiftKey) {
-		  					offset = toPoint(offset).multiplyBy(3);
-		  				}
+		  		var p1 = map.mouseEventToContainerPoint(e.touches[0]),
+		  		    p2 = map.mouseEventToContainerPoint(e.touches[1]);
 
-		  				map.panBy(offset);
+		  		this._centerPoint = map.getSize()._divideBy(2);
+		  		this._startLatLng = map.containerPointToLatLng(this._centerPoint);
+		  		if (map.options.touchZoom !== 'center') {
+		  			this._pinchStartLatLng = map.containerPointToLatLng(p1.add(p2)._divideBy(2));
+		  		}
 
-		  				if (map.options.maxBounds) {
-		  					map.panInsideBounds(map.options.maxBounds);
-		  				}
-		  			}
-		  		} else if (key in this._zoomKeys) {
-		  			map.setZoom(map.getZoom() + (e.shiftKey ? 3 : 1) * this._zoomKeys[key]);
+		  		this._startDist = p1.distanceTo(p2);
+		  		this._startZoom = map.getZoom();
 
-		  		} else if (key === 27 && map._popup && map._popup.options.closeOnEscapeKey) {
-		  			map.closePopup();
+		  		this._moved = false;
+		  		this._zooming = true;
 
-		  		} else {
-		  			return;
-		  		}
+		  		map._stop();
 
-		  		stop(e);
-		  	}
-		  });
+		  		on(document, 'touchmove', this._onTouchMove, this);
+		  		on(document, 'touchend', this._onTouchEnd, this);
 
-		  // @section Handlers
-		  // @section Handlers
-		  // @property keyboard: Handler
-		  // Keyboard navigation handler.
-		  Map.addInitHook('addHandler', 'keyboard', Keyboard);
+		  		preventDefault(e);
+		  	},
 
-		  /*
-		   * L.Handler.ScrollWheelZoom is used by L.Map to enable mouse scroll wheel zoom on the map.
-		   */
+		  	_onTouchMove: function (e) {
+		  		if (!e.touches || e.touches.length !== 2 || !this._zooming) { return; }
 
-		  // @namespace Map
-		  // @section Interaction Options
-		  Map.mergeOptions({
-		  	// @section Mouse wheel options
-		  	// @option scrollWheelZoom: Boolean|String = true
-		  	// Whether the map can be zoomed by using the mouse wheel. If passed `'center'`,
-		  	// it will zoom to the center of the view regardless of where the mouse was.
-		  	scrollWheelZoom: true,
+		  		var map = this._map,
+		  		    p1 = map.mouseEventToContainerPoint(e.touches[0]),
+		  		    p2 = map.mouseEventToContainerPoint(e.touches[1]),
+		  		    scale = p1.distanceTo(p2) / this._startDist;
 
-		  	// @option wheelDebounceTime: Number = 40
-		  	// Limits the rate at which a wheel can fire (in milliseconds). By default
-		  	// user can't zoom via wheel more often than once per 40 ms.
-		  	wheelDebounceTime: 40,
+		  		this._zoom = map.getScaleZoom(scale, this._startZoom);
 
-		  	// @option wheelPxPerZoomLevel: Number = 60
-		  	// How many scroll pixels (as reported by [L.DomEvent.getWheelDelta](#domevent-getwheeldelta))
-		  	// mean a change of one full zoom level. Smaller values will make wheel-zooming
-		  	// faster (and vice versa).
-		  	wheelPxPerZoomLevel: 60
-		  });
+		  		if (!map.options.bounceAtZoomLimits && (
+		  			(this._zoom < map.getMinZoom() && scale < 1) ||
+		  			(this._zoom > map.getMaxZoom() && scale > 1))) {
+		  			this._zoom = map._limitZoom(this._zoom);
+		  		}
 
-		  var ScrollWheelZoom = Handler.extend({
-		  	addHooks: function () {
-		  		on(this._map._container, 'wheel', this._onWheelScroll, this);
+		  		if (map.options.touchZoom === 'center') {
+		  			this._center = this._startLatLng;
+		  			if (scale === 1) { return; }
+		  		} else {
+		  			// Get delta from pinch to center, so centerLatLng is delta applied to initial pinchLatLng
+		  			var delta = p1._add(p2)._divideBy(2)._subtract(this._centerPoint);
+		  			if (scale === 1 && delta.x === 0 && delta.y === 0) { return; }
+		  			this._center = map.unproject(map.project(this._pinchStartLatLng, this._zoom).subtract(delta), this._zoom);
+		  		}
 
-		  		this._delta = 0;
-		  	},
+		  		if (!this._moved) {
+		  			map._moveStart(true, false);
+		  			this._moved = true;
+		  		}
 
-		  	removeHooks: function () {
-		  		off(this._map._container, 'wheel', this._onWheelScroll, this);
+		  		cancelAnimFrame(this._animRequest);
+
+		  		var moveFn = bind(map._move, map, this._center, this._zoom, {pinch: true, round: false});
+		  		this._animRequest = requestAnimFrame(moveFn, this, true);
+
+		  		preventDefault(e);
 		  	},
 
-		  	_onWheelScroll: function (e) {
-		  		var delta = getWheelDelta(e);
+		  	_onTouchEnd: function () {
+		  		if (!this._moved || !this._zooming) {
+		  			this._zooming = false;
+		  			return;
+		  		}
 
-		  		var debounce = this._map.options.wheelDebounceTime;
+		  		this._zooming = false;
+		  		cancelAnimFrame(this._animRequest);
 
-		  		this._delta += delta;
-		  		this._lastMousePos = this._map.mouseEventToContainerPoint(e);
+		  		off(document, 'touchmove', this._onTouchMove, this);
+		  		off(document, 'touchend', this._onTouchEnd, this);
 
-		  		if (!this._startTime) {
-		  			this._startTime = +new Date();
+		  		// Pinch updates GridLayers' levels only when zoomSnap is off, so zoomSnap becomes noUpdate.
+		  		if (this._map.options.zoomAnimation) {
+		  			this._map._animateZoom(this._center, this._map._limitZoom(this._zoom), true, this._map.options.zoomSnap);
+		  		} else {
+		  			this._map._resetView(this._center, this._map._limitZoom(this._zoom));
 		  		}
+		  	}
+		  });
 
-		  		var left = Math.max(debounce - (+new Date() - this._startTime), 0);
+		  // @section Handlers
+		  // @property touchZoom: Handler
+		  // Touch zoom handler.
+		  Map.addInitHook('addHandler', 'touchZoom', TouchZoom);
 
-		  		clearTimeout(this._timer);
-		  		this._timer = setTimeout(bind(this._performZoom, this), left);
+		  Map.BoxZoom = BoxZoom;
+		  Map.DoubleClickZoom = DoubleClickZoom;
+		  Map.Drag = Drag;
+		  Map.Keyboard = Keyboard;
+		  Map.ScrollWheelZoom = ScrollWheelZoom;
+		  Map.Tap = Tap;
+		  Map.TouchZoom = TouchZoom;
 
-		  		stop(e);
-		  	},
+		  exports.version = version;
+		  exports.Control = Control;
+		  exports.control = control;
+		  exports.Browser = Browser;
+		  exports.Evented = Evented;
+		  exports.Mixin = Mixin;
+		  exports.Util = Util;
+		  exports.Class = Class;
+		  exports.Handler = Handler;
+		  exports.extend = extend;
+		  exports.bind = bind;
+		  exports.stamp = stamp;
+		  exports.setOptions = setOptions;
+		  exports.DomEvent = DomEvent;
+		  exports.DomUtil = DomUtil;
+		  exports.PosAnimation = PosAnimation;
+		  exports.Draggable = Draggable;
+		  exports.LineUtil = LineUtil;
+		  exports.PolyUtil = PolyUtil;
+		  exports.Point = Point;
+		  exports.point = toPoint;
+		  exports.Bounds = Bounds;
+		  exports.bounds = toBounds;
+		  exports.Transformation = Transformation;
+		  exports.transformation = toTransformation;
+		  exports.Projection = index;
+		  exports.LatLng = LatLng;
+		  exports.latLng = toLatLng;
+		  exports.LatLngBounds = LatLngBounds;
+		  exports.latLngBounds = toLatLngBounds;
+		  exports.CRS = CRS;
+		  exports.GeoJSON = GeoJSON;
+		  exports.geoJSON = geoJSON;
+		  exports.geoJson = geoJson;
+		  exports.Layer = Layer;
+		  exports.LayerGroup = LayerGroup;
+		  exports.layerGroup = layerGroup;
+		  exports.FeatureGroup = FeatureGroup;
+		  exports.featureGroup = featureGroup;
+		  exports.ImageOverlay = ImageOverlay;
+		  exports.imageOverlay = imageOverlay;
+		  exports.VideoOverlay = VideoOverlay;
+		  exports.videoOverlay = videoOverlay;
+		  exports.SVGOverlay = SVGOverlay;
+		  exports.svgOverlay = svgOverlay;
+		  exports.DivOverlay = DivOverlay;
+		  exports.Popup = Popup;
+		  exports.popup = popup;
+		  exports.Tooltip = Tooltip;
+		  exports.tooltip = tooltip;
+		  exports.Icon = Icon;
+		  exports.icon = icon;
+		  exports.DivIcon = DivIcon;
+		  exports.divIcon = divIcon;
+		  exports.Marker = Marker;
+		  exports.marker = marker;
+		  exports.TileLayer = TileLayer;
+		  exports.tileLayer = tileLayer;
+		  exports.GridLayer = GridLayer;
+		  exports.gridLayer = gridLayer;
+		  exports.SVG = SVG;
+		  exports.svg = svg$1;
+		  exports.Renderer = Renderer;
+		  exports.Canvas = Canvas;
+		  exports.canvas = canvas$1;
+		  exports.Path = Path;
+		  exports.CircleMarker = CircleMarker;
+		  exports.circleMarker = circleMarker;
+		  exports.Circle = Circle;
+		  exports.circle = circle;
+		  exports.Polyline = Polyline;
+		  exports.polyline = polyline;
+		  exports.Polygon = Polygon;
+		  exports.polygon = polygon;
+		  exports.Rectangle = Rectangle;
+		  exports.rectangle = rectangle;
+		  exports.Map = Map;
+		  exports.map = createMap;
 
-		  	_performZoom: function () {
-		  		var map = this._map,
-		  		    zoom = map.getZoom(),
-		  		    snap = this._map.options.zoomSnap || 0;
+		  var oldL = window.L;
+		  exports.noConflict = function() {
+		  	window.L = oldL;
+		  	return this;
+		  };
 
-		  		map._stop(); // stop panning and fly animations if any
+		  // Always export us to window global (see #2364)
+		  window.L = exports;
 
-		  		// map the delta with a sigmoid function to -4..4 range leaning on -1..1
-		  		var d2 = this._delta / (this._map.options.wheelPxPerZoomLevel * 4),
-		  		    d3 = 4 * Math.log(2 / (1 + Math.exp(-Math.abs(d2)))) / Math.LN2,
-		  		    d4 = snap ? Math.ceil(d3 / snap) * snap : d3,
-		  		    delta = map._limitZoom(zoom + (this._delta > 0 ? d4 : -d4)) - zoom;
+		})));
+		
+	} (leafletSrc$1, leafletSrc$1.exports));
+	return leafletSrc$1.exports;
+}
 
-		  		this._delta = 0;
-		  		this._startTime = null;
+var leafletSrcExports = /*@__PURE__*/ requireLeafletSrc();
 
-		  		if (!delta) { return; }
+var __defProp$e = Object.defineProperty;
+var __defProps$7 = Object.defineProperties;
+var __getOwnPropDescs$7 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$a = Object.getOwnPropertySymbols;
+var __hasOwnProp$a = Object.prototype.hasOwnProperty;
+var __propIsEnum$a = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$e = (obj, key, value) => key in obj ? __defProp$e(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$a = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$a.call(b, prop))
+      __defNormalProp$e(a, prop, b[prop]);
+  if (__getOwnPropSymbols$a)
+    for (var prop of __getOwnPropSymbols$a(b)) {
+      if (__propIsEnum$a.call(b, prop))
+        __defNormalProp$e(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$7 = (a, b) => __defProps$7(a, __getOwnPropDescs$7(b));
+function createControl(control, options = {}, map) {
+  const resolvedOptions = resolveControlOptions(options);
+  const C = leafletSrcExports.Control.extend({
+    onAdd(leafletMap) {
+      const addClass = [
+        "leaflet-control",
+        resolvedOptions.bar ? "leaflet-bar" : "",
+        resolvedOptions.addClass
+      ].filter(Boolean).join(" ");
+      const element = createControlElement(
+        control,
+        __spreadProps$7(__spreadValues$a({}, resolvedOptions), { addClass }),
+        map != null ? map : leafletMap
+      );
+      if (!resolvedOptions.margin) {
+        element.style.margin = "0px";
+      }
+      return element;
+    },
+    onRemove(leafletMap) {
+      control.onRemove(map != null ? map : leafletMap);
+    }
+  });
+  const instance = new C();
+  setControlOptions(instance, resolvedOptions);
+  return instance;
+}
+
+function createButtonControl(options, map) {
+  return createControl(
+    createButtonControlContent(options),
+    { bar: true, margin: options.margin },
+    map
+  );
+}
+
+function createToggleControl(options, map) {
+  const toggleContent = createToggleControlContent(options);
+  const control = createControl(
+    toggleContent,
+    { bar: true, margin: options.margin },
+    map
+  );
+  control.onClick = toggleContent.onClick;
+  control.changeStatus = toggleContent.changeStatus;
+  control.getStatus = toggleContent.getStatus;
+  control.switch = toggleContent.switch;
+  Object.defineProperty(control, "disableOnSecondClick", {
+    configurable: true,
+    get: () => toggleContent.disableOnSecondClick,
+    set: (value) => {
+      toggleContent.disableOnSecondClick = value;
+    }
+  });
+  control.onStatusChange = toggleContent.onStatusChange;
+  return control;
+}
+
+var __defProp$d = Object.defineProperty;
+var __defProps$6 = Object.defineProperties;
+var __getOwnPropDescs$6 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$9 = Object.getOwnPropertySymbols;
+var __hasOwnProp$9 = Object.prototype.hasOwnProperty;
+var __propIsEnum$9 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$d = (obj, key, value) => key in obj ? __defProp$d(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$9 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$9.call(b, prop))
+      __defNormalProp$d(a, prop, b[prop]);
+  if (__getOwnPropSymbols$9)
+    for (var prop of __getOwnPropSymbols$9(b)) {
+      if (__propIsEnum$9.call(b, prop))
+        __defNormalProp$d(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$6 = (a, b) => __defProps$6(a, __getOwnPropDescs$6(b));
+var __publicField$9 = (obj, key, value) => __defNormalProp$d(obj, typeof key !== "symbol" ? key + "" : key, value);
+class LeafletControlContainer {
+  constructor(map, options = {}) {
+    __publicField$9(this, "map");
+    __publicField$9(this, "controlContainer");
+    __publicField$9(this, "targets", /* @__PURE__ */ new WeakMap());
+    __publicField$9(this, "ids", /* @__PURE__ */ new WeakMap());
+    this.map = map;
+    this.controlContainer = this.createControlContainer(options);
+    this.controlContainer.addTo(map.getContainer());
+  }
+  addControl(control, position, options = {}) {
+    const targetPosition = typeof position === "string" ? position : "top-left";
+    control.options.position = targetPosition.replace(
+      "-",
+      ""
+    );
+    this.map.addControl(control);
+    const container = control.getContainer();
+    if (container) {
+      this.controlContainer.append(container, position, options.order, control);
+      this.targets.set(control, container);
+      if (options.id) {
+        this.controlContainer.registerIDContainer(
+          options.id,
+          container,
+          control
+        );
+        this.ids.set(control, options.id);
+      }
+    }
+    return control;
+  }
+  removeControl(control) {
+    this.map.removeControl(control);
+    const id = this.ids.get(control);
+    if (id) {
+      this.controlContainer.unregisterIDContainer(id);
+      this.ids.delete(control);
+    }
+    const target = this.targets.get(control);
+    if (target) {
+      this.controlContainer.removeTarget(target);
+      this.targets.delete(control);
+    }
+  }
+  append(element, position, order = 0) {
+    this.controlContainer.append(element, position, order);
+  }
+  registerIDContainer(id, controlRoot, control) {
+    this.controlContainer.registerIDContainer(id, controlRoot, control);
+  }
+  unregisterIDContainer(id) {
+    this.controlContainer.unregisterIDContainer(id);
+  }
+  detach() {
+    this.controlContainer.detach();
+  }
+  getContainer() {
+    return this.controlContainer.getContainer();
+  }
+  getControlContainer() {
+    return this.controlContainer;
+  }
+  createControlContainer(options) {
+    const mapAny = this.map;
+    const controlCorners = mapAny._controlCorners || {};
+    const getCorner = (key, selector) => controlCorners[key] || this.map.getContainer().querySelector(selector) || void 0;
+    return new ControlContainer(__spreadProps$6(__spreadValues$9({}, options), {
+      map: this.map,
+      container: mapAny._controlContainer,
+      positionContainers: {
+        "top-left": getCorner("topleft", ".leaflet-top.leaflet-left"),
+        "top-right": getCorner("topright", ".leaflet-top.leaflet-right"),
+        "bottom-left": getCorner("bottomleft", ".leaflet-bottom.leaflet-left"),
+        "bottom-right": getCorner(
+          "bottomright",
+          ".leaflet-bottom.leaflet-right"
+        )
+      }
+    }));
+  }
+}
 
-		  		if (map.options.scrollWheelZoom === 'center') {
-		  			map.setZoom(zoom + delta);
-		  		} else {
-		  			map.setZoomAround(this._lastMousePos, zoom + delta);
-		  		}
-		  	}
-		  });
+var domain;
 
-		  // @section Handlers
-		  // @property scrollWheelZoom: Handler
-		  // Scroll wheel zoom handler.
-		  Map.addInitHook('addHandler', 'scrollWheelZoom', ScrollWheelZoom);
+// This constructor is used to store event handlers. Instantiating this is
+// faster than explicitly calling `Object.create(null)` to get a "clean" empty
+// object (tested with v8 v4.9).
+function EventHandlers() {}
+EventHandlers.prototype = Object.create(null);
 
-		  /*
-		   * L.Map.Tap is used to enable mobile hacks like quick taps and long hold.
-		   */
+function EventEmitter() {
+  EventEmitter.init.call(this);
+}
 
-		  // @namespace Map
-		  // @section Interaction Options
-		  Map.mergeOptions({
-		  	// @section Touch interaction options
-		  	// @option tap: Boolean = true
-		  	// Enables mobile hacks for supporting instant taps (fixing 200ms click
-		  	// delay on iOS/Android) and touch holds (fired as `contextmenu` events).
-		  	tap: true,
+// nodejs oddity
+// require('events') === require('events').EventEmitter
+EventEmitter.EventEmitter = EventEmitter;
 
-		  	// @option tapTolerance: Number = 15
-		  	// The max number of pixels a user can shift his finger during touch
-		  	// for it to be considered a valid tap.
-		  	tapTolerance: 15
-		  });
+EventEmitter.usingDomains = false;
 
-		  var Tap = Handler.extend({
-		  	addHooks: function () {
-		  		on(this._map._container, 'touchstart', this._onDown, this);
-		  	},
+EventEmitter.prototype.domain = undefined;
+EventEmitter.prototype._events = undefined;
+EventEmitter.prototype._maxListeners = undefined;
 
-		  	removeHooks: function () {
-		  		off(this._map._container, 'touchstart', this._onDown, this);
-		  	},
+// By default EventEmitters will print a warning if more than 10 listeners are
+// added to it. This is a useful default which helps finding memory leaks.
+EventEmitter.defaultMaxListeners = 10;
 
-		  	_onDown: function (e) {
-		  		if (!e.touches) { return; }
+EventEmitter.init = function() {
+  this.domain = null;
+  if (EventEmitter.usingDomains) {
+    // if there is an active domain, then attach to it.
+    if (domain.active && !(this instanceof domain.Domain)) {
+      this.domain = domain.active;
+    }
+  }
 
-		  		preventDefault(e);
+  if (!this._events || this._events === Object.getPrototypeOf(this)._events) {
+    this._events = new EventHandlers();
+    this._eventsCount = 0;
+  }
 
-		  		this._fireClick = true;
+  this._maxListeners = this._maxListeners || undefined;
+};
 
-		  		// don't simulate click or track longpress if more than 1 touch
-		  		if (e.touches.length > 1) {
-		  			this._fireClick = false;
-		  			clearTimeout(this._holdTimeout);
-		  			return;
-		  		}
+// Obviously not all Emitters should be limited to 10. This function allows
+// that to be increased. Set to zero for unlimited.
+EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
+  if (typeof n !== 'number' || n < 0 || isNaN(n))
+    throw new TypeError('"n" argument must be a positive number');
+  this._maxListeners = n;
+  return this;
+};
 
-		  		var first = e.touches[0],
-		  		    el = first.target;
+function $getMaxListeners(that) {
+  if (that._maxListeners === undefined)
+    return EventEmitter.defaultMaxListeners;
+  return that._maxListeners;
+}
 
-		  		this._startPos = this._newPos = new Point(first.clientX, first.clientY);
+EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
+  return $getMaxListeners(this);
+};
 
-		  		// if touching a link, highlight it
-		  		if (el.tagName && el.tagName.toLowerCase() === 'a') {
-		  			addClass(el, 'leaflet-active');
-		  		}
+// These standalone emit* functions are used to optimize calling of event
+// handlers for fast cases because emit() itself often has a variable number of
+// arguments and can be deoptimized because of that. These functions always have
+// the same number of arguments and thus do not get deoptimized, so the code
+// inside them can execute faster.
+function emitNone(handler, isFn, self) {
+  if (isFn)
+    handler.call(self);
+  else {
+    var len = handler.length;
+    var listeners = arrayClone(handler, len);
+    for (var i = 0; i < len; ++i)
+      listeners[i].call(self);
+  }
+}
+function emitOne(handler, isFn, self, arg1) {
+  if (isFn)
+    handler.call(self, arg1);
+  else {
+    var len = handler.length;
+    var listeners = arrayClone(handler, len);
+    for (var i = 0; i < len; ++i)
+      listeners[i].call(self, arg1);
+  }
+}
+function emitTwo(handler, isFn, self, arg1, arg2) {
+  if (isFn)
+    handler.call(self, arg1, arg2);
+  else {
+    var len = handler.length;
+    var listeners = arrayClone(handler, len);
+    for (var i = 0; i < len; ++i)
+      listeners[i].call(self, arg1, arg2);
+  }
+}
+function emitThree(handler, isFn, self, arg1, arg2, arg3) {
+  if (isFn)
+    handler.call(self, arg1, arg2, arg3);
+  else {
+    var len = handler.length;
+    var listeners = arrayClone(handler, len);
+    for (var i = 0; i < len; ++i)
+      listeners[i].call(self, arg1, arg2, arg3);
+  }
+}
 
-		  		// simulate long hold but setting a timeout
-		  		this._holdTimeout = setTimeout(bind(function () {
-		  			if (this._isTapValid()) {
-		  				this._fireClick = false;
-		  				this._onUp();
-		  				this._simulateEvent('contextmenu', first);
-		  			}
-		  		}, this), 1000);
+function emitMany(handler, isFn, self, args) {
+  if (isFn)
+    handler.apply(self, args);
+  else {
+    var len = handler.length;
+    var listeners = arrayClone(handler, len);
+    for (var i = 0; i < len; ++i)
+      listeners[i].apply(self, args);
+  }
+}
 
-		  		this._simulateEvent('mousedown', first);
+EventEmitter.prototype.emit = function emit(type) {
+  var er, handler, len, args, i, events, domain;
+  var doError = (type === 'error');
 
-		  		on(document, {
-		  			touchmove: this._onMove,
-		  			touchend: this._onUp
-		  		}, this);
-		  	},
+  events = this._events;
+  if (events)
+    doError = (doError && events.error == null);
+  else if (!doError)
+    return false;
 
-		  	_onUp: function (e) {
-		  		clearTimeout(this._holdTimeout);
+  domain = this.domain;
 
-		  		off(document, {
-		  			touchmove: this._onMove,
-		  			touchend: this._onUp
-		  		}, this);
+  // If there is no 'error' event listener then throw.
+  if (doError) {
+    er = arguments[1];
+    if (domain) {
+      if (!er)
+        er = new Error('Uncaught, unspecified "error" event');
+      er.domainEmitter = this;
+      er.domain = domain;
+      er.domainThrown = false;
+      domain.emit('error', er);
+    } else if (er instanceof Error) {
+      throw er; // Unhandled 'error' event
+    } else {
+      // At least give some kind of context to the user
+      var err = new Error('Uncaught, unspecified "error" event. (' + er + ')');
+      err.context = er;
+      throw err;
+    }
+    return false;
+  }
 
-		  		if (this._fireClick && e && e.changedTouches) {
+  handler = events[type];
 
-		  			var first = e.changedTouches[0],
-		  			    el = first.target;
+  if (!handler)
+    return false;
 
-		  			if (el && el.tagName && el.tagName.toLowerCase() === 'a') {
-		  				removeClass(el, 'leaflet-active');
-		  			}
+  var isFn = typeof handler === 'function';
+  len = arguments.length;
+  switch (len) {
+    // fast cases
+    case 1:
+      emitNone(handler, isFn, this);
+      break;
+    case 2:
+      emitOne(handler, isFn, this, arguments[1]);
+      break;
+    case 3:
+      emitTwo(handler, isFn, this, arguments[1], arguments[2]);
+      break;
+    case 4:
+      emitThree(handler, isFn, this, arguments[1], arguments[2], arguments[3]);
+      break;
+    // slower
+    default:
+      args = new Array(len - 1);
+      for (i = 1; i < len; i++)
+        args[i - 1] = arguments[i];
+      emitMany(handler, isFn, this, args);
+  }
 
-		  			this._simulateEvent('mouseup', first);
+  return true;
+};
 
-		  			// simulate click if the touch didn't move too much
-		  			if (this._isTapValid()) {
-		  				this._simulateEvent('click', first);
-		  			}
-		  		}
-		  	},
+function _addListener(target, type, listener, prepend) {
+  var m;
+  var events;
+  var existing;
 
-		  	_isTapValid: function () {
-		  		return this._newPos.distanceTo(this._startPos) <= this._map.options.tapTolerance;
-		  	},
+  if (typeof listener !== 'function')
+    throw new TypeError('"listener" argument must be a function');
 
-		  	_onMove: function (e) {
-		  		var first = e.touches[0];
-		  		this._newPos = new Point(first.clientX, first.clientY);
-		  		this._simulateEvent('mousemove', first);
-		  	},
+  events = target._events;
+  if (!events) {
+    events = target._events = new EventHandlers();
+    target._eventsCount = 0;
+  } else {
+    // To avoid recursion in the case that type === "newListener"! Before
+    // adding it to the listeners, first emit "newListener".
+    if (events.newListener) {
+      target.emit('newListener', type,
+                  listener.listener ? listener.listener : listener);
 
-		  	_simulateEvent: function (type, e) {
-		  		var simulatedEvent = document.createEvent('MouseEvents');
+      // Re-assign `events` because a newListener handler could have caused the
+      // this._events to be assigned to a new object
+      events = target._events;
+    }
+    existing = events[type];
+  }
 
-		  		simulatedEvent._simulated = true;
-		  		e.target._simulatedClick = true;
+  if (!existing) {
+    // Optimize the case of one listener. Don't need the extra array object.
+    existing = events[type] = listener;
+    ++target._eventsCount;
+  } else {
+    if (typeof existing === 'function') {
+      // Adding the second element, need to change to array.
+      existing = events[type] = prepend ? [listener, existing] :
+                                          [existing, listener];
+    } else {
+      // If we've already got an array, just append.
+      if (prepend) {
+        existing.unshift(listener);
+      } else {
+        existing.push(listener);
+      }
+    }
 
-		  		simulatedEvent.initMouseEvent(
-		  		        type, true, true, window, 1,
-		  		        e.screenX, e.screenY,
-		  		        e.clientX, e.clientY,
-		  		        false, false, false, false, 0, null);
+    // Check for listener leak
+    if (!existing.warned) {
+      m = $getMaxListeners(target);
+      if (m && m > 0 && existing.length > m) {
+        existing.warned = true;
+        var w = new Error('Possible EventEmitter memory leak detected. ' +
+                            existing.length + ' ' + type + ' listeners added. ' +
+                            'Use emitter.setMaxListeners() to increase limit');
+        w.name = 'MaxListenersExceededWarning';
+        w.emitter = target;
+        w.type = type;
+        w.count = existing.length;
+        emitWarning(w);
+      }
+    }
+  }
 
-		  		e.target.dispatchEvent(simulatedEvent);
-		  	}
-		  });
+  return target;
+}
+function emitWarning(e) {
+  typeof console.warn === 'function' ? console.warn(e) : console.log(e);
+}
+EventEmitter.prototype.addListener = function addListener(type, listener) {
+  return _addListener(this, type, listener, false);
+};
 
-		  // @section Handlers
-		  // @property tap: Handler
-		  // Mobile touch hacks (quick tap and touch hold) handler.
-		  if (touch && (!pointer || safari)) {
-		  	Map.addInitHook('addHandler', 'tap', Tap);
-		  }
+EventEmitter.prototype.on = EventEmitter.prototype.addListener;
 
-		  /*
-		   * L.Handler.TouchZoom is used by L.Map to add pinch zoom on supported mobile browsers.
-		   */
+EventEmitter.prototype.prependListener =
+    function prependListener(type, listener) {
+      return _addListener(this, type, listener, true);
+    };
 
-		  // @namespace Map
-		  // @section Interaction Options
-		  Map.mergeOptions({
-		  	// @section Touch interaction options
-		  	// @option touchZoom: Boolean|String = *
-		  	// Whether the map can be zoomed by touch-dragging with two fingers. If
-		  	// passed `'center'`, it will zoom to the center of the view regardless of
-		  	// where the touch events (fingers) were. Enabled for touch-capable web
-		  	// browsers except for old Androids.
-		  	touchZoom: touch && !android23,
+function _onceWrap(target, type, listener) {
+  var fired = false;
+  function g() {
+    target.removeListener(type, g);
+    if (!fired) {
+      fired = true;
+      listener.apply(target, arguments);
+    }
+  }
+  g.listener = listener;
+  return g;
+}
 
-		  	// @option bounceAtZoomLimits: Boolean = true
-		  	// Set it to false if you don't want the map to zoom beyond min/max zoom
-		  	// and then bounce back when pinch-zooming.
-		  	bounceAtZoomLimits: true
-		  });
+EventEmitter.prototype.once = function once(type, listener) {
+  if (typeof listener !== 'function')
+    throw new TypeError('"listener" argument must be a function');
+  this.on(type, _onceWrap(this, type, listener));
+  return this;
+};
 
-		  var TouchZoom = Handler.extend({
-		  	addHooks: function () {
-		  		addClass(this._map._container, 'leaflet-touch-zoom');
-		  		on(this._map._container, 'touchstart', this._onTouchStart, this);
-		  	},
+EventEmitter.prototype.prependOnceListener =
+    function prependOnceListener(type, listener) {
+      if (typeof listener !== 'function')
+        throw new TypeError('"listener" argument must be a function');
+      this.prependListener(type, _onceWrap(this, type, listener));
+      return this;
+    };
 
-		  	removeHooks: function () {
-		  		removeClass(this._map._container, 'leaflet-touch-zoom');
-		  		off(this._map._container, 'touchstart', this._onTouchStart, this);
-		  	},
+// emits a 'removeListener' event iff the listener was removed
+EventEmitter.prototype.removeListener =
+    function removeListener(type, listener) {
+      var list, events, position, i, originalListener;
 
-		  	_onTouchStart: function (e) {
-		  		var map = this._map;
-		  		if (!e.touches || e.touches.length !== 2 || map._animatingZoom || this._zooming) { return; }
+      if (typeof listener !== 'function')
+        throw new TypeError('"listener" argument must be a function');
 
-		  		var p1 = map.mouseEventToContainerPoint(e.touches[0]),
-		  		    p2 = map.mouseEventToContainerPoint(e.touches[1]);
+      events = this._events;
+      if (!events)
+        return this;
 
-		  		this._centerPoint = map.getSize()._divideBy(2);
-		  		this._startLatLng = map.containerPointToLatLng(this._centerPoint);
-		  		if (map.options.touchZoom !== 'center') {
-		  			this._pinchStartLatLng = map.containerPointToLatLng(p1.add(p2)._divideBy(2));
-		  		}
+      list = events[type];
+      if (!list)
+        return this;
 
-		  		this._startDist = p1.distanceTo(p2);
-		  		this._startZoom = map.getZoom();
+      if (list === listener || (list.listener && list.listener === listener)) {
+        if (--this._eventsCount === 0)
+          this._events = new EventHandlers();
+        else {
+          delete events[type];
+          if (events.removeListener)
+            this.emit('removeListener', type, list.listener || listener);
+        }
+      } else if (typeof list !== 'function') {
+        position = -1;
 
-		  		this._moved = false;
-		  		this._zooming = true;
+        for (i = list.length; i-- > 0;) {
+          if (list[i] === listener ||
+              (list[i].listener && list[i].listener === listener)) {
+            originalListener = list[i].listener;
+            position = i;
+            break;
+          }
+        }
 
-		  		map._stop();
+        if (position < 0)
+          return this;
 
-		  		on(document, 'touchmove', this._onTouchMove, this);
-		  		on(document, 'touchend', this._onTouchEnd, this);
+        if (list.length === 1) {
+          list[0] = undefined;
+          if (--this._eventsCount === 0) {
+            this._events = new EventHandlers();
+            return this;
+          } else {
+            delete events[type];
+          }
+        } else {
+          spliceOne(list, position);
+        }
 
-		  		preventDefault(e);
-		  	},
+        if (events.removeListener)
+          this.emit('removeListener', type, originalListener || listener);
+      }
 
-		  	_onTouchMove: function (e) {
-		  		if (!e.touches || e.touches.length !== 2 || !this._zooming) { return; }
+      return this;
+    };
+    
+// Alias for removeListener added in NodeJS 10.0
+// https://nodejs.org/api/events.html#events_emitter_off_eventname_listener
+EventEmitter.prototype.off = function(type, listener){
+    return this.removeListener(type, listener);
+};
 
-		  		var map = this._map,
-		  		    p1 = map.mouseEventToContainerPoint(e.touches[0]),
-		  		    p2 = map.mouseEventToContainerPoint(e.touches[1]),
-		  		    scale = p1.distanceTo(p2) / this._startDist;
+EventEmitter.prototype.removeAllListeners =
+    function removeAllListeners(type) {
+      var listeners, events;
 
-		  		this._zoom = map.getScaleZoom(scale, this._startZoom);
+      events = this._events;
+      if (!events)
+        return this;
 
-		  		if (!map.options.bounceAtZoomLimits && (
-		  			(this._zoom < map.getMinZoom() && scale < 1) ||
-		  			(this._zoom > map.getMaxZoom() && scale > 1))) {
-		  			this._zoom = map._limitZoom(this._zoom);
-		  		}
+      // not listening for removeListener, no need to emit
+      if (!events.removeListener) {
+        if (arguments.length === 0) {
+          this._events = new EventHandlers();
+          this._eventsCount = 0;
+        } else if (events[type]) {
+          if (--this._eventsCount === 0)
+            this._events = new EventHandlers();
+          else
+            delete events[type];
+        }
+        return this;
+      }
 
-		  		if (map.options.touchZoom === 'center') {
-		  			this._center = this._startLatLng;
-		  			if (scale === 1) { return; }
-		  		} else {
-		  			// Get delta from pinch to center, so centerLatLng is delta applied to initial pinchLatLng
-		  			var delta = p1._add(p2)._divideBy(2)._subtract(this._centerPoint);
-		  			if (scale === 1 && delta.x === 0 && delta.y === 0) { return; }
-		  			this._center = map.unproject(map.project(this._pinchStartLatLng, this._zoom).subtract(delta), this._zoom);
-		  		}
+      // emit removeListener for all listeners on all events
+      if (arguments.length === 0) {
+        var keys = Object.keys(events);
+        for (var i = 0, key; i < keys.length; ++i) {
+          key = keys[i];
+          if (key === 'removeListener') continue;
+          this.removeAllListeners(key);
+        }
+        this.removeAllListeners('removeListener');
+        this._events = new EventHandlers();
+        this._eventsCount = 0;
+        return this;
+      }
 
-		  		if (!this._moved) {
-		  			map._moveStart(true, false);
-		  			this._moved = true;
-		  		}
+      listeners = events[type];
 
-		  		cancelAnimFrame(this._animRequest);
+      if (typeof listeners === 'function') {
+        this.removeListener(type, listeners);
+      } else if (listeners) {
+        // LIFO order
+        do {
+          this.removeListener(type, listeners[listeners.length - 1]);
+        } while (listeners[0]);
+      }
 
-		  		var moveFn = bind(map._move, map, this._center, this._zoom, {pinch: true, round: false});
-		  		this._animRequest = requestAnimFrame(moveFn, this, true);
+      return this;
+    };
 
-		  		preventDefault(e);
-		  	},
+EventEmitter.prototype.listeners = function listeners(type) {
+  var evlistener;
+  var ret;
+  var events = this._events;
 
-		  	_onTouchEnd: function () {
-		  		if (!this._moved || !this._zooming) {
-		  			this._zooming = false;
-		  			return;
-		  		}
+  if (!events)
+    ret = [];
+  else {
+    evlistener = events[type];
+    if (!evlistener)
+      ret = [];
+    else if (typeof evlistener === 'function')
+      ret = [evlistener.listener || evlistener];
+    else
+      ret = unwrapListeners(evlistener);
+  }
 
-		  		this._zooming = false;
-		  		cancelAnimFrame(this._animRequest);
+  return ret;
+};
 
-		  		off(document, 'touchmove', this._onTouchMove, this);
-		  		off(document, 'touchend', this._onTouchEnd, this);
+EventEmitter.listenerCount = function(emitter, type) {
+  if (typeof emitter.listenerCount === 'function') {
+    return emitter.listenerCount(type);
+  } else {
+    return listenerCount.call(emitter, type);
+  }
+};
 
-		  		// Pinch updates GridLayers' levels only when zoomSnap is off, so zoomSnap becomes noUpdate.
-		  		if (this._map.options.zoomAnimation) {
-		  			this._map._animateZoom(this._center, this._map._limitZoom(this._zoom), true, this._map.options.zoomSnap);
-		  		} else {
-		  			this._map._resetView(this._center, this._map._limitZoom(this._zoom));
-		  		}
-		  	}
-		  });
+EventEmitter.prototype.listenerCount = listenerCount;
+function listenerCount(type) {
+  var events = this._events;
 
-		  // @section Handlers
-		  // @property touchZoom: Handler
-		  // Touch zoom handler.
-		  Map.addInitHook('addHandler', 'touchZoom', TouchZoom);
+  if (events) {
+    var evlistener = events[type];
 
-		  Map.BoxZoom = BoxZoom;
-		  Map.DoubleClickZoom = DoubleClickZoom;
-		  Map.Drag = Drag;
-		  Map.Keyboard = Keyboard;
-		  Map.ScrollWheelZoom = ScrollWheelZoom;
-		  Map.Tap = Tap;
-		  Map.TouchZoom = TouchZoom;
+    if (typeof evlistener === 'function') {
+      return 1;
+    } else if (evlistener) {
+      return evlistener.length;
+    }
+  }
 
-		  exports.version = version;
-		  exports.Control = Control;
-		  exports.control = control;
-		  exports.Browser = Browser;
-		  exports.Evented = Evented;
-		  exports.Mixin = Mixin;
-		  exports.Util = Util;
-		  exports.Class = Class;
-		  exports.Handler = Handler;
-		  exports.extend = extend;
-		  exports.bind = bind;
-		  exports.stamp = stamp;
-		  exports.setOptions = setOptions;
-		  exports.DomEvent = DomEvent;
-		  exports.DomUtil = DomUtil;
-		  exports.PosAnimation = PosAnimation;
-		  exports.Draggable = Draggable;
-		  exports.LineUtil = LineUtil;
-		  exports.PolyUtil = PolyUtil;
-		  exports.Point = Point;
-		  exports.point = toPoint;
-		  exports.Bounds = Bounds;
-		  exports.bounds = toBounds;
-		  exports.Transformation = Transformation;
-		  exports.transformation = toTransformation;
-		  exports.Projection = index;
-		  exports.LatLng = LatLng;
-		  exports.latLng = toLatLng;
-		  exports.LatLngBounds = LatLngBounds;
-		  exports.latLngBounds = toLatLngBounds;
-		  exports.CRS = CRS;
-		  exports.GeoJSON = GeoJSON;
-		  exports.geoJSON = geoJSON;
-		  exports.geoJson = geoJson;
-		  exports.Layer = Layer;
-		  exports.LayerGroup = LayerGroup;
-		  exports.layerGroup = layerGroup;
-		  exports.FeatureGroup = FeatureGroup;
-		  exports.featureGroup = featureGroup;
-		  exports.ImageOverlay = ImageOverlay;
-		  exports.imageOverlay = imageOverlay;
-		  exports.VideoOverlay = VideoOverlay;
-		  exports.videoOverlay = videoOverlay;
-		  exports.SVGOverlay = SVGOverlay;
-		  exports.svgOverlay = svgOverlay;
-		  exports.DivOverlay = DivOverlay;
-		  exports.Popup = Popup;
-		  exports.popup = popup;
-		  exports.Tooltip = Tooltip;
-		  exports.tooltip = tooltip;
-		  exports.Icon = Icon;
-		  exports.icon = icon;
-		  exports.DivIcon = DivIcon;
-		  exports.divIcon = divIcon;
-		  exports.Marker = Marker;
-		  exports.marker = marker;
-		  exports.TileLayer = TileLayer;
-		  exports.tileLayer = tileLayer;
-		  exports.GridLayer = GridLayer;
-		  exports.gridLayer = gridLayer;
-		  exports.SVG = SVG;
-		  exports.svg = svg$1;
-		  exports.Renderer = Renderer;
-		  exports.Canvas = Canvas;
-		  exports.canvas = canvas$1;
-		  exports.Path = Path;
-		  exports.CircleMarker = CircleMarker;
-		  exports.circleMarker = circleMarker;
-		  exports.Circle = Circle;
-		  exports.circle = circle;
-		  exports.Polyline = Polyline;
-		  exports.polyline = polyline;
-		  exports.Polygon = Polygon;
-		  exports.polygon = polygon;
-		  exports.Rectangle = Rectangle;
-		  exports.rectangle = rectangle;
-		  exports.Map = Map;
-		  exports.map = createMap;
+  return 0;
+}
 
-		  var oldL = window.L;
-		  exports.noConflict = function() {
-		  	window.L = oldL;
-		  	return this;
-		  };
+EventEmitter.prototype.eventNames = function eventNames() {
+  return this._eventsCount > 0 ? Reflect.ownKeys(this._events) : [];
+};
 
-		  // Always export us to window global (see #2364)
-		  window.L = exports;
+// About 1.5x faster than the two-arg version of Array#splice().
+function spliceOne(list, index) {
+  for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1)
+    list[i] = list[k];
+  list.pop();
+}
 
-		})));
-		
-	} (leafletSrc$1, leafletSrc$1.exports));
-	return leafletSrc$1.exports;
+function arrayClone(arr, i) {
+  var copy = new Array(i);
+  while (i--)
+    copy[i] = arr[i];
+  return copy;
 }
 
-var leafletSrcExports = /*@__PURE__*/ requireLeafletSrc();
+function unwrapListeners(arr) {
+  var ret = new Array(arr.length);
+  for (var i = 0; i < ret.length; ++i) {
+    ret[i] = arr[i].listener || arr[i];
+  }
+  return ret;
+}
 
 class AttributionControl extends leafletSrcExports.Control.Attribution {
   // options: AttributionControlOptions
@@ -14562,81 +15341,6 @@ class AttributionControl extends leafletSrcExports.Control.Attribution {
   }
 }
 
-function createControl(control, options = {}, map) {
-  const C = leafletSrcExports.Control.extend({
-    onAdd() {
-      const element = document.createElement("div");
-      const content = control.onAdd(map);
-      element.classList.add("leaflet-control");
-      if (options.bar) {
-        element.classList.add("leaflet-bar");
-      }
-      if (options.addClass) {
-        element.classList.add(options.addClass);
-      }
-      if (!options.margin && !options.bar) {
-        element.style.marginBottom = "0px";
-        element.style.marginTop = "0px";
-        element.style.marginLeft = "0px";
-        element.style.marginRight = "0px";
-      }
-      if (content) {
-        element.appendChild(content);
-      }
-      leafletSrcExports.DomEvent.disableClickPropagation(element);
-      return element;
-    },
-    onRemove() {
-      control.onRemove();
-    }
-  });
-  return new C();
-}
-
-function createButtonControl(options, map) {
-  const link = document.createElement("a");
-  const title = options.title || "";
-  link.href = "#";
-  link.title = title;
-  link.setAttribute("role", "button");
-  link.setAttribute("aria-label", title);
-  if (options.addClass) {
-    link.classList.add(options.addClass);
-  }
-  leafletSrcExports.DomEvent.disableClickPropagation(link);
-  leafletSrcExports.DomEvent.on(link, "click", leafletSrcExports.DomEvent.stop);
-  if (options.html instanceof HTMLElement) {
-    link.appendChild(options.html);
-  } else if (typeof options.html === "string") {
-    link.innerHTML = options.html;
-  }
-  const onClick = (e) => {
-    e.stopPropagation();
-    options.onClick();
-  };
-  return createControl(
-    {
-      onAdd() {
-        if (options.onClick !== void 0) {
-          link.addEventListener("click", onClick);
-        }
-        return link;
-      },
-      onRemove() {
-        const parent = link.parentNode;
-        if (parent) {
-          parent.removeChild(link);
-        }
-        if (options.onClick !== void 0) {
-          link.removeEventListener("click", onClick);
-        }
-      }
-    },
-    { bar: true },
-    map
-  );
-}
-
 function debounce(cb, wait = 10) {
   let timeoutId;
   function wrapper(...args) {
@@ -16351,6 +17055,7 @@ const _LeafletMapAdapter = class _LeafletMapAdapter {
     __publicField(this, "emitter", new EventEmitter());
     __publicField(this, "map");
     __publicField(this, "_resizeObserver");
+    __publicField(this, "_controlContainer");
     __publicField(this, "_unselectCb", []);
     __publicField(this, "_universalEvents", [
       "move",
@@ -16389,6 +17094,7 @@ const _LeafletMapAdapter = class _LeafletMapAdapter {
       this._updateMinZoomForBounds(minZoom);
       this._watchSizeChangeToUpdateMinZoom();
       const defPane = this.map.createPane("order-0");
+      this._controlContainer = new LeafletControlContainer(this.map);
       this.map._addUnselectCb = (def) => {
         this._addUnselectCb(def);
       };
@@ -16401,12 +17107,19 @@ const _LeafletMapAdapter = class _LeafletMapAdapter {
     if (this.map) {
       this.map.remove();
     }
+    if (this._controlContainer) {
+      this._controlContainer.detach();
+      this._controlContainer = void 0;
+    }
     this._stopWatchSizeChangeToUpdateMinZoom();
   }
   getContainer() {
     return this.map && this.map.getContainer();
   }
   getControlContainer() {
+    if (this._controlContainer) {
+      return this._controlContainer.getContainer();
+    }
     const controlContainer = this.map && this.map._controlContainer;
     if (controlContainer) {
       return controlContainer;
@@ -16520,16 +17233,17 @@ const _LeafletMapAdapter = class _LeafletMapAdapter {
   createButtonControl(options) {
     return createButtonControl(options, this);
   }
-  addControl(control, position) {
-    control.options.position = position.replace("-", "");
-    if (this.map) {
-      this.map.addControl(control);
-      return control;
+  createToggleControl(options) {
+    return createToggleControl(options, this);
+  }
+  addControl(control, position, options) {
+    if (this._controlContainer) {
+      return this._controlContainer.addControl(control, position, options);
     }
   }
   removeControl(control) {
-    if (this.map) {
-      this.map.removeControl(control);
+    if (this._controlContainer) {
+      this._controlContainer.removeControl(control);
     }
   }
   removeLayer(layer) {