ablok-components 0.3.28 → 0.3.29

package/dist/vue-leaflet.es-DRzm3SqP.mjs

@@ -0,0 +1,1871 @@
+import { defineComponent as O, ref as p, inject as S, onMounted as j, markRaw as P, nextTick as g, h as U, reactive as mt, provide as M, computed as te, onBeforeUnmount as X, watch as Ze, onUnmounted as de, render as vt } from "vue";
+const ue = (e, o) => {
+  for (const t of Object.keys(o))
+    e.on(t, o[t]);
+}, ce = (e) => {
+  for (const o of Object.keys(e)) {
+    const t = e[o];
+    t && G(t.cancel) && t.cancel();
+  }
+}, We = (e) => !e || typeof e.charAt != "function" ? e : e.charAt(0).toUpperCase() + e.slice(1), G = (e) => typeof e == "function", h = (e, o, t) => {
+  for (const r in t) {
+    const n = "set" + We(r);
+    e[n] ? Ze(
+      () => t[r],
+      (l, s) => {
+        e[n](l, s);
+      }
+    ) : o[n] && Ze(
+      () => t[r],
+      (l) => {
+        o[n](l);
+      }
+    );
+  }
+}, b = (e, o, t = {}) => {
+  const r = { ...t };
+  for (const n in e) {
+    const l = o[n], s = e[n];
+    l && (l && l.custom === !0 || s !== void 0 && (r[n] = s));
+  }
+  return r;
+}, C = (e) => {
+  const o = {}, t = {};
+  for (const r in e)
+    if (r.startsWith("on") && !r.startsWith("onUpdate") && r !== "onReady") {
+      const n = r.slice(2).toLocaleLowerCase();
+      o[n] = e[r];
+    } else
+      t[r] = e[r];
+  return { listeners: o, attrs: t };
+}, Je = async (e) => {
+  const o = await Promise.all([
+    import("./marker-icon-2x-DVSLMKfE.mjs"),
+    import("./marker-icon-DbhCZIpd.mjs"),
+    import("./marker-shadow-ZZvxUwqf.mjs")
+  ]);
+  delete e.Default.prototype._getIconUrl, e.Default.mergeOptions({
+    iconRetinaUrl: o[0].default,
+    iconUrl: o[1].default,
+    shadowUrl: o[2].default
+  });
+}, V = (e) => {
+  const o = p(
+    (...r) => console.warn(`Method ${e} has been invoked without being replaced`)
+  ), t = (...r) => o.value(...r);
+  return t.wrapped = o, M(e, t), t;
+}, K = (e, o) => e.wrapped.value = o, f = typeof self == "object" && self.self === self && self || typeof global == "object" && global.global === global && global || globalThis, m = (e) => {
+  const o = S(e);
+  if (o === void 0)
+    throw new Error(
+      `Attempt to inject ${e.description} before it was provided.`
+    );
+  return o;
+}, Jt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  WINDOW_OR_GLOBAL: f,
+  assertInject: m,
+  bindEventHandlers: ue,
+  cancelDebounces: ce,
+  capitalizeFirstLetter: We,
+  isFunction: G,
+  propsBinder: h,
+  propsToLeafletOptions: b,
+  provideLeafletWrapper: V,
+  remapEvents: C,
+  resetWebpackIcon: Je,
+  updateLeafletWrapper: K
+}, Symbol.toStringTag, { value: "Module" })), L = /* @__PURE__ */ Symbol(
+  "useGlobalLeaflet"
+), B = /* @__PURE__ */ Symbol("addLayer"), Y = /* @__PURE__ */ Symbol("removeLayer"), Z = /* @__PURE__ */ Symbol(
+  "registerControl"
+), ye = /* @__PURE__ */ Symbol(
+  "registerLayerControl"
+), me = /* @__PURE__ */ Symbol(
+  "canSetParentHtml"
+), ve = /* @__PURE__ */ Symbol("setParentHtml"), fe = /* @__PURE__ */ Symbol("setIcon"), be = /* @__PURE__ */ Symbol("bindPopup"), ge = /* @__PURE__ */ Symbol("bindTooltip"), he = /* @__PURE__ */ Symbol("unbindPopup"), Le = /* @__PURE__ */ Symbol("unbindTooltip"), qt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  AddLayerInjection: B,
+  BindPopupInjection: be,
+  BindTooltipInjection: ge,
+  CanSetParentHtmlInjection: me,
+  RegisterControlInjection: Z,
+  RegisterLayerControlInjection: ye,
+  RemoveLayerInjection: Y,
+  SetIconInjection: fe,
+  SetParentHtmlInjection: ve,
+  UnbindPopupInjection: he,
+  UnbindTooltipInjection: Le,
+  UseGlobalLeafletInjection: L
+}, Symbol.toStringTag, { value: "Module" })), E = {
+  options: {
+    type: Object,
+    default: () => ({}),
+    custom: !0
+  }
+}, W = (e) => ({ options: e.options, methods: {} }), ft = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  componentProps: E,
+  setupComponent: W
+}, Symbol.toStringTag, { value: "Module" })), x = {
+  ...E,
+  pane: {
+    type: String
+  },
+  attribution: {
+    type: String
+  },
+  name: {
+    type: String,
+    custom: !0
+  },
+  layerType: {
+    type: String,
+    custom: !0
+  },
+  visible: {
+    type: Boolean,
+    custom: !0,
+    default: !0
+  }
+}, J = (e, o, t) => {
+  const r = m(B), n = m(Y), { options: l, methods: s } = W(e), a = b(
+    e,
+    x,
+    l
+  ), i = () => r({ leafletObject: o.value }), u = () => n({ leafletObject: o.value }), d = {
+    ...s,
+    setAttribution(y) {
+      u(), o.value.options.attribution = y, e.visible && i();
+    },
+    setName() {
+      u(), e.visible && i();
+    },
+    setLayerType() {
+      u(), e.visible && i();
+    },
+    setVisible(y) {
+      o.value && (y ? i() : u());
+    },
+    bindPopup(y) {
+      if (!o.value || !G(o.value.bindPopup)) {
+        console.warn(
+          "Attempt to bind popup before bindPopup method available on layer."
+        );
+        return;
+      }
+      o.value.bindPopup(y);
+    },
+    bindTooltip(y) {
+      if (!o.value || !G(o.value.bindTooltip)) {
+        console.warn(
+          "Attempt to bind tooltip before bindTooltip method available on layer."
+        );
+        return;
+      }
+      o.value.bindTooltip(y);
+    },
+    unbindTooltip() {
+      o.value && (G(o.value.closeTooltip) && o.value.closeTooltip(), G(o.value.unbindTooltip) && o.value.unbindTooltip());
+    },
+    unbindPopup() {
+      o.value && (G(o.value.closePopup) && o.value.closePopup(), G(o.value.unbindPopup) && o.value.unbindPopup());
+    },
+    updateVisibleProp(y) {
+      t.emit("update:visible", y);
+    }
+  };
+  return M(be, d.bindPopup), M(ge, d.bindTooltip), M(he, d.unbindPopup), M(Le, d.unbindTooltip), de(() => {
+    d.unbindPopup(), d.unbindTooltip(), u();
+  }), { options: a, methods: d };
+}, R = (e, o) => {
+  if (e && o.default)
+    return U("div", { style: { display: "none" } }, o.default());
+}, bt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  layerProps: x,
+  render: R,
+  setupLayer: J
+}, Symbol.toStringTag, { value: "Module" })), Oe = {
+  ...x,
+  interactive: {
+    type: Boolean,
+    default: void 0
+  },
+  bubblingMouseEvents: {
+    type: Boolean,
+    default: void 0
+  }
+}, qe = (e, o, t) => {
+  const { options: r, methods: n } = J(
+    e,
+    o,
+    t
+  );
+  return { options: b(
+    e,
+    Oe,
+    r
+  ), methods: n };
+}, gt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  interactiveLayerProps: Oe,
+  setupInteractiveLayer: qe
+}, Symbol.toStringTag, { value: "Module" })), oe = {
+  ...Oe,
+  stroke: {
+    type: Boolean,
+    default: void 0
+  },
+  color: {
+    type: String
+  },
+  weight: {
+    type: Number
+  },
+  opacity: {
+    type: Number
+  },
+  lineCap: {
+    type: String
+  },
+  lineJoin: {
+    type: String
+  },
+  dashArray: {
+    type: String
+  },
+  dashOffset: {
+    type: String
+  },
+  fill: {
+    type: Boolean,
+    default: void 0
+  },
+  fillColor: {
+    type: String
+  },
+  fillOpacity: {
+    type: Number
+  },
+  fillRule: {
+    type: String
+  },
+  className: {
+    type: String
+  }
+}, Se = (e, o, t) => {
+  const { options: r, methods: n } = qe(e, o, t), l = b(
+    e,
+    oe,
+    r
+  ), s = m(Y), a = {
+    ...n,
+    setStroke(i) {
+      o.value.setStyle({ stroke: i });
+    },
+    setColor(i) {
+      o.value.setStyle({ color: i });
+    },
+    setWeight(i) {
+      o.value.setStyle({ weight: i });
+    },
+    setOpacity(i) {
+      o.value.setStyle({ opacity: i });
+    },
+    setLineCap(i) {
+      o.value.setStyle({ lineCap: i });
+    },
+    setLineJoin(i) {
+      o.value.setStyle({ lineJoin: i });
+    },
+    setDashArray(i) {
+      o.value.setStyle({ dashArray: i });
+    },
+    setDashOffset(i) {
+      o.value.setStyle({ dashOffset: i });
+    },
+    setFill(i) {
+      o.value.setStyle({ fill: i });
+    },
+    setFillColor(i) {
+      o.value.setStyle({ fillColor: i });
+    },
+    setFillOpacity(i) {
+      o.value.setStyle({ fillOpacity: i });
+    },
+    setFillRule(i) {
+      o.value.setStyle({ fillRule: i });
+    },
+    setClassName(i) {
+      o.value.setStyle({ className: i });
+    }
+  };
+  return X(() => {
+    s({ leafletObject: o.value });
+  }), { options: l, methods: a };
+}, ht = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  pathProps: oe,
+  setupPath: Se
+}, Symbol.toStringTag, { value: "Module" })), re = {
+  ...oe,
+  /**
+   * Radius of the marker in pixels.
+   */
+  radius: {
+    type: Number
+  },
+  latLng: {
+    type: [Object, Array],
+    required: !0,
+    custom: !0
+  }
+}, je = (e, o, t) => {
+  const { options: r, methods: n } = Se(
+    e,
+    o,
+    t
+  ), l = b(
+    e,
+    re,
+    r
+  ), s = {
+    ...n,
+    setRadius(a) {
+      o.value.setRadius(a);
+    },
+    setLatLng(a) {
+      o.value.setLatLng(a);
+    }
+  };
+  return { options: l, methods: s };
+}, Lt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  circleMarkerProps: re,
+  setupCircleMarker: je
+}, Symbol.toStringTag, { value: "Module" })), _e = {
+  ...re,
+  /**
+   * Radius of the circle in meters.
+   */
+  radius: {
+    type: Number
+  }
+}, He = (e, o, t) => {
+  const { options: r, methods: n } = je(e, o, t), l = b(
+    e,
+    _e,
+    r
+  ), s = {
+    ...n
+  };
+  return { options: l, methods: s };
+}, Ot = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  circleProps: _e,
+  setupCircle: He
+}, Symbol.toStringTag, { value: "Module" })), Ht = O({
+  name: "LCircle",
+  props: _e,
+  setup(e, o) {
+    const t = p(), r = p(!1), n = S(L), l = m(B), { options: s, methods: a } = He(e, t, o);
+    return j(async () => {
+      const { circle: i } = n ? f.L : await import("./leaflet-src.esm-BSRIxBxW.mjs");
+      t.value = P(i(e.latLng, s));
+      const { listeners: u } = C(o.attrs);
+      t.value.on(u), h(a, t.value, e), l({
+        ...e,
+        ...a,
+        leafletObject: t.value
+      }), r.value = !0, g(() => o.emit("ready", t.value));
+    }), { ready: r, leafletObject: t };
+  },
+  render() {
+    return R(this.ready, this.$slots);
+  }
+}), Vt = O({
+  name: "LCircleMarker",
+  props: re,
+  setup(e, o) {
+    const t = p(), r = p(!1), n = S(L), l = m(B), { options: s, methods: a } = je(
+      e,
+      t,
+      o
+    );
+    return j(async () => {
+      const { circleMarker: i } = n ? f.L : await import("./leaflet-src.esm-BSRIxBxW.mjs");
+      t.value = P(
+        i(e.latLng, s)
+      );
+      const { listeners: u } = C(o.attrs);
+      t.value.on(u), h(a, t.value, e), l({
+        ...e,
+        ...a,
+        leafletObject: t.value
+      }), r.value = !0, g(() => o.emit("ready", t.value));
+    }), { ready: r, leafletObject: t };
+  },
+  render() {
+    return R(this.ready, this.$slots);
+  }
+}), $ = {
+  ...E,
+  position: {
+    type: String
+  }
+}, q = (e, o) => {
+  const { options: t, methods: r } = W(e), n = b(
+    e,
+    $,
+    t
+  ), l = {
+    ...r,
+    setPosition(s) {
+      o.value && o.value.setPosition(s);
+    }
+  };
+  return de(() => {
+    o.value && o.value.remove();
+  }), { options: n, methods: l };
+}, Ve = (e) => e.default ? U("div", { ref: "root" }, e.default()) : null, St = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  controlProps: $,
+  renderLControl: Ve,
+  setupControl: q
+}, Symbol.toStringTag, { value: "Module" })), Kt = O({
+  name: "LControl",
+  props: {
+    ...$,
+    disableClickPropagation: {
+      type: Boolean,
+      custom: !0,
+      default: !0
+    },
+    disableScrollPropagation: {
+      type: Boolean,
+      custom: !0,
+      default: !1
+    }
+  },
+  setup(e, o) {
+    const t = p(), r = p(), n = S(L), l = m(Z), { options: s, methods: a } = q(e, t);
+    return j(async () => {
+      const { Control: i, DomEvent: u } = n ? f.L : await import("./leaflet-src.esm-BSRIxBxW.mjs"), d = i.extend({
+        onAdd() {
+          return r.value;
+        }
+      });
+      t.value = P(new d(s)), h(a, t.value, e), l({ leafletObject: t.value }), e.disableClickPropagation && r.value && u.disableClickPropagation(r.value), e.disableScrollPropagation && r.value && u.disableScrollPropagation(r.value), g(() => o.emit("ready", t.value));
+    }), { root: r, leafletObject: t };
+  },
+  render() {
+    return Ve(this.$slots);
+  }
+}), Pe = {
+  ...$,
+  prefix: {
+    type: String
+  }
+}, Ke = (e, o) => {
+  const { options: t, methods: r } = q(
+    e,
+    o
+  ), n = b(
+    e,
+    Pe,
+    t
+  ), l = {
+    ...r,
+    setPrefix(s) {
+      o.value.setPrefix(s);
+    }
+  };
+  return { options: n, methods: l };
+}, jt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  controlAttributionProps: Pe,
+  setupControlAttribution: Ke
+}, Symbol.toStringTag, { value: "Module" })), Qt = O({
+  name: "LControlAttribution",
+  props: Pe,
+  setup(e, o) {
+    const t = p(), r = S(L), n = m(Z), { options: l, methods: s } = Ke(e, t);
+    return j(async () => {
+      const { control: a } = r ? f.L : await import("./leaflet-src.esm-BSRIxBxW.mjs");
+      t.value = P(
+        a.attribution(l)
+      ), h(s, t.value, e), n({ leafletObject: t.value }), g(() => o.emit("ready", t.value));
+    }), { leafletObject: t };
+  },
+  render() {
+    return null;
+  }
+}), Te = {
+  ...$,
+  collapsed: {
+    type: Boolean,
+    default: void 0
+  },
+  autoZIndex: {
+    type: Boolean,
+    default: void 0
+  },
+  hideSingleBase: {
+    type: Boolean,
+    default: void 0
+  },
+  sortLayers: {
+    type: Boolean,
+    default: void 0
+  },
+  sortFunction: {
+    type: Function
+  }
+}, Qe = (e, o) => {
+  const { options: t } = q(e, o);
+  return { options: b(
+    e,
+    Te,
+    t
+  ), methods: {
+    addLayer(r) {
+      r.layerType === "base" ? o.value.addBaseLayer(r.leafletObject, r.name) : r.layerType === "overlay" && o.value.addOverlay(r.leafletObject, r.name);
+    },
+    removeLayer(r) {
+      o.value.removeLayer(r.leafletObject);
+    }
+  } };
+}, _t = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  controlLayersProps: Te,
+  setupControlLayers: Qe
+}, Symbol.toStringTag, { value: "Module" })), Xt = O({
+  name: "LControlLayers",
+  props: Te,
+  setup(e, o) {
+    const t = p(), r = S(L), n = m(ye), { options: l, methods: s } = Qe(e, t);
+    return j(async () => {
+      const { control: a } = r ? f.L : await import("./leaflet-src.esm-BSRIxBxW.mjs");
+      t.value = P(
+        a.layers(void 0, void 0, l)
+      ), h(s, t.value, e), n({
+        ...e,
+        ...s,
+        leafletObject: t.value
+      }), g(() => o.emit("ready", t.value));
+    }), { leafletObject: t };
+  },
+  render() {
+    return null;
+  }
+}), Ce = {
+  ...$,
+  maxWidth: {
+    type: Number
+  },
+  metric: {
+    type: Boolean,
+    default: void 0
+  },
+  imperial: {
+    type: Boolean,
+    default: void 0
+  },
+  updateWhenIdle: {
+    type: Boolean,
+    default: void 0
+  }
+}, Xe = (e, o) => {
+  const { options: t, methods: r } = q(
+    e,
+    o
+  );
+  return { options: b(
+    e,
+    Ce,
+    t
+  ), methods: r };
+}, Pt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  controlScaleProps: Ce,
+  setupControlScale: Xe
+}, Symbol.toStringTag, { value: "Module" })), Yt = O({
+  name: "LControlScale",
+  props: Ce,
+  setup(e, o) {
+    const t = p(), r = S(L), n = m(Z), { options: l, methods: s } = Xe(e, t);
+    return j(async () => {
+      const { control: a } = r ? f.L : await import("./leaflet-src.esm-BSRIxBxW.mjs");
+      t.value = P(a.scale(l)), h(s, t.value, e), n({ leafletObject: t.value }), g(() => o.emit("ready", t.value));
+    }), { leafletObject: t };
+  },
+  render() {
+    return null;
+  }
+}), Be = {
+  ...$,
+  zoomInText: {
+    type: String
+  },
+  zoomInTitle: {
+    type: String
+  },
+  zoomOutText: {
+    type: String
+  },
+  zoomOutTitle: {
+    type: String
+  }
+}, Ye = (e, o) => {
+  const { options: t, methods: r } = q(
+    e,
+    o
+  );
+  return { options: b(
+    e,
+    Be,
+    t
+  ), methods: r };
+}, Tt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  controlZoomProps: Be,
+  setupControlZoom: Ye
+}, Symbol.toStringTag, { value: "Module" })), eo = O({
+  name: "LControlZoom",
+  props: Be,
+  setup(e, o) {
+    const t = p(), r = S(L), n = m(Z), { options: l, methods: s } = Ye(e, t);
+    return j(async () => {
+      const { control: a } = r ? f.L : await import("./leaflet-src.esm-BSRIxBxW.mjs");
+      t.value = P(a.zoom(l)), h(s, t.value, e), n({ leafletObject: t.value }), g(() => o.emit("ready", t.value));
+    }), { leafletObject: t };
+  },
+  render() {
+    return null;
+  }
+}), ee = {
+  ...x
+}, le = (e, o, t) => {
+  const { options: r, methods: n } = J(
+    e,
+    o,
+    t
+  ), l = b(
+    e,
+    ee,
+    r
+  ), s = {
+    ...n,
+    addLayer(a) {
+      o.value.addLayer(a.leafletObject);
+    },
+    removeLayer(a) {
+      o.value.removeLayer(a.leafletObject);
+    }
+  };
+  return M(B, s.addLayer), M(Y, s.removeLayer), { options: l, methods: s };
+}, Ct = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  layerGroupProps: ee,
+  setupLayerGroup: le
+}, Symbol.toStringTag, { value: "Module" })), we = {
+  ...ee
+}, et = (e, o, t) => {
+  const { options: r, methods: n } = le(
+    e,
+    o,
+    t
+  ), l = b(
+    e,
+    we,
+    r
+  ), s = {
+    ...n
+  };
+  return { options: l, methods: s };
+}, Bt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  featureGroupProps: we,
+  setupFeatureGroup: et
+}, Symbol.toStringTag, { value: "Module" })), to = O({
+  props: we,
+  setup(e, o) {
+    const t = p(), r = p(!1), n = S(L), l = m(B), { methods: s, options: a } = et(
+      e,
+      t,
+      o
+    );
+    return j(async () => {
+      const { featureGroup: i } = n ? f.L : await import("./leaflet-src.esm-BSRIxBxW.mjs");
+      t.value = P(
+        i(void 0, a)
+      );
+      const { listeners: u } = C(o.attrs);
+      t.value.on(u), h(s, t.value, e), l({
+        ...e,
+        ...s,
+        leafletObject: t.value
+      }), r.value = !0, g(() => o.emit("ready", t.value));
+    }), { ready: r, leafletObject: t };
+  },
+  render() {
+    return R(this.ready, this.$slots);
+  }
+}), Ae = {
+  ...ee,
+  geojson: {
+    type: [Object, Array],
+    custom: !0
+  },
+  optionsStyle: {
+    type: Function,
+    custom: !0
+  }
+}, tt = (e, o, t) => {
+  const { options: r, methods: n } = le(
+    e,
+    o,
+    t
+  ), l = b(
+    e,
+    Ae,
+    r
+  );
+  Object.prototype.hasOwnProperty.call(e, "optionsStyle") && (l.style = e.optionsStyle);
+  const s = {
+    ...n,
+    setGeojson(a) {
+      o.value.clearLayers(), o.value.addData(a);
+    },
+    setOptionsStyle(a) {
+      o.value.setStyle(a);
+    },
+    getGeoJSONData() {
+      return o.value.toGeoJSON();
+    },
+    getBounds() {
+      return o.value.getBounds();
+    }
+  };
+  return { options: l, methods: s };
+}, wt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  geoJSONProps: Ae,
+  setupGeoJSON: tt
+}, Symbol.toStringTag, { value: "Module" })), oo = O({
+  props: Ae,
+  setup(e, o) {
+    const t = p(), r = p(!1), n = S(L), l = m(B), { methods: s, options: a } = tt(e, t, o);
+    return j(async () => {
+      const { geoJSON: i } = n ? f.L : await import("./leaflet-src.esm-BSRIxBxW.mjs");
+      t.value = P(i(e.geojson, a));
+      const { listeners: u } = C(o.attrs);
+      t.value.on(u), h(s, t.value, e), l({
+        ...e,
+        ...s,
+        leafletObject: t.value
+      }), r.value = !0, g(() => o.emit("ready", t.value));
+    }), { ready: r, leafletObject: t };
+  },
+  render() {
+    return R(this.ready, this.$slots);
+  }
+}), ne = {
+  ...x,
+  opacity: {
+    type: Number
+  },
+  zIndex: {
+    type: Number
+  },
+  tileSize: {
+    type: [Number, Array, Object]
+  },
+  noWrap: {
+    type: Boolean,
+    default: void 0
+  },
+  minZoom: {
+    type: Number
+  },
+  maxZoom: {
+    type: Number
+  },
+  className: {
+    type: String
+  }
+}, Ie = (e, o, t) => {
+  const { options: r, methods: n } = J(
+    e,
+    o,
+    t
+  ), l = b(
+    e,
+    ne,
+    r
+  ), s = {
+    ...n,
+    setTileComponent() {
+      var a;
+      (a = o.value) == null || a.redraw();
+    }
+  };
+  return de(() => {
+    o.value.off();
+  }), { options: l, methods: s };
+}, ot = (e, o, t, r) => e.extend({
+  initialize(n) {
+    this.tileComponents = {}, this.on("tileunload", this._unloadTile), t.setOptions(this, n);
+  },
+  createTile(n) {
+    const l = this._tileCoordsToKey(n);
+    this.tileComponents[l] = o.create("div");
+    const s = U({ setup: r, props: ["coords"] }, { coords: n });
+    return vt(s, this.tileComponents[l]), this.tileComponents[l];
+  },
+  _unloadTile(n) {
+    const l = this._tileCoordsToKey(n.coords);
+    this.tileComponents[l] && (this.tileComponents[l].innerHTML = "", this.tileComponents[l] = void 0);
+  }
+}), At = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  CreateVueGridLayer: ot,
+  gridLayerProps: ne,
+  setupGridLayer: Ie
+}, Symbol.toStringTag, { value: "Module" })), ro = O({
+  props: {
+    ...ne,
+    childRender: {
+      type: Function,
+      required: !0
+    }
+  },
+  setup(e, o) {
+    const t = p(), r = p(null), n = p(!1), l = S(L), s = m(B), { options: a, methods: i } = Ie(e, t, o);
+    return j(async () => {
+      const { GridLayer: u, DomUtil: d, Util: y } = l ? f.L : await import("./leaflet-src.esm-BSRIxBxW.mjs"), A = ot(
+        u,
+        d,
+        y,
+        e.childRender
+      );
+      t.value = P(new A(a));
+      const { listeners: v } = C(o.attrs);
+      t.value.on(v), h(i, t.value, e), s({
+        ...e,
+        ...i,
+        leafletObject: t.value
+      }), n.value = !0, g(() => o.emit("ready", t.value));
+    }), { root: r, ready: n, leafletObject: t };
+  },
+  render() {
+    return this.ready ? U("div", { style: { display: "none" }, ref: "root" }) : null;
+  }
+}), pe = {
+  iconUrl: {
+    type: String
+  },
+  iconRetinaUrl: {
+    type: String
+  },
+  iconSize: {
+    type: [Object, Array]
+  },
+  iconAnchor: {
+    type: [Object, Array]
+  },
+  popupAnchor: {
+    type: [Object, Array]
+  },
+  tooltipAnchor: {
+    type: [Object, Array]
+  },
+  shadowUrl: {
+    type: String
+  },
+  shadowRetinaUrl: {
+    type: String
+  },
+  shadowSize: {
+    type: [Object, Array]
+  },
+  shadowAnchor: {
+    type: [Object, Array]
+  },
+  bgPos: {
+    type: [Object, Array]
+  },
+  className: {
+    type: String
+  }
+}, It = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  iconProps: pe
+}, Symbol.toStringTag, { value: "Module" })), lo = O({
+  name: "LIcon",
+  props: {
+    ...pe,
+    ...E
+  },
+  setup(e, o) {
+    const t = p(), r = S(L), n = m(me), l = m(ve), s = m(fe);
+    let a, i, u, d, y;
+    const A = (N, T, w) => {
+      const I = N && N.innerHTML;
+      if (!T) {
+        w && y && n() && l(I);
+        return;
+      }
+      const { listeners: D } = C(o.attrs);
+      y && i(y, D);
+      const { options: ie } = W(e), k = b(
+        e,
+        pe,
+        ie
+      );
+      I && (k.html = I), y = k.html ? u(k) : d(k), a(y, D), s(y);
+    }, v = () => {
+      g(() => A(t.value, !0, !1));
+    }, z = () => {
+      g(() => A(t.value, !1, !0));
+    }, F = {
+      setIconUrl: v,
+      setIconRetinaUrl: v,
+      setIconSize: v,
+      setIconAnchor: v,
+      setPopupAnchor: v,
+      setTooltipAnchor: v,
+      setShadowUrl: v,
+      setShadowRetinaUrl: v,
+      setShadowAnchor: v,
+      setBgPos: v,
+      setClassName: v,
+      setHtml: v
+    };
+    return j(async () => {
+      const {
+        DomEvent: N,
+        divIcon: T,
+        icon: w
+      } = r ? f.L : await import("./leaflet-src.esm-BSRIxBxW.mjs");
+      a = N.on, i = N.off, u = T, d = w, h(F, {}, e), new MutationObserver(z).observe(t.value, {
+        attributes: !0,
+        childList: !0,
+        characterData: !0,
+        subtree: !0
+      }), v();
+    }), { root: t };
+  },
+  render() {
+    const e = this.$slots.default ? this.$slots.default() : void 0;
+    return U("div", { ref: "root" }, e);
+  }
+}), Me = {
+  ...x,
+  opacity: {
+    type: Number
+  },
+  alt: {
+    type: String
+  },
+  interactive: {
+    type: Boolean,
+    default: void 0
+  },
+  crossOrigin: {
+    type: Boolean,
+    default: void 0
+  },
+  errorOverlayUrl: {
+    type: String
+  },
+  zIndex: {
+    type: Number
+  },
+  className: {
+    type: String
+  },
+  url: {
+    type: String,
+    required: !0,
+    custom: !0
+  },
+  bounds: {
+    type: [Array, Object],
+    required: !0,
+    custom: !0
+  }
+}, rt = (e, o, t) => {
+  const { options: r, methods: n } = J(
+    e,
+    o,
+    t
+  ), l = b(
+    e,
+    Me,
+    r
+  ), s = {
+    ...n,
+    /**
+     * Sets the opacity of the overlay.
+     * @param {number} opacity
+     */
+    setOpacity(a) {
+      return o.value.setOpacity(a);
+    },
+    /**
+     * Changes the URL of the image.
+     * @param {string} url
+     */
+    setUrl(a) {
+      return o.value.setUrl(a);
+    },
+    /**
+     * Update the bounds that this ImageOverlay covers
+     * @param {LatLngBounds | Array<Array<number>>} bounds
+     */
+    setBounds(a) {
+      return o.value.setBounds(a);
+    },
+    /**
+     * Get the bounds that this ImageOverlay covers
+     * @returns {LatLngBounds}
+     */
+    getBounds() {
+      return o.value.getBounds();
+    },
+    /**
+     * Returns the instance of HTMLImageElement used by this overlay.
+     * @returns {HTMLElement}
+     */
+    getElement() {
+      return o.value.getElement();
+    },
+    /**
+     * Brings the layer to the top of all overlays.
+     */
+    bringToFront() {
+      return o.value.bringToFront();
+    },
+    /**
+     * Brings the layer to the bottom of all overlays.
+     */
+    bringToBack() {
+      return o.value.bringToBack();
+    },
+    /**
+     * Changes the zIndex of the image overlay.
+     * @param {number} zIndex
+     */
+    setZIndex(a) {
+      return o.value.setZIndex(a);
+    }
+  };
+  return { options: l, methods: s };
+}, Mt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  imageOverlayProps: Me,
+  setupImageOverlay: rt
+}, Symbol.toStringTag, { value: "Module" })), no = O({
+  name: "LImageOverlay",
+  props: Me,
+  setup(e, o) {
+    const t = p(), r = p(!1), n = S(L), l = m(B), { options: s, methods: a } = rt(
+      e,
+      t,
+      o
+    );
+    return j(async () => {
+      const { imageOverlay: i } = n ? f.L : await import("./leaflet-src.esm-BSRIxBxW.mjs");
+      t.value = P(
+        i(e.url, e.bounds, s)
+      );
+      const { listeners: u } = C(o.attrs);
+      t.value.on(u), h(a, t.value, e), l({
+        ...e,
+        ...a,
+        leafletObject: t.value
+      }), r.value = !0, g(() => o.emit("ready", t.value));
+    }), { ready: r, leafletObject: t };
+  },
+  render() {
+    return R(this.ready, this.$slots);
+  }
+}), ao = O({
+  props: ee,
+  setup(e, o) {
+    const t = p(), r = p(!1), n = S(L), l = m(B), { methods: s } = le(e, t, o);
+    return j(async () => {
+      const { layerGroup: a } = n ? f.L : await import("./leaflet-src.esm-BSRIxBxW.mjs");
+      t.value = P(
+        a(void 0, e.options)
+      );
+      const { listeners: i } = C(o.attrs);
+      t.value.on(i), h(s, t.value, e), l({
+        ...e,
+        ...s,
+        leafletObject: t.value
+      }), r.value = !0, g(() => o.emit("ready", t.value));
+    }), { ready: r, leafletObject: t };
+  },
+  render() {
+    return R(this.ready, this.$slots);
+  }
+});
+function lt(e, o, t) {
+  var r, n, l;
+  o === void 0 && (o = 50), t === void 0 && (t = {});
+  var s = (r = t.isImmediate) != null && r, a = (n = t.callback) != null && n, i = t.maxWait, u = Date.now(), d = [];
+  function y() {
+    if (i !== void 0) {
+      var v = Date.now() - u;
+      if (v + o >= i)
+        return i - v;
+    }
+    return o;
+  }
+  var A = function() {
+    var v = [].slice.call(arguments), z = this;
+    return new Promise(function(F, N) {
+      var T = s && l === void 0;
+      if (l !== void 0 && clearTimeout(l), l = setTimeout(function() {
+        if (l = void 0, u = Date.now(), !s) {
+          var I = e.apply(z, v);
+          a && a(I), d.forEach(function(D) {
+            return (0, D.resolve)(I);
+          }), d = [];
+        }
+      }, y()), T) {
+        var w = e.apply(z, v);
+        return a && a(w), F(w);
+      }
+      d.push({ resolve: F, reject: N });
+    });
+  };
+  return A.cancel = function(v) {
+    l !== void 0 && clearTimeout(l), d.forEach(function(z) {
+      return (0, z.reject)(v);
+    }), d = [];
+  }, A;
+}
+const Ee = {
+  ...E,
+  /**
+   * The center of the map, supports .sync modifier
+   */
+  center: {
+    type: [Object, Array]
+  },
+  /**
+   * The bounds of the map, supports .sync modifier
+   */
+  bounds: {
+    type: [Array, Object]
+  },
+  /**
+   * The max bounds of the map
+   */
+  maxBounds: {
+    type: [Array, Object]
+  },
+  /**
+   * The zoom of the map, supports .sync modifier
+   */
+  zoom: {
+    type: Number
+  },
+  /**
+   * The minZoom of the map
+   */
+  minZoom: {
+    type: Number
+  },
+  /**
+   * The maxZoom of the map
+   */
+  maxZoom: {
+    type: Number
+  },
+  /**
+   * The paddingBottomRight of the map
+   */
+  paddingBottomRight: {
+    type: [Object, Array]
+  },
+  /**
+   * The paddingTopLeft of the map
+   */
+  paddingTopLeft: {
+    type: Object
+  },
+  /**
+   * The padding of the map
+   */
+  padding: {
+    type: Object
+  },
+  /**
+   * The worldCopyJump option for the map
+   */
+  worldCopyJump: {
+    type: Boolean,
+    default: void 0
+  },
+  /**
+   * The CRS to use for the map. Can be an object that defines a coordinate reference
+   * system for projecting geographical points into screen coordinates and back
+   * (see https://leafletjs.com/reference-1.7.1.html#crs-l-crs-base), or a string
+   * name identifying one of Leaflet's defined CRSs, such as "EPSG4326".
+   */
+  crs: {
+    type: [String, Object]
+  },
+  maxBoundsViscosity: {
+    type: Number
+  },
+  inertia: {
+    type: Boolean,
+    default: void 0
+  },
+  inertiaDeceleration: {
+    type: Number
+  },
+  inertiaMaxSpeed: {
+    type: Number
+  },
+  easeLinearity: {
+    type: Number
+  },
+  zoomAnimation: {
+    type: Boolean,
+    default: void 0
+  },
+  zoomAnimationThreshold: {
+    type: Number
+  },
+  fadeAnimation: {
+    type: Boolean,
+    default: void 0
+  },
+  markerZoomAnimation: {
+    type: Boolean,
+    default: void 0
+  },
+  noBlockingAnimations: {
+    type: Boolean,
+    default: void 0
+  },
+  useGlobalLeaflet: {
+    type: Boolean,
+    default: !0,
+    custom: !0
+  }
+}, so = O({
+  inheritAttrs: !1,
+  emits: ["ready", "update:zoom", "update:center", "update:bounds"],
+  props: Ee,
+  setup(e, o) {
+    const t = p(), r = mt({
+      ready: !1,
+      layersToAdd: [],
+      layersInControl: []
+    }), { options: n } = W(e), l = b(
+      e,
+      Ee,
+      n
+    ), { listeners: s, attrs: a } = C(o.attrs), i = V(B), u = V(Y), d = V(Z), y = V(
+      ye
+    );
+    M(L, e.useGlobalLeaflet);
+    const A = te(() => {
+      const T = {};
+      return e.noBlockingAnimations && (T.animate = !1), T;
+    }), v = te(() => {
+      const T = A.value;
+      return e.padding && (T.padding = e.padding), e.paddingTopLeft && (T.paddingTopLeft = e.paddingTopLeft), e.paddingBottomRight && (T.paddingBottomRight = e.paddingBottomRight), T;
+    }), z = {
+      moveend: lt((T) => {
+        r.leafletRef && (o.emit("update:zoom", r.leafletRef.getZoom()), o.emit("update:center", r.leafletRef.getCenter()), o.emit("update:bounds", r.leafletRef.getBounds()));
+      }),
+      overlayadd(T) {
+        const w = r.layersInControl.find((I) => I.name === T.name);
+        w && w.updateVisibleProp(!0);
+      },
+      overlayremove(T) {
+        const w = r.layersInControl.find((I) => I.name === T.name);
+        w && w.updateVisibleProp(!1);
+      }
+    };
+    j(async () => {
+      e.useGlobalLeaflet && (f.L = f.L || await import("./leaflet-src-BsKP-mme.mjs").then((c) => c.l));
+      const { map: T, CRS: w, Icon: I, latLngBounds: D, latLng: ie, stamp: k } = e.useGlobalLeaflet ? f.L : await import("./leaflet-src.esm-BSRIxBxW.mjs");
+      try {
+        l.beforeMapMount && await l.beforeMapMount();
+      } catch (c) {
+        console.error(
+          `The following error occurred running the provided beforeMapMount hook ${c.message}`
+        );
+      }
+      await Je(I);
+      const yt = typeof l.crs == "string" ? w[l.crs] : l.crs;
+      l.crs = yt || w.EPSG3857;
+      const H = {
+        addLayer(c) {
+          c.layerType !== void 0 && (r.layerControl === void 0 ? r.layersToAdd.push(c) : r.layersInControl.find(
+            (_) => k(_.leafletObject) === k(c.leafletObject)
+          ) || (r.layerControl.addLayer(c), r.layersInControl.push(c))), c.visible !== !1 && r.leafletRef.addLayer(c.leafletObject);
+        },
+        removeLayer(c) {
+          c.layerType !== void 0 && (r.layerControl === void 0 ? r.layersToAdd = r.layersToAdd.filter(
+            (_) => _.name !== c.name
+          ) : (r.layerControl.removeLayer(c.leafletObject), r.layersInControl = r.layersInControl.filter(
+            (_) => k(_.leafletObject) !== k(c.leafletObject)
+          ))), r.leafletRef.removeLayer(c.leafletObject);
+        },
+        registerLayerControl(c) {
+          r.layerControl = c, r.layersToAdd.forEach((_) => {
+            r.layerControl.addLayer(_);
+          }), r.layersToAdd = [], d(c);
+        },
+        registerControl(c) {
+          r.leafletRef.addControl(c.leafletObject);
+        },
+        setZoom(c) {
+          const _ = r.leafletRef.getZoom();
+          c !== _ && r.leafletRef.setZoom(c, A.value);
+        },
+        setCrs(c) {
+          const _ = r.leafletRef.getBounds();
+          r.leafletRef.options.crs = c, r.leafletRef.fitBounds(_, {
+            animate: !1,
+            padding: [0, 0]
+          });
+        },
+        fitBounds(c) {
+          r.leafletRef.fitBounds(c, v.value);
+        },
+        setBounds(c) {
+          if (!c)
+            return;
+          const _ = D(c);
+          _.isValid() && !(r.lastSetBounds || r.leafletRef.getBounds()).equals(_, 0) && (r.lastSetBounds = _, r.leafletRef.fitBounds(_));
+        },
+        setCenter(c) {
+          if (c == null)
+            return;
+          const _ = ie(c), De = r.lastSetCenter || r.leafletRef.getCenter();
+          (De.lat !== _.lat || De.lng !== _.lng) && (r.lastSetCenter = _, r.leafletRef.panTo(_, A.value));
+        }
+      };
+      K(i, H.addLayer), K(u, H.removeLayer), K(d, H.registerControl), K(y, H.registerLayerControl), r.leafletRef = P(T(t.value, l)), h(H, r.leafletRef, e), ue(r.leafletRef, z), ue(r.leafletRef, s), r.ready = !0, g(() => o.emit("ready", r.leafletRef));
+    }), X(() => {
+      ce(z), r.leafletRef && (r.leafletRef.off(), r.leafletRef.remove());
+    });
+    const F = te(() => r.leafletRef), N = te(() => r.ready);
+    return { root: t, ready: N, leafletObject: F, attrs: a };
+  },
+  render({ attrs: e }) {
+    return e.style || (e.style = {}), e.style.width || (e.style.width = "100%"), e.style.height || (e.style.height = "100%"), U(
+      "div",
+      {
+        ...e,
+        ref: "root"
+      },
+      this.ready && this.$slots.default ? this.$slots.default() : {}
+    );
+  }
+}), Rt = ["Symbol(Comment)", "Symbol(Text)"], zt = ["LTooltip", "LPopup"], Re = {
+  ...x,
+  draggable: {
+    type: Boolean,
+    default: void 0
+  },
+  icon: {
+    type: [Object]
+  },
+  zIndexOffset: {
+    type: Number
+  },
+  latLng: {
+    type: [Object, Array],
+    custom: !0,
+    required: !0
+  }
+}, nt = (e, o, t) => {
+  const { options: r, methods: n } = J(
+    e,
+    o,
+    t
+  ), l = b(
+    e,
+    Re,
+    r
+  ), s = {
+    ...n,
+    setDraggable(a) {
+      o.value.dragging && (a ? o.value.dragging.enable() : o.value.dragging.disable());
+    },
+    latLngSync(a) {
+      t.emit("update:latLng", a.latlng), t.emit("update:lat-lng", a.latlng);
+    },
+    setLatLng(a) {
+      if (a != null && o.value) {
+        const i = o.value.getLatLng();
+        (!i || !i.equals(a)) && o.value.setLatLng(a);
+      }
+    }
+  };
+  return { options: l, methods: s };
+}, at = (e, o) => {
+  const t = o.slots.default && o.slots.default();
+  return t && t.length && t.some(Nt);
+};
+function Nt(e) {
+  return !(Rt.includes(e.type.toString()) || zt.includes(e.type.name));
+}
+const kt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  markerProps: Re,
+  setupMarker: nt,
+  shouldBlankIcon: at
+}, Symbol.toStringTag, { value: "Module" })), io = O({
+  name: "LMarker",
+  props: Re,
+  setup(e, o) {
+    const t = p(), r = p(!1), n = S(L), l = m(B);
+    M(
+      me,
+      () => {
+        var u;
+        return !!((u = t.value) != null && u.getElement());
+      }
+    ), M(ve, (u) => {
+      var d, y;
+      const A = G((d = t.value) == null ? void 0 : d.getElement) && ((y = t.value) == null ? void 0 : y.getElement());
+      A && (A.innerHTML = u);
+    }), M(
+      fe,
+      (u) => {
+        var d;
+        return ((d = t.value) == null ? void 0 : d.setIcon) && t.value.setIcon(u);
+      }
+    );
+    const { options: s, methods: a } = nt(e, t, o), i = {
+      moveHandler: lt(a.latLngSync)
+    };
+    return j(async () => {
+      const { marker: u, divIcon: d } = n ? f.L : await import("./leaflet-src.esm-BSRIxBxW.mjs");
+      at(s, o) && (s.icon = d({ className: "" })), t.value = P(u(e.latLng, s));
+      const { listeners: y } = C(o.attrs);
+      t.value.on(y), t.value.on("move", i.moveHandler), h(a, t.value, e), l({
+        ...e,
+        ...a,
+        leafletObject: t.value
+      }), r.value = !0, g(() => o.emit("ready", t.value));
+    }), X(() => ce(i)), { ready: r, leafletObject: t };
+  },
+  render() {
+    return R(this.ready, this.$slots);
+  }
+}), ae = {
+  ...oe,
+  smoothFactor: {
+    type: Number
+  },
+  noClip: {
+    type: Boolean,
+    default: void 0
+  },
+  latLngs: {
+    type: Array,
+    required: !0,
+    custom: !0
+  }
+}, ze = (e, o, t) => {
+  const { options: r, methods: n } = Se(
+    e,
+    o,
+    t
+  ), l = b(
+    e,
+    ae,
+    r
+  ), s = {
+    ...n,
+    setSmoothFactor(a) {
+      o.value.setStyle({ smoothFactor: a });
+    },
+    setNoClip(a) {
+      o.value.setStyle({ noClip: a });
+    },
+    addLatLng(a) {
+      o.value.addLatLng(a);
+    }
+  };
+  return { options: l, methods: s };
+}, Gt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  polylineProps: ae,
+  setupPolyline: ze
+}, Symbol.toStringTag, { value: "Module" })), Q = {
+  ...ae
+}, Ne = (e, o, t) => {
+  const { options: r, methods: n } = ze(
+    e,
+    o,
+    t
+  ), l = b(
+    e,
+    Q,
+    r
+  ), s = {
+    ...n,
+    toGeoJSON(a) {
+      return o.value.toGeoJSON(a);
+    }
+  };
+  return { options: l, methods: s };
+}, Ut = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  polygonProps: Q,
+  setupPolygon: Ne
+}, Symbol.toStringTag, { value: "Module" })), uo = O({
+  name: "LPolygon",
+  props: Q,
+  setup(e, o) {
+    const t = p(), r = p(!1), n = S(L), l = m(B), { options: s, methods: a } = Ne(e, t, o);
+    return j(async () => {
+      const { polygon: i } = n ? f.L : await import("./leaflet-src.esm-BSRIxBxW.mjs");
+      t.value = P(i(e.latLngs, s));
+      const { listeners: u } = C(o.attrs);
+      t.value.on(u), h(a, t.value, e), l({
+        ...e,
+        ...a,
+        leafletObject: t.value
+      }), r.value = !0, g(() => o.emit("ready", t.value));
+    }), { ready: r, leafletObject: t };
+  },
+  render() {
+    return R(this.ready, this.$slots);
+  }
+}), po = O({
+  name: "LPolyline",
+  props: ae,
+  setup(e, o) {
+    const t = p(), r = p(!1), n = S(L), l = m(B), { options: s, methods: a } = ze(e, t, o);
+    return j(async () => {
+      const { polyline: i } = n ? f.L : await import("./leaflet-src.esm-BSRIxBxW.mjs");
+      t.value = P(
+        i(e.latLngs, s)
+      );
+      const { listeners: u } = C(o.attrs);
+      t.value.on(u), h(a, t.value, e), l({
+        ...e,
+        ...a,
+        leafletObject: t.value
+      }), r.value = !0, g(() => o.emit("ready", t.value));
+    }), { ready: r, leafletObject: t };
+  },
+  render() {
+    return R(this.ready, this.$slots);
+  }
+}), ke = {
+  ...E,
+  content: {
+    type: String,
+    default: null
+  }
+}, Ge = (e, o) => {
+  const { options: t, methods: r } = W(e), n = {
+    ...r,
+    setContent(l) {
+      o.value && l !== null && l !== void 0 && o.value.setContent(l);
+    }
+  };
+  return { options: t, methods: n };
+}, Ue = (e) => e.default ? U("div", { ref: "root" }, e.default()) : null, xt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  popperProps: ke,
+  render: Ue,
+  setupPopper: Ge
+}, Symbol.toStringTag, { value: "Module" })), st = {
+  ...ke,
+  latLng: {
+    type: [Object, Array],
+    default: () => []
+  }
+}, it = (e, o) => {
+  const { options: t, methods: r } = Ge(e, o);
+  return { options: t, methods: r };
+}, $t = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  popupProps: st,
+  setupPopup: it
+}, Symbol.toStringTag, { value: "Module" })), co = O({
+  name: "LPopup",
+  props: st,
+  setup(e, o) {
+    const t = p(), r = p(null), n = S(L), l = m(be), s = m(he), { options: a, methods: i } = it(e, t);
+    return j(async () => {
+      const { popup: u } = n ? f.L : await import("./leaflet-src.esm-BSRIxBxW.mjs");
+      t.value = P(u(a)), e.latLng !== void 0 && t.value.setLatLng(e.latLng), h(i, t.value, e);
+      const { listeners: d } = C(o.attrs);
+      t.value.on(d), t.value.setContent(e.content || r.value || ""), l(t.value), g(() => o.emit("ready", t.value));
+    }), X(() => {
+      s();
+    }), { root: r, leafletObject: t };
+  },
+  render() {
+    return Ue(this.$slots);
+  }
+}), xe = {
+  ...Q,
+  latLngs: {
+    ...Q.latLngs,
+    required: !1
+  },
+  bounds: {
+    type: Object,
+    custom: !0
+  }
+}, ut = (e, o, t) => {
+  const { options: r, methods: n } = Ne(
+    e,
+    o,
+    t
+  ), l = b(
+    e,
+    xe,
+    r
+  ), s = {
+    ...n,
+    setBounds(a) {
+      o.value.setBounds(a);
+    },
+    setLatLngs(a) {
+      o.value.setBounds(a);
+    }
+  };
+  return { options: l, methods: s };
+}, Ft = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  rectangleProps: xe,
+  setupRectangle: ut
+}, Symbol.toStringTag, { value: "Module" })), yo = O({
+  name: "LRectangle",
+  props: xe,
+  setup(e, o) {
+    const t = p(), r = p(!1), n = S(L), l = m(B), { options: s, methods: a } = ut(e, t, o);
+    return j(async () => {
+      const { rectangle: i, latLngBounds: u } = n ? f.L : await import("./leaflet-src.esm-BSRIxBxW.mjs"), d = e.bounds ? u(e.bounds) : u(e.latLngs || []);
+      t.value = P(i(d, s));
+      const { listeners: y } = C(o.attrs);
+      t.value.on(y), h(a, t.value, e), l({
+        ...e,
+        ...a,
+        leafletObject: t.value
+      }), r.value = !0, g(() => o.emit("ready", t.value));
+    }), { ready: r, leafletObject: t };
+  },
+  render() {
+    return R(this.ready, this.$slots);
+  }
+}), se = {
+  ...ne,
+  tms: {
+    type: Boolean,
+    default: void 0
+  },
+  subdomains: {
+    type: [String, Array],
+    validator: (e) => typeof e == "string" ? !0 : Array.isArray(e) ? e.every((o) => typeof o == "string") : !1
+  },
+  detectRetina: {
+    type: Boolean,
+    default: void 0
+  },
+  url: {
+    type: String,
+    required: !0,
+    custom: !0
+  }
+}, $e = (e, o, t) => {
+  const { options: r, methods: n } = Ie(e, o, t), l = b(
+    e,
+    se,
+    r
+  ), s = {
+    ...n
+  };
+  return { options: l, methods: s };
+}, Dt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  setupTileLayer: $e,
+  tileLayerProps: se
+}, Symbol.toStringTag, { value: "Module" })), mo = O({
+  props: se,
+  setup(e, o) {
+    const t = p(), r = S(L), n = m(B), { options: l, methods: s } = $e(e, t, o);
+    return j(async () => {
+      const { tileLayer: a } = r ? f.L : await import("./leaflet-src.esm-BSRIxBxW.mjs");
+      t.value = P(a(e.url, l));
+      const { listeners: i } = C(o.attrs);
+      t.value.on(i), h(s, t.value, e), n({
+        ...e,
+        ...s,
+        leafletObject: t.value
+      }), g(() => o.emit("ready", t.value));
+    }), { leafletObject: t };
+  },
+  render() {
+    return null;
+  }
+}), pt = {
+  ...ke
+}, dt = (e, o) => {
+  const { options: t, methods: r } = Ge(e, o), n = m(Le);
+  return X(() => {
+    n();
+  }), { options: t, methods: r };
+}, Zt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  setupTooltip: dt,
+  tooltipProps: pt
+}, Symbol.toStringTag, { value: "Module" })), vo = O({
+  name: "LTooltip",
+  props: pt,
+  setup(e, o) {
+    const t = p(), r = p(null), n = S(L), l = m(ge), { options: s, methods: a } = dt(e, t);
+    return j(async () => {
+      const { tooltip: i } = n ? f.L : await import("./leaflet-src.esm-BSRIxBxW.mjs");
+      t.value = P(i(s)), h(a, t.value, e);
+      const { listeners: u } = C(o.attrs);
+      t.value.on(u), t.value.setContent(e.content || r.value || ""), l(t.value), g(() => o.emit("ready", t.value));
+    }), { root: r, leafletObject: t };
+  },
+  render() {
+    return Ue(this.$slots);
+  }
+}), Fe = {
+  ...se,
+  layers: {
+    type: String,
+    required: !0
+  },
+  styles: {
+    type: String
+  },
+  format: {
+    type: String
+  },
+  transparent: {
+    type: Boolean,
+    default: void 0
+  },
+  version: {
+    type: String
+  },
+  crs: {
+    type: Object
+  },
+  uppercase: {
+    type: Boolean,
+    default: void 0
+  }
+}, ct = (e, o, t) => {
+  const { options: r, methods: n } = $e(e, o, t);
+  return {
+    options: b(
+      e,
+      Fe,
+      r
+    ),
+    methods: {
+      ...n
+    }
+  };
+}, Et = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  setupWMSTileLayer: ct,
+  wmsTileLayerProps: Fe
+}, Symbol.toStringTag, { value: "Module" })), fo = O({
+  props: Fe,
+  setup(e, o) {
+    const t = p(), r = S(L), n = m(B), { options: l, methods: s } = ct(
+      e,
+      t,
+      o
+    );
+    return j(async () => {
+      const { tileLayer: a } = r ? f.L : await import("./leaflet-src.esm-BSRIxBxW.mjs");
+      t.value = P(
+        a.wms(e.url, l)
+      );
+      const { listeners: i } = C(o.attrs);
+      t.value.on(i), h(s, t.value, e), n({
+        ...e,
+        ...s,
+        leafletObject: t.value
+      }), g(() => o.emit("ready", t.value));
+    }), { leafletObject: t };
+  },
+  render() {
+    return null;
+  }
+}), bo = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Circle: Ot,
+  CircleMarker: Lt,
+  Component: ft,
+  Control: St,
+  ControlAttribution: jt,
+  ControlLayers: _t,
+  ControlScale: Pt,
+  ControlZoom: Tt,
+  FeatureGroup: Bt,
+  GeoJSON: wt,
+  GridLayer: At,
+  Icon: It,
+  ImageOverlay: Mt,
+  InteractiveLayer: gt,
+  Layer: bt,
+  LayerGroup: Ct,
+  Marker: kt,
+  Path: ht,
+  Polygon: Ut,
+  Polyline: Gt,
+  Popper: xt,
+  Popup: $t,
+  Rectangle: Ft,
+  TileLayer: Dt,
+  Tooltip: Zt,
+  WmsTileLayer: Et
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  bo as Functions,
+  qt as InjectionKeys,
+  Ht as LCircle,
+  Vt as LCircleMarker,
+  Kt as LControl,
+  Qt as LControlAttribution,
+  Xt as LControlLayers,
+  Yt as LControlScale,
+  eo as LControlZoom,
+  to as LFeatureGroup,
+  oo as LGeoJson,
+  ro as LGridLayer,
+  lo as LIcon,
+  no as LImageOverlay,
+  ao as LLayerGroup,
+  so as LMap,
+  io as LMarker,
+  uo as LPolygon,
+  po as LPolyline,
+  co as LPopup,
+  yo as LRectangle,
+  mo as LTileLayer,
+  vo as LTooltip,
+  fo as LWmsTileLayer,
+  Jt as Utilities
+};