@nextgis/leaflet-map-adapter 3.1.0 → 4.0.0-alpha.1

package/lib/leaflet-map-adapter.global.js

@@ -1,477 +1,602 @@
-/** Bundle of @nextgis/leaflet-map-adapter; version: 3.1.0; author: NextGIS */
+/** Bundle of @nextgis/leaflet-map-adapter; version: 4.0.0-alpha.1; author: NextGIS */
 var LeafletMapAdapter = (function () {
   'use strict';
 
-  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);
+  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$h = Object.defineProperty;
+  var __defProps$8 = Object.defineProperties;
+  var __getOwnPropDescs$8 = Object.getOwnPropertyDescriptors;
+  var __getOwnPropSymbols$c = Object.getOwnPropertySymbols;
+  var __hasOwnProp$c = Object.prototype.hasOwnProperty;
+  var __propIsEnum$c = Object.prototype.propertyIsEnumerable;
+  var __defNormalProp$h = (obj, key, value) => key in obj ? __defProp$h(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __spreadValues$c = (a, b) => {
+    for (var prop in b || (b = {}))
+      if (__hasOwnProp$c.call(b, prop))
+        __defNormalProp$h(a, prop, b[prop]);
+    if (__getOwnPropSymbols$c)
+      for (var prop of __getOwnPropSymbols$c(b)) {
+        if (__propIsEnum$c.call(b, prop))
+          __defNormalProp$h(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$c({}, 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$g = Object.defineProperty;
+  var __defNormalProp$g = (obj, key, value) => key in obj ? __defProp$g(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __publicField$a = (obj, key, value) => __defNormalProp$g(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: {}};
@@ -14188,365 +14313,1019 @@ var LeafletMapAdapter = (function () {
   		  });
 
   		  // @section Handlers
-  		  // @property scrollWheelZoom: Handler
-  		  // Scroll wheel zoom handler.
-  		  Map.addInitHook('addHandler', 'scrollWheelZoom', ScrollWheelZoom);
+  		  // @property scrollWheelZoom: Handler
+  		  // Scroll wheel zoom handler.
+  		  Map.addInitHook('addHandler', 'scrollWheelZoom', ScrollWheelZoom);
+
+  		  /*
+  		   * L.Map.Tap is used to enable mobile hacks like quick taps and long hold.
+  		   */
+
+  		  // @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,
+
+  		  	// @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 Tap = Handler.extend({
+  		  	addHooks: function () {
+  		  		on(this._map._container, 'touchstart', this._onDown, this);
+  		  	},
+
+  		  	removeHooks: function () {
+  		  		off(this._map._container, 'touchstart', this._onDown, this);
+  		  	},
+
+  		  	_onDown: function (e) {
+  		  		if (!e.touches) { return; }
+
+  		  		preventDefault(e);
+
+  		  		this._fireClick = true;
+
+  		  		// don't simulate click or track longpress if more than 1 touch
+  		  		if (e.touches.length > 1) {
+  		  			this._fireClick = false;
+  		  			clearTimeout(this._holdTimeout);
+  		  			return;
+  		  		}
+
+  		  		var first = e.touches[0],
+  		  		    el = first.target;
+
+  		  		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);
+  		  	},
+
+  		  	_onUp: function (e) {
+  		  		clearTimeout(this._holdTimeout);
+
+  		  		off(document, {
+  		  			touchmove: this._onMove,
+  		  			touchend: this._onUp
+  		  		}, this);
+
+  		  		if (this._fireClick && e && e.changedTouches) {
+
+  		  			var first = e.changedTouches[0],
+  		  			    el = first.target;
+
+  		  			if (el && el.tagName && el.tagName.toLowerCase() === 'a') {
+  		  				removeClass(el, 'leaflet-active');
+  		  			}
+
+  		  			this._simulateEvent('mouseup', first);
+
+  		  			// simulate click if the touch didn't move too much
+  		  			if (this._isTapValid()) {
+  		  				this._simulateEvent('click', first);
+  		  			}
+  		  		}
+  		  	},
+
+  		  	_isTapValid: function () {
+  		  		return this._newPos.distanceTo(this._startPos) <= this._map.options.tapTolerance;
+  		  	},
+
+  		  	_onMove: function (e) {
+  		  		var first = e.touches[0];
+  		  		this._newPos = new Point(first.clientX, first.clientY);
+  		  		this._simulateEvent('mousemove', first);
+  		  	},
+
+  		  	_simulateEvent: function (type, e) {
+  		  		var simulatedEvent = document.createEvent('MouseEvents');
+
+  		  		simulatedEvent._simulated = true;
+  		  		e.target._simulatedClick = true;
+
+  		  		simulatedEvent.initMouseEvent(
+  		  		        type, true, true, window, 1,
+  		  		        e.screenX, e.screenY,
+  		  		        e.clientX, e.clientY,
+  		  		        false, false, false, false, 0, null);
+
+  		  		e.target.dispatchEvent(simulatedEvent);
+  		  	}
+  		  });
+
+  		  // @section Handlers
+  		  // @property tap: Handler
+  		  // Mobile touch hacks (quick tap and touch hold) handler.
+  		  if (touch && (!pointer || safari)) {
+  		  	Map.addInitHook('addHandler', 'tap', Tap);
+  		  }
+
+  		  /*
+  		   * 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);
+  		  	},
+
+  		  	removeHooks: function () {
+  		  		removeClass(this._map._container, 'leaflet-touch-zoom');
+  		  		off(this._map._container, 'touchstart', this._onTouchStart, this);
+  		  	},
+
+  		  	_onTouchStart: function (e) {
+  		  		var map = this._map;
+  		  		if (!e.touches || e.touches.length !== 2 || map._animatingZoom || this._zooming) { return; }
+
+  		  		var p1 = map.mouseEventToContainerPoint(e.touches[0]),
+  		  		    p2 = map.mouseEventToContainerPoint(e.touches[1]);
+
+  		  		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));
+  		  		}
+
+  		  		this._startDist = p1.distanceTo(p2);
+  		  		this._startZoom = map.getZoom();
+
+  		  		this._moved = false;
+  		  		this._zooming = true;
+
+  		  		map._stop();
+
+  		  		on(document, 'touchmove', this._onTouchMove, this);
+  		  		on(document, 'touchend', this._onTouchEnd, this);
+
+  		  		preventDefault(e);
+  		  	},
+
+  		  	_onTouchMove: function (e) {
+  		  		if (!e.touches || e.touches.length !== 2 || !this._zooming) { return; }
+
+  		  		var map = this._map,
+  		  		    p1 = map.mouseEventToContainerPoint(e.touches[0]),
+  		  		    p2 = map.mouseEventToContainerPoint(e.touches[1]),
+  		  		    scale = p1.distanceTo(p2) / this._startDist;
+
+  		  		this._zoom = map.getScaleZoom(scale, this._startZoom);
+
+  		  		if (!map.options.bounceAtZoomLimits && (
+  		  			(this._zoom < map.getMinZoom() && scale < 1) ||
+  		  			(this._zoom > map.getMaxZoom() && scale > 1))) {
+  		  			this._zoom = map._limitZoom(this._zoom);
+  		  		}
+
+  		  		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);
+  		  		}
+
+  		  		if (!this._moved) {
+  		  			map._moveStart(true, false);
+  		  			this._moved = true;
+  		  		}
+
+  		  		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);
+  		  	},
+
+  		  	_onTouchEnd: function () {
+  		  		if (!this._moved || !this._zooming) {
+  		  			this._zooming = false;
+  		  			return;
+  		  		}
+
+  		  		this._zooming = false;
+  		  		cancelAnimFrame(this._animRequest);
+
+  		  		off(document, 'touchmove', this._onTouchMove, this);
+  		  		off(document, 'touchend', this._onTouchEnd, this);
+
+  		  		// 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));
+  		  		}
+  		  	}
+  		  });
+
+  		  // @section Handlers
+  		  // @property touchZoom: Handler
+  		  // Touch zoom handler.
+  		  Map.addInitHook('addHandler', 'touchZoom', TouchZoom);
 
-  		  /*
-  		   * L.Map.Tap is used to enable mobile hacks like quick taps and long hold.
-  		   */
+  		  Map.BoxZoom = BoxZoom;
+  		  Map.DoubleClickZoom = DoubleClickZoom;
+  		  Map.Drag = Drag;
+  		  Map.Keyboard = Keyboard;
+  		  Map.ScrollWheelZoom = ScrollWheelZoom;
+  		  Map.Tap = Tap;
+  		  Map.TouchZoom = TouchZoom;
 
-  		  // @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,
+  		  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;
 
-  		  	// @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 oldL = window.L;
+  		  exports.noConflict = function() {
+  		  	window.L = oldL;
+  		  	return this;
+  		  };
 
-  		  var Tap = Handler.extend({
-  		  	addHooks: function () {
-  		  		on(this._map._container, 'touchstart', this._onDown, this);
-  		  	},
+  		  // Always export us to window global (see #2364)
+  		  window.L = exports;
 
-  		  	removeHooks: function () {
-  		  		off(this._map._container, 'touchstart', this._onDown, this);
-  		  	},
+  		})));
+  		
+  	} (leafletSrc$1, leafletSrc$1.exports));
+  	return leafletSrc$1.exports;
+  }
 
