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

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

@@ -1,474 +1,599 @@
-/** Bundle of @nextgis/leaflet-map-adapter; version: 3.1.0; author: NextGIS */
-var domain;
-
-// This constructor is used to store event handlers. Instantiating this is
-// faster than explicitly calling `Object.create(null)` to get a "clean" empty
-// object (tested with v8 v4.9).
-function EventHandlers() {}
-EventHandlers.prototype = Object.create(null);
-
-function EventEmitter() {
-  EventEmitter.init.call(this);
+/** Bundle of @nextgis/leaflet-map-adapter; version: 4.0.0-alpha.1; author: NextGIS */
+function getElement(el) {
+  if (typeof el === "string") {
+    let el_ = document.getElementById(el);
+    if (!el_) {
+      try {
+        el_ = document.querySelector(el);
+      } catch (e) {
+      }
+    }
+    return el_ || void 0;
+  }
+  return el;
 }
 
-// nodejs oddity
-// require('events') === require('events').EventEmitter
-EventEmitter.EventEmitter = EventEmitter;
-
-EventEmitter.usingDomains = false;
-
-EventEmitter.prototype.domain = undefined;
-EventEmitter.prototype._events = undefined;
-EventEmitter.prototype._maxListeners = undefined;
-
-// By default EventEmitters will print a warning if more than 10 listeners are
-// added to it. This is a useful default which helps finding memory leaks.
-EventEmitter.defaultMaxListeners = 10;
+var __defProp$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: {}};
@@ -14185,365 +14310,1019 @@ function requireLeafletSrc () {
 		  });
 
 		  // @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
@@ -14562,81 +15341,6 @@ class AttributionControl extends leafletSrcExports.Control.Attribution {
   }
 }
 
-function createControl(control, options = {}, map) {
-  const C = leafletSrcExports.Control.extend({
-    onAdd() {
-      const element = document.createElement("div");
-      const content = control.onAdd(map);
-      element.classList.add("leaflet-control");
-      if (options.bar) {
-        element.classList.add("leaflet-bar");
-      }
-      if (options.addClass) {
-        element.classList.add(options.addClass);
-      }
-      if (!options.margin && !options.bar) {
-        element.style.marginBottom = "0px";
-        element.style.marginTop = "0px";
-        element.style.marginLeft = "0px";
-        element.style.marginRight = "0px";
-      }
-      if (content) {
-        element.appendChild(content);
-      }
-      leafletSrcExports.DomEvent.disableClickPropagation(element);
-      return element;
-    },
-    onRemove() {
-      control.onRemove();
-    }
-  });
-  return new C();
-}
-
-function createButtonControl(options, map) {
-  const link = document.createElement("a");
-  const title = options.title || "";
-  link.href = "#";
-  link.title = title;
-  link.setAttribute("role", "button");
-  link.setAttribute("aria-label", title);
-  if (options.addClass) {
-    link.classList.add(options.addClass);
-  }
-  leafletSrcExports.DomEvent.disableClickPropagation(link);
-  leafletSrcExports.DomEvent.on(link, "click", leafletSrcExports.DomEvent.stop);
-  if (options.html instanceof HTMLElement) {
-    link.appendChild(options.html);
-  } else if (typeof options.html === "string") {
-    link.innerHTML = options.html;
-  }
-  const onClick = (e) => {
-    e.stopPropagation();
-    options.onClick();
-  };
-  return createControl(
-    {
-      onAdd() {
-        if (options.onClick !== void 0) {
-          link.addEventListener("click", onClick);
-        }
-        return link;
-      },
-      onRemove() {
-        const parent = link.parentNode;
-        if (parent) {
-          parent.removeChild(link);
-        }
-        if (options.onClick !== void 0) {
-          link.removeEventListener("click", onClick);
-        }
-      }
-    },
-    { bar: true },
-    map
-  );
-}
-
 function debounce(cb, wait = 10) {
   let timeoutId;
   function wrapper(...args) {
@@ -14781,9 +15485,9 @@ function createFeaturePositionOptions(features) {
   };
 }
 
-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;
@@ -14818,19 +15522,19 @@ function convertMapClickEvent(evt) {
   };
 }
 
-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;
 };
