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

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

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