text: import { setOptions, layerGroup, DomEvent } from 'leaflet';
  
  var capitalizeFirstLetter = function (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) {
          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 findRealParent = function (firstVueParent) {
    var found = false;
    while (!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
      },
      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 (newVal, oldVal) {
        if (newVal === oldVal) { return; }
        this.parentContainer.removeLayer(this);
        if (this.visible) {
          this.parentContainer.addLayer(this);
        }
      },
      setLayerType: function setLayerType (newVal, oldVal) {
        if (newVal === oldVal) { return; }
        this.parentContainer.removeLayer(this);
        if (this.visible) {
          this.parentContainer.addLayer(this);
        }
      },
      setVisible: function setVisible (newVal, oldVal) {
        if (newVal === oldVal) { return; }
        if (this.mapObject) {
          if (newVal) {
            this.parentContainer.addLayer(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();
        }
      }
    }
  };
  
  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 script = {
    name: 'LLayerGroup',
    mixins: [LayerGroupMixin],
    data: function data () {
      return {
        ready: false
      };
    },
    mounted: function mounted () {
      var this$1 = this;
  
      this.mapObject = layerGroup();
      propsBinder(this, this.mapObject, this.$options.props);
      DomEvent.on(this.mapObject, this.$listeners);
      this.ready = true;
      this.parentContainer = findRealParent(this.$parent);
      if (this.visible) {
        this.parentContainer.addLayer(this);
      }
      this.$nextTick(function () {
        this$1.$emit('ready', this$1.mapObject);
      });
    }
  };
  
  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 hook(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 () {
        style.call(this, createInjectorShadow(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;
  }
  
  var normalizeComponent_1 = normalizeComponent;
  
  /* 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 */
    
  
    
    var LLayerGroup = normalizeComponent_1(
      { render: __vue_render__, staticRenderFns: __vue_staticRenderFns__ },
      __vue_inject_styles__,
      __vue_script__,
      __vue_scope_id__,
      __vue_is_functional_template__,
      __vue_module_identifier__,
      undefined,
      undefined
    );
  
  export default LLayerGroup;
  