@@ -14840,7 +15544,7 @@ function createMouseEvent({
 }) {
   const layer_ = source.target;
   const feature = layer_.feature;
-  const opt = __spreadValues$8({
+  const opt = __spreadValues$9({
     layer,
     feature,
     event: convertMapClickEvent(source),
@@ -14849,23 +15553,23 @@ function createMouseEvent({
   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");
@@ -14881,7 +15585,7 @@ class GeoJsonEvents {
     if (onClick_) {
       this._onclick = (e) => {
         const selected = !!this.layer._getSelected(layer);
-        onClick_(__spreadValues$7({
+        onClick_(__spreadValues$8({
           selected
         }, this._createMouseEvent(e)));
       };
@@ -14891,7 +15595,7 @@ class GeoJsonEvents {
       this._ondblclick = (e) => {
         leafletSrcExports.DomEvent.stopPropagation(e);
         const selected = !!this.layer._getSelected(layer);
-        onDoubleClick(__spreadValues$7({
+        onDoubleClick(__spreadValues$8({
           selected
         }, this._createMouseEvent(e)));
       };
@@ -14942,21 +15646,21 @@ function isPaintCallback(paint) {
   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;
 };
@@ -14964,16 +15668,16 @@ var __spreadProps$5 = (a, b) => __defProps$5(a, __getOwnPropDescs$5(b));
 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");
@@ -15055,7 +15759,7 @@ class GeoJsonPaint {
     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
@@ -15081,7 +15785,7 @@ class GeoJsonPaint {
     }
     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) {
@@ -15103,26 +15807,26 @@ class GeoJsonPaint {
   }
 }
 
-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) => {
@@ -15170,7 +15874,7 @@ class GeoJsonAdapter extends BaseAdapter {
   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;
@@ -15219,7 +15923,7 @@ class GeoJsonAdapter extends BaseAdapter {
   }
   getSelected() {
     return this._selectedLayers.map((x) => {
-      return __spreadValues$5({
+      return __spreadValues$6({
         target: this,
         feature: x.feature,
         layer: x
@@ -15238,14 +15942,14 @@ class GeoJsonAdapter extends BaseAdapter {
       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
@@ -15266,7 +15970,7 @@ class GeoJsonAdapter extends BaseAdapter {
   getLayers() {
     return this._layers.map(({ layer, feature }) => {
       const visible = layer && !!layer._map;
-      return __spreadValues$5({
+      return __spreadValues$6({
         feature,
         layer,
         visible,
@@ -15384,13 +16088,13 @@ class GeoJsonAdapter extends BaseAdapter {
     }
   }
   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);
     }
@@ -15407,7 +16111,7 @@ class GeoJsonAdapter extends BaseAdapter {
       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)));
       }
@@ -15426,7 +16130,7 @@ class GeoJsonAdapter extends BaseAdapter {
         autoPan,
         maxWidth,
         closeButton: closeButton_
-      } = __spreadValues$5({
+      } = __spreadValues$6({
         minWidth: 300
       }, options);
       const closeButton = closeButton_ != null ? closeButton_ : !this.options.selectOnHover;
@@ -15442,7 +16146,7 @@ class GeoJsonAdapter extends BaseAdapter {
       };
       let content;
       if (options.createPopupContent) {
-        content = yield options.createPopupContent(__spreadValues$5({
+        content = yield options.createPopupContent(__spreadValues$6({
           layer,
           feature,
           target: this,
@@ -15520,9 +16224,9 @@ class GeoJsonAdapter extends BaseAdapter {
         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" }));
             }
           }
         };
@@ -15538,7 +16242,7 @@ class GeoJsonAdapter extends BaseAdapter {
   _onEachFeature(feature, layer) {
     const layer_ = this.layer;
     if (layer_) {
-      const def = __spreadValues$5({
+      const def = __spreadValues$6({
         target: this,
         feature,
         layer
@@ -15573,7 +16277,7 @@ class GeoJsonAdapter extends BaseAdapter {
         setTimeout(() => {
           if (popup) {
             this._openPopup(
-              __spreadValues$5({
+              __spreadValues$6({
                 target: this,
                 layer,
                 feature
@@ -15591,7 +16295,7 @@ class GeoJsonAdapter extends BaseAdapter {
     leafletSrcExports.DomEvent.stopPropagation(e);
     const layer = e.target;
     const feature = layer.feature;
-    const def = __spreadValues$5({
+    const def = __spreadValues$6({
       target: this,
       layer,
       feature
@@ -15624,7 +16328,7 @@ class GeoJsonAdapter extends BaseAdapter {
     }
     if (this.options.onSelect) {
       const features = def.feature ? [def.feature] : [];
-      this.options.onSelect(__spreadValues$5({
+      this.options.onSelect(__spreadValues$6({
         type,
         layer: this,
         features
@@ -15682,37 +16386,89 @@ class GeoJsonAdapter extends BaseAdapter {
   }
 }
 
+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];
 }
 
@@ -15821,7 +16577,7 @@ class ImageOverlay extends leafletSrcExports.ImageOverlay {
   }
   _initImage() {
     super._initImage();
-    const { headers, withCredentials } = this.options;
+    const { headers, request, withCredentials } = this.options;
     const img = this._image;
     const src = img.src;
     img.src = "";
@@ -15829,6 +16585,7 @@ class ImageOverlay extends leafletSrcExports.ImageOverlay {
       const [promise, abortFunc] = callAjax({
         src,
         headers,
+        request,
         withCredentials
       });
       promise.then((imgUrl) => {
@@ -15937,6 +16694,7 @@ class ImageLayer extends leafletSrcExports.Layer {
       opacity: 0,
       pane: this.options.pane,
       headers: this.options.headers,
+      request: this.options.request,
       withCredentials: this.options.withCredentials
     });
     overlay.addTo(this._map);
@@ -16061,15 +16819,17 @@ class ImageAdapter extends BaseAdapter {
     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) {
@@ -16106,7 +16866,8 @@ function makeRemote(Base) {
       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;
@@ -16197,10 +16958,10 @@ class TileAdapter extends BaseAdapter {
           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 {
@@ -16305,10 +17066,10 @@ class WmsAdapter extends BaseAdapter {
         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);
@@ -16351,6 +17112,7 @@ const _LeafletMapAdapter = class _LeafletMapAdapter {
     __publicField(this, "emitter", new EventEmitter());
     __publicField(this, "map");
     __publicField(this, "_resizeObserver");
+    __publicField(this, "_controlContainer");
     __publicField(this, "_unselectCb", []);
     __publicField(this, "_universalEvents", [
       "move",
@@ -16389,6 +17151,7 @@ const _LeafletMapAdapter = class _LeafletMapAdapter {
       this._updateMinZoomForBounds(minZoom);
       this._watchSizeChangeToUpdateMinZoom();
       const defPane = this.map.createPane("order-0");
+      this._controlContainer = new LeafletControlContainer(this.map);
       this.map._addUnselectCb = (def) => {
         this._addUnselectCb(def);
       };
@@ -16401,12 +17164,19 @@ const _LeafletMapAdapter = class _LeafletMapAdapter {
     if (this.map) {
       this.map.remove();
     }
+    if (this._controlContainer) {
+      this._controlContainer.detach();
+      this._controlContainer = void 0;
+    }
     this._stopWatchSizeChangeToUpdateMinZoom();
   }
   getContainer() {
     return this.map && this.map.getContainer();
   }
   getControlContainer() {
+    if (this._controlContainer) {
+      return this._controlContainer.getContainer();
+    }
     const controlContainer = this.map && this.map._controlContainer;
     if (controlContainer) {
       return controlContainer;
@@ -16520,16 +17290,17 @@ const _LeafletMapAdapter = class _LeafletMapAdapter {
   createButtonControl(options) {
     return createButtonControl(options, this);
   }
-  addControl(control, position) {
-    control.options.position = position.replace("-", "");
-    if (this.map) {
-      this.map.addControl(control);
-      return control;
+  createToggleControl(options) {
+    return createToggleControl(options, this);
+  }
+  addControl(control, position, options) {
+    if (this._controlContainer) {
+      return this._controlContainer.addControl(control, position, options);
     }
   }
   removeControl(control) {
-    if (this.map) {
-      this.map.removeControl(control);
+    if (this._controlContainer) {
+      this._controlContainer.removeControl(control);
     }
   }
   removeLayer(layer) {