-  		  	_onDown: function (e) {
-  		  		if (!e.touches) { return; }
+  var leafletSrcExports = /*@__PURE__*/ requireLeafletSrc();
 
-  		  		preventDefault(e);
+  var __defProp$f = Object.defineProperty;
+  var __defProps$7 = Object.defineProperties;
+  var __getOwnPropDescs$7 = Object.getOwnPropertyDescriptors;
+  var __getOwnPropSymbols$b = Object.getOwnPropertySymbols;
+  var __hasOwnProp$b = Object.prototype.hasOwnProperty;
+  var __propIsEnum$b = Object.prototype.propertyIsEnumerable;
+  var __defNormalProp$f = (obj, key, value) => key in obj ? __defProp$f(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$f(a, prop, b[prop]);
+    if (__getOwnPropSymbols$b)
+      for (var prop of __getOwnPropSymbols$b(b)) {
+        if (__propIsEnum$b.call(b, prop))
+          __defNormalProp$f(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$b({}, 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;
+  }
 
-  		  		this._fireClick = true;
+  function createButtonControl(options, map) {
+    return createControl(
+      createButtonControlContent(options),
+      { bar: true, margin: options.margin },
+      map
+    );
+  }
 
-  		  		// don't simulate click or track longpress if more than 1 touch
-  		  		if (e.touches.length > 1) {
-  		  			this._fireClick = false;
-  		  			clearTimeout(this._holdTimeout);
-  		  			return;
-  		  		}
+  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 first = e.touches[0],
-  		  		    el = first.target;
+  var __defProp$e = Object.defineProperty;
+  var __defProps$6 = Object.defineProperties;
+  var __getOwnPropDescs$6 = 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$6 = (a, b) => __defProps$6(a, __getOwnPropDescs$6(b));
+  var __publicField$9 = (obj, key, value) => __defNormalProp$e(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$a({}, 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"
+          )
+        }
+      }));
+    }
+  }
 
-  		  		this._startPos = this._newPos = new Point(first.clientX, first.clientY);
+  var domain;
 
-  		  		// if touching a link, highlight it
-  		  		if (el.tagName && el.tagName.toLowerCase() === 'a') {
-  		  			addClass(el, 'leaflet-active');
-  		  		}
+  // 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);
 
-  		  		// 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 EventEmitter() {
+    EventEmitter.init.call(this);
+  }
 
