text: (function (global, factory) {
      typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('leaflet'), require('vue')) :
          typeof define === 'function' && define.amd ? define(['exports', 'leaflet', 'vue'], factory) :
              (global = global || self, factory(global.Vue2Leaflet = {}, global.L, global.Vue));
  }(this, (function (exports, leaflet, Vue) { 'use strict';
  
      Vue = Vue && Object.prototype.hasOwnProperty.call(Vue, 'default') ? Vue['default'] : Vue;
  
      var debounce = function (fn, time) {
          var timeout;
  
          var debouncedFunction = function() {
              var args = [], len = arguments.length;
              while ( len-- ) args[ len ] = arguments[ len ];
  
              var context = this;
              if (timeout) {
                  clearTimeout(timeout);
              }
              timeout = setTimeout(function () {
                  fn.apply(context, args);
                  timeout = null;
              }, time);
          };
  
          debouncedFunction.cancel = function() {
              if (timeout) {
                  clearTimeout(timeout);
              }
          };
  
          return debouncedFunction;
      };
  
      var capitalizeFirstLetter = function (string) {
          if (!string || typeof string.charAt !== 'function') {
              return string;
          }
          return string.charAt(0).toUpperCase() + string.slice(1);
      };
  
      var propsBinder = function (vueElement, leafletElement, props, options) {
          var loop = function ( key ) {
              var setMethodName = 'set' + capitalizeFirstLetter(key);
              var deepValue =
                  props[key].type === Object ||
                  props[key].type === Array ||
                  Array.isArray(props[key].type);
              if (props[key].custom && vueElement[setMethodName]) {
                  vueElement.$watch(
                      key,
                      function (newVal, oldVal) {
                          vueElement[setMethodName](newVal, oldVal);
                      },
                      {
                          deep: deepValue,
                      }
                  );
              } else if (setMethodName === 'setOptions') {
                  vueElement.$watch(
                      key,
                      function (newVal, oldVal) {
                          leaflet.setOptions(leafletElement, newVal);
                      },
                      {
                          deep: deepValue,
                      }
                  );
              } else if (leafletElement[setMethodName]) {
                  vueElement.$watch(
                      key,
                      function (newVal, oldVal) {
                          leafletElement[setMethodName](newVal);
                      },
                      {
                          deep: deepValue,
                      }
                  );
              }
          };
  
          for (var key in props) loop( key );
      };
  
      var collectionCleaner = function (options) {
          var result = {};
          for (var key in options) {
              var value = options[key];
              if (value !== null && value !== undefined) {
                  result[key] = value;
              }
          }
          return result;
      };
  
      var optionsMerger = function (props, instance) {
          var options =
              instance.options && instance.options.constructor === Object
                  ? instance.options
                  : {};
          props = props && props.constructor === Object ? props : {};
          var result = collectionCleaner(options);
          props = collectionCleaner(props);
          var defaultProps = instance.$options.props;
          for (var key in props) {
              var def = defaultProps[key]
                  ? defaultProps[key].default &&
                  typeof defaultProps[key].default === 'function'
                      ? defaultProps[key].default.call()
                      : defaultProps[key].default
                  : Symbol('unique');
              var isEqual = false;
              if (Array.isArray(def)) {
                  isEqual = JSON.stringify(def) === JSON.stringify(props[key]);
              } else {
                  isEqual = def === props[key];
              }
              if (result[key] && !isEqual) {
                  console.warn(
                      (key + " props is overriding the value passed in the options props")
                  );
                  result[key] = props[key];
              } else if (!result[key]) {
                  result[key] = props[key];
              }
          }
          return result;
      };
  
      var findRealParent = function (firstVueParent) {
          var found = false;
          while (firstVueParent && !found) {
              if (firstVueParent.mapObject === undefined) {
                  firstVueParent = firstVueParent.$parent;
              } else {
                  found = true;
              }
          }
          return firstVueParent;
      };
  
      var Layer = {
          props: {
              pane: {
                  type: String,
                  default: 'overlayPane',
              },
              attribution: {
                  type: String,
                  default: null,
                  custom: true,
              },
              name: {
                  type: String,
                  custom: true,
                  default: undefined,
              },
              layerType: {
                  type: String,
                  custom: true,
                  default: undefined,
              },
              visible: {
                  type: Boolean,
                  custom: true,
                  default: true,
              },
          },
          mounted: function mounted() {
              this.layerOptions = {
                  attribution: this.attribution,
                  pane: this.pane,
              };
          },
          beforeDestroy: function beforeDestroy() {
              this.unbindPopup();
              this.unbindTooltip();
              this.parentContainer.removeLayer(this);
          },
          methods: {
              setAttribution: function setAttribution(val, old) {
                  var attributionControl = this.$parent.mapObject.attributionControl;
                  attributionControl.removeAttribution(old).addAttribution(val);
              },
              setName: function setName() {
                  this.parentContainer.removeLayer(this);
                  if (this.visible) {
                      this.parentContainer.addLayer(this);
                  }
              },
              setLayerType: function setLayerType() {
                  this.parentContainer.removeLayer(this);
                  if (this.visible) {
                      this.parentContainer.addLayer(this);
                  }
              },
              setVisible: function setVisible(isVisible) {
                  if (this.mapObject) {
                      if (isVisible) {
                          this.parentContainer.addLayer(this);
                      } else {
                          if (this.parentContainer.hideLayer) {
                              this.parentContainer.hideLayer(this);
                          } else {
                              this.parentContainer.removeLayer(this);
                          }
                      }
                  }
              },
              unbindTooltip: function unbindTooltip() {
                  var tooltip = this.mapObject ? this.mapObject.getTooltip() : null;
                  if (tooltip) {
                      tooltip.unbindTooltip();
                  }
              },
              unbindPopup: function unbindPopup() {
                  var popup = this.mapObject ? this.mapObject.getPopup() : null;
                  if (popup) {
                      popup.unbindPopup();
                  }
              },
              updateVisibleProp: function updateVisibleProp(value) {
                  /**
                   * Triggers when the visible prop needs to be updated
                   * @type {boolean}
                   * @property {boolean} value - value of the visible property
                   */
                  this.$emit('update:visible', value);
              },
          },
      };
  
      var InteractiveLayer = {
          props: {
              interactive: {
                  type: Boolean,
                  default: true
              },
              bubblingMouseEvents: {
                  type: Boolean,
                  default: true
              }
          },
          mounted: function mounted () {
              this.interactiveLayerOptions = {
                  interactive: this.interactive,
                  bubblingMouseEvents: this.bubblingMouseEvents
              };
          }
      };
  
      var Path = {
          mixins: [Layer, InteractiveLayer],
          props: {
              lStyle: {
                  type: Object,
                  custom: true,
                  default: null
              },
              stroke: {
                  type: Boolean,
                  custom: true,
                  default: true
              },
              color: {
                  type: String,
                  custom: true,
                  default: '#3388ff'
              },
              weight: {
                  type: Number,
                  custom: true,
                  default: 3
              },
              opacity: {
                  type: Number,
                  custom: true,
                  default: 1.0
              },
              lineCap: {
                  type: String,
                  custom: true,
                  default: 'round'
              },
              lineJoin: {
                  type: String,
                  custom: true,
                  default: 'round'
              },
              dashArray: {
                  type: String,
                  custom: true,
                  default: null
              },
              dashOffset: {
                  type: String,
                  custom: true,
                  default: null
              },
              fill: {
                  type: Boolean,
                  custom: true,
                  default: false
              },
              fillColor: {
                  type: String,
                  custom: true,
                  default: '#3388ff'
              },
              fillOpacity: {
                  type: Number,
                  custom: true,
                  default: 0.2
              },
              fillRule: {
                  type: String,
                  custom: true,
                  default: 'evenodd'
              },
              className: {
                  type: String,
                  custom: true,
                  default: null
              }
          },
          mounted: function mounted () {
              this.pathOptions = Object.assign({}, this.layerOptions,
                  this.interactiveLayerOptions,
                  {stroke: this.stroke,
                      color: this.color,
                      weight: this.weight,
                      opacity: this.opacity,
                      lineCap: this.lineCap,
                      lineJoin: this.lineJoin,
                      dashArray: this.dashArray,
                      dashOffset: this.dashOffset,
                      fill: this.fill,
                      fillColor: this.fillColor,
                      fillOpacity: this.fillOpacity,
                      fillRule: this.fillRule,
                      className: this.className});
  
              if (this.lStyle) {
                  console.warn('lStyle is deprecated and is going to be removed in the next major version');
                  for (var style in this.lStyle) {
                      this.pathOptions[style] = this.lStyle[style];
                  }
              }
          },
          beforeDestroy: function beforeDestroy () {
              if (this.parentContainer) {
                  this.parentContainer.removeLayer(this);
              } else {
                  console.error('Missing parent container');
              }
          },
          methods: {
              setLStyle: function setLStyle (newVal) {
                  this.mapObject.setStyle(newVal);
              },
              setStroke: function setStroke (newVal) {
                  this.mapObject.setStyle({ stroke: newVal });
              },
              setColor: function setColor (newVal) {
                  this.mapObject.setStyle({ color: newVal });
              },
              setWeight: function setWeight (newVal) {
                  this.mapObject.setStyle({ weight: newVal });
              },
              setOpacity: function setOpacity (newVal) {
                  this.mapObject.setStyle({ opacity: newVal });
              },
              setLineCap: function setLineCap (newVal) {
                  this.mapObject.setStyle({ lineCap: newVal });
              },
              setLineJoin: function setLineJoin (newVal) {
                  this.mapObject.setStyle({ lineJoin: newVal });
              },
              setDashArray: function setDashArray (newVal) {
                  this.mapObject.setStyle({ dashArray: newVal });
              },
              setDashOffset: function setDashOffset (newVal) {
                  this.mapObject.setStyle({ dashOffset: newVal });
              },
              setFill: function setFill (newVal) {
                  this.mapObject.setStyle({ fill: newVal });
              },
              setFillColor: function setFillColor (newVal) {
                  this.mapObject.setStyle({ fillColor: newVal });
              },
              setFillOpacity: function setFillOpacity (newVal) {
                  this.mapObject.setStyle({ fillOpacity: newVal });
              },
              setFillRule: function setFillRule (newVal) {
                  this.mapObject.setStyle({ fillRule: newVal });
              },
              setClassName: function setClassName (newVal) {
                  this.mapObject.setStyle({ className: newVal });
              }
          }
      };
  
      var CircleMixin = {
          mixins: [Path],
          props: {
              fill: {
                  type: Boolean,
                  custom: true,
                  default: true
              },
              radius: {
                  type: Number,
                  default: null
              }
          },
          mounted: function mounted () {
              this.circleOptions = Object.assign({}, this.pathOptions,
                  {radius: this.radius});
          }
      };
  
      var ControlMixin = {
          props: {
              position: {
                  type: String,
                  default: 'topright'
              }
          },
          mounted: function mounted () {
              this.controlOptions = {
                  position: this.position
              };
          },
          beforeDestroy: function beforeDestroy () {
              if (this.mapObject) {
                  this.mapObject.remove();
              }
          }
      };
  
      var GridLayerMixin = {
          mixins: [Layer],
          props: {
              pane: {
                  type: String,
                  default: 'tilePane'
              },
              opacity: {
                  type: Number,
                  custom: false,
                  default: 1.0
              },
              zIndex: {
                  type: Number,
                  default: 1
              },
              tileSize: {
                  type: Number,
                  default: 256
              },
              noWrap: {
                  type: Boolean,
                  default: false
              }
          },
          mounted: function mounted () {
              this.gridLayerOptions = Object.assign({}, this.layerOptions,
                  {pane: this.pane,
                      opacity: this.opacity,
                      zIndex: this.zIndex,
                      tileSize: this.tileSize,
                      noWrap: this.noWrap});
          }
      };
  
      var ImageOverlayMixin = {
          mixins: [Layer, InteractiveLayer],
          props: {
              url: {
                  type: String,
                  custom: true
              },
              bounds: {
                  custom: true
              },
              opacity: {
                  type: Number,
                  custom: true,
                  default: 1.0
              },
              alt: {
                  type: String,
                  default: ''
              },
              interactive: {
                  type: Boolean,
                  default: false
              },
              crossOrigin: {
                  type: Boolean,
                  default: false
              },
              errorOverlayUrl: {
                  type: String,
                  custom: true,
                  default: ''
              },
              zIndex: {
                  type: Number,
                  custom: true,
                  default: 1
              },
              className: {
                  type: String,
                  default: ''
              }
          },
          mounted: function mounted () {
              this.imageOverlayOptions = Object.assign({}, this.layerOptions,
                  this.interactiveLayerOptions,
                  {opacity: this.opacity,
                      alt: this.alt,
                      interactive: this.interactive,
                      crossOrigin: this.crossOrigin,
                      errorOverlayUrl: this.errorOverlayUrl,
                      zIndex: this.zIndex,
                      className: this.className});
          },
          methods: {
              setOpacity: function setOpacity (opacity) {
                  return this.mapObject.setOpacity(opacity);
              },
              setUrl: function setUrl (url) {
                  return this.mapObject.setUrl(url);
              },
              setBounds: function setBounds (bounds) {
                  return this.mapObject.setBounds(bounds);
              },
              getBounds: function getBounds () {
                  return this.mapObject.getBounds();
              },
              getElement: function getElement () {
                  return this.mapObject.getElement();
              },
              bringToFront: function bringToFront () {
                  return this.mapObject.bringToFront();
              },
              bringToBack: function bringToBack () {
                  return this.mapObject.bringToBack();
              }
          },
          render: function render () {
              return null;
          }
      };
  
      var LayerGroupMixin = {
          mixins: [Layer],
          mounted: function mounted () {
              this.layerGroupOptions = this.layerOptions;
          },
          methods: {
              addLayer: function addLayer (layer, alreadyAdded) {
                  if (!alreadyAdded) {
                      this.mapObject.addLayer(layer.mapObject);
                  }
                  this.parentContainer.addLayer(layer, true);
              },
              removeLayer: function removeLayer (layer, alreadyRemoved) {
                  if (!alreadyRemoved) {
                      this.mapObject.removeLayer(layer.mapObject);
                  }
                  this.parentContainer.removeLayer(layer, true);
              }
          }
      };
  
      var Options = {
          props: {
              /**
               * Leaflet options to pass to the component constructor
               */
              options: {
                  type: Object,
                  default: function () { return ({}); }
              }
          }
      };
  
      var PolylineMixin = {
          mixins: [Path],
          props: {
              smoothFactor: {
                  type: Number,
                  custom: true,
                  default: 1.0
              },
              noClip: {
                  type: Boolean,
                  custom: true,
                  default: false
              }
          },
          data: function data () {
              return {
                  ready: false
              };
          },
          mounted: function mounted () {
              this.polyLineOptions = Object.assign({}, this.pathOptions,
                  {smoothFactor: this.smoothFactor,
                      noClip: this.noClip});
          },
          methods: {
              setSmoothFactor: function setSmoothFactor (newVal) {
                  this.mapObject.setStyle({ smoothFactor: newVal });
              },
              setNoClip: function setNoClip (newVal) {
                  this.mapObject.setStyle({ noClip: newVal });
              },
              addLatLng: function addLatLng (value) {
                  this.mapObject.addLatLng(value);
              }
          }
      };
  
      var Polygon = {
          mixins: [PolylineMixin],
          props: {
              fill: {
                  type: Boolean,
                  custom: true,
                  default: true
              }
          },
          mounted: function mounted () {
              this.polygonOptions = this.polyLineOptions;
          },
          methods: {
              getGeoJSONData: function getGeoJSONData () {
                  return this.mapObject.toGeoJSON();
              }
          }
      };
  
      var Popper = {
          props: {
              content: {
                  type: String,
                  default: null,
                  custom: true
              }
          },
          mounted: function mounted () {
              this.popperOptions = {};
          },
          methods: {
              setContent: function setContent (newVal) {
                  if (this.mapObject && newVal !== null && newVal !== undefined) {
                      this.mapObject.setContent(newVal);
                  }
              }
          },
          render: function render (h) {
              if (this.$slots.default) {
                  return h('div', this.$slots.default);
              }
              return null;
          }
      };
  
      var TileLayerMixin = {
          mixins: [GridLayerMixin],
          props: {
              tms: {
                  type: Boolean,
                  default: false,
              },
              subdomains: {
                  type: [String, Array],
                  default: 'abc',
                  validator: function (prop) {
                      if (typeof prop === 'string') { return true; }
                      // Validates array that array only contains only strings
                      if (Array.isArray(prop)) {
                          return prop.every(function (subdomain) { return typeof subdomain === 'string'; });
                      }
                      return false;
                  },
              },
              detectRetina: {
                  type: Boolean,
                  default: false,
              },
          },
          mounted: function mounted() {
              this.tileLayerOptions = Object.assign({}, this.gridLayerOptions,
                  {tms: this.tms,
                      subdomains: this.subdomains,
                      detectRetina: this.detectRetina});
          },
          render: function render() {
              return null;
          },
      };
  
      var TileLayerWMS = {
          mixins: [TileLayerMixin],
          props: {
              layers: {
                  type: String,
                  default: ''
              },
              styles: {
                  type: String,
                  default: ''
              },
              format: {
                  type: String,
                  default: 'image/jpeg'
              },
              transparent: {
                  type: Boolean,
                  custom: false
              },
              version: {
                  type: String,
                  default: '1.1.1'
              },
              crs: {
                  default: null
              },
              upperCase: {
                  type: Boolean,
                  default: false
              }
          },
          mounted: function mounted () {
              this.tileLayerWMSOptions = Object.assign({}, this.tileLayerOptions,
                  {layers: this.layers,
                      styles: this.styles,
                      format: this.format,
                      transparent: this.transparent,
                      version: this.version,
                      crs: this.crs,
                      upperCase: this.upperCase});
          }
      };
  
      //
  
      /**
       * Draw a path in the shape of a circle around a center positioned at `latLng` coordinates
       */
      var script = {
          name: 'LCircle',
          mixins: [CircleMixin, Options],
          props: {
              latLng: {
                  type: [Object, Array],
                  default: function () { return [0, 0]; },
              },
          },
          data: function data() {
              return {
                  ready: false,
              };
          },
          mounted: function mounted() {
              var this$1 = this;
  
              var options = optionsMerger(this.circleOptions, this);
              this.mapObject = leaflet.circle(this.latLng, options);
              leaflet.DomEvent.on(this.mapObject, this.$listeners);
              propsBinder(this, this.mapObject, this.$options.props);
              this.ready = true;
              this.parentContainer = findRealParent(this.$parent);
              this.parentContainer.addLayer(this, !this.visible);
              this.$nextTick(function () {
                  /**
                   * Triggers when the component is ready
                   * @type {object}
                   * @property {object} mapObject - reference to leaflet map object
                   */
                  this$1.$emit('ready', this$1.mapObject);
              });
          },
          methods: {},
      };
  
      function normalizeComponent(template, style, script, scopeId, isFunctionalTemplate, moduleIdentifier /* server only */, shadowMode, createInjector, createInjectorSSR, createInjectorShadow) {
          if (typeof shadowMode !== 'boolean') {
              createInjectorSSR = createInjector;
              createInjector = shadowMode;
              shadowMode = false;
          }
          // Vue.extend constructor export interop.
          var options = typeof script === 'function' ? script.options : script;
          // render functions
          if (template && template.render) {
              options.render = template.render;
              options.staticRenderFns = template.staticRenderFns;
              options._compiled = true;
              // functional template
              if (isFunctionalTemplate) {
                  options.functional = true;
              }
          }
          // scopedId
          if (scopeId) {
              options._scopeId = scopeId;
          }
          var hook;
          if (moduleIdentifier) {
              // server build
              hook = function (context) {
                  // 2.3 injection
                  context =
                      context || // cached call
                      (this.$vnode && this.$vnode.ssrContext) || // stateful
                      (this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext); // functional
                  // 2.2 with runInNewContext: true
                  if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') {
                      context = __VUE_SSR_CONTEXT__;
                  }
                  // inject component styles
                  if (style) {
                      style.call(this, createInjectorSSR(context));
                  }
                  // register component module identifier for async chunk inference
                  if (context && context._registeredComponents) {
                      context._registeredComponents.add(moduleIdentifier);
                  }
              };
              // used by ssr in case component is cached and beforeCreate
              // never gets called
              options._ssrRegister = hook;
          }
          else if (style) {
              hook = shadowMode
                  ? function (context) {
                      style.call(this, createInjectorShadow(context, this.$root.$options.shadowRoot));
                  }
                  : function (context) {
                      style.call(this, createInjector(context));
                  };
          }
          if (hook) {
              if (options.functional) {
                  // register for functional component in vue file
                  var originalRender = options.render;
                  options.render = function renderWithStyleInjection(h, context) {
                      hook.call(context);
                      return originalRender(h, context);
                  };
              }
              else {
                  // inject component registration as beforeCreate hook
                  var existing = options.beforeCreate;
                  options.beforeCreate = existing ? [].concat(existing, hook) : [hook];
              }
          }
          return script;
      }
  
      /* script */
      var __vue_script__ = script;
  
      /* template */
      var __vue_render__ = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div',{staticStyle:{"display":"none"}},[(_vm.ready)?_vm._t("default"):_vm._e()],2)};
      var __vue_staticRenderFns__ = [];
  
      /* style */
      var __vue_inject_styles__ = undefined;
      /* scoped */
      var __vue_scope_id__ = undefined;
      /* module identifier */
      var __vue_module_identifier__ = undefined;
      /* functional template */
      var __vue_is_functional_template__ = false;
      /* style inject */
  
      /* style inject SSR */
  
      /* style inject shadow dom */
  
  
  
      var __vue_component__ = /*#__PURE__*/normalizeComponent(
          { render: __vue_render__, staticRenderFns: __vue_staticRenderFns__ },
          __vue_inject_styles__,
          __vue_script__,
          __vue_scope_id__,
          __vue_is_functional_template__,
          __vue_module_identifier__,
          false,
          undefined,
          undefined,
          undefined
      );
  
      //
  
      /**
       * A marker in the shape of a circle
       */
      var script$1 = {
          name: 'LCircleMarker',
          mixins: [CircleMixin, Options],
          props: {
              latLng: {
                  type: [Object, Array],
                  default: function () { return [0, 0]; },
              },
              pane: {
                  type: String,
                  default: 'markerPane',
              },
          },
          data: function data() {
              return {
                  ready: false,
              };
          },
          mounted: function mounted() {
              var this$1 = this;
  
              var options = optionsMerger(this.circleOptions, this);
              this.mapObject = leaflet.circleMarker(this.latLng, options);
              leaflet.DomEvent.on(this.mapObject, this.$listeners);
              propsBinder(this, this.mapObject, this.$options.props);
              this.ready = true;
              this.parentContainer = findRealParent(this.$parent);
              this.parentContainer.addLayer(this, !this.visible);
              this.$nextTick(function () {
                  /**
                   * Triggers when the component is ready
                   * @type {object}
                   * @property {object} mapObject - reference to leaflet map object
                   */
                  this$1.$emit('ready', this$1.mapObject);
              });
          },
      };
  
      /* script */
      var __vue_script__$1 = script$1;
  
      /* template */
      var __vue_render__$1 = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div',{staticStyle:{"display":"none"}},[(_vm.ready)?_vm._t("default"):_vm._e()],2)};
      var __vue_staticRenderFns__$1 = [];
  
      /* style */
      var __vue_inject_styles__$1 = undefined;
      /* scoped */
      var __vue_scope_id__$1 = undefined;
      /* module identifier */
      var __vue_module_identifier__$1 = undefined;
      /* functional template */
      var __vue_is_functional_template__$1 = false;
      /* style inject */
  
      /* style inject SSR */
  
      /* style inject shadow dom */
  
  
  
      var __vue_component__$1 = /*#__PURE__*/normalizeComponent(
          { render: __vue_render__$1, staticRenderFns: __vue_staticRenderFns__$1 },
          __vue_inject_styles__$1,
          __vue_script__$1,
          __vue_scope_id__$1,
          __vue_is_functional_template__$1,
          __vue_module_identifier__$1,
          false,
          undefined,
          undefined,
          undefined
      );
  
      //
  
      /**
       * Add any custom component as a leaflet control
       */
      var script$2 = {
          name: 'LControl',
          mixins: [ControlMixin, Options],
          props: {
              disableClickPropagation: {
                  type: Boolean,
                  custom: true,
                  default: true,
              },
              disableScrollPropagation: {
                  type: Boolean,
                  custom: true,
                  default: false,
              }
          },
          mounted: function mounted() {
              var this$1 = this;
  
              var LControl = leaflet.Control.extend({
                  element: undefined,
                  onAdd: function onAdd() {
                      return this.element;
                  },
                  setElement: function setElement(el) {
                      this.element = el;
                  },
              });
              var options = optionsMerger(this.controlOptions, this);
              this.mapObject = new LControl(options);
              propsBinder(this, this.mapObject, this.$options.props);
              this.parentContainer = findRealParent(this.$parent);
              this.mapObject.setElement(this.$el);
              if (this.disableClickPropagation) {
                  leaflet.DomEvent.disableClickPropagation(this.$el);
              }
              if (this.disableScrollPropagation) {
                  leaflet.DomEvent.disableScrollPropagation(this.$el);
              }
              this.mapObject.addTo(this.parentContainer.mapObject);
              this.$nextTick(function () {
                  /**
                   * Triggers when the component is ready
                   * @type {object}
                   * @property {object} mapObject - reference to leaflet map object
                   */
                  this$1.$emit('ready', this$1.mapObject);
              });
          },
      };
  
      /* script */
      var __vue_script__$2 = script$2;
  
      /* template */
      var __vue_render__$2 = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div',[_vm._t("default")],2)};
      var __vue_staticRenderFns__$2 = [];
  
      /* style */
      var __vue_inject_styles__$2 = undefined;
      /* scoped */
      var __vue_scope_id__$2 = undefined;
      /* module identifier */
      var __vue_module_identifier__$2 = undefined;
      /* functional template */
      var __vue_is_functional_template__$2 = false;
      /* style inject */
  
      /* style inject SSR */
  
      /* style inject shadow dom */
  
  
  
      var __vue_component__$2 = /*#__PURE__*/normalizeComponent(
          { render: __vue_render__$2, staticRenderFns: __vue_staticRenderFns__$2 },
          __vue_inject_styles__$2,
          __vue_script__$2,
          __vue_scope_id__$2,
          __vue_is_functional_template__$2,
          __vue_module_identifier__$2,
          false,
          undefined,
          undefined,
          undefined
      );
  
      /**
       * Add any custom component as a leaflet control-attribution
       */
      var script$3 = {
          name: 'LControlAttribution',
          mixins: [ControlMixin, Options],
          props: {
              prefix: {
                  type: [String, Boolean],
                  default: null,
              },
          },
          mounted: function mounted() {
              var this$1 = this;
  
              var options = optionsMerger(
                  Object.assign({}, this.controlOptions,
                      {prefix: this.prefix}),
                  this
              );
              this.mapObject = leaflet.control.attribution(options);
              propsBinder(this, this.mapObject, this.$options.props);
              this.mapObject.addTo(this.$parent.mapObject);
              this.$nextTick(function () {
                  /**
                   * Triggers when the component is ready
                   * @type {object}
                   * @property {object} mapObject - reference to leaflet map object
                   */
                  this$1.$emit('ready', this$1.mapObject);
              });
          },
          render: function render() {
              return null;
          },
      };
  
      /* script */
      var __vue_script__$3 = script$3;
  
      /* template */
  
      /* style */
      var __vue_inject_styles__$3 = undefined;
      /* scoped */
      var __vue_scope_id__$3 = undefined;
      /* module identifier */
      var __vue_module_identifier__$3 = undefined;
      /* functional template */
      var __vue_is_functional_template__$3 = undefined;
      /* style inject */
  
      /* style inject SSR */
  
      /* style inject shadow dom */
  
  
  
      var __vue_component__$3 = /*#__PURE__*/normalizeComponent(
          {},
          __vue_inject_styles__$3,
          __vue_script__$3,
          __vue_scope_id__$3,
          __vue_is_functional_template__$3,
          __vue_module_identifier__$3,
          false,
          undefined,
          undefined,
          undefined
      );
  
      /**
       * Add any custom component as a leaflet control-layers
       */
      var script$4 = {
          name: 'LControlLayers',
          mixins: [ControlMixin, Options],
          props: {
              collapsed: {
                  type: Boolean,
                  default: true,
              },
              autoZIndex: {
                  type: Boolean,
                  default: true,
              },
              hideSingleBase: {
                  type: Boolean,
                  default: false,
              },
              sortLayers: {
                  type: Boolean,
                  default: false,
              },
              sortFunction: {
                  type: Function,
                  default: undefined,
              },
          },
          mounted: function mounted() {
              var this$1 = this;
  
              var options = optionsMerger(
                  Object.assign({}, this.controlOptions,
                      {collapsed: this.collapsed,
                          autoZIndex: this.autoZIndex,
                          hideSingleBase: this.hideSingleBase,
                          sortLayers: this.sortLayers,
                          sortFunction: this.sortFunction}),
                  this
              );
              this.mapObject = leaflet.control.layers(null, null, options);
              propsBinder(this, this.mapObject, this.$options.props);
              this.$parent.registerLayerControl(this);
              this.$nextTick(function () {
                  /**
                   * Triggers when the component is ready
                   * @type {object}
                   * @property {object} mapObject - reference to leaflet map object
                   */
                  this$1.$emit('ready', this$1.mapObject);
              });
          },
          methods: {
              addLayer: function addLayer(layer) {
                  if (layer.layerType === 'base') {
                      this.mapObject.addBaseLayer(layer.mapObject, layer.name);
                  } else if (layer.layerType === 'overlay') {
                      this.mapObject.addOverlay(layer.mapObject, layer.name);
                  }
              },
              removeLayer: function removeLayer(layer) {
                  this.mapObject.removeLayer(layer.mapObject);
              },
          },
          render: function render() {
              return null;
          },
      };
  
      /* script */
      var __vue_script__$4 = script$4;
  
      /* template */
  
      /* style */
      var __vue_inject_styles__$4 = undefined;
      /* scoped */
      var __vue_scope_id__$4 = undefined;
      /* module identifier */
      var __vue_module_identifier__$4 = undefined;
      /* functional template */
      var __vue_is_functional_template__$4 = undefined;
      /* style inject */
  
      /* style inject SSR */
  
      /* style inject shadow dom */
  
  
  
      var __vue_component__$4 = /*#__PURE__*/normalizeComponent(
          {},
          __vue_inject_styles__$4,
          __vue_script__$4,
          __vue_scope_id__$4,
          __vue_is_functional_template__$4,
          __vue_module_identifier__$4,
          false,
          undefined,
          undefined,
          undefined
      );
  
      /**
       * Add any custom component as a leaflet control-scale
       */
      var script$5 = {
          name: 'LControlScale',
          mixins: [ControlMixin, Options],
          props: {
              maxWidth: {
                  type: Number,
                  default: 100,
              },
              metric: {
                  type: Boolean,
                  default: true,
              },
              imperial: {
                  type: Boolean,
                  default: true,
              },
              updateWhenIdle: {
                  type: Boolean,
                  default: false,
              },
          },
          mounted: function mounted() {
              var this$1 = this;
  
              var options = optionsMerger(
                  Object.assign({}, this.controlOptions,
                      {maxWidth: this.maxWidth,
                          metric: this.metric,
                          imperial: this.imperial,
                          updateWhenIdle: this.updateWhenIdle}),
                  this
              );
              this.mapObject = leaflet.control.scale(options);
              propsBinder(this, this.mapObject, this.$options.props);
              this.mapObject.addTo(this.$parent.mapObject);
              this.$nextTick(function () {
                  /**
                   * Triggers when the component is ready
                   * @type {object}
                   * @property {object} mapObject - reference to leaflet map object
                   */
                  this$1.$emit('ready', this$1.mapObject);
              });
          },
          render: function render() {
              return null;
          },
      };
  
      /* script */
      var __vue_script__$5 = script$5;
  
      /* template */
  
      /* style */
      var __vue_inject_styles__$5 = undefined;
      /* scoped */
      var __vue_scope_id__$5 = undefined;
      /* module identifier */
      var __vue_module_identifier__$5 = undefined;
      /* functional template */
      var __vue_is_functional_template__$5 = undefined;
      /* style inject */
  
      /* style inject SSR */
  
      /* style inject shadow dom */
  
  
  
      var __vue_component__$5 = /*#__PURE__*/normalizeComponent(
          {},
          __vue_inject_styles__$5,
          __vue_script__$5,
          __vue_scope_id__$5,
          __vue_is_functional_template__$5,
          __vue_module_identifier__$5,
          false,
          undefined,
          undefined,
          undefined
      );
  
      /**
       * Add any custom component as a leaflet control-zoom
       */
      var script$6 = {
          name: 'LControlZoom',
          mixins: [ControlMixin, Options],
          props: {
              zoomInText: {
                  type: String,
                  default: '+',
              },
              zoomInTitle: {
                  type: String,
                  default: 'Zoom in',
              },
              zoomOutText: {
                  type: String,
                  default: '-',
              },
              zoomOutTitle: {
                  type: String,
                  default: 'Zoom out',
              },
          },
          mounted: function mounted() {
              var this$1 = this;
  
              var options = optionsMerger(
                  Object.assign({}, this.controlOptions,
                      {zoomInText: this.zoomInText,
                          zoomInTitle: this.zoomInTitle,
                          zoomOutText: this.zoomOutText,
                          zoomOutTitle: this.zoomOutTitle}),
                  this
              );
              this.mapObject = leaflet.control.zoom(options);
              propsBinder(this, this.mapObject, this.$options.props);
              this.mapObject.addTo(this.$parent.mapObject);
              this.$nextTick(function () {
                  /**
                   * Triggers when the component is ready
                   * @type {object}
                   * @property {object} mapObject - reference to leaflet map object
                   */
                  this$1.$emit('ready', this$1.mapObject);
              });
          },
          render: function render() {
              return null;
          },
      };
  
      /* script */
      var __vue_script__$6 = script$6;
  
      /* template */
  
      /* style */
      var __vue_inject_styles__$6 = undefined;
      /* scoped */
      var __vue_scope_id__$6 = undefined;
      /* module identifier */
      var __vue_module_identifier__$6 = undefined;
      /* functional template */
      var __vue_is_functional_template__$6 = undefined;
      /* style inject */
  
      /* style inject SSR */
  
      /* style inject shadow dom */
  
  
  
      var __vue_component__$6 = /*#__PURE__*/normalizeComponent(
          {},
          __vue_inject_styles__$6,
          __vue_script__$6,
          __vue_scope_id__$6,
          __vue_is_functional_template__$6,
          __vue_module_identifier__$6,
          false,
          undefined,
          undefined,
          undefined
      );
  
      //
  
      /**
       * Group together elements of the maps  including: markers, geoJSON, polylines and polygon, tooltip and popup.
       */
      var script$7 = {
          name: 'LFeatureGroup',
          mixins: [LayerGroupMixin, Options],
          data: function data() {
              return {
                  ready: false,
              };
          },
          mounted: function mounted() {
              var this$1 = this;
  
              this.mapObject = leaflet.featureGroup();
              propsBinder(this, this.mapObject, this.$options.props);
              leaflet.DomEvent.on(this.mapObject, this.$listeners);
              this.ready = true;
              this.parentContainer = findRealParent(this.$parent);
              if (this.visible) {
                  this.parentContainer.addLayer(this);
              }
              this.$nextTick(function () {
                  /**
                   * Triggers when the component is ready
                   * @type {object}
                   * @property {object} mapObject - reference to leaflet map object
                   */
                  this$1.$emit('ready', this$1.mapObject);
              });
          },
      };
  
      /* script */
      var __vue_script__$7 = script$7;
  
      /* template */
      var __vue_render__$3 = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div',{staticStyle:{"display":"none"}},[(_vm.ready)?_vm._t("default"):_vm._e()],2)};
      var __vue_staticRenderFns__$3 = [];
  
      /* style */
      var __vue_inject_styles__$7 = undefined;
      /* scoped */
      var __vue_scope_id__$7 = undefined;
      /* module identifier */
      var __vue_module_identifier__$7 = undefined;
      /* functional template */
      var __vue_is_functional_template__$7 = false;
      /* style inject */
  
      /* style inject SSR */
  
      /* style inject shadow dom */
  
  
  
      var __vue_component__$7 = /*#__PURE__*/normalizeComponent(
          { render: __vue_render__$3, staticRenderFns: __vue_staticRenderFns__$3 },
          __vue_inject_styles__$7,
          __vue_script__$7,
          __vue_scope_id__$7,
          __vue_is_functional_template__$7,
          __vue_module_identifier__$7,
          false,
          undefined,
          undefined,
          undefined
      );
  
      /**
       * Easily display a geo-json on the map
       */
      var script$8 = {
          name: 'LGeoJson',
          mixins: [LayerGroupMixin, Options],
          props: {
              geojson: {
                  type: [Object, Array],
                  custom: true,
                  default: function () { return ({}); },
              },
              options: {
                  type: Object,
                  custom: true,
                  default: function () { return ({}); },
              },
              optionsStyle: {
                  type: [Object, Function],
                  custom: true,
                  default: null,
              },
          },
          computed: {
              mergedOptions: function mergedOptions() {
                  return optionsMerger(
                      Object.assign({}, this.layerGroupOptions,
                          {style: this.optionsStyle}),
                      this
                  );
              },
          },
          mounted: function mounted() {
              var this$1 = this;
  
              this.mapObject = leaflet.geoJSON(this.geojson, this.mergedOptions);
              leaflet.DomEvent.on(this.mapObject, this.$listeners);
              propsBinder(this, this.mapObject, this.$options.props);
              this.parentContainer = findRealParent(this.$parent);
              this.parentContainer.addLayer(this, !this.visible);
              this.$nextTick(function () {
                  /**
                   * Triggers when the component is ready
                   * @type {object}
                   * @property {object} mapObject - reference to leaflet map object
                   */
                  this$1.$emit('ready', this$1.mapObject);
              });
          },
          beforeDestroy: function beforeDestroy() {
              this.parentContainer.mapObject.removeLayer(this.mapObject);
          },
          methods: {
              setGeojson: function setGeojson(newVal) {
                  this.mapObject.clearLayers();
                  this.mapObject.addData(newVal);
              },
              getGeoJSONData: function getGeoJSONData() {
                  return this.mapObject.toGeoJSON();
              },
              getBounds: function getBounds() {
                  return this.mapObject.getBounds();
              },
              setOptions: function setOptions$1(newVal, oldVal) {
                  this.mapObject.clearLayers();
                  leaflet.setOptions(this.mapObject, this.mergedOptions);
                  this.mapObject.addData(this.geojson);
              },
              setOptionsStyle: function setOptionsStyle(newVal, oldVal) {
                  this.mapObject.setStyle(newVal);
              },
          },
          render: function render() {
              return null;
          },
      };
  
      /* script */
      var __vue_script__$8 = script$8;
  
      /* template */
  
      /* style */
      var __vue_inject_styles__$8 = undefined;
      /* scoped */
      var __vue_scope_id__$8 = undefined;
      /* module identifier */
      var __vue_module_identifier__$8 = undefined;
      /* functional template */
      var __vue_is_functional_template__$8 = undefined;
      /* style inject */
  
      /* style inject SSR */
  
      /* style inject shadow dom */
  
  
  
      var __vue_component__$8 = /*#__PURE__*/normalizeComponent(
          {},
          __vue_inject_styles__$8,
          __vue_script__$8,
          __vue_scope_id__$8,
          __vue_is_functional_template__$8,
          __vue_module_identifier__$8,
          false,
          undefined,
          undefined,
          undefined
      );
  
      //
  
      /**
       * Creates a map layer where each tile is an instantiated Vue component.
       * Each tile component is given `coords` props by `l-grid-layer` to indicate
       * the zoom level and position of the tile
       * (see https://leafletjs.com/examples/extending/extending-2-layers.html#lgridlayer-and-dom-elements).
       */
      var script$9 = {
          name: 'LGridLayer',
          mixins: [GridLayerMixin, Options],
  
          props: {
              tileComponent: {
                  type: Object,
                  custom: true,
                  required: true,
              },
          },
  
          data: function data() {
              return {
                  tileComponents: {},
              };
          },
  
          computed: {
              TileConstructor: function TileConstructor() {
                  return Vue.extend(this.tileComponent);
              },
          },
  
          mounted: function mounted() {
              var this$1 = this;
  
              var GLayer = leaflet.GridLayer.extend({});
              var options = optionsMerger(this.gridLayerOptions, this);
              this.mapObject = new GLayer(options);
              leaflet.DomEvent.on(this.mapObject, this.$listeners);
              this.mapObject.on('tileunload', this.onUnload, this);
              propsBinder(this, this.mapObject, this.$options.props);
              this.mapObject.createTile = this.createTile;
              this.parentContainer = findRealParent(this.$parent);
              this.parentContainer.addLayer(this, !this.visible);
              this.$nextTick(function () {
                  /**
                   * Triggers when the component is ready
                   * @type {object}
                   * @property {object} mapObject - reference to leaflet map object
                   */
                  this$1.$emit('ready', this$1.mapObject);
              });
          },
          beforeDestroy: function beforeDestroy() {
              this.parentContainer.removeLayer(this.mapObject);
              this.mapObject.off('tileunload', this.onUnload);
              this.mapObject = null;
          },
  
          methods: {
              createTile: function createTile(coords) {
                  var div = leaflet.DomUtil.create('div');
                  var dummy = leaflet.DomUtil.create('div');
                  div.appendChild(dummy);
  
                  var tileInstance = new this.TileConstructor({
                      el: dummy,
                      parent: this,
                      propsData: {
                          coords: coords,
                      },
                  });
  
                  var key = this.mapObject._tileCoordsToKey(coords);
                  this.tileComponents[key] = tileInstance;
  
                  return div;
              },
  
              onUnload: function onUnload(e) {
                  var key = this.mapObject._tileCoordsToKey(e.coords);
                  if (typeof this.tileComponents[key] !== 'undefined') {
                      this.tileComponents[key].$destroy();
                      this.tileComponents[key].$el.remove();
                      delete this.tileComponents[key];
                  }
              },
  
              setTileComponent: function setTileComponent(newVal) {
                  this.mapObject.redraw();
              },
          },
      };
  
      /* script */
      var __vue_script__$9 = script$9;
  
      /* template */
      var __vue_render__$4 = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div')};
      var __vue_staticRenderFns__$4 = [];
  
      /* style */
      var __vue_inject_styles__$9 = undefined;
      /* scoped */
      var __vue_scope_id__$9 = undefined;
      /* module identifier */
      var __vue_module_identifier__$9 = undefined;
      /* functional template */
      var __vue_is_functional_template__$9 = false;
      /* style inject */
  
      /* style inject SSR */
  
      /* style inject shadow dom */
  
  
  
      var __vue_component__$9 = /*#__PURE__*/normalizeComponent(
          { render: __vue_render__$4, staticRenderFns: __vue_staticRenderFns__$4 },
          __vue_inject_styles__$9,
          __vue_script__$9,
          __vue_scope_id__$9,
          __vue_is_functional_template__$9,
          __vue_module_identifier__$9,
          false,
          undefined,
          undefined,
          undefined
      );
  
      //
  
      /**
       * Easy and reactive way to configure the icon of a marker
       */
      var script$a = {
          name: 'LIcon',
          props: {
              iconUrl: {
                  type: String,
                  custom: true,
                  default: null,
              },
              iconRetinaUrl: {
                  type: String,
                  custom: true,
                  default: null,
              },
              iconSize: {
                  type: [Object, Array],
                  custom: true,
                  default: null,
              },
              iconAnchor: {
                  type: [Object, Array],
                  custom: true,
                  default: null,
              },
              popupAnchor: {
                  type: [Object, Array],
                  custom: true,
                  default: function () { return [0, 0]; },
              },
              tooltipAnchor: {
                  type: [Object, Array],
                  custom: true,
                  default: function () { return [0, 0]; },
              },
              shadowUrl: {
                  type: String,
                  custom: true,
                  default: null,
              },
              shadowRetinaUrl: {
                  type: String,
                  custom: true,
                  default: null,
              },
              shadowSize: {
                  type: [Object, Array],
                  custom: true,
                  default: null,
              },
              shadowAnchor: {
                  type: [Object, Array],
                  custom: true,
                  default: null,
              },
              bgPos: {
                  type: [Object, Array],
                  custom: true,
                  default: function () { return [0, 0]; },
              },
              className: {
                  type: String,
                  custom: true,
                  default: '',
              },
              options: {
                  type: Object,
                  custom: true,
                  default: function () { return ({}); },
              },
          },
  
          data: function data() {
              return {
                  parentContainer: null,
                  observer: null,
                  recreationNeeded: false,
                  swapHtmlNeeded: false,
              };
          },
  
          mounted: function mounted() {
              var this$1 = this;
  
              this.parentContainer = findRealParent(this.$parent);
              if (!this.parentContainer) {
                  throw new Error('No parent container with mapObject found for LIcon');
              }
              propsBinder(this, this.parentContainer.mapObject, this.$options.props);
  
              this.observer = new MutationObserver(function () {
                  this$1.scheduleHtmlSwap();
              });
              this.observer.observe(this.$el, {
                  attributes: true,
                  childList: true,
                  characterData: true,
                  subtree: true,
              });
              this.scheduleCreateIcon();
          },
  
          beforeDestroy: function beforeDestroy() {
              if (this.parentContainer.mapObject) {
                  this.parentContainer.mapObject.setIcon(this.parentContainer.$props.icon);
              }
  
              this.observer.disconnect();
          },
  
          methods: {
              scheduleCreateIcon: function scheduleCreateIcon() {
                  this.recreationNeeded = true;
  
                  this.$nextTick(this.createIcon);
              },
  
              scheduleHtmlSwap: function scheduleHtmlSwap() {
                  this.htmlSwapNeeded = true;
  
                  this.$nextTick(this.createIcon);
              },
  
              createIcon: function createIcon() {
                  // If only html of a divIcon changed, we can just replace the DOM without the need of recreating the whole icon
                  if (
                      this.htmlSwapNeeded &&
                      !this.recreationNeeded &&
                      this.iconObject &&
                      this.parentContainer.mapObject.getElement()
                  ) {
                      this.parentContainer.mapObject.getElement().innerHTML = this.$el.innerHTML;
  
                      this.htmlSwapNeeded = false;
                      return;
                  }
  
                  if (!this.recreationNeeded) {
                      return;
                  }
  
                  if (this.iconObject) {
                      leaflet.DomEvent.off(this.iconObject, this.$listeners);
                  }
  
                  var options = optionsMerger(
                      {
                          iconUrl: this.iconUrl,
                          iconRetinaUrl: this.iconRetinaUrl,
                          iconSize: this.iconSize,
                          iconAnchor: this.iconAnchor,
                          popupAnchor: this.popupAnchor,
                          tooltipAnchor: this.tooltipAnchor,
                          shadowUrl: this.shadowUrl,
                          shadowRetinaUrl: this.shadowRetinaUrl,
                          shadowSize: this.shadowSize,
                          shadowAnchor: this.shadowAnchor,
                          bgPos: this.bgPos,
                          className: this.className,
                          html: this.$el.innerHTML || this.html,
                      },
                      this
                  );
  
                  if (options.html) {
                      this.iconObject = leaflet.divIcon(options);
                  } else {
                      this.iconObject = leaflet.icon(options);
                  }
  
                  leaflet.DomEvent.on(this.iconObject, this.$listeners);
  
                  this.parentContainer.mapObject.setIcon(this.iconObject);
  
                  this.recreationNeeded = false;
                  this.htmlSwapNeeded = false;
              },
  
              setIconUrl: function setIconUrl() {
                  this.scheduleCreateIcon();
              },
              setIconRetinaUrl: function setIconRetinaUrl() {
                  this.scheduleCreateIcon();
              },
              setIconSize: function setIconSize() {
                  this.scheduleCreateIcon();
              },
              setIconAnchor: function setIconAnchor() {
                  this.scheduleCreateIcon();
              },
              setPopupAnchor: function setPopupAnchor() {
                  this.scheduleCreateIcon();
              },
              setTooltipAnchor: function setTooltipAnchor() {
                  this.scheduleCreateIcon();
              },
              setShadowUrl: function setShadowUrl() {
                  this.scheduleCreateIcon();
              },
              setShadowRetinaUrl: function setShadowRetinaUrl() {
                  this.scheduleCreateIcon();
              },
              setShadowAnchor: function setShadowAnchor() {
                  this.scheduleCreateIcon();
              },
              setBgPos: function setBgPos() {
                  this.scheduleCreateIcon();
              },
              setClassName: function setClassName() {
                  this.scheduleCreateIcon();
              },
              setHtml: function setHtml() {
                  this.scheduleCreateIcon();
              },
          },
  
          render: function render() {
              return null;
          },
      };
  
      /* script */
      var __vue_script__$a = script$a;
  
      /* template */
      var __vue_render__$5 = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div',[_vm._t("default")],2)};
      var __vue_staticRenderFns__$5 = [];
  
      /* style */
      var __vue_inject_styles__$a = undefined;
      /* scoped */
      var __vue_scope_id__$a = undefined;
      /* module identifier */
      var __vue_module_identifier__$a = undefined;
      /* functional template */
      var __vue_is_functional_template__$a = false;
      /* style inject */
  
      /* style inject SSR */
  
      /* style inject shadow dom */
  
  
  
      var __vue_component__$a = /*#__PURE__*/normalizeComponent(
          { render: __vue_render__$5, staticRenderFns: __vue_staticRenderFns__$5 },
          __vue_inject_styles__$a,
          __vue_script__$a,
          __vue_scope_id__$a,
          __vue_is_functional_template__$a,
          __vue_module_identifier__$a,
          false,
          undefined,
          undefined,
          undefined
      );
  
      /**
       * Set a default icon
       * @deprecated since version 2.0
       */
      var script$b = {
          name: 'LIconDefault',
          props: {
              imagePath: {
                  type: String,
                  custom: true,
                  default: '',
              },
          },
          mounted: function mounted() {
              leaflet.Icon.Default.imagePath = this.imagePath;
              propsBinder(this, {}, this.$options.props);
          },
          methods: {
              setImagePath: function setImagePath(newVal) {
                  leaflet.Icon.Default.imagePath = newVal;
              },
          },
          render: function render() {
              return null;
          },
      };
  
      /* script */
      var __vue_script__$b = script$b;
  
      /* template */
  
      /* style */
      var __vue_inject_styles__$b = undefined;
      /* scoped */
      var __vue_scope_id__$b = undefined;
      /* module identifier */
      var __vue_module_identifier__$b = undefined;
      /* functional template */
      var __vue_is_functional_template__$b = undefined;
      /* style inject */
  
      /* style inject SSR */
  
      /* style inject shadow dom */
  
  
  
      var __vue_component__$b = /*#__PURE__*/normalizeComponent(
          {},
          __vue_inject_styles__$b,
          __vue_script__$b,
          __vue_scope_id__$b,
          __vue_is_functional_template__$b,
          __vue_module_identifier__$b,
          false,
          undefined,
          undefined,
          undefined
      );
  
      /**
       * Easily display a image overlay.
       */
      var script$c = {
          name: 'LImageOverlay',
          mixins: [ImageOverlayMixin, Options],
          mounted: function mounted() {
              var this$1 = this;
  
              var options = optionsMerger(this.imageOverlayOptions, this);
              this.mapObject = leaflet.imageOverlay(this.url, this.bounds, options);
              leaflet.DomEvent.on(this.mapObject, this.$listeners);
              propsBinder(this, this.mapObject, this.$options.props);
              this.parentContainer = findRealParent(this.$parent);
              this.parentContainer.addLayer(this, !this.visible);
              this.$nextTick(function () {
                  /**
                   * Triggers when the component is ready
                   * @type {object}
                   * @property {object} mapObject - reference to leaflet map object
                   */
                  this$1.$emit('ready', this$1.mapObject);
              });
          },
          render: function render() {
              return null;
          },
      };
  
      /* script */
      var __vue_script__$c = script$c;
  
      /* template */
  
      /* style */
      var __vue_inject_styles__$c = undefined;
      /* scoped */
      var __vue_scope_id__$c = undefined;
      /* module identifier */
      var __vue_module_identifier__$c = undefined;
      /* functional template */
      var __vue_is_functional_template__$c = undefined;
      /* style inject */
  
      /* style inject SSR */
  
      /* style inject shadow dom */
  
  
  
      var __vue_component__$c = /*#__PURE__*/normalizeComponent(
          {},
          __vue_inject_styles__$c,
          __vue_script__$c,
          __vue_scope_id__$c,
          __vue_is_functional_template__$c,
          __vue_module_identifier__$c,
          false,
          undefined,
          undefined,
          undefined
      );
  
      //
  
      /**
       * Group together elements of the maps  including: markers, geoJSON, polylines and polygon, tooltip and popup.
       */
      var script$d = {
          name: 'LLayerGroup',
          mixins: [LayerGroupMixin, Options],
          data: function data() {
              return {
                  ready: false,
              };
          },
          mounted: function mounted() {
              var this$1 = this;
  
              this.mapObject = leaflet.layerGroup();
              propsBinder(this, this.mapObject, this.$options.props);
              leaflet.DomEvent.on(this.mapObject, this.$listeners);
              this.ready = true;
              this.parentContainer = findRealParent(this.$parent);
              if (this.visible) {
                  this.parentContainer.addLayer(this);
              }
              this.$nextTick(function () {
                  /**
                   * Triggers when the component is ready
                   * @type {object}
                   * @property {object} mapObject - reference to leaflet map object
                   */
                  this$1.$emit('ready', this$1.mapObject);
              });
          },
      };
  
      /* script */
      var __vue_script__$d = script$d;
  
      /* template */
      var __vue_render__$6 = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div',{staticStyle:{"display":"none"}},[(_vm.ready)?_vm._t("default"):_vm._e()],2)};
      var __vue_staticRenderFns__$6 = [];
  
      /* style */
      var __vue_inject_styles__$d = undefined;
      /* scoped */
      var __vue_scope_id__$d = undefined;
      /* module identifier */
      var __vue_module_identifier__$d = undefined;
      /* functional template */
      var __vue_is_functional_template__$d = false;
      /* style inject */
  
      /* style inject SSR */
  
      /* style inject shadow dom */
  
  
  
      var __vue_component__$d = /*#__PURE__*/normalizeComponent(
          { render: __vue_render__$6, staticRenderFns: __vue_staticRenderFns__$6 },
          __vue_inject_styles__$d,
          __vue_script__$d,
          __vue_scope_id__$d,
          __vue_is_functional_template__$d,
          __vue_module_identifier__$d,
          false,
          undefined,
          undefined,
          undefined
      );
  
      //
  
      /**
       * Base component, contains and wrap all the other components.
       */
      var script$e = {
          name: 'LMap',
          mixins: [Options],
          props: {
              /**
               * The center of the map, supports .sync modifier
               */
              center: {
                  type: [Object, Array],
                  custom: true,
                  default: function () { return [0, 0]; },
              },
              /**
               * The bounds of the map, supports .sync modifier
               */
              bounds: {
                  type: [Array, Object],
                  custom: true,
                  default: null,
              },
              /**
               * The max bounds of the map
               */
              maxBounds: {
                  type: [Array, Object],
                  default: null,
              },
              /**
               * The zoom of the map, supports .sync modifier
               */
              zoom: {
                  type: Number,
                  custom: true,
                  default: 0,
              },
              /**
               * The minZoom of the map
               */
              minZoom: {
                  type: Number,
                  default: null,
              },
              /**
               * The maxZoom of the map
               */
              maxZoom: {
                  type: Number,
                  default: null,
              },
              /**
               * The paddingBottomRight of the map
               */
              paddingBottomRight: {
                  type: Array,
                  custom: true,
                  default: null,
              },
              /**
               * The paddingTopLeft of the map
               */
              paddingTopLeft: {
                  type: Array,
                  custom: true,
                  default: null,
              },
              /**
               * The padding of the map
               */
              padding: {
                  type: Array,
                  custom: true,
                  default: null,
              },
              /**
               * The worldCopyJump option for the map
               */
              worldCopyJump: {
                  type: Boolean,
                  default: false,
              },
              /**
               * The crs option for the map
               * @values CRS.EPSG3857
               */
              crs: {
                  type: Object,
                  custom: true,
                  default: function () { return leaflet.CRS.EPSG3857; },
              },
              maxBoundsViscosity: {
                  type: Number,
                  default: null,
              },
              inertia: {
                  type: Boolean,
                  default: null,
              },
              inertiaDeceleration: {
                  type: Number,
                  default: null,
              },
              inertiaMaxSpeed: {
                  type: Number,
                  default: null,
              },
              easeLinearity: {
                  type: Number,
                  default: null,
              },
              zoomAnimation: {
                  type: Boolean,
                  default: null,
              },
              zoomAnimationThreshold: {
                  type: Number,
                  default: null,
              },
              fadeAnimation: {
                  type: Boolean,
                  default: null,
              },
              markerZoomAnimation: {
                  type: Boolean,
                  default: null,
              },
              noBlockingAnimations: {
                  type: Boolean,
                  default: false,
              },
          },
          data: function data() {
              return {
                  ready: false,
                  lastSetCenter: this.center ? leaflet.latLng(this.center) : null,
                  lastSetBounds: this.bounds ? leaflet.latLngBounds(this.bounds) : null,
                  layerControl: undefined,
                  layersToAdd: [],
                  layersInControl: [],
              };
          },
          computed: {
              fitBoundsOptions: function fitBoundsOptions() {
                  var options = {
                      animate: this.noBlockingAnimations ? false : null,
                  };
                  if (this.padding) {
                      options.padding = this.padding;
                  } else {
                      if (this.paddingBottomRight) {
                          options.paddingBottomRight = this.paddingBottomRight;
                      }
                      if (this.paddingTopLeft) {
                          options.paddingTopLeft = this.paddingTopLeft;
                      }
                  }
                  return options;
              },
          },
          beforeDestroy: function beforeDestroy() {
              if (this.debouncedMoveEndHandler) {
                  this.debouncedMoveEndHandler.cancel();
              }
  
              if (this.mapObject) {
                  this.mapObject.remove();
              }
          },
          mounted: function mounted() {
              var this$1 = this;
  
              var options = optionsMerger(
                  {
                      minZoom: this.minZoom,
                      maxZoom: this.maxZoom,
                      maxBounds: this.maxBounds,
                      maxBoundsViscosity: this.maxBoundsViscosity,
                      worldCopyJump: this.worldCopyJump,
                      crs: this.crs,
                      center: this.center,
                      zoom: this.zoom,
                      inertia: this.inertia,
                      inertiaDeceleration: this.inertiaDeceleration,
                      inertiaMaxSpeed: this.inertiaMaxSpeed,
                      easeLinearity: this.easeLinearity,
                      zoomAnimation: this.zoomAnimation,
                      zoomAnimationThreshold: this.zoomAnimationThreshold,
                      fadeAnimation: this.fadeAnimation,
                      markerZoomAnimation: this.markerZoomAnimation,
                  },
                  this
              );
              this.mapObject = leaflet.map(this.$el, options);
              if (this.bounds) {
                  this.fitBounds(this.bounds);
              }
              this.debouncedMoveEndHandler = debounce(this.moveEndHandler, 100);
              this.mapObject.on('moveend', this.debouncedMoveEndHandler);
              this.mapObject.on('overlayadd', this.overlayAddHandler);
              this.mapObject.on('overlayremove', this.overlayRemoveHandler);
              leaflet.DomEvent.on(this.mapObject, this.$listeners);
              propsBinder(this, this.mapObject, this.$options.props);
              this.ready = true;
              /**
               * DEPRECATED event
               * @deprecated
               */
              this.$emit('leaflet:load');
              this.$nextTick(function () {
                  /**
                   * Triggers when the component is ready
                   * @type {object}
                   * @property {object} mapObject - reference to leaflet map object
                   */
                  this$1.$emit('ready', this$1.mapObject);
              });
          },
          methods: {
              registerLayerControl: function registerLayerControl(lControlLayers) {
                  var this$1 = this;
  
                  this.layerControl = lControlLayers;
                  this.mapObject.addControl(lControlLayers.mapObject);
                  this.layersToAdd.forEach(function (layer) {
                      this$1.layerControl.addLayer(layer);
                  });
                  this.layersToAdd = [];
              },
              addLayer: function addLayer(layer, alreadyAdded) {
                  if (layer.layerType !== undefined) {
                      if (this.layerControl === undefined) {
                          this.layersToAdd.push(layer);
                      } else {
                          var exist = this.layersInControl.find(
                              function (l) { return l.mapObject._leaflet_id === layer.mapObject._leaflet_id; }
                          );
                          if (!exist) {
                              this.layerControl.addLayer(layer);
                              this.layersInControl.push(layer);
                          }
                      }
                  }
                  if (!alreadyAdded && layer.visible !== false) {
                      this.mapObject.addLayer(layer.mapObject);
                  }
              },
              hideLayer: function hideLayer(layer) {
                  this.mapObject.removeLayer(layer.mapObject);
              },
              removeLayer: function removeLayer(layer, alreadyRemoved) {
                  if (layer.layerType !== undefined) {
                      if (this.layerControl === undefined) {
                          this.layersToAdd = this.layersToAdd.filter(
                              function (l) { return l.name !== layer.name; }
                          );
                      } else {
                          this.layerControl.removeLayer(layer);
                          this.layersInControl = this.layersInControl.filter(
                              function (l) { return l.mapObject._leaflet_id !== layer.mapObject._leaflet_id; }
                          );
                      }
                  }
                  if (!alreadyRemoved) {
                      this.mapObject.removeLayer(layer.mapObject);
                  }
              },
              setZoom: function setZoom(newVal, oldVal) {
                  if (newVal === undefined || newVal === null) { return; }
                  this.mapObject.setZoom(newVal, {
                      animate: this.noBlockingAnimations ? false : null,
                  });
                  this.cacheMapView();
              },
              setCenter: function setCenter(newVal, oldVal) {
                  if (newVal == null) {
                      return;
                  }
                  var newCenter = leaflet.latLng(newVal);
                  var oldCenter = this.lastSetCenter || this.mapObject.getCenter();
                  if (oldCenter.lat !== newCenter.lat || oldCenter.lng !== newCenter.lng) {
                      this.lastSetCenter = newCenter;
                      this.mapObject.panTo(newCenter, {
                          animate: this.noBlockingAnimations ? false : null,
                      });
                      this.cacheMapView(undefined, newCenter);
                  }
              },
              setBounds: function setBounds(newVal, oldVal) {
                  if (!newVal) {
                      return;
                  }
                  var newBounds = leaflet.latLngBounds(newVal);
                  if (!newBounds.isValid()) {
                      return;
                  }
                  var oldBounds = this.lastSetBounds || this.mapObject.getBounds();
                  var boundsChanged = !oldBounds.equals(newBounds, 0); // set maxMargin to 0 - check exact equals
                  if (boundsChanged) {
                      this.fitBounds(newBounds);
                      this.cacheMapView(newBounds);
                  }
              },
              setPaddingBottomRight: function setPaddingBottomRight(newVal, oldVal) {
                  this.paddingBottomRight = newVal;
              },
              setPaddingTopLeft: function setPaddingTopLeft(newVal, oldVal) {
                  this.paddingTopLeft = newVal;
              },
              setPadding: function setPadding(newVal, oldVal) {
                  this.padding = newVal;
              },
              setCrs: function setCrs(newVal, oldVal) {
                  var mapObject = this.mapObject,
                      prevBounds = mapObject.getBounds();
                  mapObject.options.crs = newVal;
                  this.fitBounds(prevBounds, { animate: false });
              },
              fitBounds: function fitBounds(bounds, overrideOptions) {
                  this.mapObject.fitBounds(bounds, Object.assign({}, this.fitBoundsOptions, overrideOptions));
              },
              moveEndHandler: function moveEndHandler() {
                  /**
                   * Triggers when zoom is updated
                   * @type {number,string}
                   */
                  this.$emit('update:zoom', this.mapObject.getZoom());
                  var center = this.mapObject.getCenter();
                  /**
                   * Triggers when center is updated
                   * @type {object,array}
                   */
                  this.$emit('update:center', center);
                  var bounds = this.mapObject.getBounds();
                  /**
                   * Triggers when bounds are updated
                   * @type {object}
                   */
                  this.$emit('update:bounds', bounds);
              },
              overlayAddHandler: function overlayAddHandler(e) {
                  var layer = this.layersInControl.find(function (l) { return l.name === e.name; });
                  if (layer) {
                      layer.updateVisibleProp(true);
                  }
              },
              overlayRemoveHandler: function overlayRemoveHandler(e) {
                  var layer = this.layersInControl.find(function (l) { return l.name === e.name; });
                  if (layer) {
                      layer.updateVisibleProp(false);
                  }
              },
              cacheMapView: function cacheMapView(bounds, center) {
                  // Cache the last values used to define the map view by mutating props.
                  this.lastSetBounds = bounds || this.mapObject.getBounds();
                  this.lastSetCenter = center || this.lastSetBounds.getCenter();
              },
          },
      };
  
      var isOldIE = typeof navigator !== 'undefined' &&
          /msie [6-9]\\b/.test(navigator.userAgent.toLowerCase());
      function createInjector(context) {
          return function (id, style) { return addStyle(id, style); };
      }
      var HEAD;
      var styles = {};
      function addStyle(id, css) {
          var group = isOldIE ? css.media || 'default' : id;
          var style = styles[group] || (styles[group] = { ids: new Set(), styles: [] });
          if (!style.ids.has(id)) {
              style.ids.add(id);
              var code = css.source;
              if (css.map) {
                  // https://developer.chrome.com/devtools/docs/javascript-debugging
                  // this makes source maps inside style tags work properly in Chrome
                  code += '\n/*# sourceURL=' + css.map.sources[0] + ' */';
                  // http://stackoverflow.com/a/26603875
                  code +=
                      '\n/*# sourceMappingURL=data:application/json;base64,' +
                      btoa(unescape(encodeURIComponent(JSON.stringify(css.map)))) +
                      ' */';
              }
              if (!style.element) {
                  style.element = document.createElement('style');
                  style.element.type = 'text/css';
                  if (css.media)
                  { style.element.setAttribute('media', css.media); }
                  if (HEAD === undefined) {
                      HEAD = document.head || document.getElementsByTagName('head')[0];
                  }
                  HEAD.appendChild(style.element);
              }
              if ('styleSheet' in style.element) {
                  style.styles.push(code);
                  style.element.styleSheet.cssText = style.styles
                      .filter(Boolean)
                      .join('\n');
              }
              else {
                  var index = style.ids.size - 1;
                  var textNode = document.createTextNode(code);
                  var nodes = style.element.childNodes;
                  if (nodes[index])
                  { style.element.removeChild(nodes[index]); }
                  if (nodes.length)
                  { style.element.insertBefore(textNode, nodes[index]); }
                  else
                  { style.element.appendChild(textNode); }
              }
          }
      }
  
      /* script */
      var __vue_script__$e = script$e;
  
      /* template */
      var __vue_render__$7 = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div',{staticClass:"vue2leaflet-map"},[(_vm.ready)?_vm._t("default"):_vm._e()],2)};
      var __vue_staticRenderFns__$7 = [];
  
      /* style */
      var __vue_inject_styles__$e = function (inject) {
          if (!inject) { return }
          inject("data-v-09f270aa_0", { source: ".vue2leaflet-map{height:100%;width:100%}", map: undefined, media: undefined });
  
      };
      /* scoped */
      var __vue_scope_id__$e = undefined;
      /* module identifier */
      var __vue_module_identifier__$e = undefined;
      /* functional template */
      var __vue_is_functional_template__$e = false;
      /* style inject SSR */
  
      /* style inject shadow dom */
  
  
  
      var __vue_component__$e = /*#__PURE__*/normalizeComponent(
          { render: __vue_render__$7, staticRenderFns: __vue_staticRenderFns__$7 },
          __vue_inject_styles__$e,
          __vue_script__$e,
          __vue_scope_id__$e,
          __vue_is_functional_template__$e,
          __vue_module_identifier__$e,
          false,
          createInjector,
          undefined,
          undefined
      );
  
      /**
       * Marker component, lets you add and personalize markers on the map
       */
      var script$f = {
          name: 'LMarker',
          mixins: [Layer, Options],
          props: {
              pane: {
                  type: String,
                  default: 'markerPane',
              },
              draggable: {
                  type: Boolean,
                  custom: true,
                  default: false,
              },
              latLng: {
                  type: [Object, Array],
                  custom: true,
                  default: null,
              },
              icon: {
                  type: [Object],
                  custom: false,
                  default: function () { return new leaflet.Icon.Default(); },
              },
              opacity: {
                  type: Number,
                  custom: false,
                  default: 1.0,
              },
              zIndexOffset: {
                  type: Number,
                  custom: false,
                  default: null,
              },
          },
          data: function data() {
              return {
                  ready: false,
              };
          },
          beforeDestroy: function beforeDestroy() {
              if (this.debouncedLatLngSync) {
                  this.debouncedLatLngSync.cancel();
              }
          },
          mounted: function mounted() {
              var this$1 = this;
  
              var options = optionsMerger(
                  Object.assign({}, this.layerOptions,
                      {icon: this.icon,
                          zIndexOffset: this.zIndexOffset,
                          draggable: this.draggable,
                          opacity: this.opacity}),
                  this
              );
              this.mapObject = leaflet.marker(this.latLng, options);
              leaflet.DomEvent.on(this.mapObject, this.$listeners);
              this.debouncedLatLngSync = debounce(this.latLngSync, 100);
              this.mapObject.on('move', this.debouncedLatLngSync);
              propsBinder(this, this.mapObject, this.$options.props);
              this.parentContainer = findRealParent(this.$parent);
              this.parentContainer.addLayer(this, !this.visible);
              this.ready = true;
              this.$nextTick(function () {
                  /**
                   * Triggers when the component is ready
                   * @type {object}
                   * @property {object} mapObject - reference to leaflet map object
                   */
                  this$1.$emit('ready', this$1.mapObject);
              });
          },
          methods: {
              setDraggable: function setDraggable(newVal, oldVal) {
                  if (this.mapObject.dragging) {
                      newVal
                          ? this.mapObject.dragging.enable()
                          : this.mapObject.dragging.disable();
                  }
              },
              setLatLng: function setLatLng(newVal) {
                  if (newVal == null) {
                      return;
                  }
  
                  if (this.mapObject) {
                      var oldLatLng = this.mapObject.getLatLng();
                      var newLatLng = leaflet.latLng(newVal);
                      if (
                          newLatLng.lat !== oldLatLng.lat ||
                          newLatLng.lng !== oldLatLng.lng
                      ) {
                          this.mapObject.setLatLng(newLatLng);
                      }
                  }
              },
              latLngSync: function latLngSync(event) {
                  this.$emit('update:latLng', event.latlng);
                  this.$emit('update:lat-lng', event.latlng);
              },
          },
          render: function(h) {
              if (this.ready && this.$slots.default) {
                  return h('div', { style: { display: 'none' } }, this.$slots.default);
              }
              return null;
          },
      };
  
      /* script */
      var __vue_script__$f = script$f;
  
      /* template */
  
      /* style */
      var __vue_inject_styles__$f = undefined;
      /* scoped */
      var __vue_scope_id__$f = undefined;
      /* module identifier */
      var __vue_module_identifier__$f = undefined;
      /* functional template */
      var __vue_is_functional_template__$f = undefined;
      /* style inject */
  
      /* style inject SSR */
  
      /* style inject shadow dom */
  
  
  
      var __vue_component__$f = /*#__PURE__*/normalizeComponent(
          {},
          __vue_inject_styles__$f,
          __vue_script__$f,
          __vue_scope_id__$f,
          __vue_is_functional_template__$f,
          __vue_module_identifier__$f,
          false,
          undefined,
          undefined,
          undefined
      );
  
      //
  
      /**
       * Easily draw a polygon on the map
       */
      var script$g = {
          name: 'LPolygon',
          mixins: [Polygon, Options],
          props: {
              latLngs: {
                  type: Array,
                  default: function () { return []; },
              },
          },
          data: function data() {
              return {
                  ready: false,
              };
          },
          mounted: function mounted() {
              var this$1 = this;
  
              var options = optionsMerger(this.polygonOptions, this);
              this.mapObject = leaflet.polygon(this.latLngs, options);
              leaflet.DomEvent.on(this.mapObject, this.$listeners);
              propsBinder(this, this.mapObject, this.$options.props);
              this.ready = true;
              this.parentContainer = findRealParent(this.$parent);
              this.parentContainer.addLayer(this, !this.visible);
              this.$nextTick(function () {
                  /**
                   * Triggers when the component is ready
                   * @type {object}
                   * @property {object} mapObject - reference to leaflet map object
                   */
                  this$1.$emit('ready', this$1.mapObject);
              });
          },
      };
  
      /* script */
      var __vue_script__$g = script$g;
  
      /* template */
      var __vue_render__$8 = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div',{staticStyle:{"display":"none"}},[(_vm.ready)?_vm._t("default"):_vm._e()],2)};
      var __vue_staticRenderFns__$8 = [];
  
      /* style */
      var __vue_inject_styles__$g = undefined;
      /* scoped */
      var __vue_scope_id__$g = undefined;
      /* module identifier */
      var __vue_module_identifier__$g = undefined;
      /* functional template */
      var __vue_is_functional_template__$g = false;
      /* style inject */
  
      /* style inject SSR */
  
      /* style inject shadow dom */
  
  
  
      var __vue_component__$g = /*#__PURE__*/normalizeComponent(
          { render: __vue_render__$8, staticRenderFns: __vue_staticRenderFns__$8 },
          __vue_inject_styles__$g,
          __vue_script__$g,
          __vue_scope_id__$g,
          __vue_is_functional_template__$g,
          __vue_module_identifier__$g,
          false,
          undefined,
          undefined,
          undefined
      );
  
      //
  
      /**
       * Easily draw a polyline on the map
       */
      var script$h = {
          name: 'LPolyline',
          mixins: [PolylineMixin, Options],
          props: {
              latLngs: {
                  type: Array,
                  default: function () { return []; },
              },
          },
          data: function data() {
              return {
                  ready: false,
              };
          },
          mounted: function mounted() {
              var this$1 = this;
  
              var options = optionsMerger(this.polyLineOptions, this);
              this.mapObject = leaflet.polyline(this.latLngs, options);
              leaflet.DomEvent.on(this.mapObject, this.$listeners);
              propsBinder(this, this.mapObject, this.$options.props);
              this.ready = true;
              this.parentContainer = findRealParent(this.$parent);
              this.parentContainer.addLayer(this, !this.visible);
              this.$nextTick(function () {
                  /**
                   * Triggers when the component is ready
                   * @type {object}
                   * @property {object} mapObject - reference to leaflet map object
                   */
                  this$1.$emit('ready', this$1.mapObject);
              });
          },
      };
  
      /* script */
      var __vue_script__$h = script$h;
  
      /* template */
      var __vue_render__$9 = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div',{staticStyle:{"display":"none"}},[(_vm.ready)?_vm._t("default"):_vm._e()],2)};
      var __vue_staticRenderFns__$9 = [];
  
      /* style */
      var __vue_inject_styles__$h = undefined;
      /* scoped */
      var __vue_scope_id__$h = undefined;
      /* module identifier */
      var __vue_module_identifier__$h = undefined;
      /* functional template */
      var __vue_is_functional_template__$h = false;
      /* style inject */
  
      /* style inject SSR */
  
      /* style inject shadow dom */
  
  
  
      var __vue_component__$h = /*#__PURE__*/normalizeComponent(
          { render: __vue_render__$9, staticRenderFns: __vue_staticRenderFns__$9 },
          __vue_inject_styles__$h,
          __vue_script__$h,
          __vue_scope_id__$h,
          __vue_is_functional_template__$h,
          __vue_module_identifier__$h,
          false,
          undefined,
          undefined,
          undefined
      );
  
      /**
       * Display a popup on the map
       */
      var script$i = {
          name: 'LPopup',
          mixins: [Popper, Options],
          props: {
              latLng: {
                  type: [Object, Array],
                  default: function () { return []; },
              },
          },
          mounted: function mounted() {
              var this$1 = this;
  
              var options = optionsMerger(this.popperOptions, this);
              this.mapObject = leaflet.popup(options);
              if (this.latLng !== undefined) {
                  this.mapObject.setLatLng(this.latLng);
              }
              leaflet.DomEvent.on(this.mapObject, this.$listeners);
              propsBinder(this, this.mapObject, this.$options.props);
              this.mapObject.setContent(this.content || this.$el);
              this.parentContainer = findRealParent(this.$parent);
              this.parentContainer.mapObject.bindPopup(this.mapObject);
              this.$nextTick(function () {
                  /**
                   * Triggers when the component is ready
                   * @type {object}
                   * @property {object} mapObject - reference to leaflet map object
                   */
                  this$1.$emit('ready', this$1.mapObject);
              });
          },
          beforeDestroy: function beforeDestroy() {
              if (this.parentContainer) {
                  if (this.parentContainer.unbindPopup) {
                      this.parentContainer.unbindPopup();
                  } else if (
                      this.parentContainer.mapObject &&
                      this.parentContainer.mapObject.unbindPopup
                  ) {
                      this.parentContainer.mapObject.unbindPopup();
                  }
              }
          },
      };
  
      /* script */
      var __vue_script__$i = script$i;
  
      /* template */
  
      /* style */
      var __vue_inject_styles__$i = undefined;
      /* scoped */
      var __vue_scope_id__$i = undefined;
      /* module identifier */
      var __vue_module_identifier__$i = undefined;
      /* functional template */
      var __vue_is_functional_template__$i = undefined;
      /* style inject */
  
      /* style inject SSR */
  
      /* style inject shadow dom */
  
  
  
      var __vue_component__$i = /*#__PURE__*/normalizeComponent(
          {},
          __vue_inject_styles__$i,
          __vue_script__$i,
          __vue_scope_id__$i,
          __vue_is_functional_template__$i,
          __vue_module_identifier__$i,
          false,
          undefined,
          undefined,
          undefined
      );
  
      //
  
      /**
       * Easily draw a rectangle on the map
       */
      var script$j = {
          name: 'LRectangle',
          mixins: [Polygon, Options],
          props: {
              bounds: {
                  default: function () { return [[0,0],[0,0]]; },
                  validator: function (value) { return value && leaflet.latLngBounds(value).isValid(); },
              },
          },
          data: function data() {
              return {
                  ready: false,
              };
          },
          mounted: function mounted() {
              var this$1 = this;
  
              var options = optionsMerger(this.polygonOptions, this);
              this.mapObject = leaflet.rectangle(this.bounds, options);
              leaflet.DomEvent.on(this.mapObject, this.$listeners);
              propsBinder(this, this.mapObject, this.$options.props);
              this.ready = true;
              this.parentContainer = findRealParent(this.$parent);
              this.parentContainer.addLayer(this, !this.visible);
              this.$nextTick(function () {
                  /**
                   * Triggers when the component is ready
                   * @type {object}
                   * @property {object} mapObject - reference to leaflet map object
                   */
                  this$1.$emit('ready', this$1.mapObject);
              });
          },
      };
  
      /* script */
      var __vue_script__$j = script$j;
  
      /* template */
      var __vue_render__$a = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div',{staticStyle:{"display":"none"}},[(_vm.ready)?_vm._t("default"):_vm._e()],2)};
      var __vue_staticRenderFns__$a = [];
  
      /* style */
      var __vue_inject_styles__$j = undefined;
      /* scoped */
      var __vue_scope_id__$j = undefined;
      /* module identifier */
      var __vue_module_identifier__$j = undefined;
      /* functional template */
      var __vue_is_functional_template__$j = false;
      /* style inject */
  
      /* style inject SSR */
  
      /* style inject shadow dom */
  
  
  
      var __vue_component__$j = /*#__PURE__*/normalizeComponent(
          { render: __vue_render__$a, staticRenderFns: __vue_staticRenderFns__$a },
          __vue_inject_styles__$j,
          __vue_script__$j,
          __vue_scope_id__$j,
          __vue_is_functional_template__$j,
          __vue_module_identifier__$j,
          false,
          undefined,
          undefined,
          undefined
      );
  
      //
  
      /**
       * Load tiles from a map server and display them accordingly to map zoom, center and size
       */
      var script$k = {
          name: 'LTileLayer',
          mixins: [TileLayerMixin, Options],
          props: {
              url: {
                  type: String,
                  default: null,
              },
              tileLayerClass: {
                  type: Function,
                  default: leaflet.tileLayer,
              },
          },
          mounted: function mounted() {
              var this$1 = this;
  
              var options = optionsMerger(this.tileLayerOptions, this);
              this.mapObject = this.tileLayerClass(this.url, options);
              leaflet.DomEvent.on(this.mapObject, this.$listeners);
              propsBinder(this, this.mapObject, this.$options.props);
              this.parentContainer = findRealParent(this.$parent);
              this.parentContainer.addLayer(this, !this.visible);
              this.$nextTick(function () {
                  /**
                   * Triggers when the component is ready
                   * @type {object}
                   * @property {object} mapObject - reference to leaflet map object
                   */
                  this$1.$emit('ready', this$1.mapObject);
              });
          },
      };
  
      /* script */
      var __vue_script__$k = script$k;
  
      /* template */
      var __vue_render__$b = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div')};
      var __vue_staticRenderFns__$b = [];
  
      /* style */
      var __vue_inject_styles__$k = undefined;
      /* scoped */
      var __vue_scope_id__$k = undefined;
      /* module identifier */
      var __vue_module_identifier__$k = undefined;
      /* functional template */
      var __vue_is_functional_template__$k = false;
      /* style inject */
  
      /* style inject SSR */
  
      /* style inject shadow dom */
  
  
  
      var __vue_component__$k = /*#__PURE__*/normalizeComponent(
          { render: __vue_render__$b, staticRenderFns: __vue_staticRenderFns__$b },
          __vue_inject_styles__$k,
          __vue_script__$k,
          __vue_scope_id__$k,
          __vue_is_functional_template__$k,
          __vue_module_identifier__$k,
          false,
          undefined,
          undefined,
          undefined
      );
  
      /**
       * Display a tooltip on the map
       */
      var script$l = {
          name: 'LTooltip',
          mixins: [Popper, Options],
          mounted: function mounted() {
              var this$1 = this;
  
              var options = optionsMerger(this.popperOptions, this);
              this.mapObject = leaflet.tooltip(options);
              leaflet.DomEvent.on(this.mapObject, this.$listeners);
              propsBinder(this, this.mapObject, this.$options.props);
              this.mapObject.setContent(this.content || this.$el);
              this.parentContainer = findRealParent(this.$parent);
              this.parentContainer.mapObject.bindTooltip(this.mapObject);
              this.$nextTick(function () {
                  /**
                   * Triggers when the component is ready
                   * @type {object}
                   * @property {object} mapObject - reference to leaflet map object
                   */
                  this$1.$emit('ready', this$1.mapObject);
              });
          },
          beforeDestroy: function beforeDestroy() {
              if (this.parentContainer) {
                  if (this.parentContainer.unbindTooltip) {
                      this.parentContainer.unbindTooltip();
                  } else if (
                      this.parentContainer.mapObject &&
                      this.parentContainer.mapObject.unbindTooltip
                  ) {
                      this.parentContainer.mapObject.unbindTooltip();
                  }
              }
          },
      };
  
      /* script */
      var __vue_script__$l = script$l;
  
      /* template */
  
      /* style */
      var __vue_inject_styles__$l = undefined;
      /* scoped */
      var __vue_scope_id__$l = undefined;
      /* module identifier */
      var __vue_module_identifier__$l = undefined;
      /* functional template */
      var __vue_is_functional_template__$l = undefined;
      /* style inject */
  
      /* style inject SSR */
  
      /* style inject shadow dom */
  
  
  
      var __vue_component__$l = /*#__PURE__*/normalizeComponent(
          {},
          __vue_inject_styles__$l,
          __vue_script__$l,
          __vue_scope_id__$l,
          __vue_is_functional_template__$l,
          __vue_module_identifier__$l,
          false,
          undefined,
          undefined,
          undefined
      );
  
      /**
       * Display WMS services as tile layers on the map
       */
      var script$m = {
          name: 'LWMSTileLayer',
          mixins: [TileLayerWMS, Options],
          props: {
              baseUrl: {
                  type: String,
                  default: null,
              },
          },
          mounted: function mounted() {
              var this$1 = this;
  
              var options = optionsMerger(this.tileLayerWMSOptions, this);
              this.mapObject = leaflet.tileLayer.wms(this.baseUrl, options);
              leaflet.DomEvent.on(this.mapObject, this.$listeners);
              propsBinder(this, this.mapObject, this.$options.props);
              this.parentContainer = findRealParent(this.$parent);
              this.parentContainer.addLayer(this, !this.visible);
              this.$nextTick(function () {
                  /**
                   * Triggers when the component is ready
                   * @type {object}
                   * @property {object} mapObject - reference to leaflet map object
                   */
                  this$1.$emit('ready', this$1.mapObject);
              });
          },
      };
  
      /* script */
      var __vue_script__$m = script$m;
  
      /* template */
  
      /* style */
      var __vue_inject_styles__$m = undefined;
      /* scoped */
      var __vue_scope_id__$m = undefined;
      /* module identifier */
      var __vue_module_identifier__$m = undefined;
      /* functional template */
      var __vue_is_functional_template__$m = undefined;
      /* style inject */
  
      /* style inject SSR */
  
      /* style inject shadow dom */
  
  
  
      var __vue_component__$m = /*#__PURE__*/normalizeComponent(
          {},
          __vue_inject_styles__$m,
          __vue_script__$m,
          __vue_scope_id__$m,
          __vue_is_functional_template__$m,
          __vue_module_identifier__$m,
          false,
          undefined,
          undefined,
          undefined
      );
  
      exports.CircleMixin = CircleMixin;
      exports.ControlMixin = ControlMixin;
      exports.GridLayerMixin = GridLayerMixin;
      exports.ImageOverlayMixin = ImageOverlayMixin;
      exports.InteractiveLayerMixin = InteractiveLayer;
      exports.LCircle = __vue_component__;
      exports.LCircleMarker = __vue_component__$1;
      exports.LControl = __vue_component__$2;
      exports.LControlAttribution = __vue_component__$3;
      exports.LControlLayers = __vue_component__$4;
      exports.LControlScale = __vue_component__$5;
      exports.LControlZoom = __vue_component__$6;
      exports.LFeatureGroup = __vue_component__$7;
      exports.LGeoJson = __vue_component__$8;
      exports.LGridLayer = __vue_component__$9;
      exports.LIcon = __vue_component__$a;
      exports.LIconDefault = __vue_component__$b;
      exports.LImageOverlay = __vue_component__$c;
      exports.LLayerGroup = __vue_component__$d;
      exports.LMap = __vue_component__$e;
      exports.LMarker = __vue_component__$f;
      exports.LPolygon = __vue_component__$g;
      exports.LPolyline = __vue_component__$h;
      exports.LPopup = __vue_component__$i;
      exports.LRectangle = __vue_component__$j;
      exports.LTileLayer = __vue_component__$k;
      exports.LTooltip = __vue_component__$l;
      exports.LWMSTileLayer = __vue_component__$m;
      exports.LayerGroupMixin = LayerGroupMixin;
      exports.LayerMixin = Layer;
      exports.OptionsMixin = Options;
      exports.PathMixin = Path;
      exports.PolygonMixin = Polygon;
      exports.PolylineMixin = PolylineMixin;
      exports.PopperMixin = Popper;
      exports.TileLayerMixin = TileLayerMixin;
      exports.TileLayerWMSMixin = TileLayerWMS;
      exports.capitalizeFirstLetter = capitalizeFirstLetter;
      exports.collectionCleaner = collectionCleaner;
      exports.debounce = debounce;
      exports.findRealParent = findRealParent;
      exports.optionsMerger = optionsMerger;
      exports.propsBinder = propsBinder;
  
      Object.defineProperty(exports, '__esModule', { value: true });
  
  })));