-  		  		this._simulateEvent('mousedown', first);
+  // nodejs oddity
+  // require('events') === require('events').EventEmitter
+  EventEmitter.EventEmitter = EventEmitter;
 
-  		  		on(document, {
-  		  			touchmove: this._onMove,
-  		  			touchend: this._onUp
-  		  		}, this);
-  		  	},
+  EventEmitter.usingDomains = false;
 
-  		  	_onUp: function (e) {
-  		  		clearTimeout(this._holdTimeout);
+  EventEmitter.prototype.domain = undefined;
+  EventEmitter.prototype._events = undefined;
+  EventEmitter.prototype._maxListeners = undefined;
 
-  		  		off(document, {
-  		  			touchmove: this._onMove,
-  		  			touchend: this._onUp
-  		  		}, 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;
 
-  		  		if (this._fireClick && e && e.changedTouches) {
+  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;
+      }
+    }
 
-  		  			var first = e.changedTouches[0],
-  		  			    el = first.target;
+    if (!this._events || this._events === Object.getPrototypeOf(this)._events) {
+      this._events = new EventHandlers();
+      this._eventsCount = 0;
+    }
 
-  		  			if (el && el.tagName && el.tagName.toLowerCase() === 'a') {
-  		  				removeClass(el, 'leaflet-active');
-  		  			}
+    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;
+  };
 
-  		  			this._simulateEvent('mouseup', first);
+  function $getMaxListeners(that) {
+    if (that._maxListeners === undefined)
+      return EventEmitter.defaultMaxListeners;
+    return that._maxListeners;
+  }
 
-  		  			// simulate click if the touch didn't move too much
-  		  			if (this._isTapValid()) {
-  		  				this._simulateEvent('click', first);
-  		  			}
-  		  		}
-  		  	},
+  EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
+    return $getMaxListeners(this);
+  };
 
-  		  	_isTapValid: function () {
-  		  		return this._newPos.distanceTo(this._startPos) <= this._map.options.tapTolerance;
-  		  	},
+  // 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);
+    }
+  }
 
-  		  	_onMove: function (e) {
-  		  		var first = e.touches[0];
-  		  		this._newPos = new Point(first.clientX, first.clientY);
-  		  		this._simulateEvent('mousemove', first);
-  		  	},
+  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);
+    }
+  }
 
-  		  	_simulateEvent: function (type, e) {
-  		  		var simulatedEvent = document.createEvent('MouseEvents');
+  EventEmitter.prototype.emit = function emit(type) {
+    var er, handler, len, args, i, events, domain;
+    var doError = (type === 'error');
 
-  		  		simulatedEvent._simulated = true;
-  		  		e.target._simulatedClick = true;
+    events = this._events;
+    if (events)
+      doError = (doError && events.error == null);
+    else if (!doError)
+      return false;
 
-  		  		simulatedEvent.initMouseEvent(
-  		  		        type, true, true, window, 1,
-  		  		        e.screenX, e.screenY,
-  		  		        e.clientX, e.clientY,
-  		  		        false, false, false, false, 0, null);
+    domain = this.domain;
 
-  		  		e.target.dispatchEvent(simulatedEvent);
-  		  	}
-  		  });
+    // 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;
+    }
 
-  		  // @section Handlers
-  		  // @property tap: Handler
-  		  // Mobile touch hacks (quick tap and touch hold) handler.
-  		  if (touch && (!pointer || safari)) {
-  		  	Map.addInitHook('addHandler', 'tap', Tap);
-  		  }
+    handler = events[type];
 
-  		  /*
-  		   * L.Handler.TouchZoom is used by L.Map to add pinch zoom on supported mobile browsers.
-  		   */
+    if (!handler)
+      return false;
 
-  		  // @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,
+    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);
+    }
 
-  		  	// @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
-  		  });
+    return true;
+  };
 
-  		  var TouchZoom = Handler.extend({
-  		  	addHooks: function () {
-  		  		addClass(this._map._container, 'leaflet-touch-zoom');
-  		  		on(this._map._container, 'touchstart', this._onTouchStart, this);
-  		  	},
+  function _addListener(target, type, listener, prepend) {
+    var m;
+    var events;
+    var existing;
 
-  		  	removeHooks: function () {
-  		  		removeClass(this._map._container, 'leaflet-touch-zoom');
-  		  		off(this._map._container, 'touchstart', this._onTouchStart, this);
-  		  	},
+    if (typeof listener !== 'function')
+      throw new TypeError('"listener" argument must be a function');
 
-  		  	_onTouchStart: function (e) {
-  		  		var map = this._map;
-  		  		if (!e.touches || e.touches.length !== 2 || map._animatingZoom || this._zooming) { return; }
+    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);
 
-  		  		var p1 = map.mouseEventToContainerPoint(e.touches[0]),
-  		  		    p2 = map.mouseEventToContainerPoint(e.touches[1]);
+        // 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];
+    }
 
-  		  		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 (!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);
+        }
+      }
 
-  		  		this._startDist = p1.distanceTo(p2);
-  		  		this._startZoom = map.getZoom();
+      // 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);
+        }
+      }
+    }
 
-  		  		this._moved = false;
-  		  		this._zooming = true;
+    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);
+  };
 
-  		  		map._stop();
+  EventEmitter.prototype.on = EventEmitter.prototype.addListener;
 
-  		  		on(document, 'touchmove', this._onTouchMove, this);
-  		  		on(document, 'touchend', this._onTouchEnd, this);
+  EventEmitter.prototype.prependListener =
+      function prependListener(type, listener) {
+        return _addListener(this, type, listener, true);
+      };
 
-  		  		preventDefault(e);
-  		  	},
+  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;
+  }
 
-  		  	_onTouchMove: function (e) {
-  		  		if (!e.touches || e.touches.length !== 2 || !this._zooming) { return; }
+  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 map = this._map,
-  		  		    p1 = map.mouseEventToContainerPoint(e.touches[0]),
-  		  		    p2 = map.mouseEventToContainerPoint(e.touches[1]),
-  		  		    scale = p1.distanceTo(p2) / this._startDist;
+  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;
+      };
 
-  		  		this._zoom = map.getScaleZoom(scale, this._startZoom);
+  // emits a 'removeListener' event iff the listener was removed
+  EventEmitter.prototype.removeListener =
+      function removeListener(type, listener) {
+        var list, events, position, i, originalListener;
 
-  		  		if (!map.options.bounceAtZoomLimits && (
-  		  			(this._zoom < map.getMinZoom() && scale < 1) ||
-  		  			(this._zoom > map.getMaxZoom() && scale > 1))) {
-  		  			this._zoom = map._limitZoom(this._zoom);
-  		  		}
+        if (typeof listener !== 'function')
+          throw new TypeError('"listener" argument must be a function');
 
-  		  		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);
-  		  		}
+        events = this._events;
+        if (!events)
+          return this;
 
-  		  		if (!this._moved) {
-  		  			map._moveStart(true, false);
-  		  			this._moved = true;
-  		  		}
+        list = events[type];
+        if (!list)
+          return this;
 
-  		  		cancelAnimFrame(this._animRequest);
+        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;
 
-  		  		var moveFn = bind(map._move, map, this._center, this._zoom, {pinch: true, round: false});
-  		  		this._animRequest = requestAnimFrame(moveFn, this, 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;
+            }
+          }
 
-  		  		preventDefault(e);
-  		  	},
+          if (position < 0)
+            return this;
 
-  		  	_onTouchEnd: function () {
-  		  		if (!this._moved || !this._zooming) {
-  		  			this._zooming = false;
-  		  			return;
-  		  		}
+          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);
+          }
 
-  		  		this._zooming = false;
-  		  		cancelAnimFrame(this._animRequest);
+          if (events.removeListener)
+            this.emit('removeListener', type, originalListener || listener);
+        }
 
-  		  		off(document, 'touchmove', this._onTouchMove, this);
-  		  		off(document, 'touchend', this._onTouchEnd, this);
+        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);
+  };
 
-  		  		// 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.removeAllListeners =
+      function removeAllListeners(type) {
+        var listeners, events;
 
-  		  // @section Handlers
-  		  // @property touchZoom: Handler
-  		  // Touch zoom handler.
-  		  Map.addInitHook('addHandler', 'touchZoom', TouchZoom);
+        events = this._events;
+        if (!events)
+          return this;
 
-  		  Map.BoxZoom = BoxZoom;
-  		  Map.DoubleClickZoom = DoubleClickZoom;
-  		  Map.Drag = Drag;
-  		  Map.Keyboard = Keyboard;
-  		  Map.ScrollWheelZoom = ScrollWheelZoom;
-  		  Map.Tap = Tap;
-  		  Map.TouchZoom = TouchZoom;
+        // 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;
+        }
 
-  		  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;
+        // 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;
+        }
 
-  		  var oldL = window.L;
-  		  exports.noConflict = function() {
-  		  	window.L = oldL;
-  		  	return this;
-  		  };
+        listeners = events[type];
 
-  		  // Always export us to window global (see #2364)
-  		  window.L = exports;
+        if (typeof listeners === 'function') {
+          this.removeListener(type, listeners);
+        } else if (listeners) {
+          // LIFO order
+          do {
+            this.removeListener(type, listeners[listeners.length - 1]);
+          } while (listeners[0]);
+        }
 
-  		})));
-  		
-  	} (leafletSrc$1, leafletSrc$1.exports));
-  	return leafletSrc$1.exports;
+        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;
   }
 
-  var leafletSrcExports = /*@__PURE__*/ requireLeafletSrc();
+  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];
+    }
+    return ret;
+  }
 
   class AttributionControl extends leafletSrcExports.Control.Attribution {
     // options: AttributionControlOptions
@@ -14565,81 +15344,6 @@ var LeafletMapAdapter = (function () {
     }
   }
 
-  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) {
@@ -14784,9 +15488,9 @@ var LeafletMapAdapter = (function () {
     };
   }
 
-  var __defProp$c = Object.defineProperty;
-  var __defNormalProp$c = (obj, key, value) => key in obj ? __defProp$c(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-  var __publicField$8 = (obj, key, value) => __defNormalProp$c(obj, typeof key !== "symbol" ? key + "" : key, value);
+  var __defProp$d = Object.defineProperty;
+  var __defNormalProp$d = (obj, key, value) => key in obj ? __defProp$d(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __publicField$8 = (obj, key, value) => __defNormalProp$d(obj, typeof key !== "symbol" ? key + "" : key, value);
   class BaseAdapter {
     constructor(map, options) {
       this.map = map;
@@ -14821,19 +15525,19 @@ var LeafletMapAdapter = (function () {
     };
   }
 
-  var __defProp$b = Object.defineProperty;
-  var __getOwnPropSymbols$8 = Object.getOwnPropertySymbols;
-  var __hasOwnProp$8 = Object.prototype.hasOwnProperty;
-  var __propIsEnum$8 = Object.prototype.propertyIsEnumerable;
-  var __defNormalProp$b = (obj, key, value) => key in obj ? __defProp$b(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-  var __spreadValues$8 = (a, b) => {
+  var __defProp$c = Object.defineProperty;
+  var __getOwnPropSymbols$9 = Object.getOwnPropertySymbols;
+  var __hasOwnProp$9 = Object.prototype.hasOwnProperty;
+  var __propIsEnum$9 = Object.prototype.propertyIsEnumerable;
+  var __defNormalProp$c = (obj, key, value) => key in obj ? __defProp$c(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$8.call(b, prop))
-        __defNormalProp$b(a, prop, b[prop]);
-    if (__getOwnPropSymbols$8)
-      for (var prop of __getOwnPropSymbols$8(b)) {
-        if (__propIsEnum$8.call(b, prop))
-          __defNormalProp$b(a, prop, b[prop]);
+      if (__hasOwnProp$9.call(b, prop))
+        __defNormalProp$c(a, prop, b[prop]);
+    if (__getOwnPropSymbols$9)
+      for (var prop of __getOwnPropSymbols$9(b)) {
+        if (__propIsEnum$9.call(b, prop))
+          __defNormalProp$c(a, prop, b[prop]);
       }
     return a;
   };
@@ -14843,7 +15547,7 @@ var LeafletMapAdapter = (function () {
   }) {
     const layer_ = source.target;
     const feature = layer_.feature;
-    const opt = __spreadValues$8({
+    const opt = __spreadValues$9({
       layer,
       feature,
       event: convertMapClickEvent(source),
@@ -14852,23 +15556,23 @@ var LeafletMapAdapter = (function () {
     return opt;
   }
 
-  var __defProp$a = Object.defineProperty;
-  var __getOwnPropSymbols$7 = Object.getOwnPropertySymbols;
-  var __hasOwnProp$7 = Object.prototype.hasOwnProperty;
-  var __propIsEnum$7 = Object.prototype.propertyIsEnumerable;
-  var __defNormalProp$a = (obj, key, value) => key in obj ? __defProp$a(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-  var __spreadValues$7 = (a, b) => {
+  var __defProp$b = Object.defineProperty;
+  var __getOwnPropSymbols$8 = Object.getOwnPropertySymbols;
+  var __hasOwnProp$8 = Object.prototype.hasOwnProperty;
+  var __propIsEnum$8 = Object.prototype.propertyIsEnumerable;
+  var __defNormalProp$b = (obj, key, value) => key in obj ? __defProp$b(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __spreadValues$8 = (a, b) => {
     for (var prop in b || (b = {}))
-      if (__hasOwnProp$7.call(b, prop))
-        __defNormalProp$a(a, prop, b[prop]);
-    if (__getOwnPropSymbols$7)
-      for (var prop of __getOwnPropSymbols$7(b)) {
-        if (__propIsEnum$7.call(b, prop))
-          __defNormalProp$a(a, prop, b[prop]);
+      if (__hasOwnProp$8.call(b, prop))
+        __defNormalProp$b(a, prop, b[prop]);
+    if (__getOwnPropSymbols$8)
+      for (var prop of __getOwnPropSymbols$8(b)) {
+        if (__propIsEnum$8.call(b, prop))
+          __defNormalProp$b(a, prop, b[prop]);
       }
     return a;
   };
-  var __publicField$7 = (obj, key, value) => __defNormalProp$a(obj, typeof key !== "symbol" ? key + "" : key, value);
+  var __publicField$7 = (obj, key, value) => __defNormalProp$b(obj, typeof key !== "symbol" ? key + "" : key, value);
   class GeoJsonEvents {
     constructor(layer) {
       __publicField$7(this, "layer");
@@ -14884,7 +15588,7 @@ var LeafletMapAdapter = (function () {
       if (onClick_) {
         this._onclick = (e) => {
           const selected = !!this.layer._getSelected(layer);
-          onClick_(__spreadValues$7({
+          onClick_(__spreadValues$8({
             selected
           }, this._createMouseEvent(e)));
         };
@@ -14894,7 +15598,7 @@ var LeafletMapAdapter = (function () {
         this._ondblclick = (e) => {
           leafletSrcExports.DomEvent.stopPropagation(e);
           const selected = !!this.layer._getSelected(layer);
-          onDoubleClick(__spreadValues$7({
+          onDoubleClick(__spreadValues$8({
             selected
           }, this._createMouseEvent(e)));
         };
@@ -14945,21 +15649,21 @@ var LeafletMapAdapter = (function () {
     return false;
   }
 
-  var __defProp$9 = Object.defineProperty;
+  var __defProp$a = Object.defineProperty;
   var __defProps$5 = Object.defineProperties;
   var __getOwnPropDescs$5 = Object.getOwnPropertyDescriptors;
-  var __getOwnPropSymbols$6 = Object.getOwnPropertySymbols;
-  var __hasOwnProp$6 = Object.prototype.hasOwnProperty;
-  var __propIsEnum$6 = Object.prototype.propertyIsEnumerable;
-  var __defNormalProp$9 = (obj, key, value) => key in obj ? __defProp$9(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-  var __spreadValues$6 = (a, b) => {
+  var __getOwnPropSymbols$7 = Object.getOwnPropertySymbols;
+  var __hasOwnProp$7 = Object.prototype.hasOwnProperty;
+  var __propIsEnum$7 = Object.prototype.propertyIsEnumerable;
+  var __defNormalProp$a = (obj, key, value) => key in obj ? __defProp$a(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __spreadValues$7 = (a, b) => {
     for (var prop in b || (b = {}))
-      if (__hasOwnProp$6.call(b, prop))
-        __defNormalProp$9(a, prop, b[prop]);
-    if (__getOwnPropSymbols$6)
-      for (var prop of __getOwnPropSymbols$6(b)) {
-        if (__propIsEnum$6.call(b, prop))
-          __defNormalProp$9(a, prop, b[prop]);
+      if (__hasOwnProp$7.call(b, prop))
+        __defNormalProp$a(a, prop, b[prop]);
+    if (__getOwnPropSymbols$7)
+      for (var prop of __getOwnPropSymbols$7(b)) {
+        if (__propIsEnum$7.call(b, prop))
+          __defNormalProp$a(a, prop, b[prop]);
       }
     return a;
   };
@@ -14967,16 +15671,16 @@ var LeafletMapAdapter = (function () {
   var __objRest$2 = (source, exclude) => {
     var target = {};
     for (var prop in source)
-      if (__hasOwnProp$6.call(source, prop) && exclude.indexOf(prop) < 0)
+      if (__hasOwnProp$7.call(source, prop) && exclude.indexOf(prop) < 0)
         target[prop] = source[prop];
-    if (source != null && __getOwnPropSymbols$6)
-      for (var prop of __getOwnPropSymbols$6(source)) {
-        if (exclude.indexOf(prop) < 0 && __propIsEnum$6.call(source, prop))
+    if (source != null && __getOwnPropSymbols$7)
+      for (var prop of __getOwnPropSymbols$7(source)) {
+        if (exclude.indexOf(prop) < 0 && __propIsEnum$7.call(source, prop))
           target[prop] = source[prop];
       }
     return target;
   };
-  var __publicField$6 = (obj, key, value) => __defNormalProp$9(obj, key + "" , value);
+  var __publicField$6 = (obj, key, value) => __defNormalProp$a(obj, key + "" , value);
   class GeoJsonPaint {
     constructor(layer) {
       __publicField$6(this, "layer");
@@ -15058,7 +15762,7 @@ var LeafletMapAdapter = (function () {
       if (html) {
         element.innerHTML = html;
       }
-      const divIcon = new leafletSrcExports.DivIcon(__spreadProps$5(__spreadValues$6({
+      const divIcon = new leafletSrcExports.DivIcon(__spreadProps$5(__spreadValues$7({
         className: ""
       }, toLIconOpt), {
         html: element
@@ -15084,7 +15788,7 @@ var LeafletMapAdapter = (function () {
       }
       return (_, latlng) => {
         const p = PAINT;
-        return new leafletSrcExports.CircleMarker(latlng, this.preparePaint(__spreadValues$6(__spreadValues$6({}, p), icon)));
+        return new leafletSrcExports.CircleMarker(latlng, this.preparePaint(__spreadValues$7(__spreadValues$7({}, p), icon)));
       };
     }
     createPaintOptions(paint) {
@@ -15106,26 +15810,26 @@ var LeafletMapAdapter = (function () {
     }
   }
 
-  var __defProp$8 = Object.defineProperty;
+  var __defProp$9 = Object.defineProperty;
   var __defProps$4 = Object.defineProperties;
   var __getOwnPropDescs$4 = Object.getOwnPropertyDescriptors;
-  var __getOwnPropSymbols$5 = Object.getOwnPropertySymbols;
-  var __hasOwnProp$5 = Object.prototype.hasOwnProperty;
-  var __propIsEnum$5 = Object.prototype.propertyIsEnumerable;
-  var __defNormalProp$8 = (obj, key, value) => key in obj ? __defProp$8(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-  var __spreadValues$5 = (a, b) => {
+  var __getOwnPropSymbols$6 = Object.getOwnPropertySymbols;
+  var __hasOwnProp$6 = Object.prototype.hasOwnProperty;
+  var __propIsEnum$6 = Object.prototype.propertyIsEnumerable;
+  var __defNormalProp$9 = (obj, key, value) => key in obj ? __defProp$9(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __spreadValues$6 = (a, b) => {
     for (var prop in b || (b = {}))
-      if (__hasOwnProp$5.call(b, prop))
-        __defNormalProp$8(a, prop, b[prop]);
-    if (__getOwnPropSymbols$5)
-      for (var prop of __getOwnPropSymbols$5(b)) {
-        if (__propIsEnum$5.call(b, prop))
-          __defNormalProp$8(a, prop, b[prop]);
+      if (__hasOwnProp$6.call(b, prop))
+        __defNormalProp$9(a, prop, b[prop]);
+    if (__getOwnPropSymbols$6)
+      for (var prop of __getOwnPropSymbols$6(b)) {
+        if (__propIsEnum$6.call(b, prop))
+          __defNormalProp$9(a, prop, b[prop]);
       }
     return a;
   };
   var __spreadProps$4 = (a, b) => __defProps$4(a, __getOwnPropDescs$4(b));
-  var __publicField$5 = (obj, key, value) => __defNormalProp$8(obj, typeof key !== "symbol" ? key + "" : key, value);
+  var __publicField$5 = (obj, key, value) => __defNormalProp$9(obj, typeof key !== "symbol" ? key + "" : key, value);
   var __async = (__this, __arguments, generator) => {
     return new Promise((resolve, reject) => {
       var fulfilled = (value) => {
@@ -15173,7 +15877,7 @@ var LeafletMapAdapter = (function () {
     addLayer(options) {
       Object.assign(this.options, options);
       this.paint = options.paint;
-      this.layer = new leafletSrcExports.FeatureGroup([], __spreadProps$4(__spreadValues$5({}, options.nativeOptions), {
+      this.layer = new leafletSrcExports.FeatureGroup([], __spreadProps$4(__spreadValues$6({}, options.nativeOptions), {
         pane: this.pane
       }));
       this.selectedPaint = options.selectedPaint;
@@ -15222,7 +15926,7 @@ var LeafletMapAdapter = (function () {
     }
     getSelected() {
       return this._selectedLayers.map((x) => {
-        return __spreadValues$5({
+        return __spreadValues$6({
           target: this,
           feature: x.feature,
           layer: x
@@ -15241,14 +15945,14 @@ var LeafletMapAdapter = (function () {
         const filteredLayers = [];
         this._layers.forEach(({ feature, layer }) => {
           if (layer) {
-            const ok = fun ? fun(__spreadValues$5({
+            const ok = fun ? fun(__spreadValues$6({
               target: this,
               feature,
               layer
             }, createFeaturePositionOptions(feature))) : true;
             if (ok) {
               layer_.addLayer(layer);
-              filteredLayers.push(__spreadValues$5({
+              filteredLayers.push(__spreadValues$6({
                 target: this,
                 feature,
                 layer
@@ -15269,7 +15973,7 @@ var LeafletMapAdapter = (function () {
     getLayers() {
       return this._layers.map(({ layer, feature }) => {
         const visible = layer && !!layer._map;
-        return __spreadValues$5({
+        return __spreadValues$6({
           feature,
           layer,
           visible,
@@ -15387,13 +16091,13 @@ var LeafletMapAdapter = (function () {
       }
     }
     updatePaint(paint) {
-      this.paint = __spreadValues$5(__spreadValues$5({}, this.paint), paint);
+      this.paint = __spreadValues$6(__spreadValues$6({}, this.paint), paint);
       for (const l of this._layers) {
         this._paint.setPaint(l, this.paint);
       }
     }
     updateSelectedPaint(paint) {
-      this.selectedPaint = __spreadValues$5(__spreadValues$5({}, this.selectedPaint), paint);
+      this.selectedPaint = __spreadValues$6(__spreadValues$6({}, this.selectedPaint), paint);
       for (const l of this._selectedLayers) {
         this._paint.setPaint(l, this.selectedPaint);
       }
@@ -15410,7 +16114,7 @@ var LeafletMapAdapter = (function () {
         if (feature.properties && labelField) {
           message = feature.properties[labelField];
         } else if (label) {
-          message = label(__spreadValues$5(__spreadValues$5({
+          message = label(__spreadValues$6(__spreadValues$6({
             target: this
           }, layerDef), createFeaturePositionOptions(feature)));
         }
@@ -15429,7 +16133,7 @@ var LeafletMapAdapter = (function () {
           autoPan,
           maxWidth,
           closeButton: closeButton_
-        } = __spreadValues$5({
+        } = __spreadValues$6({
           minWidth: 300
         }, options);
         const closeButton = closeButton_ != null ? closeButton_ : !this.options.selectOnHover;
@@ -15445,7 +16149,7 @@ var LeafletMapAdapter = (function () {
         };
         let content;
         if (options.createPopupContent) {
-          content = yield options.createPopupContent(__spreadValues$5({
+          content = yield options.createPopupContent(__spreadValues$6({
             layer,
             feature,
             target: this,
@@ -15523,9 +16227,9 @@ var LeafletMapAdapter = (function () {
           lopt = {
             style: (feature) => {
               if (feature) {
-                return this._paint.preparePaint(__spreadValues$5(__spreadValues$5({}, PAINT), paint(feature)));
+                return this._paint.preparePaint(__spreadValues$6(__spreadValues$6({}, PAINT), paint(feature)));
               } else {
-                return this._paint.preparePaint(__spreadProps$4(__spreadValues$5({}, PAINT), { type: "path" }));
+                return this._paint.preparePaint(__spreadProps$4(__spreadValues$6({}, PAINT), { type: "path" }));
               }
             }
           };
@@ -15541,7 +16245,7 @@ var LeafletMapAdapter = (function () {
     _onEachFeature(feature, layer) {
       const layer_ = this.layer;
       if (layer_) {
-        const def = __spreadValues$5({
+        const def = __spreadValues$6({
           target: this,
           feature,
           layer
@@ -15576,7 +16280,7 @@ var LeafletMapAdapter = (function () {
           setTimeout(() => {
             if (popup) {
               this._openPopup(
-                __spreadValues$5({
+                __spreadValues$6({
                   target: this,
                   layer,
                   feature
@@ -15594,7 +16298,7 @@ var LeafletMapAdapter = (function () {
       leafletSrcExports.DomEvent.stopPropagation(e);
       const layer = e.target;
       const feature = layer.feature;
-      const def = __spreadValues$5({
+      const def = __spreadValues$6({
         target: this,
         layer,
         feature
@@ -15627,7 +16331,7 @@ var LeafletMapAdapter = (function () {
       }
       if (this.options.onSelect) {
         const features = def.feature ? [def.feature] : [];
-        this.options.onSelect(__spreadValues$5({
+        this.options.onSelect(__spreadValues$6({
           type,
           layer: this,
           features
@@ -15685,37 +16389,89 @@ var LeafletMapAdapter = (function () {
     }
   }
 
+  var __defProp$8 = Object.defineProperty;
+  var __getOwnPropSymbols$5 = Object.getOwnPropertySymbols;
+  var __hasOwnProp$5 = Object.prototype.hasOwnProperty;
+  var __propIsEnum$5 = Object.prototype.propertyIsEnumerable;
+  var __defNormalProp$8 = (obj, key, value) => key in obj ? __defProp$8(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __spreadValues$5 = (a, b) => {
+    for (var prop in b || (b = {}))
+      if (__hasOwnProp$5.call(b, prop))
+        __defNormalProp$8(a, prop, b[prop]);
+    if (__getOwnPropSymbols$5)
+      for (var prop of __getOwnPropSymbols$5(b)) {
+        if (__propIsEnum$5.call(b, prop))
+          __defNormalProp$8(a, prop, b[prop]);
+      }
+    return a;
+  };
+  function hasHeaders(headers) {
+    return !!headers && Object.keys(headers).length > 0;
+  }
+  function normalizeLayerRequestOptions(request) {
+    if (!request) {
+      return void 0;
+    }
+    const normalized = __spreadValues$5({}, request);
+    return hasLayerRequestOptions(normalized) ? normalized : void 0;
+  }
+  function getLayerRequestOptions(options) {
+    const request = options == null ? void 0 : options.request;
+    const headers = __spreadValues$5(__spreadValues$5({}, (options == null ? void 0 : options.headers) || {}), (request == null ? void 0 : request.headers) || {});
+    const result = {};
+    if (hasHeaders(headers)) {
+      result.headers = headers;
+    }
+    if (options == null ? void 0 : options.withCredentials) {
+      result.credentials = "include";
+    }
+    if ((request == null ? void 0 : request.credentials) !== void 0) {
+      result.credentials = request.credentials;
+    }
+    if ((request == null ? void 0 : request.cache) !== void 0) {
+      result.cache = request.cache;
+    }
+    return normalizeLayerRequestOptions(result);
+  }
+  function hasLayerRequestOptions(request) {
+    return !!(request && (hasHeaders(request.headers) || request.credentials !== void 0 || request.cache !== void 0 && request.cache !== "default"));
+  }
+
   function callAjax({
     src,
     headers,
-    withCredentials
+    withCredentials,
+    request
   }) {
-    let abortFunc = () => {
-    };
-    const promise = new Promise((resolve, reject) => {
-      const xhr = new XMLHttpRequest();
-      xhr.open("GET", src);
-      xhr.responseType = "arraybuffer";
-      for (const h in headers) {
-        xhr.setRequestHeader(h, headers[h]);
+    const layerRequest = getLayerRequestOptions({
+      headers,
+      request,
+      withCredentials
+    });
+    const requestHeaders = (layerRequest == null ? void 0 : layerRequest.headers) || {};
+    const controller = new AbortController();
+    const promise = fetch(src, {
+      cache: layerRequest == null ? void 0 : layerRequest.cache,
+      credentials: layerRequest == null ? void 0 : layerRequest.credentials,
+      headers: requestHeaders,
+      signal: controller.signal
+    }).then((response) => {
+      if (!response.ok) {
+        throw new Error(response.statusText);
       }
-      if (withCredentials) {
-        xhr.withCredentials = withCredentials;
+      return response.blob();
+    }).then((blob) => {
+      const urlCreator = window.URL || window.webkitURL;
+      return urlCreator.createObjectURL(blob);
+    }).catch((er) => {
+      if (er.name === "AbortError") {
+        return "";
       }
-      xhr.onload = function() {
-        const arrayBufferView = new Uint8Array(this.response);
-        const blob = new Blob([arrayBufferView], { type: "image/png" });
-        const urlCreator = window.URL || window.webkitURL;
-        const imageUrl = urlCreator.createObjectURL(blob);
-        resolve(imageUrl);
-      };
-      xhr.onerror = reject;
-      xhr.send();
-      abortFunc = () => {
-        xhr.abort();
-        resolve("");
-      };
+      throw er;
     });
+    const abortFunc = () => {
+      controller.abort();
+    };
     return [promise, abortFunc];
   }
 
@@ -15824,7 +16580,7 @@ var LeafletMapAdapter = (function () {
     }
     _initImage() {
       super._initImage();
-      const { headers, withCredentials } = this.options;
+      const { headers, request, withCredentials } = this.options;
       const img = this._image;
       const src = img.src;
       img.src = "";
@@ -15832,6 +16588,7 @@ var LeafletMapAdapter = (function () {
         const [promise, abortFunc] = callAjax({
           src,
           headers,
+          request,
           withCredentials
         });
         promise.then((imgUrl) => {
@@ -15940,6 +16697,7 @@ var LeafletMapAdapter = (function () {
         opacity: 0,
         pane: this.options.pane,
         headers: this.options.headers,
+        request: this.options.request,
         withCredentials: this.options.withCredentials
       });
       overlay.addTo(this._map);
@@ -16064,15 +16822,17 @@ var LeafletMapAdapter = (function () {
       const url = options && options.url;
       if (url) {
         const updateWmsParamsFromOpt = options.updateWmsParams;
-        this.layer = new ImageLayer(url, __spreadValues$4(__spreadValues$4(__spreadValues$4({
+        const request = getLayerRequestOptions(options);
+        this.layer = new ImageLayer(url, __spreadProps$3(__spreadValues$4(__spreadValues$4(__spreadValues$4({
           pane: this.pane,
-          headers: options.headers,
           setViewDelay: options.setViewDelay
         }, __spreadProps$3(__spreadValues$4({
           transparent: true
         }, options), {
           opacity: (_a = options.opacity) != null ? _a : void 0
-        })), options.params), options.nativeOptions));
+        })), options.params), options.nativeOptions), {
+          request
+        }));
         if (updateWmsParamsFromOpt) {
           const updateWmsParams = this.layer.updateWmsParams;
           this.layer.updateWmsParams = function(map) {
@@ -16109,7 +16869,8 @@ var LeafletMapAdapter = (function () {
         const [promise, abortFunc] = callAjax({
           src,
           withCredentials: this.options.withCredentials,
-          headers: this.options.headers
+          headers: this.options.headers,
+          request: this.options.request
         });
         promise.then((response) => {
           tile.src = response;
@@ -16200,10 +16961,10 @@ var LeafletMapAdapter = (function () {
             tileLayerOptions.subdomains = opt.subdomains;
           }
           let layer;
-          if (opt.headers || opt.withCredentials) {
+          const request = getLayerRequestOptions(opt);
+          if (request) {
             layer = new TileLayer(url, __spreadProps$2(__spreadValues$3({}, tileLayerOptions), {
-              headers: opt.headers,
-              withCredentials: opt.withCredentials,
+              request,
               setViewDelay: opt.setViewDelay
             }));
           } else {
@@ -16308,10 +17069,10 @@ var LeafletMapAdapter = (function () {
           transparent: true
         }, options.nativeOptions);
         let layer;
-        if (opt.headers || opt.withCredentials) {
+        const request = getLayerRequestOptions(opt);
+        if (request) {
           layer = new WmsLayer(url, __spreadProps(__spreadValues$1({}, layerOptions), {
-            headers: opt.headers,
-            withCredentials: opt.withCredentials
+            request
           }));
         } else {
           layer = new leafletSrcExports.TileLayer.WMS(url, layerOptions);
@@ -16354,6 +17115,7 @@ var LeafletMapAdapter = (function () {
       __publicField(this, "emitter", new EventEmitter());
       __publicField(this, "map");
       __publicField(this, "_resizeObserver");
+      __publicField(this, "_controlContainer");
       __publicField(this, "_unselectCb", []);
       __publicField(this, "_universalEvents", [
         "move",
@@ -16392,6 +17154,7 @@ var LeafletMapAdapter = (function () {
         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);
         };
@@ -16404,12 +17167,19 @@ var LeafletMapAdapter = (function () {
       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;
@@ -16523,16 +17293,17 @@ var LeafletMapAdapter = (function () {
     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) {