tg-map-vue3 3.0.1

package/dist/tg-map.js

@@ -0,0 +1,4871 @@
+var Wt = Object.defineProperty;
+var Vt = (i, e, t) => e in i ? Wt(i, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : i[e] = t;
+var h = (i, e, t) => (Vt(i, typeof e != "symbol" ? e + "" : e, t), t);
+import { defineComponent as C, computed as Ht, openBlock as D, createElementBlock as Z, createElementVNode as Ft, createCommentVNode as dt, renderSlot as A, normalizeClass as q, normalizeStyle as Ut, withDirectives as Yt, vShow as Kt, mergeProps as qt, toHandlers as Xt } from "vue";
+function I(i) {
+  throw new Error(i);
+}
+function Jt(i) {
+  throw new Error(`Unsupported: ${i}`);
+}
+function Ci(i) {
+  throw new Error(`todo: ${i}`);
+}
+function wi(i) {
+  return i;
+}
+function fe(...i) {
+}
+function Qt(i) {
+  return i != null;
+}
+function V(i, e) {
+  return {
+    type: String,
+    default: e,
+    validator: (t) => Object.values(i).includes(t)
+  };
+}
+function er(i, e) {
+  return {
+    type: String,
+    default: e,
+    validator: (t) => i.includes(t)
+  };
+}
+function z(i) {
+  return {
+    type: i,
+    required: !0
+  };
+}
+function m(i, e) {
+  return {
+    type: i,
+    default: e
+  };
+}
+function xi(i) {
+  const e = {};
+  return Object.entries(i).forEach(([t, r]) => {
+    const s = `__${t}`;
+    e[t] = {
+      get() {
+        const o = this[s];
+        return o === void 0 ? r : o;
+      },
+      set(o) {
+        this[s] = o;
+      }
+      // Vue3已经不支持该属性
+      // cache: false
+    };
+  }), e;
+}
+const ie = {
+  enumerable: !0,
+  configurable: !0,
+  get: fe,
+  set: fe
+};
+function tr(i) {
+  return Object.keys(i).forEach((e) => {
+    const t = i[e];
+    let r = !1;
+    typeof t == "function" ? (ie.get = t, ie.set = fe, r = !0) : typeof t == "object" && typeof t.get == "function" && (ie.get = t.get, ie.set = t.set, r = !0), r && (i[e] = Object.defineProperty(i, e, ie));
+  }), i;
+}
+function Ei(i) {
+  return tr(i);
+}
+function rr(i, e) {
+  return e._e();
+}
+function ue(i, e) {
+  const t = i.$options[e];
+  if (t)
+    for (const r of t)
+      r.call(i);
+}
+function we(i, e) {
+  for (const t of i)
+    if (t.$options.name === e.name)
+      return t;
+}
+const ki = {
+  /**
+   * @event 一般来说传{@link Tg.Event}对象, 但传其他对象也不会报错
+   */
+  eventLog(i) {
+    console.log(i), this.$_prev_type = i && i.type, this.$_prev_time = Date.now();
+  },
+  /** @see eventLog */
+  eventLogLess(i) {
+    ((i && i.type) !== this.$_prev_type || Date.now() - (this.$_prev_time ?? 0) > 1e3) && this.eventLog(i);
+  }
+};
+var ye;
+((i) => {
+  function e(r, s) {
+    if (r !== void 0)
+      return Object.values(s).includes(r) ? r : void 0;
+  }
+  i.toEnumOrNull = e;
+  function t(r) {
+    return r.split(`
+`).map((s) => s.trim()).join(`
+`);
+  }
+  i.trimIndent = t;
+})(ye || (ye = {}));
+const _t = "$map", Ie = "onCreate", Pe = "onDestroy", w = C({
+  inject: [_t],
+  mounted() {
+    ue(this, Ie);
+  },
+  beforeDestroy() {
+    ue(this, Pe);
+  },
+  methods: {
+    recreate() {
+      ue(this, Pe), ue(this, Ie);
+    }
+  },
+  render(i) {
+    return rr(i, this);
+  }
+});
+var Mt = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {}, j = {}, ir = {
+  get exports() {
+    return j;
+  },
+  set exports(i) {
+    j = i;
+  }
+};
+(function(i) {
+  (function(e, t) {
+    i.exports ? i.exports = t() : e.coordtransform = t();
+  })(Mt, function() {
+    var e = 52.35987755982988, t = 3.141592653589793, r = 6378245, s = 0.006693421622965943;
+    function o(p, f, v, O) {
+      this.west = Math.min(p, v), this.north = Math.max(f, O), this.east = Math.max(p, v), this.south = Math.min(f, O);
+    }
+    o.prototype.contain = function(p, f) {
+      return this.west <= p && this.east >= p && this.north >= f && this.south <= f;
+    };
+    var a = [
+      new o(79.4462, 49.2204, 96.33, 42.8899),
+      new o(109.6872, 54.1415, 135.0002, 39.3742),
+      new o(73.1246, 42.8899, 124.143255, 29.5297),
+      new o(82.9684, 29.5297, 97.0352, 26.7186),
+      new o(97.0253, 29.5297, 124.367395, 20.414096),
+      new o(107.975793, 20.414096, 111.744104, 17.871542)
+    ], g = [
+      new o(119.921265, 25.398623, 122.497559, 21.785006),
+      new o(101.8652, 22.284, 106.665, 20.0988),
+      new o(106.4525, 21.5422, 108.051, 20.4878),
+      new o(109.0323, 55.8175, 119.127, 50.3257),
+      new o(127.4568, 55.8175, 137.0227, 49.5574),
+      new o(131.2662, 44.8922, 137.0227, 42.5692),
+      new o(73.1246, 35.398637, 77.948114, 29.5297)
+    ];
+    function n(p, f) {
+      for (var v = 0; v < a.length; v++)
+        if (a[v].contain(p, f)) {
+          for (var O = 0; O < g.length; O++)
+            if (g[O].contain(p, f))
+              return !1;
+          return !0;
+        }
+      return !1;
+    }
+    function l(p, f) {
+      var v = p - 65e-4, O = f - 6e-3, F = Math.sqrt(v * v + O * O) - 2e-5 * Math.sin(O * e), B = Math.atan2(O, v) - 3e-6 * Math.cos(v * e), pe = F * Math.cos(B), Ce = F * Math.sin(B);
+      return [pe, Ce];
+    }
+    function c(p, f) {
+      var v = Math.sqrt(p * p + f * f) + 2e-5 * Math.sin(f * e), O = Math.atan2(f, p) + 3e-6 * Math.cos(p * e), F = v * Math.cos(O) + 65e-4, B = v * Math.sin(O) + 6e-3;
+      return [F, B];
+    }
+    function u(p, f) {
+      return n(p, f) ? b(p, f) : [p, f];
+    }
+    function d(p, f) {
+      if (!n(p, f))
+        return [p, f];
+      var v = b(p, f);
+      return [p * 2 - v[0], f * 2 - v[1]];
+    }
+    function b(p, f) {
+      var v = M(p - 105, f - 35), O = T(p - 105, f - 35), F = f / 180 * t, B = Math.sin(F);
+      B = 1 - s * B * B;
+      var pe = Math.sqrt(B);
+      v = v * 180 / (r * (1 - s) / (B * pe) * t), O = O * 180 / (r / pe * Math.cos(F) * t);
+      var Ce = f + v, jt = p + O;
+      return [jt, Ce];
+    }
+    function M(p, f) {
+      var v = -100 + 2 * p + 3 * f + 0.2 * f * f + 0.1 * p * f + 0.2 * Math.sqrt(Math.abs(p));
+      return v += (20 * Math.sin(6 * p * t) + 20 * Math.sin(2 * p * t)) * 2 / 3, v += (20 * Math.sin(f * t) + 40 * Math.sin(f / 3 * t)) * 2 / 3, v += (160 * Math.sin(f / 12 * t) + 320 * Math.sin(f * t / 30)) * 2 / 3, v;
+    }
+    function T(p, f) {
+      var v = 300 + p + 2 * f + 0.1 * p * p + 0.1 * p * f + 0.1 * Math.sqrt(Math.abs(p));
+      return v += (20 * Math.sin(6 * p * t) + 20 * Math.sin(2 * p * t)) * 2 / 3, v += (20 * Math.sin(p * t) + 40 * Math.sin(p / 3 * t)) * 2 / 3, v += (150 * Math.sin(p / 12 * t) + 300 * Math.sin(p / 30 * t)) * 2 / 3, v;
+    }
+    return {
+      // 向前兼容
+      bd09togcj02: l,
+      gcj02tobd09: c,
+      wgs84togcj02: u,
+      gcj02towgs84: d,
+      // 小驼峰命名风格
+      bd09ToGcj02: l,
+      gcj02ToBd09: c,
+      wgs84ToGcj02: u,
+      gcj02ToWgs84: d,
+      bd09ToWgs84: function(p, f) {
+        if (!n(p, f))
+          return [p, f];
+        var v = l(p, f);
+        return d(v[0], v[1]);
+      },
+      wgs84ToBd09: function(p, f) {
+        if (!n(p, f))
+          return [p, f];
+        var v = u(p, f);
+        return c(v[0], v[1]);
+      }
+    };
+  });
+})(ir);
+function ne(i, e) {
+  if (!i)
+    throw new Error(`AssertionError: ${e}`);
+}
+function pt(i) {
+  throw new Error(`Unexpected object: ${i}`);
+}
+var Y = /* @__PURE__ */ ((i) => (i.wgs84 = "wgs84", i.gcj02 = "gcj02", i.bd09 = "bd09", i))(Y || {});
+const xe = "wgs84", S = class {
+  constructor(e, t, r) {
+    this.lat = e, this.lng = t, this.coord = r;
+  }
+  /** @param coord Baidu Map的坐标一般都是bd09 */
+  static fromBaidu(e, t) {
+    return new S(e.lat, e.lng, t);
+  }
+  /** @param coord Google Map的坐标依据地图类型不同是不一样的 */
+  static fromGoogle(e, t) {
+    return new S(e.lat(), e.lng(), t);
+  }
+  static fromHere(e, t) {
+    return new S(e.lat, e.lng, t);
+  }
+  static fromLiteral(e) {
+    return new S(e.lat, e.lng, e.coord || xe);
+  }
+  static fromLngLat(e, t, r = xe) {
+    return new S(t, e, r);
+  }
+  static create(e, t, r = xe) {
+    return new S(e, t, r);
+  }
+  to(e) {
+    if (this.coord === e)
+      return this;
+    const [t, r] = this.convert(e);
+    return new S(r, t, e);
+  }
+  toBaidu(e) {
+    let t = this.lat, r = this.lng;
+    return this.coord !== e && ([r, t] = this.convert(e)), new BMap.Point(r, t);
+  }
+  toGoogle(e) {
+    let t = this.lat, r = this.lng;
+    return this.coord !== e && ([r, t] = this.convert(e)), new google.maps.LatLng(t, r);
+  }
+  toHere(e) {
+    let t = this.lat, r = this.lng;
+    return this.coord !== e && ([r, t] = this.convert(e)), new H.geo.Point(t, r);
+  }
+  /**
+   * 该方法之所以设计的这么不友好, 是为了防止不必要的开销(大概有点影响😅)
+   *
+   * @returns `[lng, lat]` 注意不要取错顺序
+   * @throws 若当前coord和targetCoord相同, 会抛异常, 故请在外部判断
+   */
+  // TODO: 2023/03/14 ipcjs 这里设成private, 有些地方会报类型错误...
+  /*private*/
+  convert(e) {
+    switch (this.coord) {
+      case "bd09":
+        return e === "gcj02" ? j.bd09ToGcj02(this.lng, this.lat) : j.bd09ToWgs84(this.lng, this.lat);
+      case "gcj02":
+        return e === "wgs84" ? j.gcj02ToWgs84(this.lng, this.lat) : j.gcj02ToBd09(this.lng, this.lat);
+      case "wgs84":
+        return e === "bd09" ? j.wgs84ToBd09(this.lng, this.lat) : j.wgs84ToGcj02(this.lng, this.lat);
+    }
+    throw new Error(`不支持的坐标转换: ${this.coord}=>${e}`);
+  }
+  equals(e) {
+    return this === e ? !0 : this.lat === e.lat && this.lng === e.lng && this.coord === e.coord;
+  }
+  toString() {
+    return JSON.stringify(this);
+  }
+};
+let y = S;
+h(y, "ZERO", S.create(0, 0));
+const U = class {
+  /**
+   * 不推荐直接创建LatLngBounds, sw和ne的大小关系可能没法保证, 推荐用LatLngBounds.Builder或者LatLngBounds.from等静态方法来创建
+   * @param sw 西南, lat/lng更小
+   * @param ne 东北, lat/lng更大
+   */
+  constructor(e, t) {
+    h(this, "coord");
+    this.sw = e, this.ne = t, ne(e.coord === t.coord, "sw和ne的coord应该相同"), ne(Number.isFinite(e.lat) && Number.isFinite(e.lng) && Number.isFinite(t.lat) && Number.isFinite(t.lng), `sw(${e})和ne(${t})不能包含NaN或Infinite`), ne(e.lat <= t.lat, `sw.lat(${e.lat})应该比ne.lat(${t.lat})小`), this.coord = e.coord;
+  }
+  static isBetweenLng(e, t, r) {
+    return e <= t ? e <= r && r <= t : e <= r || r <= t;
+  }
+  static fromArray(e) {
+    if (e.length === 0)
+      return;
+    const t = new U.Builder(e[0]);
+    for (let r = 1; r < e.length; r++)
+      t.include(e[r]);
+    return t.build();
+  }
+  static from(...e) {
+    return this.fromArray(e) ?? I("positions中没有点");
+  }
+  static fromGoogle(e, t) {
+    return new U(
+      y.fromGoogle(e.getSouthWest(), t),
+      y.fromGoogle(e.getNorthEast(), t)
+    );
+  }
+  static fromBaidu(e, t) {
+    return new U(
+      y.fromBaidu(e.getSouthWest(), t),
+      y.fromBaidu(e.getNorthEast(), t)
+    );
+  }
+  static create(e, t) {
+    return this.from(e, t);
+  }
+  isEmpty() {
+    return this.sw.equals(this.ne);
+  }
+  contains(e) {
+    const { lat: t, lng: r } = e.to(this.coord);
+    return this.sw.lat <= t && t <= this.ne.lat && U.isBetweenLng(this.sw.lng, this.ne.lng, r);
+  }
+  getCenter() {
+    const e = (this.sw.lat + this.ne.lat) / 2, t = (this.sw.lng + this.ne.lng + (this.sw.lng < this.ne.lng ? 0 : 360)) / 2;
+    return y.create(e, t, this.coord);
+  }
+  toString() {
+    return JSON.stringify(this);
+  }
+  equals(e) {
+    return this.sw.equals(e.sw) && this.ne.equals(e.ne);
+  }
+  toGoogle(e) {
+    return new google.maps.LatLngBounds(this.sw.toGoogle(e), this.ne.toGoogle(e));
+  }
+  toBaidu(e) {
+    return new BMap.Bounds(this.sw.toBaidu(e), this.ne.toBaidu(e));
+  }
+  toBaiduArray(e) {
+    return [this.sw.toBaidu(e), this.ne.toBaidu(e)];
+  }
+};
+let W = U;
+h(W, "EMPTY", new U(y.ZERO, y.ZERO));
+((i) => {
+  class e {
+    constructor(r) {
+      h(this, "coord");
+      h(this, "minLat");
+      h(this, "minLng");
+      h(this, "maxLat");
+      h(this, "maxLng");
+      this.coord = r.coord, this.minLat = this.maxLat = r.lat, this.minLng = this.maxLng = r.lng;
+    }
+    build() {
+      return new i(
+        // sw对应min
+        y.create(this.minLat, this.minLng, this.coord),
+        // ne对应max
+        y.create(this.maxLat, this.maxLng, this.coord)
+      );
+    }
+    include(r) {
+      const { lat: s, lng: o } = r.to(this.coord);
+      return this.minLat = Math.min(this.minLat, s), this.maxLat = Math.max(this.maxLat, s), i.isBetweenLng(this.minLng, this.maxLng, o) || (this.delta(this.minLng, o) < this.delta(o, this.maxLng) ? this.minLng = o : this.maxLng = o), this;
+    }
+    delta(r, s) {
+      return (r - s + 360) % 360;
+    }
+  }
+  i.Builder = e;
+})(W || (W = {}));
+function Ii() {
+}
+function Pi(i) {
+  return i;
+}
+function Li(i, e) {
+  return i instanceof e;
+}
+function Bi(i, e) {
+  if (i instanceof e)
+    return i;
+}
+function re(i, e) {
+  if ((i == null ? void 0 : i.$options.name) === e.name)
+    return i;
+}
+class Re {
+  constructor(e) {
+    h(this, "latestInfoWindow");
+    /** 使用{@link setEventTargetDelegate}初始化 */
+    h(this, "delegate", void 0);
+    this.element = e, {}.NODE_ENV !== "production" && setTimeout(() => {
+      this.delegate || console.warn(`${this.constructor.name}继承了AbstractMap, 但未调用setEventTargetDelegate(delegate)`);
+    });
+  }
+  setEventTargetDelegate(e) {
+    this.delegate = e.setTarget(this);
+  }
+  addEventListener(e, t) {
+    this.delegate.addEventListener(e, t);
+  }
+  removeEventListener(e, t) {
+    this.delegate.removeEventListener(e, t);
+  }
+  /** 最后一次显示的InfoWindow, 不保证当前它仍然是打开状态 */
+  getLatestInfoWindow() {
+    return this.latestInfoWindow;
+  }
+  /** 仅用于@tg/map内部使用, 外部不要调用 */
+  setLatestInfoWindowInternal(e) {
+    this.latestInfoWindow = e;
+  }
+  addOverlayMapType(e) {
+    this.addLayer(e);
+  }
+  removeOverlayMapType(e) {
+    this.removeLayer(e);
+  }
+  addControl(e) {
+    e.addTo(this);
+  }
+  removeControl(e) {
+    e.removeFrom(this);
+  }
+  // 同名方法
+  getZoom() {
+    return this.innerMap.getZoom();
+  }
+  setZoom(e) {
+    this.innerMap.setZoom(e);
+  }
+}
+var sr = function(e) {
+  return or(e) && !nr(e);
+};
+function or(i) {
+  return !!i && typeof i == "object";
+}
+function nr(i) {
+  var e = Object.prototype.toString.call(i);
+  return e === "[object RegExp]" || e === "[object Date]" || hr(i);
+}
+var ar = typeof Symbol == "function" && Symbol.for, lr = ar ? Symbol.for("react.element") : 60103;
+function hr(i) {
+  return i.$$typeof === lr;
+}
+function cr(i) {
+  return Array.isArray(i) ? [] : {};
+}
+function ae(i, e) {
+  return e.clone !== !1 && e.isMergeableObject(i) ? Q(cr(i), i, e) : i;
+}
+function dr(i, e, t) {
+  return i.concat(e).map(function(r) {
+    return ae(r, t);
+  });
+}
+function pr(i, e) {
+  if (!e.customMerge)
+    return Q;
+  var t = e.customMerge(i);
+  return typeof t == "function" ? t : Q;
+}
+function ur(i) {
+  return Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(i).filter(function(e) {
+    return Object.propertyIsEnumerable.call(i, e);
+  }) : [];
+}
+function ut(i) {
+  return Object.keys(i).concat(ur(i));
+}
+function bt(i, e) {
+  try {
+    return e in i;
+  } catch {
+    return !1;
+  }
+}
+function gr(i, e) {
+  return bt(i, e) && !(Object.hasOwnProperty.call(i, e) && Object.propertyIsEnumerable.call(i, e));
+}
+function mr(i, e, t) {
+  var r = {};
+  return t.isMergeableObject(i) && ut(i).forEach(function(s) {
+    r[s] = ae(i[s], t);
+  }), ut(e).forEach(function(s) {
+    gr(i, s) || (bt(i, s) && t.isMergeableObject(e[s]) ? r[s] = pr(s, t)(i[s], e[s], t) : r[s] = ae(e[s], t));
+  }), r;
+}
+function Q(i, e, t) {
+  t = t || {}, t.arrayMerge = t.arrayMerge || dr, t.isMergeableObject = t.isMergeableObject || sr, t.cloneUnlessOtherwiseSpecified = ae;
+  var r = Array.isArray(e), s = Array.isArray(i), o = r === s;
+  return o ? r ? t.arrayMerge(i, e, t) : mr(i, e, t) : ae(e, t);
+}
+Q.all = function(e, t) {
+  if (!Array.isArray(e))
+    throw new Error("first argument should be an array");
+  return e.reduce(function(r, s) {
+    return Q(r, s, t);
+  }, {});
+};
+var fr = Q, Tt = fr;
+/*!
+ * isobject <https://github.com/jonschlinkert/isobject>
+ *
+ * Copyright (c) 2014-2017, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+function yr(i) {
+  return i != null && typeof i == "object" && Array.isArray(i) === !1;
+}
+/*!
+ * is-plain-object <https://github.com/jonschlinkert/is-plain-object>
+ *
+ * Copyright (c) 2014-2017, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+function gt(i) {
+  return yr(i) === !0 && Object.prototype.toString.call(i) === "[object Object]";
+}
+function Ot(i) {
+  var e, t;
+  return !(gt(i) === !1 || (e = i.constructor, typeof e != "function") || (t = e.prototype, gt(t) === !1) || t.hasOwnProperty("isPrototypeOf") === !1);
+}
+var le;
+((i) => {
+  function e(o, a) {
+    return o.reduce((g, n) => (g[a(n)] = n, g), {});
+  }
+  i.fromArray = e;
+  function t(o) {
+    return o.reduce((a, g) => (a[g[0]] = g[1], a), {});
+  }
+  i.fromEntries = t;
+  function r(o) {
+    return JSON.stringify(o, (a, g) => typeof g == "object" && Object.getPrototypeOf(g) !== Object.prototype ? g.toString !== Object.prototype.toString ? g.toString() : `[object ${Object.getPrototypeOf(g).constructor.name}]` : g);
+  }
+  i.toJsonSafely = r;
+  function s(o) {
+    Ot(o) && Object.keys(o).forEach((a) => {
+      o[a] === void 0 ? delete o[a] : s(o[a]);
+    });
+  }
+  i.deleteUndefinedPropertyOnPlainObjectDeeply = s;
+})(le || (le = {}));
+le.toJsonSafely;
+var N = /* @__PURE__ */ ((i) => (i.auto = "auto", i.none = "none", i.greedy = "greedy", i.cooperative = "cooperative", i))(N || {}), Le;
+((i) => {
+  function e(t) {
+    le.deleteUndefinedPropertyOnPlainObjectDeeply(t);
+    const r = { center: y.ZERO, zoom: 5 };
+    return Tt(r, t || {}, {
+      isMergeableObject: Ot
+    });
+  }
+  i.create = e;
+})(Le || (Le = {}));
+var Be = {}, vr = {
+  get exports() {
+    return Be;
+  },
+  set exports(i) {
+    Be = i;
+  }
+};
+(function(i, e) {
+  (function(t, r) {
+    i.exports = r();
+  })(Mt, function() {
+    var t, r = t = r || { version: "1.3.8" }, s = {};
+    r.guid = "$BAIDU$", s[r.guid] = s[r.guid] || {}, r.dom = r.dom || {}, r.dom.g = function(n) {
+      return typeof n == "string" || n instanceof String ? document.getElementById(n) : n && n.nodeName && (n.nodeType == 1 || n.nodeType == 9) ? n : null;
+    }, r.g = r.G = r.dom.g, r.dom.getDocument = function(n) {
+      return n = r.dom.g(n), n.nodeType == 9 ? n : n.ownerDocument || n.document;
+    }, r.lang = r.lang || {}, r.lang.isString = function(n) {
+      return Object.prototype.toString.call(n) == "[object String]";
+    }, r.isString = r.lang.isString, r.dom._g = function(n) {
+      return r.lang.isString(n) ? document.getElementById(n) : n;
+    }, r._g = r.dom._g, r.browser = r.browser || {}, /msie (\d+\.\d)/i.test(navigator.userAgent) && (r.browser.ie = r.ie = document.documentMode || +RegExp.$1), r.dom.getComputedStyle = function(n, l) {
+      n = r.dom._g(n);
+      var c = r.dom.getDocument(n), u;
+      return c.defaultView && c.defaultView.getComputedStyle && (u = c.defaultView.getComputedStyle(n, null), u) ? u[l] || u.getPropertyValue(l) : "";
+    }, r.dom._styleFixer = r.dom._styleFixer || {}, r.dom._styleFilter = r.dom._styleFilter || [], r.dom._styleFilter.filter = function(n, l, c) {
+      for (var u = 0, d = r.dom._styleFilter, b; b = d[u]; u++)
+        (b = b[c]) && (l = b(n, l));
+      return l;
+    }, r.string = r.string || {}, r.string.toCamelCase = function(n) {
+      return n.indexOf("-") < 0 && n.indexOf("_") < 0 ? n : n.replace(/[-_][^-_]/g, function(l) {
+        return l.charAt(1).toUpperCase();
+      });
+    }, r.dom.getStyle = function(n, l) {
+      var c = r.dom;
+      n = c.g(n), l = r.string.toCamelCase(l);
+      var u = n.style[l] || (n.currentStyle ? n.currentStyle[l] : "") || c.getComputedStyle(n, l);
+      if (!u) {
+        var d = c._styleFixer[l];
+        d && (u = d.get ? d.get(n) : r.dom.getStyle(n, d));
+      }
+      return (d = c._styleFilter) && (u = d.filter(l, u, "get")), u;
+    }, r.getStyle = r.dom.getStyle, /opera\/(\d+\.\d)/i.test(navigator.userAgent) && (r.browser.opera = +RegExp.$1), r.browser.isWebkit = /webkit/i.test(navigator.userAgent), r.browser.isGecko = /gecko/i.test(navigator.userAgent) && !/like gecko/i.test(navigator.userAgent), r.browser.isStrict = document.compatMode == "CSS1Compat", r.dom.getPosition = function(n) {
+      n = r.dom.g(n);
+      var l = r.dom.getDocument(n), c = r.browser, u = r.dom.getStyle;
+      c.isGecko > 0 && l.getBoxObjectFor && u(n, "position") == "absolute" && (n.style.top === "" || n.style.left);
+      var d = { left: 0, top: 0 }, b = c.ie && !c.isStrict ? l.body : l.documentElement, M, T;
+      if (n == b)
+        return d;
+      if (n.getBoundingClientRect) {
+        T = n.getBoundingClientRect(), d.left = Math.floor(T.left) + Math.max(l.documentElement.scrollLeft, l.body.scrollLeft), d.top = Math.floor(T.top) + Math.max(l.documentElement.scrollTop, l.body.scrollTop), d.left -= l.documentElement.clientLeft, d.top -= l.documentElement.clientTop;
+        var p = l.body, f = parseInt(u(p, "borderLeftWidth")), v = parseInt(u(p, "borderTopWidth"));
+        c.ie && !c.isStrict && (d.left -= isNaN(f) ? 2 : f, d.top -= isNaN(v) ? 2 : v);
+      } else {
+        M = n;
+        do {
+          if (d.left += M.offsetLeft, d.top += M.offsetTop, c.isWebkit > 0 && u(M, "position") == "fixed") {
+            d.left += l.body.scrollLeft, d.top += l.body.scrollTop;
+            break;
+          }
+          M = M.offsetParent;
+        } while (M && M != n);
+        for ((c.opera > 0 || c.isWebkit > 0 && u(n, "position") == "absolute") && (d.top -= l.body.offsetTop), M = n.offsetParent; M && M != l.body; )
+          d.left -= M.scrollLeft, (!c.opera || M.tagName != "TR") && (d.top -= M.scrollTop), M = M.offsetParent;
+      }
+      return d;
+    }, r.event = r.event || {}, r.event._listeners = r.event._listeners || [], r.event.on = function(n, l, c) {
+      l = l.replace(/^on/i, ""), n = r.dom._g(n);
+      var u = function(p) {
+        c.call(n, p);
+      }, d = r.event._listeners, b = r.event._eventFilter, M, T = l;
+      return l = l.toLowerCase(), b && b[l] && (M = b[l](n, l, u), T = M.type, u = M.listener), n.addEventListener ? n.addEventListener(T, u, !1) : n.attachEvent && n.attachEvent("on" + T, u), d[d.length] = [n, l, c, u, T], n;
+    }, r.on = r.event.on, function() {
+      var n = s[r.guid];
+      r.lang.guid = function() {
+        return "TANGRAM__" + (n._counter++).toString(36);
+      }, n._counter = n._counter || 1;
+    }(), s[r.guid]._instances = s[r.guid]._instances || {}, r.lang.isFunction = function(n) {
+      return Object.prototype.toString.call(n) == "[object Function]";
+    }, r.lang.Class = function(n) {
+      this.guid = n || r.lang.guid(), s[r.guid]._instances[this.guid] = this;
+    }, s[r.guid]._instances = s[r.guid]._instances || {}, r.lang.Class.prototype.dispose = function() {
+      delete s[r.guid]._instances[this.guid];
+      for (var n in this)
+        r.lang.isFunction(this[n]) || delete this[n];
+      this.disposed = !0;
+    }, r.lang.Class.prototype.toString = function() {
+      return "[object " + (this._className || "Object") + "]";
+    }, r.lang.Event = function(n, l) {
+      this.type = n, this.returnValue = !0, this.target = l || null, this.currentTarget = null;
+    }, r.lang.Class.prototype.addEventListener = function(n, l, c) {
+      if (r.lang.isFunction(l)) {
+        !this.__listeners && (this.__listeners = {});
+        var u = this.__listeners, d;
+        if (typeof c == "string" && c) {
+          if (/[^\w\-]/.test(c))
+            throw "nonstandard key:" + c;
+          l.hashCode = c, d = c;
+        }
+        n.indexOf("on") != 0 && (n = "on" + n), typeof u[n] != "object" && (u[n] = {}), d = d || r.lang.guid(), l.hashCode = d, u[n][d] = l;
+      }
+    }, r.lang.Class.prototype.removeEventListener = function(n, l) {
+      if (!(typeof l < "u" && (r.lang.isFunction(l) && !(l = l.hashCode) || !r.lang.isString(l)))) {
+        !this.__listeners && (this.__listeners = {}), n.indexOf("on") != 0 && (n = "on" + n);
+        var c = this.__listeners;
+        if (c[n])
+          if (typeof l < "u")
+            c[n][l] && delete c[n][l];
+          else
+            for (var u in c[n])
+              delete c[n][u];
+      }
+    }, r.lang.Class.prototype.dispatchEvent = function(n, l) {
+      r.lang.isString(n) && (n = new r.lang.Event(n)), !this.__listeners && (this.__listeners = {}), l = l || {};
+      for (var c in l)
+        n[c] = l[c];
+      var c, u = this.__listeners, d = n.type;
+      if (n.target = n.target || this, n.currentTarget = this, d.indexOf("on") != 0 && (d = "on" + d), r.lang.isFunction(this[d]) && this[d].apply(this, arguments), typeof u[d] == "object")
+        for (c in u[d])
+          u[d][c].apply(this, arguments);
+      return n.returnValue;
+    }, r.lang.inherits = function(n, l, c) {
+      var u, d, b = n.prototype, M = new Function();
+      M.prototype = l.prototype, d = n.prototype = new M();
+      for (u in b)
+        d[u] = b[u];
+      n.prototype.constructor = n, n.superClass = l.prototype, typeof c == "string" && (d._className = c);
+    }, r.inherits = r.lang.inherits;
+    var o = "http://api.map.baidu.com/library/TextIconOverlay/1.2/src/images/m", a = "png", g = function(n, l, c) {
+      try {
+        BMap;
+      } catch {
+        throw Error("Baidu Map JS API is not ready yet!");
+      }
+      t.lang.inherits(g, BMap.Overlay, "TextIconOverlay"), this._position = n, this._text = l, this._options = c || {}, this._styles = this._options.styles || [], this._zIndex = this._options.zIndex, !this._styles.length && this._setupDefaultStyles();
+    };
+    return g.prototype._setupDefaultStyles = function() {
+      for (var n = [53, 56, 66, 78, 90], l = 0, c; c = n[l]; l++)
+        this._styles.push({
+          url: o + l + "." + a,
+          size: new BMap.Size(c, c)
+        });
+    }, g.prototype.initialize = function(n) {
+      return this._map = n, this._domElement = document.createElement("div"), this._updateCss(), this._updateText(), this._updatePosition(), this._bind(), this._map.getPanes().markerMouseTarget.appendChild(this._domElement), this._domElement;
+    }, g.prototype.draw = function() {
+      this._map && this._updatePosition();
+    }, g.prototype.getText = function() {
+      return this._text;
+    }, g.prototype.setText = function(n) {
+      n && (!this._text || this._text.toString() != n.toString()) && (this._text = n, this._updateText(), this._updateCss(), this._updatePosition());
+    }, g.prototype.getPosition = function() {
+      return this._position;
+    }, g.prototype.setPosition = function(n) {
+      n && (!this._position || !this._position.equals(n)) && (this._position = n, this._updatePosition());
+    }, g.prototype.getStyleByText = function(n, l) {
+      var c = parseInt(n), u = parseInt(c / 10);
+      return u = Math.max(0, u), u = Math.min(u, l.length - 1), l[u];
+    }, g.prototype._updateCss = function() {
+      if (this._domElement) {
+        var n = this.getStyleByText(this._text, this._styles);
+        this._domElement.style.cssText = this._buildCssText(n);
+      }
+    }, g.prototype._updateText = function() {
+      this._domElement && (this._domElement.innerHTML = this._text);
+    }, g.prototype._updatePosition = function() {
+      if (this._domElement && this._position) {
+        var n = this._domElement.style, l = this._map.pointToOverlayPixel(this._position);
+        l.x -= Math.ceil(parseInt(n.width) / 2), l.y -= Math.ceil(parseInt(n.height) / 2), n.left = l.x + "px", n.top = l.y + "px";
+      }
+    }, g.prototype._buildCssText = function(n) {
+      var l = n.url, c = n.size, u = n.anchor, d = n.offset, b = n.textColor || "black", M = n.textSize || 10, T = [];
+      if (this._zIndex && T.push("z-index:" + this._zIndex + ";"), t.browser.ie < 7)
+        T.push('filter:progid:DXImageTransform.Microsoft.AlphaImageLoader(sizingMethod=scale,src="' + l + '");');
+      else {
+        T.push("background-image:url(" + l + ");");
+        var p = "0 0";
+        d instanceof BMap.Size && (p = d.width + "px " + d.height + "px"), T.push("background-position:" + p + ";");
+      }
+      return c instanceof BMap.Size && (u instanceof BMap.Size ? (u.height > 0 && u.height < c.height && T.push("height:" + (c.height - u.height) + "px; padding-top:" + u.height + "px;"), u.width > 0 && u.width < c.width && T.push("width:" + (c.width - u.width) + "px; padding-left:" + u.width + "px;")) : (T.push("height:" + c.height + "px; line-height:" + c.height + "px;"), T.push("width:" + c.width + "px; text-align:center;"))), T.push("cursor:pointer; color:" + b + "; position:absolute; font-size:" + M + "px; font-family:Arial,sans-serif; font-weight:bold"), T.join("");
+    }, g.prototype._bind = function() {
+      if (!this._domElement)
+        return;
+      var n = this, l = this._map, c = t.lang.Event;
+      function u(d, b) {
+        var M = d.srcElement || d.target, T = d.clientX || d.pageX, p = d.clientY || d.pageY;
+        if (d && b && T && p && M) {
+          var f = t.dom.getPosition(l.getContainer());
+          b.pixel = new BMap.Pixel(T - f.left, p - f.top), b.point = l.pixelToPoint(b.pixel);
+        }
+        return b;
+      }
+      t.event.on(this._domElement, "mouseover", function(d) {
+        n.dispatchEvent(u(d, new c("onmouseover")));
+      }), t.event.on(this._domElement, "mouseout", function(d) {
+        n.dispatchEvent(u(d, new c("onmouseout")));
+      }), t.event.on(this._domElement, "click", function(d) {
+        n.dispatchEvent(u(d, new c("onclick")));
+      });
+    }, g;
+  });
+})(vr);
+const mt = Be;
+var Ct = function(i, e, t) {
+  e = _r(e);
+  var r = i.pointToPixel(e.getNorthEast()), s = i.pointToPixel(e.getSouthWest());
+  r.x += t, r.y -= t, s.x -= t, s.y += t;
+  var o = i.pixelToPoint(r), a = i.pixelToPoint(s);
+  return new BMap.Bounds(a, o);
+}, _r = function(i) {
+  var e = ge(i.getNorthEast().lng, -180, 180), t = ge(i.getSouthWest().lng, -180, 180), r = ge(i.getNorthEast().lat, -74, 74), s = ge(i.getSouthWest().lat, -74, 74);
+  return new BMap.Bounds(new BMap.Point(t, s), new BMap.Point(e, r));
+}, ge = function(i, e, t) {
+  return e && (i = Math.max(i, e)), t && (i = Math.min(i, t)), i;
+}, wt = function(i) {
+  return Object.prototype.toString.call(i) === "[object Array]";
+}, xt = function(i, e) {
+  var t = -1;
+  if (wt(e)) {
+    if (e.indexOf)
+      t = e.indexOf(i);
+    else
+      for (var r = 0, s; s = e[r]; r++)
+        if (s === i) {
+          t = r;
+          break;
+        }
+  }
+  return t;
+}, _ = function(i, e) {
+  try {
+    BMap;
+  } catch {
+    throw Error("Baidu Map JS API is not ready yet!");
+  }
+  if (i) {
+    this._map = i, this._markers = [], this._clusters = [];
+    var t = e || {};
+    this._zIndex = t.zIndex, this._gridSize = t.gridSize || 60, this._maxZoom = t.maxZoom || 18, this._minClusterSize = t.minClusterSize || 2, this._isAverageCenter = !1, t.isAverageCenter != null && (this._isAverageCenter = t.isAverageCenter), this._styles = t.styles || [];
+    var r = this;
+    this._map.addEventListener("zoomend", function() {
+      r._redraw();
+    }), this._map.addEventListener("moveend", function() {
+      r._redraw();
+    });
+    var s = t.markers;
+    wt(s) && this.addMarkers(s);
+  }
+};
+_.prototype.addMarkers = function(i) {
+  if (i.length) {
+    for (var e = 0, t = i.length; e < t; e++)
+      this._pushMarkerTo(i[e]);
+    this._createClusters();
+  }
+};
+_.prototype._pushMarkerTo = function(i) {
+  var e = xt(i, this._markers);
+  e === -1 && (i.isInCluster = !1, this._markers.push(i));
+};
+_.prototype.addMarker = function(i) {
+  this._pushMarkerTo(i), this._createClusters();
+};
+_.prototype._createClusters = function() {
+  var i = this._map.getBounds();
+  if (i.getCenter()) {
+    for (var e = Ct(this._map, i, this._gridSize), t = 0, r; r = this._markers[t]; t++)
+      !r.isInCluster && e.containsPoint(r.getPosition()) && this._addToClosestCluster(r);
+    for (var s = this._markers.length, t = 0; t < s; t++)
+      this._clusters[t] && this._clusters[t].render();
+  }
+};
+_.prototype._addToClosestCluster = function(i) {
+  var e = 4e6, t = null;
+  i.getPosition();
+  for (var r = 0, s; s = this._clusters[r]; r++) {
+    var o = s.getCenter();
+    if (o) {
+      var a = this._map.getDistance(o, i.getPosition());
+      a < e && (e = a, t = s);
+    }
+  }
+  if (t && t.isMarkerInClusterBounds(i))
+    t.addMarker(i);
+  else {
+    var s = new L(this);
+    s.addMarker(i), this._clusters.push(s);
+  }
+};
+_.prototype._clearLastClusters = function() {
+  for (var i = 0, e; e = this._clusters[i]; i++)
+    e.remove();
+  this._clusters = [], this._removeMarkersFromCluster();
+};
+_.prototype._removeMarkersFromCluster = function() {
+  for (var i = 0, e; e = this._markers[i]; i++)
+    e.isInCluster = !1;
+};
+_.prototype._removeMarkersFromMap = function() {
+  for (var i = 0, e; e = this._markers[i]; i++) {
+    e.isInCluster = !1;
+    var t = e.getLabel();
+    this._map.removeOverlay(e), e.setLabel(t);
+  }
+};
+_.prototype._removeMarker = function(i) {
+  var e = xt(i, this._markers);
+  return e === -1 ? !1 : (this._map.removeOverlay(i), this._markers.splice(e, 1), !0);
+};
+_.prototype.removeMarker = function(i) {
+  var e = this._removeMarker(i);
+  return e && (this._clearLastClusters(), this._createClusters()), e;
+};
+_.prototype.removeMarkers = function(i) {
+  for (var e = !1, t = 0; t < i.length; t++) {
+    var r = this._removeMarker(i[t]);
+    e = e || r;
+  }
+  return e && (this._clearLastClusters(), this._createClusters()), e;
+};
+_.prototype.clearMarkers = function() {
+  this._clearLastClusters(), this._removeMarkersFromMap(), this._markers = [];
+};
+_.prototype._redraw = function() {
+  this._clearLastClusters(), this._createClusters();
+};
+_.prototype.getGridSize = function() {
+  return this._gridSize;
+};
+_.prototype.setGridSize = function(i) {
+  this._gridSize = i, this._redraw();
+};
+_.prototype.getMaxZoom = function() {
+  return this._maxZoom;
+};
+_.prototype.setMaxZoom = function(i) {
+  this._maxZoom = i, this._redraw();
+};
+_.prototype.getZIndex = function() {
+  return this._zIndex;
+};
+_.prototype.setZIndex = function(i) {
+  this._zIndex != i && (this.zIndex = i, this._redraw());
+};
+_.prototype.getStyles = function() {
+  return this._styles;
+};
+_.prototype.setStyles = function(i) {
+  this._styles = i, this._redraw();
+};
+_.prototype.getMinClusterSize = function() {
+  return this._minClusterSize;
+};
+_.prototype.setMinClusterSize = function(i) {
+  this._minClusterSize = i, this._redraw();
+};
+_.prototype.isAverageCenter = function() {
+  return this._isAverageCenter;
+};
+_.prototype.getMap = function() {
+  return this._map;
+};
+_.prototype.getMarkers = function() {
+  return this._markers;
+};
+_.prototype.getClustersCount = function() {
+  for (var i = 0, e = 0, t; t = this._clusters[e]; e++)
+    t.isReal() && i++;
+  return i;
+};
+_.prototype._textCalculator = function(i) {
+  return i.length.toString();
+};
+_.prototype._stylesIndexCalculator = null;
+_.prototype.setTextCalculator = function(i) {
+  this._textCalculator = i;
+};
+_.prototype.setStylesIndexCalculator = function(i) {
+  this._stylesIndexCalculator = i;
+};
+function L(i) {
+  var e = this;
+  this._markerClusterer = i, this._map = i.getMap(), this._minClusterSize = i.getMinClusterSize(), this._isAverageCenter = i.isAverageCenter(), this._center = null, this._markers = [], this._gridBounds = null, this._isReal = !1, this._clusterMarker = new mt(this._center, this._markers.length, {
+    styles: this._markerClusterer.getStyles(),
+    zIndex: i._zIndex
+  }), this._clusterMarker.getStyleByText = function(t, r) {
+    if (e._markerClusterer._stylesIndexCalculator) {
+      var s = e._markerClusterer._stylesIndexCalculator(e._markers, r.length);
+      return r[s];
+    }
+    return mt.prototype.getStyleByText.call(this, t, r);
+  }, this._clusterMarker.addEventListener && this._clusterMarker.addEventListener("click", function(t) {
+    e._map.setViewport(e.getBounds());
+  });
+}
+L.prototype.addMarker = function(i) {
+  if (this.isMarkerInCluster(i))
+    return !1;
+  if (!this._center)
+    this._center = i.getPosition(), this.updateGridBounds();
+  else if (this._isAverageCenter) {
+    var e = this._markers.length + 1, t = (this._center.lat * (e - 1) + i.getPosition().lat) / e, r = (this._center.lng * (e - 1) + i.getPosition().lng) / e;
+    this._center = new BMap.Point(r, t), this.updateGridBounds();
+  }
+  return i.isInCluster = !0, this._markers.push(i), !0;
+};
+L.prototype.render = function() {
+  var i = this._markers.length;
+  if (i < this._minClusterSize)
+    for (var e = 0; e < i; e++)
+      this._map.addOverlay(this._markers[e]);
+  else
+    this._map.addOverlay(this._clusterMarker), this._isReal = !0, this.updateClusterMarker();
+};
+L.prototype.isMarkerInCluster = function(i) {
+  if (this._markers.indexOf)
+    return this._markers.indexOf(i) != -1;
+  for (var e = 0, t; t = this._markers[e]; e++)
+    if (t === i)
+      return !0;
+  return !1;
+};
+L.prototype.isMarkerInClusterBounds = function(i) {
+  return this._gridBounds.containsPoint(i.getPosition());
+};
+L.prototype.isReal = function(i) {
+  return this._isReal;
+};
+L.prototype.updateGridBounds = function() {
+  var i = new BMap.Bounds(this._center, this._center);
+  this._gridBounds = Ct(this._map, i, this._markerClusterer.getGridSize());
+};
+L.prototype.updateClusterMarker = function() {
+  if (this._map.getZoom() > this._markerClusterer.getMaxZoom()) {
+    this._clusterMarker && this._map.removeOverlay(this._clusterMarker);
+    for (var i = 0, e; e = this._markers[i]; i++)
+      this._map.addOverlay(e);
+    return;
+  }
+  if (this._markers.length < this._minClusterSize) {
+    this._clusterMarker.hide();
+    return;
+  }
+  this._clusterMarker.setPosition(this._center), this._clusterMarker.setText(this._markerClusterer._textCalculator(this._markers));
+};
+L.prototype.remove = function() {
+  for (var i = 0, e; e = this._markers[i]; i++) {
+    var t = this._markers[i].getLabel();
+    this._markers[i].getMap() && this._map.removeOverlay(this._markers[i]), this._markers[i].setLabel(t);
+  }
+  this._map.removeOverlay(this._clusterMarker), this._markers.length = 0, delete this._markers;
+};
+L.prototype.getBounds = function() {
+  for (var i = new BMap.Bounds(this._center, this._center), e = 0, t; t = this._markers[e]; e++)
+    i.extend(t.getPosition());
+  return i;
+};
+L.prototype.getCenter = function() {
+  return this._center;
+};
+let Mr = class Et {
+  constructor(e, t, r) {
+    this.extend(Et, google.maps.OverlayView), this.map_ = e, this.MARKER_CLUSTER_IMAGE_PATH_ = "../images/m", this.MARKER_CLUSTER_IMAGE_EXTENSION_ = "png", this.markers_ = [], this.clusters_ = [], this.sizes = [53, 56, 66, 78, 90], this.styles_ = [], this.ready_ = !1;
+    var s = r || {};
+    this.zIndex_ = s.zIndex || google.maps.Marker.MAX_ZINDEX + 1, this.gridSize_ = s.gridSize || 60, this.minClusterSize_ = s.minimumClusterSize || 2, this.maxZoom_ = s.maxZoom || null, this.styles_ = s.styles || [], this.imagePath_ = s.imagePath || this.MARKER_CLUSTER_IMAGE_PATH_, this.imageExtension_ = s.imageExtension || this.MARKER_CLUSTER_IMAGE_EXTENSION_, this.zoomOnClick_ = !0, s.zoomOnClick != null && (this.zoomOnClick_ = s.zoomOnClick), this.averageCenter_ = !1, s.averageCenter != null && (this.averageCenter_ = s.averageCenter), this.setupStyles_(), this.setMap(e), this.prevZoom_ = this.map_.getZoom();
+    var o = this;
+    google.maps.event.addListener(this.map_, "zoom_changed", function() {
+      var a = o.map_.getZoom(), g = o.map_.minZoom || 0, n = Math.min(
+        o.map_.maxZoom || 100,
+        o.map_.mapTypes[o.map_.getMapTypeId()].maxZoom
+      );
+      a = Math.min(Math.max(a, g), n), o.prevZoom_ != a && (o.prevZoom_ = a, o.resetViewport());
+    }), google.maps.event.addListener(this.map_, "idle", function() {
+      o.redraw();
+    }), t && (t.length || Object.keys(t).length) && this.addMarkers(t, !1);
+  }
+  /**
+   * Extends a objects prototype by anothers.
+   *
+   * @param {Object} obj1 The object to be extended.
+   * @param {Object} obj2 The object to extend with.
+   * @return {Object} The new extended object.
+   * @ignore
+   */
+  extend(e, t) {
+    return function(r) {
+      for (var s in r.prototype)
+        this.prototype[s] = r.prototype[s];
+      return this;
+    }.apply(e, [t]);
+  }
+  /**
+   * Implementaion of the interface method.
+   * @ignore
+   */
+  onAdd() {
+    this.setReady_(!0);
+  }
+  /**
+   * Implementaion of the interface method.
+   * @ignore
+   */
+  draw() {
+  }
+  /**
+   * Sets up the styles object.
+   *
+   * @private
+   */
+  setupStyles_() {
+    if (!this.styles_.length)
+      for (var e = 0, t; t = this.sizes[e]; e++)
+        this.styles_.push({
+          url: this.imagePath_ + (e + 1) + "." + this.imageExtension_,
+          height: t,
+          width: t
+        });
+  }
+  /**
+   *  Fit the map to the bounds of the markers in the clusterer.
+   */
+  fitMapToMarkers() {
+    for (var e = this.getMarkers(), t = new google.maps.LatLngBounds(), r = 0, s; s = e[r]; r++)
+      t.extend(s.getPosition());
+    this.map_.fitBounds(t);
+  }
+  /**
+   * @param {number} zIndex
+   */
+  setZIndex(e) {
+    this.zIndex_ = e;
+  }
+  /**
+   * @return {number}
+   */
+  getZIndex() {
+    return this.zIndex_;
+  }
+  /**
+   *  Sets the styles.
+   *
+   *  @param {Object} styles The style to set.
+   */
+  setStyles(e) {
+    this.styles_ = e;
+  }
+  /**
+   *  Gets the styles.
+   *
+   *  @return {Object} The styles object.
+   */
+  getStyles() {
+    return this.styles_;
+  }
+  /**
+   * Whether zoom on click is set.
+   *
+   * @return {boolean} True if zoomOnClick_ is set.
+   */
+  isZoomOnClick() {
+    return this.zoomOnClick_;
+  }
+  /**
+   * Whether average center is set.
+   *
+   * @return {boolean} True if averageCenter_ is set.
+   */
+  isAverageCenter() {
+    return this.averageCenter_;
+  }
+  /**
+   *  Returns the array of markers in the clusterer.
+   *
+   *  @return {Array.<google.maps.Marker>} The markers.
+   */
+  getMarkers() {
+    return this.markers_;
+  }
+  /**
+   *  Returns the number of markers in the clusterer
+   *
+   *  @return {Number} The number of markers.
+   */
+  getTotalMarkers() {
+    return this.markers_.length;
+  }
+  /**
+   *  Sets the max zoom for the clusterer.
+   *
+   *  @param {number} maxZoom The max zoom level.
+   */
+  setMaxZoom(e) {
+    this.maxZoom_ = e;
+  }
+  /**
+   *  Gets the max zoom for the clusterer.
+   *
+   *  @return {number} The max zoom level.
+   */
+  getMaxZoom() {
+    return this.maxZoom_;
+  }
+  /**
+   *  The function for calculating the cluster icon image.
+   *
+   *  @param {Array.<google.maps.Marker>} markers The markers in the clusterer.
+   *  @param {number} numStyles The number of styles available.
+   *  @return {Object} A object properties: 'text' (string) and 'index' (number).
+   *  @private
+   */
+  calculator_(e, t) {
+    for (var r = 0, s = e.length, o = s; o !== 0; )
+      o = parseInt(o / 10, 10), r++;
+    return r = Math.min(r, t), {
+      text: s,
+      index: r
+    };
+  }
+  /**
+   * Set the calculator function.
+   *
+   * @param {function(Array, number)} calculator The function to set as the
+   *     calculator. The function should return a object properties:
+   *     'text' (string) and 'index' (number).
+   *
+   */
+  setCalculator(e) {
+    this.calculator_ = e;
+  }
+  /**
+   * Get the calculator function.
+   *
+   * @return {function(Array, number)} the calculator function.
+   */
+  getCalculator() {
+    return this.calculator_;
+  }
+  /**
+   * Add an array of markers to the clusterer.
+   *
+   * @param {Array.<google.maps.Marker>} markers The markers to add.
+   * @param {boolean=} opt_nodraw Whether to redraw the clusters.
+   */
+  addMarkers(e, t) {
+    if (e.length)
+      for (let r = 0, s; s = e[r]; r++)
+        this.pushMarkerTo_(s);
+    else if (Object.keys(e).length)
+      for (let r in e)
+        this.pushMarkerTo_(e[r]);
+    t || this.redraw();
+  }
+  /**
+   * Pushes a marker to the clusterer.
+   *
+   * @param {google.maps.Marker} marker The marker to add.
+   * @private
+   */
+  pushMarkerTo_(e) {
+    if (e.isAdded = !1, e.draggable) {
+      var t = this;
+      google.maps.event.addListener(e, "dragend", function() {
+        e.isAdded = !1, t.repaint();
+      });
+    }
+    this.markers_.push(e);
+  }
+  /**
+   * Adds a marker to the clusterer and redraws if needed.
+   *
+   * @param {google.maps.Marker} marker The marker to add.
+   * @param {boolean=} opt_nodraw Whether to redraw the clusters.
+   */
+  addMarker(e, t) {
+    this.pushMarkerTo_(e), t || this.redraw();
+  }
+  /**
+   * Removes a marker and returns true if removed, false if not
+   *
+   * @param {google.maps.Marker} marker The marker to remove
+   * @return {boolean} Whether the marker was removed or not
+   * @private
+   */
+  removeMarker_(e) {
+    var t = -1;
+    if (this.markers_.indexOf)
+      t = this.markers_.indexOf(e);
+    else
+      for (var r = 0, s; s = this.markers_[r]; r++)
+        if (s == e) {
+          t = r;
+          break;
+        }
+    return t == -1 ? !1 : (e.setMap(null), this.markers_.splice(t, 1), !0);
+  }
+  /**
+   * Remove a marker from the cluster.
+   *
+   * @param {google.maps.Marker} marker The marker to remove.
+   * @param {boolean=} opt_nodraw Optional boolean to force no redraw.
+   * @return {boolean} True if the marker was removed.
+   */
+  removeMarker(e, t) {
+    var r = this.removeMarker_(e);
+    return !t && r ? (this.resetViewport(), this.redraw(), !0) : !1;
+  }
+  /**
+   * Removes an array of markers from the cluster.
+   *
+   * @param {Array.<google.maps.Marker>} markers The markers to remove.
+   * @param {boolean=} opt_nodraw Optional boolean to force no redraw.
+   */
+  removeMarkers(e, t) {
+    for (var r = e === this.getMarkers() ? e.slice() : e, s = !1, o = 0, a; a = r[o]; o++) {
+      var g = this.removeMarker_(a);
+      s = s || g;
+    }
+    if (!t && s)
+      return this.resetViewport(), this.redraw(), !0;
+  }
+  /**
+   * Sets the clusterer's ready state.
+   *
+   * @param {boolean} ready The state.
+   * @private
+   */
+  setReady_(e) {
+    this.ready_ || (this.ready_ = e, this.createClusters_());
+  }
+  /**
+   * Returns the number of clusters in the clusterer.
+   *
+   * @return {number} The number of clusters.
+   */
+  getTotalClusters() {
+    return this.clusters_.length;
+  }
+  /**
+   * Returns the google map that the clusterer is associated with.
+   *
+   * @return {google.maps.Map} The map.
+   */
+  getMap() {
+    return this.map_;
+  }
+  /**
+   * Sets the google map that the clusterer is associated with.
+   *
+   * @param {google.maps.Map} map The map.
+   */
+  setMap(e) {
+    this.map_ = e;
+  }
+  /**
+   * Returns the size of the grid.
+   *
+   * @return {number} The grid size.
+   */
+  getGridSize() {
+    return this.gridSize_;
+  }
+  /**
+   * Sets the size of the grid.
+   *
+   * @param {number} size The grid size.
+   */
+  setGridSize(e) {
+    this.gridSize_ = e;
+  }
+  /**
+   * Returns the min cluster size.
+   *
+   * @return {number} The grid size.
+   */
+  getMinClusterSize() {
+    return this.minClusterSize_;
+  }
+  /**
+   * Sets the min cluster size.
+   *
+   * @param {number} size The grid size.
+   */
+  setMinClusterSize(e) {
+    this.minClusterSize_ = e;
+  }
+  /**
+   * Extends a bounds object by the grid size.
+   *
+   * @param {google.maps.LatLngBounds} bounds The bounds to extend.
+   * @return {google.maps.LatLngBounds} The extended bounds.
+   */
+  getExtendedBounds(e) {
+    var t = this.getProjection(), r = new google.maps.LatLng(
+      e.getNorthEast().lat(),
+      e.getNorthEast().lng()
+    ), s = new google.maps.LatLng(
+      e.getSouthWest().lat(),
+      e.getSouthWest().lng()
+    ), o = t.fromLatLngToDivPixel(r);
+    o.x += this.gridSize_, o.y -= this.gridSize_;
+    var a = t.fromLatLngToDivPixel(s);
+    a.x -= this.gridSize_, a.y += this.gridSize_;
+    var g = t.fromDivPixelToLatLng(o), n = t.fromDivPixelToLatLng(a);
+    return e.extend(g), e.extend(n), e;
+  }
+  /**
+   * Determins if a marker is contained in a bounds.
+   *
+   * @param {google.maps.Marker} marker The marker to check.
+   * @param {google.maps.LatLngBounds} bounds The bounds to check against.
+   * @return {boolean} True if the marker is in the bounds.
+   * @private
+   */
+  isMarkerInBounds_(e, t) {
+    return t.contains(e.getPosition());
+  }
+  /**
+   * Clears all clusters and markers from the clusterer.
+   */
+  clearMarkers() {
+    this.resetViewport(!0), this.markers_ = [];
+  }
+  /**
+   * Clears all existing clusters and recreates them.
+   * @param {boolean} opt_hide To also hide the marker.
+   */
+  resetViewport(e) {
+    for (let t = 0, r; r = this.clusters_[t]; t++)
+      r.remove();
+    for (let t = 0, r; r = this.markers_[t]; t++)
+      r.isAdded = !1, e && r.setMap(null);
+    this.clusters_ = [];
+  }
+  /**
+   *
+   */
+  repaint() {
+    var e = this.clusters_.slice();
+    this.clusters_.length = 0, this.resetViewport(), this.redraw(), setTimeout(function() {
+      for (var t = 0, r; r = e[t]; t++)
+        r.remove();
+    }, 0);
+  }
+  /**
+   * Redraws the clusters.
+   */
+  redraw() {
+    this.createClusters_();
+  }
+  /**
+   * Calculates the distance between two latlng locations in km.
+   * @see http://www.movable-type.co.uk/scripts/latlong.html
+   *
+   * @param {google.maps.LatLng} p1 The first lat lng point.
+   * @param {google.maps.LatLng} p2 The second lat lng point.
+   * @return {number} The distance between the two points in km.
+   * @private
+   */
+  distanceBetweenPoints_(e, t) {
+    if (!e || !t)
+      return 0;
+    var r = 6371, s = (t.lat() - e.lat()) * Math.PI / 180, o = (t.lng() - e.lng()) * Math.PI / 180, a = Math.sin(s / 2) * Math.sin(s / 2) + Math.cos(e.lat() * Math.PI / 180) * Math.cos(t.lat() * Math.PI / 180) * Math.sin(o / 2) * Math.sin(o / 2), g = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a)), n = r * g;
+    return n;
+  }
+  /**
+   * Add a marker to a cluster, or creates a new cluster.
+   *
+   * @param {google.maps.Marker} marker The marker to add.
+   * @private
+   */
+  addToClosestCluster_(e) {
+    for (var t = 4e4, r = null, s = 0, o; o = this.clusters_[s]; s++) {
+      var a = o.getCenter();
+      if (a) {
+        var g = this.distanceBetweenPoints_(a, e.getPosition());
+        g < t && (t = g, r = o);
+      }
+    }
+    if (r && r.isMarkerInClusterBounds(e))
+      r.addMarker(e);
+    else {
+      var n = new br(this);
+      n.addMarker(e), this.clusters_.push(n);
+    }
+  }
+  /**
+   * Creates the clusters.
+   *
+   * @private
+   */
+  createClusters_() {
+    if (this.ready_)
+      for (var e = new google.maps.LatLngBounds(
+        this.map_.getBounds().getSouthWest(),
+        this.map_.getBounds().getNorthEast()
+      ), t = this.getExtendedBounds(e), r = 0, s; s = this.markers_[r]; r++)
+        !s.isAdded && this.isMarkerInBounds_(s, t) && this.addToClosestCluster_(s);
+  }
+};
+class br {
+  constructor(e) {
+    this.markerClusterer_ = e, this.map_ = e.getMap(), this.gridSize_ = e.getGridSize(), this.minClusterSize_ = e.getMinClusterSize(), this.averageCenter_ = e.isAverageCenter(), this.center_ = null, this.markers_ = [], this.bounds_ = null, this.clusterIcon_ = new De(
+      this,
+      e.getStyles(),
+      e.getGridSize()
+    );
+  }
+  /**
+   * Determins if a marker is already added to the cluster.
+   *
+   * @param {google.maps.Marker} marker The marker to check.
+   * @return {boolean} True if the marker is already added.
+   */
+  isMarkerAlreadyAdded(e) {
+    if (this.markers_.indexOf)
+      return this.markers_.indexOf(e) != -1;
+    for (var t = 0, r; r = this.markers_[t]; t++)
+      if (r == e)
+        return !0;
+    return !1;
+  }
+  /**
+   * Add a marker the cluster.
+   *
+   * @param {google.maps.Marker} marker The marker to add.
+   * @return {boolean} True if the marker was added.
+   */
+  addMarker(e) {
+    if (this.isMarkerAlreadyAdded(e))
+      return !1;
+    if (!this.center_)
+      this.center_ = e.getPosition(), this.calculateBounds_();
+    else if (this.averageCenter_) {
+      var t = this.markers_.length + 1, r = (this.center_.lat() * (t - 1) + e.getPosition().lat()) / t, s = (this.center_.lng() * (t - 1) + e.getPosition().lng()) / t;
+      this.center_ = new google.maps.LatLng(r, s), this.calculateBounds_();
+    }
+    e.isAdded = !0, this.markers_.push(e);
+    var o = this.markers_.length;
+    if (o < this.minClusterSize_ && e.getMap() != this.map_ && e.setMap(this.map_), o == this.minClusterSize_)
+      for (var a = 0; a < o; a++)
+        this.markers_[a].setMap(null);
+    return o >= this.minClusterSize_ && e.setMap(null), this.updateIcon(), !0;
+  }
+  /**
+   * Returns the marker clusterer that the cluster is associated with.
+   *
+   * @return {MarkerClusterer} The associated marker clusterer.
+   */
+  getMarkerClusterer() {
+    return this.markerClusterer_;
+  }
+  /**
+   * Returns the bounds of the cluster.
+   *
+   * @return {google.maps.LatLngBounds} the cluster bounds.
+   */
+  getBounds() {
+    for (var e = new google.maps.LatLngBounds(this.center_, this.center_), t = this.getMarkers(), r = 0, s; s = t[r]; r++)
+      e.extend(s.getPosition());
+    return e;
+  }
+  /**
+   * Removes the cluster
+   */
+  remove() {
+    this.clusterIcon_.remove(), this.markers_.length = 0, delete this.markers_;
+  }
+  /**
+   * Returns the number of markers in the cluster.
+   *
+   * @return {number} The number of markers in the cluster.
+   */
+  getSize() {
+    return this.markers_.length;
+  }
+  /**
+   * Returns a list of the markers in the cluster.
+   *
+   * @return {Array.<google.maps.Marker>} The markers in the cluster.
+   */
+  getMarkers() {
+    return this.markers_;
+  }
+  /**
+   * Returns the center of the cluster.
+   *
+   * @return {google.maps.LatLng} The cluster center.
+   */
+  getCenter() {
+    return this.center_;
+  }
+  /**
+   * Calculated the extended bounds of the cluster with the grid.
+   *
+   * @private
+   */
+  calculateBounds_() {
+    var e = new google.maps.LatLngBounds(this.center_, this.center_);
+    this.bounds_ = this.markerClusterer_.getExtendedBounds(e);
+  }
+  /**
+   * Determines if a marker lies in the clusters bounds.
+   *
+   * @param {google.maps.Marker} marker The marker to check.
+   * @return {boolean} True if the marker lies in the bounds.
+   */
+  isMarkerInClusterBounds(e) {
+    return this.bounds_.contains(e.getPosition());
+  }
+  /**
+   * Returns the map that the cluster is associated with.
+   *
+   * @return {google.maps.Map} The map.
+   */
+  getMap() {
+    return this.map_;
+  }
+  /**
+   * Updates the cluster icon
+   */
+  updateIcon() {
+    var e = this.map_.getZoom(), t = this.markerClusterer_.getMaxZoom();
+    if (t && e > t) {
+      for (var r = 0, s; s = this.markers_[r]; r++)
+        s.setMap(this.map_);
+      return;
+    }
+    if (this.markers_.length < this.minClusterSize_) {
+      this.clusterIcon_.hide();
+      return;
+    }
+    var o = this.markerClusterer_.getStyles().length, a = this.markerClusterer_.getCalculator()(this.markers_, o);
+    this.clusterIcon_.setCenter(this.center_), this.clusterIcon_.setSums(a), this.clusterIcon_.show();
+  }
+}
+class De {
+  constructor(e, t, r) {
+    e.getMarkerClusterer().extend(De, google.maps.OverlayView), this.styles_ = t, this.padding_ = r || 0, this.cluster_ = e, this.center_ = null, this.map_ = e.getMap(), this.div_ = null, this.sums_ = null, this.visible_ = !1, this.setMap(this.map_);
+  }
+  /**
+   * Triggers the clusterclick event and zoom's if the option is set.
+   */
+  triggerClusterClick() {
+    var e = this.cluster_.getBounds(), t = this.cluster_.getMarkerClusterer();
+    google.maps.event.trigger(
+      t.map_,
+      "clusterclick",
+      this.cluster_
+    ), t.isZoomOnClick() && (this.map_.fitBounds(e), this.map_.setCenter(e.getCenter()));
+  }
+  /**
+   * Adding the cluster icon to the dom.
+   * @ignore
+   */
+  onAdd() {
+    if (this.div_ = document.createElement("DIV"), this.visible_) {
+      var e = this.getPosFromLatLng_(this.center_);
+      this.div_.style.cssText = this.createCss(e), this.div_.innerHTML = this.sums_.text;
+    }
+    var t = this.getPanes();
+    t.overlayMouseTarget.appendChild(this.div_);
+    var r = this;
+    google.maps.event.addDomListener(this.div_, "click", function() {
+      r.triggerClusterClick();
+    });
+  }
+  /**
+   * Returns the position to place the div dending on the latlng.
+   *
+   * @param {google.maps.LatLng} latlng The position in latlng.
+   * @return {google.maps.Point} The position in pixels.
+   * @private
+   */
+  getPosFromLatLng_(e) {
+    var t = this.getProjection().fromLatLngToDivPixel(e);
+    return t.x -= parseInt(this.width_ / 2, 10), t.y -= parseInt(this.height_ / 2, 10), t;
+  }
+  /**
+   * Draw the icon.
+   * @ignore
+   */
+  draw() {
+    if (this.visible_) {
+      var e = this.getPosFromLatLng_(this.center_);
+      this.div_.style.top = e.y + "px", this.div_.style.left = e.x + "px";
+    }
+  }
+  /**
+   * Hide the icon.
+   */
+  hide() {
+    this.div_ && (this.div_.style.display = "none"), this.visible_ = !1;
+  }
+  /**
+   * Position and show the icon.
+   */
+  show() {
+    if (this.div_) {
+      var e = this.getPosFromLatLng_(this.center_);
+      this.div_.style.cssText = this.createCss(e), this.div_.style.display = "";
+    }
+    this.visible_ = !0;
+  }
+  /**
+   * Remove the icon from the map
+   */
+  remove() {
+    this.setMap(null);
+  }
+  /**
+   * Implementation of the onRemove interface.
+   * @ignore
+   */
+  onRemove() {
+    this.div_ && this.div_.parentNode && (this.hide(), this.div_.parentNode.removeChild(this.div_), this.div_ = null);
+  }
+  /**
+   * Set the sums of the icon.
+   *
+   * @param {Object} sums The sums containing:
+   *   'text': (string) The text to display in the icon.
+   *   'index': (number) The style index of the icon.
+   */
+  setSums(e) {
+    this.sums_ = e, this.text_ = e.text, this.index_ = e.index, this.div_ && (this.div_.innerHTML = e.text), this.useStyle();
+  }
+  /**
+   * Sets the icon to the the styles.
+   */
+  useStyle() {
+    var e = Math.max(0, this.sums_.index - 1);
+    e = Math.min(this.styles_.length - 1, e);
+    var t = this.styles_[e];
+    this.url_ = t.url, this.height_ = t.height, this.width_ = t.width, this.textColor_ = t.textColor, this.anchor_ = t.anchor, this.textSize_ = t.textSize, this.backgroundPosition_ = t.backgroundPosition;
+  }
+  /**
+   * Sets the center of the icon.
+   *
+   * @param {google.maps.LatLng} center The latlng to set as the center.
+   */
+  setCenter(e) {
+    this.center_ = e;
+  }
+  /**
+   * Create the css text based on the position of the icon.
+   *
+   * @param {google.maps.Point} pos The position.
+   * @return {string} The css style text.
+   */
+  createCss(e) {
+    var t = [];
+    t.push("z-index:" + this.cluster_.markerClusterer_.getZIndex() + ";"), t.push("background-image:url(" + this.url_ + ");");
+    var r = this.backgroundPosition_ ? this.backgroundPosition_ : "0 0";
+    t.push("background-position:" + r + ";"), typeof this.anchor_ == "object" ? (typeof this.anchor_[0] == "number" && this.anchor_[0] > 0 && this.anchor_[0] < this.height_ ? t.push(
+      "height:" + (this.height_ - this.anchor_[0]) + "px; padding-top:" + this.anchor_[0] + "px;"
+    ) : t.push(
+      "height:" + this.height_ + "px; line-height:" + this.height_ + "px;"
+    ), typeof this.anchor_[1] == "number" && this.anchor_[1] > 0 && this.anchor_[1] < this.width_ ? t.push(
+      "width:" + (this.width_ - this.anchor_[1]) + "px; padding-left:" + this.anchor_[1] + "px;"
+    ) : t.push("width:" + this.width_ + "px; text-align:center;")) : t.push(
+      "height:" + this.height_ + "px; line-height:" + this.height_ + "px; width:" + this.width_ + "px; text-align:center;"
+    );
+    var s = this.textColor_ ? this.textColor_ : "black", o = this.textSize_ ? this.textSize_ : 11;
+    return t.push(
+      "cursor:pointer; top:" + e.y + "px; left:" + e.x + "px; color:" + s + "; position:absolute; font-size:" + o + "px; font-family:Arial,sans-serif; font-weight:bold"
+    ), t.join("");
+  }
+}
+var ve;
+((i) => {
+  function e(r) {
+    return {
+      url: r.url,
+      size: new BMap.Size(r.size.width, r.size.height),
+      anchor: r.anchor && new BMap.Size(r.anchor.x, r.anchor.y),
+      offset: r.offset && new BMap.Size(r.offset.x, r.offset.y),
+      textColor: r.textColor,
+      textSize: r.textSize
+    };
+  }
+  i.toBaidu = e;
+  function t(r) {
+    return {
+      url: r.url,
+      width: r.size.width,
+      height: r.size.height,
+      anchor: r.anchor && [r.anchor.y, r.anchor.x],
+      backgroundPosition: r.offset && `${r.offset.x} ${r.offset.y}`,
+      textColor: r.textColor,
+      textSize: r.textSize
+    };
+  }
+  i.toGoogle = t;
+})(ve || (ve = {}));
+class kt {
+  constructor(e) {
+    h(this, "inner");
+    this.map = e;
+  }
+  /** baidu/google 拥有相同的函数名 */
+  clearMarkers() {
+    this.inner.clearMarkers();
+  }
+  /** @see clearMarkers */
+  addMarker(e) {
+    this.inner.addMarker(e.innerOverlay);
+  }
+  /** @see clearMarkers */
+  removeMarker(e) {
+    return this.inner.removeMarker(e.innerOverlay);
+  }
+  /** @see clearMarkers */
+  addMarkers(e) {
+    this.inner.addMarkers(e.map((t) => t.innerOverlay));
+  }
+  /** @see clearMarkers */
+  removeMarkers(e) {
+    return this.inner.removeMarkers(e.map((t) => t.innerOverlay));
+  }
+}
+class Tr extends kt {
+  constructor(e, t) {
+    var s;
+    super(e), this.inner = new _(e.innerMap, {
+      // baidu的构造器中的markers, 会触发重绘, 会导致使用旧的calculator计算cluster
+      // markers: options.markers?.map(it => (it as BaiduMarker).innerOverlay),
+      gridSize: t.gridSize,
+      maxZoom: t.maxZoom,
+      minClusterSize: t.minClusterSize,
+      isAverageCenter: t.averageCenter,
+      styles: (s = t.styles) == null ? void 0 : s.map((o) => ve.toBaidu(o)),
+      zIndex: t.zIndex
+    });
+    const r = t.stylesIndexCalculator;
+    r && this.inner.setStylesIndexCalculator((o, a) => r(o.length, a)), t.markers && this.addMarkers(t.markers);
+  }
+  recreate() {
+    this.inner._redraw();
+  }
+}
+class Or extends kt {
+  constructor(e, t) {
+    var s, o;
+    super(e), this.inner = new Mr(
+      e.innerMap,
+      // google的构造器中的markers,不会触发重绘, 第一次绘制通过监听地图的'idle'事件触发, 可以直接设置
+      (s = t.markers) == null ? void 0 : s.map((a) => a.innerOverlay),
+      {
+        gridSize: t.gridSize,
+        maxZoom: t.maxZoom,
+        minimumClusterSize: t.minClusterSize,
+        averageCenter: t.averageCenter,
+        styles: (o = t.styles) == null ? void 0 : o.map((a) => ve.toGoogle(a)),
+        zIndex: t.zIndex
+      }
+    );
+    const r = t.stylesIndexCalculator;
+    r && this.inner.setCalculator((a, g) => ({
+      text: a.length,
+      // google内部, 取index时, 会`-1`...故我们这里`+1`, 抵消掉它
+      index: r(a.length, g) + 1
+    }));
+  }
+  recreate() {
+    this.inner.repaint();
+  }
+}
+function R(i, e) {
+  Object.keys(this.$listeners).forEach((t) => {
+    t.startsWith("update:") || e != null && e.includes(t) || i.addEventListener(t, this.$listeners[t]);
+  });
+}
+let Cr = 1;
+function wr() {
+  return Cr++;
+}
+function _e(i, e) {
+  return e.__id__ || (e.__id__ = wr()), `${i}::${e.__id__}`;
+}
+var Se;
+((i) => {
+  function e(r, s) {
+    const o = r.indexOf(s);
+    if (o !== -1)
+      return r.splice(o, 1)[0];
+  }
+  i.remove = e;
+  function t(r, s) {
+    for (const o of r)
+      if (o instanceof s)
+        return o;
+  }
+  i.findByType = t;
+})(Se || (Se = {}));
+var Me;
+((i) => {
+  function e(r, s) {
+    const o = r.getLength();
+    for (let a = 0; a < o; a++)
+      if (r.getAt(a) === s)
+        return a;
+    return -1;
+  }
+  i.indexOf = e;
+  function t(r, s) {
+    const o = e(r, s);
+    if (o !== -1)
+      return r.removeAt(o);
+  }
+  i.remove = t;
+})(Me || (Me = {}));
+class It {
+  constructor(e, t) {
+    h(this, "eventMap", /* @__PURE__ */ new Map());
+    h(this, "target", void 0);
+    this.inner = e, this.coordTypeSupplier = t, this.addEventListener = this.addEventListener.bind(this), this.removeEventListener = this.removeEventListener.bind(this);
+  }
+  setTarget(e) {
+    return this.target = e, this;
+  }
+}
+const ct = class extends It {
+  addEventListener(e, t) {
+    const r = _e(e, t);
+    if (this.eventMap.get(r)) {
+      console.warn("listener已经添加过了", r, t);
+      return;
+    }
+    const s = this.inner.addListener(ct.EVENT_TYPE_MAP[e] || e, (o) => {
+      const a = {
+        type: e,
+        target: this.target,
+        originalEvent: o
+      };
+      o != null && o.latLng && (a.position = y.fromGoogle(o.latLng, this.coordTypeSupplier.coordType)), t.call(this.target, a);
+    });
+    this.eventMap.set(r, s);
+  }
+  removeEventListener(e, t) {
+    const r = _e(e, t), s = this.eventMap.get(r);
+    s ? (s.remove(), this.eventMap.delete(r)) : console.warn("移除失败, 不存在该listener", r, t);
+  }
+};
+let K = ct;
+// 事件类型映射: tg => google
+h(K, "EVENT_TYPE_MAP", {
+  "center-changed": "center_changed",
+  "zoom-changed": "zoom_changed",
+  "map-type-changed": "maptypeid_changed",
+  // TODO: google地图的overlay会拦截地图的事件, 导致在map上设置的监听缺少一部分事件, 或许和事件监听的机制有关?
+  // 目前只能同时在map和overlay上监听这些事件...
+  "map-mousedown": "mousedown",
+  "map-mousemove": "mousemove",
+  "map-mouseup": "mouseup",
+  "map-dblclick": "dblclick"
+});
+const Te = class extends It {
+  addEventListener(e, t) {
+    const r = _e(e, t);
+    if (this.eventMap.get(r)) {
+      console.warn("listener已经添加过了", r, t);
+      return;
+    }
+    const s = (o) => {
+      const a = {
+        type: e,
+        target: this.target,
+        originalEvent: o
+      };
+      o.point && (a.position = y.fromBaidu(o.point, this.coordTypeSupplier.coordType)), t.call(this.target, a);
+    };
+    this.inner.addEventListener(Te.EVENT_TYPE_MAP[e] || e, s), this.eventMap.set(r, s);
+  }
+  removeEventListener(e, t) {
+    const r = _e(e, t), s = this.eventMap.get(r);
+    s ? (this.inner.removeEventListener(Te.EVENT_TYPE_MAP[e] || e, s), this.eventMap.delete(r)) : console.warn("移除失败, 不存在该listener", r, t);
+  }
+};
+let J = Te;
+// cSpell:words clickclose
+// 事件类型映射, tg => baidu
+h(J, "EVENT_TYPE_MAP", {
+  drag: "dragging",
+  closeclick: "clickclose",
+  "zoom-changed": "zoomend",
+  "map-type-changed": "maptypechange"
+});
+class xr {
+  constructor() {
+    h(this, "typeMap", /* @__PURE__ */ new Map());
+  }
+  addEventListener(e, t) {
+    let r = this.typeMap.get(e);
+    r || (r = [], this.typeMap.set(e, r)), !r.includes(t) && r.push(t);
+  }
+  removeEventListener(e, t) {
+    const r = this.typeMap.get(e);
+    r && Se.remove(r, t);
+  }
+  hasListener(e) {
+    const t = this.typeMap.get(e);
+    return t != null && t.length > 0;
+  }
+  notify(e) {
+    const t = this.typeMap.get(e.type);
+    t && t.forEach((r) => r.call(e.target, e));
+  }
+}
+class Pt {
+  constructor(e, t, r, s) {
+    h(this, "addEventListener");
+    h(this, "removeEventListener");
+    this.innerOverlay = e, this.coordType = t, this.map = r, this.delegate = s, this.delegate.setTarget(this), this.addEventListener = this.delegate.addEventListener, this.removeEventListener = this.delegate.removeEventListener;
+  }
+  remove() {
+    this.map.removeOverlay(this);
+  }
+}
+class Ze extends Pt {
+  constructor(e, t, r) {
+    super(e, t, r, new K(e, r));
+  }
+  isVisible() {
+    return this.innerOverlay.getVisible();
+  }
+  setVisible(e) {
+    this.innerOverlay.setVisible(e);
+  }
+}
+class Oe extends Pt {
+  constructor(e, t, r) {
+    super(e, t, r, new J(e, r));
+  }
+  /** 仅限内部使用; 设为private时, 生成的d.ts文件中, 方法返回值会变成any, 故改成了public */
+  get overlay() {
+    return this.innerOverlay;
+  }
+  isVisible() {
+    return this.overlay.isVisible();
+  }
+  setVisible(e) {
+    e ? this.overlay.show() : this.overlay.hide();
+  }
+  /** 在创建BaiduOverlay时, 设置options.visible, 仅内部使用 */
+  visibleOptionInternal(e) {
+    return e !== void 0 && (e || this.setVisible(!1)), this;
+  }
+}
+class Ge extends Oe {
+  constructor(e, t, r, s) {
+    super(e, t, r), this.state = s;
+  }
+  isEditable() {
+    return this.state.editable;
+  }
+  setEditable(e) {
+    this.state.editable = e, e ? this.innerOverlay.enableEditing() : this.innerOverlay.disableEditing();
+  }
+  setStrokeColor(e) {
+    this.innerOverlay.setStrokeColor(e);
+  }
+  setStrokeOpacity(e) {
+    this.innerOverlay.setStrokeOpacity(e);
+  }
+  setStrokeWeight(e) {
+    this.innerOverlay.setStrokeWeight(e);
+  }
+  setFillColor(e) {
+    this.innerOverlay.setFillColor(e);
+  }
+  setFillOpacity(e) {
+    this.innerOverlay.setFillOpacity(e);
+  }
+}
+class je extends Ze {
+  isEditable() {
+    return this.innerOverlay.getEditable();
+  }
+  setEditable(e) {
+    this.innerOverlay.setEditable(e);
+  }
+  setStrokeColor(e) {
+    this.innerOverlay.setOptions({ strokeColor: e });
+  }
+  setStrokeOpacity(e) {
+    this.innerOverlay.setOptions({ strokeOpacity: e });
+  }
+  setStrokeWeight(e) {
+    this.innerOverlay.setOptions({ strokeWeight: e });
+  }
+  setFillColor(e) {
+    this.innerOverlay.setOptions({ fillColor: e });
+  }
+  setFillOpacity(e) {
+    this.innerOverlay.setOptions({ fillOpacity: e });
+  }
+}
+class We extends Ge {
+  static create(e) {
+    const t = this.coordType, r = new BMap.Polyline(e.path.map((s) => s.toBaidu(t)), {
+      enableClicking: e.clickable,
+      enableEditing: e.editable,
+      strokeColor: e.strokeColor,
+      strokeOpacity: e.strokeOpacity,
+      strokeWeight: e.strokeWeight
+    });
+    return new We(r, t, this, { editable: e.editable === !0 }).visibleOptionInternal(e.visible);
+  }
+  getPath() {
+    return this.innerOverlay.getPath().map((e) => y.fromBaidu(e, this.coordType));
+  }
+  setPath(e) {
+    this.coordType = this.map.coordType, this.innerOverlay.setPath(e.map((t) => t.toBaidu(this.coordType)));
+  }
+}
+class Ve extends je {
+  static create(e) {
+    const t = this.coordType, r = new google.maps.Polyline({
+      path: e.path.map((s) => s.toGoogle(t)),
+      clickable: e.clickable,
+      editable: e.editable,
+      strokeColor: e.strokeColor,
+      strokeOpacity: e.strokeOpacity,
+      strokeWeight: e.strokeWeight,
+      visible: e.visible
+    });
+    return new Ve(r, t, this);
+  }
+  getPath() {
+    const e = [];
+    return this.innerOverlay.getPath().forEach((t) => {
+      e.push(y.fromGoogle(t, this.coordType));
+    }), e;
+  }
+  setPath(e) {
+    this.coordType = this.map.coordType, this.innerOverlay.setPath(e.map((t) => t.toGoogle(this.coordType)));
+  }
+}
+class He extends Ge {
+  static create(e) {
+    const t = this.coordType;
+    e.paths.length > 1 && console.warn("baidu不支持多path, 只会显示paths[0]");
+    const r = e.paths[0] || [], s = new BMap.Polygon(r.map((o) => o.toBaidu(t)), {
+      enableClicking: e.clickable,
+      enableEditing: e.editable,
+      strokeColor: e.strokeColor,
+      strokeOpacity: e.strokeOpacity,
+      strokeWeight: e.strokeWeight,
+      fillColor: e.fillColor,
+      fillOpacity: e.fillOpacity
+    });
+    return new He(s, t, this, { editable: !!e.editable }).visibleOptionInternal(e.visible);
+  }
+  getPaths() {
+    return [this.innerOverlay.getPath().map((e) => y.fromBaidu(e, this.coordType))];
+  }
+  setPaths(e) {
+    e.length > 1 && console.warn("baidu不支持多path, 只会显示paths[0]"), this.coordType = this.map.coordType, this.innerOverlay.setPath((e[0] || []).map((t) => t.toBaidu(this.coordType)));
+  }
+}
+class Fe extends je {
+  static create(e) {
+    const t = this.coordType, r = new google.maps.Polygon({
+      paths: e.paths.map((s) => s.map((o) => o.toGoogle(t))),
+      clickable: e.clickable,
+      editable: e.editable,
+      strokeColor: e.strokeColor,
+      strokeOpacity: e.strokeOpacity,
+      strokeWeight: e.strokeWeight,
+      fillColor: e.fillColor,
+      fillOpacity: e.fillOpacity,
+      visible: e.visible
+    });
+    return new Fe(r, t, this);
+  }
+  getPaths() {
+    const e = this.innerOverlay.getPaths(), t = [];
+    return e.forEach((r) => {
+      const s = [];
+      t.push(s), r.forEach((o) => {
+        s.push(y.fromGoogle(o, this.coordType));
+      });
+    }), t;
+  }
+  setPaths(e) {
+    this.coordType = this.map.coordType, this.innerOverlay.setPaths(e.map((t) => t.map((r) => r.toGoogle(this.coordType))));
+  }
+}
+class Ue extends Ge {
+  static create(e) {
+    const t = this.coordType, r = new BMap.Circle(e.center.toBaidu(t), e.radius, {
+      enableClicking: e.clickable,
+      enableEditing: e.editable,
+      strokeColor: e.strokeColor,
+      strokeOpacity: e.strokeOpacity,
+      strokeWeight: e.strokeWeight,
+      fillColor: e.fillColor,
+      fillOpacity: e.fillOpacity
+    });
+    return new Ue(r, t, this, { editable: !!e.editable }).visibleOptionInternal(e.visible);
+  }
+  setCenter(e) {
+    this.coordType = this.map.coordType, this.innerOverlay.setCenter(e.toBaidu(this.coordType));
+  }
+  getCenter() {
+    return y.fromBaidu(this.innerOverlay.getCenter(), this.coordType);
+  }
+  setRadius(e) {
+    this.innerOverlay.setRadius(e);
+  }
+  getRadius() {
+    return this.innerOverlay.getRadius();
+  }
+}
+class Ye extends je {
+  static create(e) {
+    const t = this.coordType, r = new google.maps.Circle({
+      center: e.center.toGoogle(t),
+      radius: e.radius,
+      clickable: e.clickable,
+      editable: e.editable,
+      strokeColor: e.strokeColor,
+      strokeOpacity: e.strokeOpacity,
+      strokeWeight: e.strokeWeight,
+      fillColor: e.fillColor,
+      fillOpacity: e.fillOpacity,
+      visible: e.visible
+    });
+    return new Ye(r, t, this);
+  }
+  setCenter(e) {
+    this.coordType = this.map.coordType, this.innerOverlay.setCenter(e.toGoogle(this.coordType));
+  }
+  getCenter() {
+    return y.fromGoogle(this.innerOverlay.getCenter(), this.coordType);
+  }
+  setRadius(e) {
+    this.innerOverlay.setRadius(e);
+  }
+  getRadius() {
+    return this.innerOverlay.getRadius();
+  }
+}
+class ft {
+  /**
+   * `keys`和`values`数组中可以有相同的值, 若存在相同值, 则index越小的优先级越高
+   */
+  constructor(e, t) {
+    h(this, "keyToValue", /* @__PURE__ */ new Map());
+    h(this, "valueToKey", /* @__PURE__ */ new Map());
+    ne(e.length === t.length);
+    for (let r = e.length - 1; r >= 0; r--)
+      this.keyToValue.set(e[r], t[r]), this.valueToKey.set(t[r], e[r]);
+  }
+  toKey(e) {
+    return this.valueToKey.get(e) ?? I();
+  }
+  toValue(e) {
+    return this.keyToValue.get(e) ?? I();
+  }
+}
+class Er {
+  constructor(e, t = 10) {
+    h(this, "map", /* @__PURE__ */ new Map());
+    this.values = e, this.maxSize4Debug = t;
+  }
+  /** 获取保存key-value映射的Map */
+  getValueMap(e) {
+    let t = this.map.get(e);
+    if (!t) {
+      t = /* @__PURE__ */ new Map();
+      for (let r = this.values.length - 1; r >= 0; r--) {
+        const s = this.values[r];
+        t.set(e.call(s), s);
+      }
+      this.map.set(e, t), {}.NODE_ENV !== "production" && this.map.size > this.maxSize4Debug && console.warn(`this.map的大小(${this.map.size})超过了设置的最大大小(${this.maxSize4Debug}), 这可能是由于你每次都创建新的keySelector造成的, 请保证相同功能的keySelector只创建一个对象`);
+    }
+    return t;
+  }
+  /**
+   * 直接用key获取value
+   * @param keySelector 从T中读取key的方法, 会用它当key, 缓存结果, 故多次调用需要使用相同的keySelector对象, 不要每次创建新的, 推荐直接使用T.prototype.getXxx作为keySelector
+   */
+  getOrNull(e, t) {
+    return this.getValueMap(e).get(t);
+  }
+  get(e, t) {
+    return this.getOrNull(e, t) ?? I(`key(${t})不存在与valueMap(${this.getValueMap(e)})中`);
+  }
+}
+class yt {
+  constructor(e) {
+    h(this, "value");
+    this.creator = e;
+  }
+  get() {
+    return this.value === void 0 && (this.value = this.creator()), this.value;
+  }
+}
+var x = /* @__PURE__ */ ((i) => (i.TOP_LEFT = "top-left", i.TOP_CENTER = "top-center", i.TOP_RIGHT = "top-right", i.BOTTOM_LEFT = "bottom-left", i.BOTTOM_CENTER = "bottom-center", i.BOTTOM_RIGHT = "bottom-right", i.LEFT_TOP = "left-top", i.LEFT_CENTER = "left-center", i.LEFT_BOTTOM = "left-bottom", i.RIGHT_TOP = "right-top", i.RIGHT_CENTER = "right-center", i.RIGHT_BOTTOM = "right-bottom", i))(x || {}), P;
+((i) => {
+  let e, t;
+  const r = [
+    "top-left",
+    "top-center",
+    "top-right",
+    "bottom-left",
+    "bottom-center",
+    "bottom-right",
+    "left-top",
+    "left-center",
+    "left-bottom",
+    "right-top",
+    "right-center",
+    "right-bottom"
+    /* RIGHT_BOTTOM */
+  ];
+  function s() {
+    return e || (e = new ft(r, [
+      /* | @tg/map |名字相同|         baidu         | */
+      /* TOP_LEFT      = */
+      BMAP_ANCHOR_TOP_LEFT,
+      /* TOP_CENTER      */
+      BMAP_ANCHOR_TOP_LEFT,
+      /* TOP_RIGHT     = */
+      BMAP_ANCHOR_TOP_RIGHT,
+      /* BOTTOM_LEFT   = */
+      BMAP_ANCHOR_BOTTOM_LEFT,
+      /* BOTTOM_CENTER   */
+      BMAP_ANCHOR_BOTTOM_LEFT,
+      /* BOTTOM_RIGHT  = */
+      BMAP_ANCHOR_BOTTOM_RIGHT,
+      /* LEFT_TOP        */
+      BMAP_ANCHOR_TOP_LEFT,
+      /* LEFT_CENTER     */
+      BMAP_ANCHOR_BOTTOM_LEFT,
+      /* LEFT_BOTTOM     */
+      BMAP_ANCHOR_BOTTOM_LEFT,
+      /* RIGHT_TOP       */
+      BMAP_ANCHOR_TOP_RIGHT,
+      /* RIGHT_CENTER    */
+      BMAP_ANCHOR_BOTTOM_RIGHT,
+      /* RIGHT_BOTTOM    */
+      BMAP_ANCHOR_BOTTOM_RIGHT
+    ])), e;
+  }
+  i.getBaidu = s;
+  function o() {
+    return t || (t = new ft(r, [
+      google.maps.ControlPosition.TOP_LEFT,
+      google.maps.ControlPosition.TOP_CENTER,
+      google.maps.ControlPosition.TOP_RIGHT,
+      google.maps.ControlPosition.BOTTOM_LEFT,
+      google.maps.ControlPosition.BOTTOM_CENTER,
+      google.maps.ControlPosition.BOTTOM_RIGHT,
+      google.maps.ControlPosition.LEFT_TOP,
+      google.maps.ControlPosition.LEFT_CENTER,
+      google.maps.ControlPosition.LEFT_BOTTOM,
+      google.maps.ControlPosition.RIGHT_TOP,
+      google.maps.ControlPosition.RIGHT_CENTER,
+      google.maps.ControlPosition.RIGHT_BOTTOM
+    ])), t;
+  }
+  i.getGoogle = o;
+})(P || (P = {}));
+class kr {
+  constructor(e) {
+    /** 实际添加到地图中的control对象 */
+    h(this, "inner");
+    this.position = e;
+  }
+}
+class Lt {
+}
+class Ke extends Lt {
+  constructor(e, t) {
+    super(), this.inner = e, this.position = t;
+  }
+  isVisible() {
+    return this.inner.isVisible();
+  }
+  setVisible(e) {
+    e ? this.inner.show() : this.inner.hide();
+  }
+  getPosition() {
+    return this.position ?? P.getBaidu().toKey(this.inner.getAnchor());
+  }
+  setPosition(e) {
+    this.position = e, this.inner.setAnchor(P.getBaidu().toValue(e));
+  }
+  addTo(e) {
+    e.innerMap.addControl(this.inner);
+  }
+  removeFrom(e) {
+    e.innerMap.removeControl(this.inner);
+  }
+}
+class qe extends Lt {
+  constructor(t, r) {
+    super();
+    h(this, "visible", !1);
+    h(this, "map");
+    this._type = t, this.position = r;
+  }
+  isVisible() {
+    return this.visible;
+  }
+  setVisible(t) {
+    this.visible = t, this.tryUpdateOptions();
+  }
+  getPosition() {
+    return this.position;
+  }
+  setPosition(t) {
+    this.position = t, this.tryUpdateOptions();
+  }
+  addTo(t) {
+    this.map || (this.map = t, this.setVisible(!0));
+  }
+  removeFrom() {
+    this.map && (this.setVisible(!1), this.map = void 0);
+  }
+  onCreateOptions() {
+    return {
+      position: P.getGoogle().toValue(this.position)
+    };
+  }
+  tryUpdateOptions() {
+    this.map && this.map.innerMap.setOptions({
+      [`${this._type}Control`]: this.visible,
+      [`${this._type}ControlOptions`]: this.onCreateOptions()
+    });
+  }
+}
+var $e = /* @__PURE__ */ ((i) => (i.normal = "normal", i.satellite = "satellite", i.hybrid = "hybrid", i))($e || {});
+class E {
+  constructor(e, t, r, s) {
+    this.id = e, this.baidu = t, this.google = r, this.googleCoordType = s;
+  }
+  getId() {
+    return this.id;
+  }
+  getBaiduCoordType() {
+    return Y.bd09;
+  }
+  asBaiduMapType() {
+    return this.baidu();
+  }
+  getGoogleCoordType() {
+    return this.googleCoordType;
+  }
+  /** 内置地图的id和google的id是不一样的 */
+  getGoogleMapTypeId() {
+    return this.google();
+  }
+  asGoogleMapType() {
+    Jt("google的内置地图没有对应的实例");
+  }
+}
+class Ir {
+  constructor() {
+    h(this, "baiduCache", new yt(() => new BMap.TrafficLayer()));
+    h(this, "googleCache", new yt(() => new google.maps.TrafficLayer()));
+  }
+  asBaiduLayer() {
+    return this.baiduCache.get();
+  }
+  asGoogleLayer() {
+    return this.googleCache.get();
+  }
+}
+var k;
+((i) => {
+  i.NORMAL = new E("normal", () => BMAP_NORMAL_MAP, () => google.maps.MapTypeId.ROADMAP, Y.gcj02), i.SATELLITE = new E("satellite", () => BMAP_SATELLITE_MAP, () => google.maps.MapTypeId.SATELLITE, Y.wgs84), i.HYBRID = new E("hybrid", () => BMAP_HYBRID_MAP, () => google.maps.MapTypeId.HYBRID, Y.gcj02), i.TERRAIN = new E("terrain", () => (
+    /* 三维 */
+    BMAP_PERSPECTIVE_MAP
+  ), () => (
+    /* 地形 */
+    google.maps.MapTypeId.TERRAIN
+  ), Y.wgs84), i.BUILD_IN_MAP_TYPES = new Er([i.NORMAL, i.SATELLITE, i.HYBRID, i.TERRAIN]);
+})(k || (k = {}));
+var Bt = /* @__PURE__ */ ((i) => (i.DEFAULT = "default", i.HORIZONTAL = "horizontal", i.DROPDOWN = "dropdown", i))(Bt || {});
+const St = [k.NORMAL, k.SATELLITE, k.HYBRID];
+class Xe extends Ke {
+  static create(e) {
+    const t = e.mapTypes ?? St, r = {
+      default: BMAP_MAPTYPE_CONTROL_HORIZONTAL,
+      horizontal: BMAP_MAPTYPE_CONTROL_HORIZONTAL,
+      dropdown: BMAP_MAPTYPE_CONTROL_DROPDOWN
+    }, s = new BMap.MapTypeControl({
+      type: e.type && r[e.type],
+      mapTypes: t.map((o) => o.asBaiduMapType())
+    });
+    return e.position && s.setAnchor(P.getBaidu().toValue(e.position)), new Xe(s, e.position);
+  }
+}
+const X = class extends qe {
+  constructor(e = "default", t = x.TOP_LEFT, r = St) {
+    super("mapType", t), this.type = e, this.mapTypes = r, X.type2google || (X.type2google = {
+      default: google.maps.MapTypeControlStyle.DEFAULT,
+      horizontal: google.maps.MapTypeControlStyle.HORIZONTAL_BAR,
+      dropdown: google.maps.MapTypeControlStyle.DROPDOWN_MENU
+    });
+  }
+  static create(e) {
+    return new X(e.type, e.position, e.mapTypes);
+  }
+  onCreateOptions() {
+    const e = super.onCreateOptions();
+    return e.style = X.type2google[this.type], e.mapTypeIds = this.mapTypes.map((t) => t instanceof E ? t.getGoogleMapTypeId() : t.id), e;
+  }
+  addTo(e) {
+    super.addTo(e), this.mapTypes.forEach((t) => {
+      t instanceof E || e.innerMap.mapTypes.set(t.id, t.asGoogleMapType());
+    });
+  }
+};
+let me = X;
+h(me, "type2google");
+class Je extends Ke {
+  static create(e) {
+    const t = new BMap.NavigationControl({
+      type: BMAP_NAVIGATION_CONTROL_ZOOM,
+      // enableGeolocation: true,
+      anchor: e.position && P.getBaidu().toValue(e.position)
+    });
+    return new Je(t, e.position);
+  }
+}
+class Qe extends qe {
+  static create(e) {
+    return new Qe(e.position);
+  }
+  constructor(e = x.RIGHT_BOTTOM) {
+    super("zoom", e);
+  }
+}
+class et extends Ke {
+  static create(e) {
+    const t = new BMap.ScaleControl({
+      anchor: e.position && P.getBaidu().toValue(e.position)
+    });
+    return new et(t, e.position);
+  }
+}
+class tt extends qe {
+  static create(e) {
+    return new tt(e.position);
+  }
+  constructor(e = x.BOTTOM_RIGHT) {
+    super("scale", e);
+  }
+}
+var Ae;
+((i) => {
+  function e(t) {
+    return t.scrollWidth > t.clientWidth || t.scrollHeight > t.clientHeight;
+  }
+  i.isScrollable = e;
+})(Ae || (Ae = {}));
+var ee;
+((i) => {
+  function e(r) {
+    return {
+      url: r.url,
+      size: new google.maps.Size(r.size.width, r.size.height),
+      origin: r.origin && new google.maps.Point(r.origin.x, r.origin.y),
+      // google的锚点默认就是图标的底部中点
+      anchor: r.anchor && new google.maps.Point(r.anchor.x, r.anchor.y)
+    };
+  }
+  i.toGoogle = e;
+  function t(r) {
+    return new BMap.Icon(r.url, new BMap.Size(r.size.width, r.size.height), {
+      imageOffset: r.origin && new BMap.Size(-r.origin.x, -r.origin.y),
+      // baidu的锚点默认为图标的中心点, 故需要和@tg/map统一, 改成图标的底部中点
+      anchor: r.anchor ? new BMap.Size(r.anchor.x, r.anchor.y) : new BMap.Size(r.size.width / 2, r.size.height)
+      // InfoWindow相对图标左上角的偏移量, 不指定则InfoWindow不会偏移, 直接指到marker的position上
+      // infoWindowAnchor: new BMap.Size(0, 0),
+    });
+  }
+  i.toBaidu = t;
+})(ee || (ee = {}));
+class he extends Oe {
+  constructor(e, t, r, s) {
+    super(e, t, r), this.state = s;
+  }
+  static create(e) {
+    const t = this.coordType, r = e.icon, s = {
+      title: e.title,
+      icon: r && ee.toBaidu(r),
+      enableClicking: e.clickable,
+      enableDragging: e.draggable,
+      // baidu的raiseOnDrag属性, 默认为false, 而我们的options.crossOnDrag默认为true, 故这里需要转换下
+      raiseOnDrag: e.crossOnDrag === void 0 ? !0 : e.crossOnDrag,
+      draggingCursor: e.cursor
+    }, o = new BMap.Marker(e.position.toBaidu(t), s);
+    e.zIndex !== void 0 && o.setZIndex(e.zIndex);
+    const a = e.clickable === void 0 ? !0 : e.clickable, g = !!e.draggable;
+    return new he(o, t, this, { clickable: a, draggable: g, zIndex: e.zIndex }).visibleOptionInternal(e.visible);
+  }
+  getPosition() {
+    return y.fromBaidu(this.innerOverlay.getPosition(), this.coordType);
+  }
+  setPosition(e) {
+    var t;
+    this.coordType = this.map.coordType, this.innerOverlay.setPosition(e.toBaidu(this.coordType)), (t = this.innerOverlay.__info_box__) == null || t.onMarkerPositionChanged();
+  }
+  setTitle(e) {
+    this.innerOverlay.setTitle(e);
+  }
+  getTitle() {
+    return this.innerOverlay.getTitle();
+  }
+  setIcon(e) {
+    const t = ee.toBaidu(e);
+    this.innerOverlay.setIcon(t);
+    const r = this.getLabel();
+    r && r.attachIcon(t);
+  }
+  getIcon() {
+    return this.innerOverlay.getIcon();
+  }
+  setClickable(e) {
+    this.state.clickable = e;
+  }
+  isClickable() {
+    return this.state.clickable;
+  }
+  setDraggable(e) {
+    this.state.draggable = e, e ? this.innerOverlay.enableDragging() : this.innerOverlay.disableDragging();
+  }
+  isDraggable() {
+    return this.state.draggable;
+  }
+  setZIndex(e) {
+    this.state.zIndex = e, this.innerOverlay.setZIndex(e || 0);
+  }
+  getZIndex() {
+    return this.state.zIndex;
+  }
+  setLabel(e) {
+    const t = this.getLabel();
+    t && t.attachIcon(void 0), e && e.attachIcon(this.innerOverlay.getIcon()), this.innerOverlay.setLabel(e == null ? void 0 : e.innerOverlay);
+  }
+  getLabel() {
+    var e;
+    return (e = this.innerOverlay.getLabel()) == null ? void 0 : e.__label__;
+  }
+}
+class rt extends Ze {
+  constructor() {
+    super(...arguments);
+    h(this, "label");
+    h(this, "labelPositionListener");
+    h(this, "labelVisibleListener");
+    h(this, "labelMapChangedListener");
+  }
+  static create(t) {
+    const r = this.coordType, s = t.icon, o = {
+      position: t.position.toGoogle(r),
+      title: t.title,
+      zIndex: t.zIndex,
+      visible: t.visible,
+      icon: s && ee.toGoogle(s),
+      clickable: t.clickable,
+      draggable: t.draggable,
+      // google的crossOnDrag和我们的crossOnDrag是匹配的, 不需要转换
+      crossOnDrag: t.crossOnDrag,
+      cursor: t.cursor,
+      // InfoWindow相对marker的position的偏移量, 若不指定, 则偏移到marker的icon的上部中央
+      anchorPoint: new google.maps.Point(0, 0)
+    };
+    return new rt(new google.maps.Marker(o), r, this);
+  }
+  getPosition() {
+    return y.fromGoogle(this.innerOverlay.getPosition(), this.coordType);
+  }
+  setPosition(t) {
+    this.coordType = this.map.coordType, this.innerOverlay.setPosition(t.toGoogle(this.coordType));
+  }
+  setTitle(t) {
+    this.innerOverlay.setTitle(t);
+  }
+  getTitle() {
+    return this.innerOverlay.getTitle() || "";
+  }
+  setIcon(t) {
+    this.innerOverlay.setIcon(ee.toGoogle(t));
+  }
+  getIcon() {
+    return this.innerOverlay.getIcon();
+  }
+  setClickable(t) {
+    this.innerOverlay.setClickable(t);
+  }
+  isClickable() {
+    return this.innerOverlay.getClickable();
+  }
+  setDraggable(t) {
+    this.innerOverlay.setDraggable(t);
+  }
+  isDraggable() {
+    return !!this.innerOverlay.getDraggable();
+  }
+  setZIndex(t) {
+    this.innerOverlay.setZIndex(t === void 0 ? null : t);
+  }
+  getZIndex() {
+    const t = this.innerOverlay.getZIndex();
+    return t === null ? void 0 : t;
+  }
+  setLabel(t) {
+    if (this.label && this.map.removeOverlay(this.label), this.labelPositionListener && this.labelPositionListener.remove(), this.labelVisibleListener && this.labelVisibleListener.remove(), this.labelMapChangedListener && this.labelMapChangedListener.remove(), t) {
+      const r = () => {
+        t.innerOverlay.setPosition(this.innerOverlay.getPosition());
+      }, s = () => {
+        t.innerOverlay.setVisible(this.innerOverlay.getVisible());
+      }, o = () => {
+        this.innerOverlay.getMap() ? this.map.addOverlay(t) : this.map.removeOverlay(t);
+      };
+      o(), r(), s(), this.label = t, this.labelMapChangedListener = this.innerOverlay.addListener("map_changed", o), this.labelPositionListener = this.innerOverlay.addListener("position_changed", r), this.labelVisibleListener = this.innerOverlay.addListener("visible_changed", s);
+    } else
+      this.label = void 0, this.labelPositionListener = void 0, this.labelVisibleListener = void 0, this.labelMapChangedListener = void 0;
+  }
+}
+class it {
+  constructor(e) {
+    this.delegate = e, this.delegate.setTarget(this);
+  }
+  addEventListener(e, t) {
+    this.delegate.addEventListener(e, t);
+  }
+  removeEventListener(e, t) {
+    this.delegate.removeEventListener(e, t);
+  }
+}
+class st extends it {
+  constructor(e, t, r) {
+    super(new J(e, t)), this.inner = e, this.map = t, this.state = r;
+  }
+  static create(e) {
+    const t = e.position || y.ZERO, r = new BMap.InfoWindow(e.content, {
+      maxWidth: e.maxWidth,
+      offset: e.offset && new BMap.Size(e.offset.x, e.offset.y),
+      enableAutoPan: !e.disableAutoPan
+    });
+    return new st(r, this, { position: t });
+  }
+  isOpen() {
+    return this.inner.isOpen();
+  }
+  open(e) {
+    e ? e.innerOverlay.openInfoWindow(this.inner) : this.map.innerMap.openInfoWindow(this.inner, (this.state.position || y.ZERO).toBaidu(this.map.coordType)), this.map.setLatestInfoWindowInternal(this);
+  }
+  close() {
+    this.inner.isOpen() && this.map.innerMap.closeInfoWindow();
+  }
+  getPosition() {
+    const e = this.inner.getPosition();
+    return e && y.fromBaidu(e, this.map.coordType) || this.state.position || y.ZERO;
+  }
+  setPosition(e) {
+    this.state.position = e, this.inner.isOpen() && this.open();
+  }
+}
+class ot extends it {
+  constructor(t, r) {
+    super(new K(t, r));
+    h(this, "eventHub", new xr());
+    h(this, "isOpened", !1);
+    this.inner = t, this.map = r, t.addListener("closeclick", () => {
+      this.isOpened = !1, this.eventHub.hasListener("close") && this.eventHub.notify({ type: "close", target: this });
+    }), t.addListener("map_changed", () => {
+      const s = this.isOpened;
+      this.isOpened = !!t.getMap(), s && !this.isOpened && this.eventHub.hasListener("close") && this.eventHub.notify({ type: "close", target: this });
+    });
+  }
+  static create(t) {
+    const r = t.position || y.ZERO, s = new google.maps.InfoWindow({
+      content: t.content,
+      maxWidth: t.maxWidth,
+      pixelOffset: t.offset && new google.maps.Size(t.offset.x, t.offset.y),
+      position: r.toGoogle(this.coordType),
+      disableAutoPan: t.disableAutoPan
+    });
+    return new ot(s, this);
+  }
+  isOpen() {
+    return this.isOpened;
+  }
+  addEventListener(t, r) {
+    if (t === "open" || t === "close") {
+      this.eventHub.addEventListener(t, r);
+      return;
+    }
+    super.addEventListener(t, r);
+  }
+  removeEventListener(t, r) {
+    if (t === "open" || t === "close") {
+      this.eventHub.removeEventListener(t, r);
+      return;
+    }
+    super.removeEventListener(t, r);
+  }
+  open(t) {
+    if (!this.isOpened) {
+      if (this.map.mapOptions.infoWindowMode === "single") {
+        const r = this.map.getLatestInfoWindow();
+        r && r.close();
+      }
+      this.inner.open(this.map.innerMap, t == null ? void 0 : t.innerOverlay), this.isOpened = !0, this.map.setLatestInfoWindowInternal(this), this.eventHub.notify({ type: "open", target: this });
+    }
+  }
+  close() {
+    this.isOpened && (this.isOpened = !1, this.inner.close(), this.eventHub.notify({ type: "close", target: this }));
+  }
+  getPosition() {
+    return y.fromGoogle(this.inner.getPosition(), this.map.coordType);
+  }
+  setPosition(t) {
+    this.inner.setPosition(t.toGoogle(this.map.coordType));
+  }
+}
+var ce;
+((i) => {
+  i.ZERO = { x: 0, y: 0 };
+})(ce || (ce = {}));
+let Ee;
+function Pr(i, e, t, r) {
+  return Ee || (Ee = Lr()), new Ee(i, e, t, r);
+}
+function Lr() {
+  return class extends google.maps.OverlayView {
+    constructor(t, r, s, o) {
+      super();
+      h(this, "container");
+      this.position = r, this.offset = s, this.zIndex = o, this.container = document.createElement("div"), this.container.className = "label-container", this.container.style.position = "absolute", o && this.setZIndex(o), this.container.addEventListener("click", () => {
+        google.maps.event.trigger(this, "click");
+      }), this.setElement(t);
+    }
+    setZIndex(t) {
+      this.container.style.zIndex = `${t}`;
+    }
+    setElement(t) {
+      const r = this.container.firstChild;
+      r !== t && (r ? this.container.replaceChild(r, t) : this.container.appendChild(t));
+    }
+    /** @override */
+    onAdd() {
+      this.zIndex ? this.getPanes().overlayMouseTarget.appendChild(this.container) : this.getPanes().overlayLayer.appendChild(this.container);
+    }
+    /** @override */
+    draw() {
+      var t, r;
+      if (this.container.style.display = this.position ? "block" : "none", this.position) {
+        const s = this.getProjection();
+        if (s) {
+          const o = s.fromLatLngToDivPixel(this.position);
+          this.container.style.left = `${o.x + (((t = this.offset) == null ? void 0 : t.x) ?? 0)}px`, this.container.style.top = `${o.y + (((r = this.offset) == null ? void 0 : r.y) ?? 0)}px`;
+        }
+      }
+    }
+    /** @override */
+    onRemove() {
+      var t;
+      (t = this.container.parentNode) == null || t.removeChild(this.container);
+    }
+    setPosition(t) {
+      this.position = t, this.draw();
+    }
+    getPosition() {
+      return this.position;
+    }
+    setOffset(t) {
+      this.offset = t, this.draw();
+    }
+    getOffset() {
+      return this.offset;
+    }
+    getVisible() {
+      return this.container.style.visibility !== "hidden";
+    }
+    setVisible(t) {
+      this.container.style.visibility = t ? "visible" : "hidden";
+    }
+  };
+}
+var te;
+((i) => {
+  function e(r) {
+    return typeof r == "string" ? r : r.outerHTML;
+  }
+  i.toString = e;
+  function t(r) {
+    if (typeof r == "string") {
+      const s = document.createElement("div");
+      return s.innerHTML = r, s;
+    }
+    return r;
+  }
+  i.toElement = t;
+})(te || (te = {}));
+class nt extends Oe {
+  constructor(t, r, s, o) {
+    super(t, r, s);
+    h(this, "icon");
+    h(this, "content", void 0);
+    h(this, "contentObserver");
+    this.setContentInternal(o, !0);
+  }
+  static create(t) {
+    var a;
+    const r = this.coordType, s = new BMap.Label(te.toString(t.content), {
+      position: (a = t.position) == null ? void 0 : a.toBaidu(r),
+      offset: t.offset && new BMap.Size(t.offset.x, t.offset.y)
+    });
+    t.zIndex && s.setZIndex(t.zIndex), s.setStyle({
+      border: "0px",
+      padding: "0px",
+      backgroundColor: "unset"
+    });
+    const o = new nt(s, r, this, t.content);
+    return s.__label__ = o, o;
+  }
+  setContentInternal(t, r = !1) {
+    this.content !== t && (this.contentObserver && (this.contentObserver.disconnect(), this.contentObserver = void 0), typeof t != "string" && (this.contentObserver = new MutationObserver(() => {
+      this.innerOverlay.setContent(t.outerHTML);
+    }), this.contentObserver.observe(t, {
+      attributes: !0,
+      characterData: !0,
+      childList: !0,
+      subtree: !0
+    })), r || this.innerOverlay.setContent(te.toString(t)), this.content = t);
+  }
+  setZIndex(t) {
+    this.innerOverlay.setZIndex(t);
+  }
+  getPosition() {
+    return y.fromBaidu(this.innerOverlay.getPosition(), this.coordType);
+  }
+  setPosition(t) {
+    this.coordType = this.map.coordType, this.innerOverlay.setPosition(t.toBaidu(this.coordType));
+  }
+  getOffset() {
+    const t = this.innerOverlay.getOffset();
+    let r = 0, s = 0;
+    return this.icon && (r = this.icon.anchor.width, s = this.icon.anchor.height), { x: t.width - r, y: t.height - s };
+  }
+  setOffset(t) {
+    let r = 0, s = 0;
+    this.icon && (r = this.icon.anchor.width, s = this.icon.anchor.height), this.innerOverlay.setOffset(new BMap.Size(t.x + r, t.y + s));
+  }
+  setContent(t) {
+    this.setContentInternal(t);
+  }
+  /**
+   * 关联新的Icon, 内部使用的方法
+   * @description baidu中Label默认左上角对齐Icon的左上, 我们要将其转换为对齐marker的position
+   * */
+  attachIcon(t) {
+    const r = this.innerOverlay.getOffset();
+    let s = r.width, o = r.height;
+    this.icon && (s -= this.icon.anchor.width, o -= this.icon.anchor.height), t && (s += t.anchor.width, o += t.anchor.height), this.innerOverlay.setOffset(new BMap.Size(s, o)), this.icon = t;
+  }
+}
+class at extends Ze {
+  static create(e) {
+    var s;
+    const t = this.coordType, r = Pr(
+      te.toElement(e.content),
+      (s = e.position) == null ? void 0 : s.toGoogle(t),
+      e.offset,
+      e.zIndex
+    );
+    return new at(r, t, this);
+  }
+  setZIndex(e) {
+    this.innerOverlay.setZIndex(e);
+  }
+  setContent(e) {
+    this.innerOverlay.setElement(te.toElement(e));
+  }
+  getPosition() {
+    const e = this.innerOverlay.getPosition();
+    return e ? y.fromGoogle(e, this.coordType) : y.ZERO;
+  }
+  setPosition(e) {
+    this.coordType = this.map.coordType, this.innerOverlay.setPosition(e.toGoogle(this.coordType));
+  }
+  getOffset() {
+    return this.innerOverlay.getOffset() ?? ce.ZERO;
+  }
+  setOffset(e) {
+    this.innerOverlay.setOffset(e);
+  }
+}
+function $t() {
+  BMap.OverlayV3 || (BMap.OverlayV3 = BMap.Overlay);
+}
+let ke;
+function Br(i, e, t, r, s, o) {
+  return ke || (ke = Sr()), new ke(i, e, t, r, s, o);
+}
+function Sr() {
+  $t();
+  const i = new BMap.Point(0, 0);
+  return class extends BMap.OverlayV3 {
+    constructor(r, s = i, o = ce.ZERO, a, g = 654, n = "") {
+      super();
+      // 类表达式不能有私有成员, 故改成public
+      h(this, "container");
+      h(this, "border");
+      h(this, "inner");
+      h(this, "map");
+      h(this, "marker");
+      this.content = r, this.position = s, this.offset = o;
+      const l = "baidu-info-box-container";
+      this.container = document.createElement("div"), this.container.className = l, this.container.style.position = "absolute", this.border = document.createElement("div"), this.border.className = `${l}__border ${n}`, this.inner = document.createElement("div"), this.inner.className = l + "__inner";
+      const c = document.createElement("img");
+      c.className = l + "__close", c.src = "data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20width%3D%2224px%22%20height%3D%2224px%22%20viewBox%3D%220%200%2024%2024%22%20fill%3D%22%23000000%22%3E%0A%20%20%20%20%3Cpath%20d%3D%22M19%206.41L17.59%205%2012%2010.59%206.41%205%205%206.41%2010.59%2012%205%2017.59%206.41%2019%2012%2013.41%2017.59%2019%2019%2017.59%2013.41%2012z%22%2F%3E%0A%20%20%20%20%3Cpath%20d%3D%22M0%200h24v24H0z%22%20fill%3D%22none%22%2F%3E%0A%3C%2Fsvg%3E%0A", c.addEventListener("click", () => {
+        this.close(), this.dispatchEvent({ type: "onclickclose" });
+      }), this.inner.appendChild(r), this.border.appendChild(this.inner), this.border.appendChild(c), this.container.appendChild(this.border), a && this.setZIndex(a), this.setMaxWidth(g), this.onMarkerPositionChanged = this.onMarkerPositionChanged.bind(this);
+    }
+    /** @override */
+    initialize(r) {
+      return this.map = r, r.getPanes().floatPane.appendChild(this.container), this.container;
+    }
+    /** @override */
+    draw() {
+      if (!this.map)
+        return;
+      const r = this.marker ? this.marker.getPosition() : this.position, s = this.map.pointToOverlayPixel(r), o = s.x + this.offset.x, a = s.y + this.offset.y;
+      this.container.style.left = `${o}px`, this.container.style.top = `${a}px`;
+    }
+    open(r, s) {
+      s && s === this.marker || (this.marker && this.detachMarker(this.marker), this.marker = s, this.marker && this.attachMarker(this.marker), this.isOpen() ? this.draw() : this.marker && !this.marker.getMap() || r.addOverlay(this));
+    }
+    attachMarker(r) {
+      r.__info_box__ = this, r.addEventListener("dragging", this.onMarkerPositionChanged), r.addEventListener("dragend", this.onMarkerPositionChanged);
+    }
+    detachMarker(r) {
+      r.__info_box__ = void 0, r.removeEventListener("dragging", this.onMarkerPositionChanged), r.removeEventListener("dragend", this.onMarkerPositionChanged);
+    }
+    close() {
+      this.map && (this.map.removeOverlay(this), this.marker && (this.detachMarker(this.marker), this.marker = void 0), this.map = void 0);
+    }
+    isOpen() {
+      return this.map && this.map.getPanes().floatPane === this.container.parentNode;
+    }
+    onMarkerPositionChanged() {
+      this.draw();
+    }
+    setZIndex(r) {
+      this.container.style.zIndex = `${r}`;
+    }
+    setMaxWidth(r) {
+      this.border.style.maxWidth = `${r}px`;
+    }
+    setPosition(r) {
+      this.marker || (this.position = r, this.draw());
+    }
+    getPosition() {
+      return this.position;
+    }
+    setOffset(r) {
+      this.offset = r, this.draw();
+    }
+    getOffset() {
+      return this.offset;
+    }
+  };
+}
+class lt extends Oe {
+  constructor(e, t, r) {
+    super(e, t, r), this.baiduMap = r;
+  }
+  static create(e) {
+    var s;
+    const t = this.coordType, r = Br(
+      e.content,
+      (s = e.position) == null ? void 0 : s.toBaidu(t),
+      e.offset,
+      e.zIndex,
+      e.maxWidth,
+      e.borderClass
+    );
+    return new lt(r, t, this);
+  }
+  open(e) {
+    this.innerOverlay.open(this.baiduMap.innerMap, e == null ? void 0 : e.innerOverlay);
+  }
+  close() {
+    this.innerOverlay.close();
+  }
+  getPosition() {
+    return y.fromBaidu(this.innerOverlay.getPosition(), this.coordType);
+  }
+  setPosition(e) {
+    this.coordType = this.map.coordType, this.innerOverlay.setPosition(e.toBaidu(this.coordType));
+  }
+  setMaxWidth(e) {
+    this.innerOverlay.setMaxWidth(e);
+  }
+  setZIndex(e) {
+    this.innerOverlay.setZIndex(e);
+  }
+}
+class ht extends it {
+  constructor(e, t, r) {
+    super(new K(e, r)), this.inner = e, this.coordType = t, this.map = r;
+  }
+  static create(e) {
+    var o;
+    const t = this.coordType, r = new google.maps.InfoWindow({
+      content: e.content,
+      position: (o = e.position) == null ? void 0 : o.toGoogle(t),
+      pixelOffset: e.offset && new google.maps.Size(e.offset.x, e.offset.y),
+      zIndex: e.zIndex,
+      maxWidth: e.maxWidth
+    }), s = e.borderClass;
+    return s && r.addListener("domready", () => {
+      var g;
+      const a = (g = e.content.parentElement) == null ? void 0 : g.parentElement;
+      a && a.className.includes("gm-style-iw-c") && !a.className.includes(s) && (a.className += ` ${s}`);
+    }), new ht(r, t, this);
+  }
+  open(e) {
+    this.inner.open(this.map.innerMap, e == null ? void 0 : e.innerOverlay);
+  }
+  close() {
+    this.inner.close();
+  }
+  getPosition() {
+    return y.fromGoogle(this.inner.getPosition(), this.coordType);
+  }
+  setPosition(e) {
+    this.coordType = this.map.coordType, this.inner.setPosition(e.toGoogle(this.coordType));
+  }
+  isOpen() {
+    return this.inner.getMap() != null;
+  }
+  setMaxWidth(e) {
+    if (this.isOpen()) {
+      const t = this.inner.getMap(), r = this.inner.getAnchor();
+      this.inner.close(), this.inner.setOptions({ maxWidth: e }), this.inner.open(t, r);
+    } else
+      this.inner.setOptions({ maxWidth: e });
+  }
+  setZIndex(e) {
+    this.inner.setZIndex(e);
+  }
+}
+class $r extends Re {
+  constructor(t, r) {
+    var s;
+    super(t);
+    h(this, "buildInMapTypeId2BIMT");
+    h(this, "baiduMapType2BIMT");
+    h(this, "map");
+    h(this, "createLabel", nt.create);
+    h(this, "createCircle", Ue.create);
+    h(this, "createPolygon", He.create);
+    h(this, "createPolyline", We.create);
+    h(this, "createInfoWindow", st.create);
+    h(this, "createInfoBox", lt.create);
+    h(this, "createMarker", he.create);
+    h(this, "createMapTypeControl", Xe.create);
+    h(this, "createZoomControl", Je.create);
+    h(this, "createScaleControl", et.create);
+    this.buildInMapTypeId2BIMT = k.BUILD_IN_MAP_TYPES.getValueMap(E.prototype.getId), this.baiduMapType2BIMT = k.BUILD_IN_MAP_TYPES.getValueMap(E.prototype.asBaiduMapType), this.map = new BMap.Map(t, {
+      minZoom: r.minZoom,
+      maxZoom: r.maxZoom,
+      mapType: r.buildInMapTypeId && ((s = this.buildInMapTypeId2BIMT.get(r.buildInMapTypeId)) == null ? void 0 : s.asBaiduMapType()),
+      enableMapClick: !1
+      // 关闭底图点击功能
+    }), this.map.centerAndZoom(r.center.toBaidu(this.coordType), r.zoom), this.setGestureHandling(r.gestureHandling), r.infoWindowMode === "multi" && console.warn("baidu不支持多个InfoWindow, 可能会出现未知问题"), r.mapStyle && this.map.setMapStyle2(r.mapStyle.toBaidu()), this.setEventTargetDelegate(new J(this.map, this)), this.map.addEventListener("addoverlay", (o) => {
+      const a = o.target.__info_box__;
+      a && (console.debug("add:info-box", a), this.map.addOverlay(a));
+    }), this.map.addEventListener("removeoverlay", (o) => {
+      const a = o.target.__info_box__;
+      a && (console.debug("remove:info-box", a), this.map.removeOverlay(a));
+    });
+  }
+  setDefaultCursor(t) {
+    this.innerMap.setDefaultCursor(t);
+  }
+  setGestureHandling(t = N.auto) {
+    switch (t === N.auto && (t = this.element.parentElement && Ae.isScrollable(this.element.parentElement) ? N.cooperative : N.greedy), t) {
+      case N.cooperative:
+        this.map.disableScrollWheelZoom(), this.map.enableDragging(), this.map.enableDoubleClickZoom();
+        break;
+      case N.greedy:
+        this.map.enableScrollWheelZoom(), this.map.enableDragging(), this.map.enableDoubleClickZoom();
+        break;
+      case N.none:
+        this.map.disableDragging(), this.map.disableScrollWheelZoom(), this.map.disableDoubleClickZoom();
+        break;
+    }
+  }
+  get innerMap() {
+    return this.map;
+  }
+  get coordType() {
+    return this.getMapType().getBaiduCoordType();
+  }
+  addEventListener(t, r) {
+    if (t === "center-changed") {
+      super.addEventListener("movestart", r), super.addEventListener("moving", r), super.addEventListener("moveend", r), super.addEventListener("zoomend", r);
+      return;
+    }
+    super.addEventListener(t, r);
+  }
+  removeEventListener(t, r) {
+    if (t === "center-changed") {
+      super.removeEventListener("movestart", r), super.removeEventListener("moving", r), super.removeEventListener("moveend", r), super.removeEventListener("zoomend", r);
+      return;
+    }
+    super.removeEventListener(t, r);
+  }
+  fromContainerPointToLatLng(t) {
+    return y.fromBaidu(this.innerMap.pixelToPoint(new BMap.Pixel(t.x, t.y)), this.coordType);
+  }
+  fromLatLngToContainerPoint(t) {
+    return this.innerMap.pointToPixel(t.toBaidu(this.coordType));
+  }
+  setDraggable(t) {
+    t ? this.innerMap.enableDragging() : this.innerMap.disableDragging();
+  }
+  setDisableDoubleClickZoom(t) {
+    t ? this.map.enableDoubleClickZoom() : this.map.disableDoubleClickZoom();
+  }
+  getCenter() {
+    return y.fromBaidu(this.map.getCenter(), this.coordType);
+  }
+  setCenter(t) {
+    this.map.setCenter(t.toBaidu(this.coordType));
+  }
+  setMinZoom(t) {
+    this.map.setMinZoom(t);
+  }
+  setMaxZoom(t) {
+    this.map.setMaxZoom(t);
+  }
+  setMapStyle(t) {
+    this.map.setMapStyle2(t.toBaidu());
+  }
+  setBuildInMapTypeId(t) {
+    var s;
+    const r = (s = this.buildInMapTypeId2BIMT.get(t)) == null ? void 0 : s.asBaiduMapType();
+    this.map.setMapType(r ?? I("理论上来说不可能为空"));
+  }
+  setMapType(t) {
+    this.map.setMapType(t.asBaiduMapType());
+  }
+  getMapType() {
+    const t = this.map.getMapType(), r = this.baiduMapType2BIMT.get(t);
+    return r || (t.__baidu_map_type__ ?? I("实现asBaiduMapType()时, 忘了给实例设置__baidu_map_type__?"));
+  }
+  addLayer(t) {
+    this.map.addTileLayer(t.asBaiduLayer());
+  }
+  removeLayer(t) {
+    this.map.removeTileLayer(t.asBaiduLayer());
+  }
+  panTo(t) {
+    this.map.panTo(t.toBaidu(this.coordType));
+  }
+  panBy(t, r) {
+    this.map.panBy(t, r);
+  }
+  fitBounds(t, r) {
+    this.map.setViewport(t.toBaiduArray(this.coordType), {
+      // enableAnimation: true, // 默认为true
+      margins: r && [r.top, r.right, r.bottom, r.left]
+    });
+  }
+  getBounds() {
+    return W.fromBaidu(this.map.getBounds(), this.coordType);
+  }
+  addElementOverlay(t) {
+    this.map.addOverlay(t.asBaidu());
+  }
+  removeElementOverlay(t) {
+    this.map.removeOverlay(t.asBaidu());
+  }
+  addOverlay(t) {
+    this.map.addOverlay(t.innerOverlay);
+  }
+  removeOverlay(t) {
+    this.map.removeOverlay(t.innerOverlay);
+  }
+  addCustomControl(t) {
+    if (!t.inner) {
+      const r = class extends BMap.Control {
+        constructor() {
+          super(...arguments);
+          h(this, "defaultAnchor", P.getBaidu().toValue(t.position));
+          h(this, "defaultOffset", new BMap.Size(0, 0));
+        }
+        initialize(o) {
+          const a = t.onCreateElement();
+          return o.getContainer().appendChild(a), a;
+        }
+      };
+      t.inner = new r(), this.map.addControl(t.inner);
+    }
+  }
+  removeCustomControl(t) {
+    t.inner && (ne(t.inner instanceof BMap.Control, `control.inner(${t.inner})需要是BMap.Control`), this.map.removeControl(t.inner));
+  }
+  createMarkerClusterer(t) {
+    return new Tr(this, t);
+  }
+}
+class Ar extends Re {
+  constructor(t, r) {
+    var o;
+    super(t);
+    h(this, "buildInMapTypeId2BIMT");
+    h(this, "googleMapTypeId2BIMT");
+    h(this, "map");
+    h(this, "createLabel", at.create);
+    h(this, "createCircle", Ye.create);
+    h(this, "createPolygon", Fe.create);
+    h(this, "createPolyline", Ve.create);
+    h(this, "createInfoWindow", ot.create);
+    h(this, "createInfoBox", ht.create);
+    h(this, "createMarker", rt.create);
+    h(this, "createMapTypeControl", me.create);
+    h(this, "createZoomControl", Qe.create);
+    h(this, "createScaleControl", tt.create);
+    this.mapOptions = r, this.buildInMapTypeId2BIMT = k.BUILD_IN_MAP_TYPES.getValueMap(E.prototype.getId), this.googleMapTypeId2BIMT = k.BUILD_IN_MAP_TYPES.getValueMap(E.prototype.getGoogleMapTypeId);
+    const s = r.buildInMapTypeId && this.buildInMapTypeId2BIMT.get(r.buildInMapTypeId);
+    this.map = new google.maps.Map(t, {
+      center: r.center.toGoogle((s ?? k.NORMAL).getGoogleCoordType()),
+      zoom: r.zoom,
+      disableDefaultUI: !0,
+      streetViewControl: !0,
+      gestureHandling: r.gestureHandling,
+      minZoom: r.minZoom,
+      maxZoom: r.maxZoom,
+      styles: (o = r.mapStyle) == null ? void 0 : o.toGoogle(),
+      mapTypeId: s == null ? void 0 : s.getGoogleMapTypeId()
+    }), this.setEventTargetDelegate(new K(this.map, this));
+  }
+  setDefaultCursor(t) {
+    this.innerMap.setOptions({ draggableCursor: t });
+  }
+  setGestureHandling(t) {
+    this.map.setOptions({
+      gestureHandling: t
+    });
+  }
+  get innerMap() {
+    return this.map;
+  }
+  get coordType() {
+    return this.getMapType().getGoogleCoordType();
+  }
+  fromContainerPointToLatLng(t) {
+    const r = this.innerMap.getProjection(), s = this.innerMap.getBounds();
+    if (r == null || s == null)
+      return y.ZERO;
+    const o = r.fromLatLngToPoint(s.getSouthWest()), a = r.fromLatLngToPoint(s.getNorthEast()), g = Math.pow(2, this.innerMap.getZoom()), n = new google.maps.Point(t.x / g + o.x, t.y / g + a.y);
+    return y.fromGoogle(r.fromPointToLatLng(n), this.coordType);
+  }
+  fromLatLngToContainerPoint(t) {
+    const r = this.innerMap.getProjection(), s = this.innerMap.getBounds();
+    if (r == null || s == null)
+      return ce.ZERO;
+    const o = r.fromLatLngToPoint(s.getSouthWest()), a = r.fromLatLngToPoint(s.getNorthEast()), g = Math.pow(2, this.innerMap.getZoom()), n = r.fromLatLngToPoint(t.toGoogle(this.coordType));
+    return { x: (n.x - o.x) * g, y: (n.y - a.y) * g };
+  }
+  setDraggable(t) {
+    this.innerMap.setOptions({ draggable: t });
+  }
+  setDisableDoubleClickZoom(t) {
+    this.map.setOptions({ disableDoubleClickZoom: t });
+  }
+  getCenter() {
+    return y.fromGoogle(this.map.getCenter(), this.coordType);
+  }
+  setCenter(t) {
+    this.map.setCenter(t.toGoogle(this.coordType));
+  }
+  setMinZoom(t) {
+    this.map.setOptions({ minZoom: t });
+  }
+  setMaxZoom(t) {
+    this.map.setOptions({ maxZoom: t });
+  }
+  setMapStyle(t) {
+    this.map.setOptions({ styles: t.toGoogle() });
+  }
+  setBuildInMapTypeId(t) {
+    var s;
+    const r = (s = this.buildInMapTypeId2BIMT.get(t)) == null ? void 0 : s.getGoogleMapTypeId();
+    this.map.setMapTypeId(r ?? I("理论上来说不可能为空"));
+  }
+  setMapType(t) {
+    t instanceof E ? this.map.setMapTypeId(t.getGoogleMapTypeId()) : (this.map.mapTypes.set(t.id, t.asGoogleMapType()), this.map.setMapTypeId(t.id));
+  }
+  getMapType() {
+    const t = this.map.getMapTypeId(), r = this.googleMapTypeId2BIMT.get(t);
+    return r || (this.map.mapTypes.get(t).__google_map_type__ ?? I(`实现${t}的asGoogleMapType()时, 忘了给实例设置__google_map_type__?`));
+  }
+  addOverlayMapType(t) {
+    this.map.overlayMapTypes.push(t.asGoogleMapType());
+  }
+  removeOverlayMapType(t) {
+    Me.remove(this.map.overlayMapTypes, t.asGoogleMapType());
+  }
+  addLayer(t) {
+    t.asGoogleLayer().setMap(this.map);
+  }
+  removeLayer(t) {
+    t.asGoogleLayer().setMap(null);
+  }
+  panTo(t) {
+    this.map.panTo(t.toGoogle(this.coordType));
+  }
+  panBy(t, r) {
+    this.map.panBy(t, r);
+  }
+  fitBounds(t, r) {
+    this.map.fitBounds(t.toGoogle(this.coordType), r);
+  }
+  getBounds() {
+    const t = this.map.getBounds();
+    return t ? W.fromGoogle(t, this.coordType) : W.EMPTY;
+  }
+  addElementOverlay(t) {
+    t.asGoogle().setMap(this.map);
+  }
+  removeElementOverlay(t) {
+    t.asGoogle().setMap(null);
+  }
+  addOverlay(t) {
+    t.innerOverlay.setMap(this.map);
+  }
+  removeOverlay(t) {
+    t.innerOverlay.setMap(null);
+  }
+  addCustomControl(t) {
+    t.inner || (t.inner = t.onCreateElement(), this.map.controls[P.getGoogle().toValue(t.position)].push(t.inner));
+  }
+  removeCustomControl(t) {
+    if (t.inner) {
+      const r = this.map.controls[P.getGoogle().toValue(t.position)];
+      Me.remove(r, t.inner);
+    }
+  }
+  createMarkerClusterer(t) {
+    return new Or(this, t);
+  }
+}
+const be = ["3.0"], zr = {
+  baidu: {
+    version: "3.0",
+    // TODO: 在build时好像会被静态替换, 导致使用者不能无法设置它
+    // 详见： https://cn.vitejs.dev/guide/build.html#library-mode:~:text=%E6%A8%A1%E5%BC%8F%E4%B8%8B%EF%BC%8C%E6%89%80%E6%9C%89-,({}).*,-%E7%94%A8%E6%B3%95%E5%9C%A8%E6%9E%84
+    key: {}.VITE_APP_DEV_KEY_BAIDU,
+    language: ""
+  },
+  google: {
+    version: "",
+    key: {}.VITE_APP_DEV_KEY_GOOGLE,
+    language: "en-us"
+  },
+  here: {
+    version: be[0],
+    key: {}.VITE_APP_DEV_KEY_HERE,
+    language: ""
+  }
+};
+let At;
+function zt() {
+  return At || I("请先安装: Vue<PartialTgMapConfig>.use(TgMap, {})");
+}
+function Nr(i) {
+  i != null && (At = Tt(zr, i));
+}
+class Rr extends Re {
+  constructor(t, r) {
+    var a;
+    super(t);
+    h(this, "map");
+    h(this, "defaultLayers");
+    this.mapOptions = r;
+    const s = zt().here;
+    be.includes(s.version) || I(`不支持${s.version}, HereMap当前只支持如下版本: ${be}`);
+    const o = new H.service.Platform({
+      app_id: s.key.split(",")[0],
+      app_code: s.key.split(",")[1]
+    });
+    this.defaultLayers = o.createDefaultLayers(), this.map = new H.Map(t, this.defaultLayers.normal.map, {
+      zoom: r.zoom,
+      center: (a = r.center) == null ? void 0 : a.toHere(this.coordType)
+    }), new H.mapevents.Behavior(new H.mapevents.MapEvents(this.map)), H.ui.UI.createDefault(this.map, this.defaultLayers);
+  }
+  setDefaultCursor(t) {
+    throw new Error("Method not implemented.");
+  }
+  get innerMap() {
+    return this.map;
+  }
+  get coordType() {
+    return Y.wgs84;
+  }
+  getCenter() {
+    return y.fromHere(this.map.getCenter(), this.coordType);
+  }
+  setCenter(t) {
+    this.map.setCenter(t.toHere(this.coordType));
+  }
+  // TODO: 实现其他方法
+  setDraggable(t) {
+    throw new Error("Method not implemented.");
+  }
+  setDisableDoubleClickZoom(t) {
+    throw new Error("Method not implemented.");
+  }
+  fromContainerPointToLatLng(t) {
+    throw new Error("Method not implemented.");
+  }
+  fromLatLngToContainerPoint(t) {
+    throw new Error("Method not implemented.");
+  }
+  addElementOverlay(t) {
+    throw new Error("Method not implemented.");
+  }
+  removeElementOverlay(t) {
+    throw new Error("Method not implemented.");
+  }
+  createInfoBox(t) {
+    throw new Error("Method not implemented.");
+  }
+  createLabel(t) {
+    throw new Error("Method not implemented.");
+  }
+  fitBounds(t, r) {
+    throw new Error("Method not implemented.");
+  }
+  getBounds() {
+    throw new Error("Method not implemented.");
+  }
+  panTo(t) {
+    throw new Error("Method not implemented.");
+  }
+  panBy(t, r) {
+    throw new Error("Method not implemented.");
+  }
+  setBuildInMapTypeId(t) {
+    throw new Error("Method not implemented.");
+  }
+  setMapType(t) {
+    throw new Error("Method not implemented.");
+  }
+  getMapType() {
+    throw new Error("Method not implemented.");
+  }
+  addLayer(t) {
+    throw new Error("Method not implemented.");
+  }
+  removeLayer(t) {
+    throw new Error("Method not implemented.");
+  }
+  setGestureHandling(t) {
+    throw new Error("Method not implemented.");
+  }
+  setMinZoom(t) {
+    throw new Error("Method not implemented.");
+  }
+  setMaxZoom(t) {
+    throw new Error("Method not implemented.");
+  }
+  setMapStyle(t) {
+    throw new Error("Method not implemented.");
+  }
+  addOverlay(t) {
+    throw new Error("Method not implemented.");
+  }
+  removeOverlay(t) {
+    throw new Error("Method not implemented.");
+  }
+  createMarker(t) {
+    throw new Error("Method not implemented.");
+  }
+  createMarkerClusterer(t) {
+    throw new Error("Method not implemented.");
+  }
+  createInfoWindow(t) {
+    throw new Error("Method not implemented.");
+  }
+  createPolyline(t) {
+    throw new Error("Method not implemented.");
+  }
+  createPolygon(t) {
+    throw new Error("Method not implemented.");
+  }
+  createCircle(t) {
+    throw new Error("Method not implemented.");
+  }
+  addCustomControl(t) {
+    throw new Error("Method not implemented.");
+  }
+  removeCustomControl(t) {
+    throw new Error("Method not implemented.");
+  }
+  createMapTypeControl(t) {
+    throw new Error("Method not implemented.");
+  }
+  createZoomControl(t) {
+    throw new Error("Method not implemented.");
+  }
+  createScaleControl(t) {
+    throw new Error("Method not implemented.");
+  }
+}
+var $ = /* @__PURE__ */ ((i) => (i.google = "google", i.baidu = "baidu", i.here = "here", i))($ || {}), ze;
+((i) => {
+  function e(t, r, s) {
+    const o = Le.create(s);
+    switch (t) {
+      case "google":
+        return new Ar(r, o);
+      case "baidu":
+        return new $r(r, o);
+      case "here":
+        return new Rr(r, o);
+    }
+  }
+  i.createMap = e;
+})(ze || (ze = {}));
+function Dr(i, e) {
+  const t = window, r = Zr(i);
+  if (t[r])
+    return Promise.resolve();
+  switch (i != $.here && !e.key && I(`请先配置${i}地图的key`), i) {
+    case $.google:
+      return vt(`https://maps.googleapis.com/maps/api/js?key=${e.key}&language=${e.language}`);
+    case $.baidu:
+      return vt(`https://api.map.baidu.com/api?v=${e.version}&ak=${e.key}`);
+    case $.here:
+      return oe(se("core", e.version)).then(() => Promise.all([
+        // 其他大多数模块都可以同时载入
+        oe(se("service", e.version)),
+        oe(se("mapevents", e.version)),
+        oe(se("clustering", e.version)),
+        oe(se("ui", e.version))
+      ])).catch((s) => (delete t[r], Promise.reject(s)));
+  }
+}
+function se(i, e = be[0]) {
+  return `https://js.api.here.com/v3/${e}/mapsjs-${i}.js`;
+}
+function Zr(i) {
+  switch (i) {
+    case $.google:
+      return "google";
+    case $.baidu:
+      return "BMap";
+    case $.here:
+      return "H";
+  }
+}
+let Gr = 0;
+function vt(i, e = "callback") {
+  return new Promise((t, r) => {
+    const s = `__callback${Gr++}`;
+    window[s] = t;
+    const o = document.createElement("script");
+    o.src = `${i}&${e}=${s}`, o.onerror = r, document.body.appendChild(o);
+  });
+}
+function oe(i) {
+  return new Promise((e, t) => {
+    const r = document.createElement("script");
+    r.src = i, r.onload = e, r.onerror = t, document.body.appendChild(r);
+  });
+}
+const jr = C({
+  name: "tg-map",
+  props: {
+    /** type没做响应式, 但外部可以把type作为tg-map的key, 让type修改时完全重建tg-map */
+    type: V($, $.google),
+    /**
+     * 当对该属性使用双向绑定时, 改变center将触发update:center又反过来触发center改变, 最终导致无限循环...
+     * 当前通过setCenter()时判断center是否有改变来避免该问题, 但为了避免可能存在的问题, 另外设计了如下机制:
+     * - :center-sync-delay="300": 延时同步center, 防止center的值更新过快
+     * - :current-center.sync="currentCenter": 实时获取center的值
+     * - :last-center.sync="center": 获取tg-map销毁时的最后的center的值, 使用这种方式可以做到type切换时保留中心点位置
+     * @see AbstractMapEventMap.center-changed
+     * */
+    center: z(y),
+    /**
+     * 同步center的延时
+     * @default 300
+     * @see center
+     */
+    centerSyncDelay: m(Number, 300),
+    /**
+     * 仅用来获取center的值, 需要设置center的值请使用`center`属性
+     * @see center
+     * */
+    currentCenter: m(y),
+    /**
+     * 仅用于获取tg-map销毁时的最后的center的值
+     * @see center
+     */
+    lastCenter: m(y),
+    zoom: z(Number),
+    infoWindowMode: er(["single", "multi"]),
+    gestureHandling: V(N),
+    minZoom: m(Number),
+    maxZoom: m(Number),
+    mapStyle: m(Object),
+    /** 设置为除BuildInMapTypeId以外的值时, 无实际效果... */
+    mapTypeId: m(String),
+    /** 优先级比mapTypeId高 */
+    mapType: m(Object)
+  },
+  data() {
+    return {
+      map: void 0,
+      isDestroyed: !1
+    };
+  },
+  setup() {
+    return {
+      centerSyncTimeoutId: 0
+    };
+  },
+  computed: {
+    propsJson() {
+      return le.toJsonSafely(this.$props);
+    }
+  },
+  watch: {
+    center(i) {
+      this.map && (this.map.getCenter().equals(i) || (console.debug("<tg-map> setCenter", i), this.map.setCenter(i)));
+    },
+    zoom(i) {
+      var e;
+      (e = this.map) == null || e.setZoom(i);
+    },
+    gestureHandling(i) {
+      var e;
+      (e = this.map) == null || e.setGestureHandling(i);
+    },
+    minZoom(i) {
+      var e;
+      (e = this.map) == null || e.setMinZoom(i);
+    },
+    maxZoom(i) {
+      var e;
+      (e = this.map) == null || e.setMaxZoom(i);
+    },
+    mapStyle(i) {
+      var e;
+      (e = this.map) == null || e.setMapStyle(i);
+    },
+    mapTypeId(i) {
+      if (this.map) {
+        const e = ye.toEnumOrNull(i, $e);
+        e && this.map.setBuildInMapTypeId(e);
+      }
+    },
+    mapType(i) {
+      var e;
+      (e = this.map) == null || e.setMapType(i ?? k.NORMAL);
+    }
+  },
+  provide() {
+    return {
+      [_t]: Ht(() => this.map)
+    };
+  },
+  async created() {
+    const { type: i } = this;
+    try {
+      await Dr(i, zt()[i]);
+    } catch (s) {
+      this.$emit("error", s);
+      return;
+    }
+    if (this.isDestroyed) {
+      console.warn(`tg-map(type=${i})已销毁, 不需要继续执行`);
+      return;
+    }
+    const e = this.map = ze.createMap(
+      i,
+      this.$refs.map,
+      /* options: */
+      {
+        center: this.center,
+        zoom: this.zoom,
+        infoWindowMode: this.infoWindowMode,
+        gestureHandling: this.gestureHandling,
+        minZoom: this.minZoom,
+        maxZoom: this.maxZoom,
+        mapStyle: this.mapStyle,
+        // 若不能转换成BuildInMapTypeId, 则会设为undefined
+        buildInMapTypeId: ye.toEnumOrNull(this.mapTypeId, $e)
+      }
+    );
+    if (this.mapType && e.setMapType(this.mapType), "ready" in this.$listeners && console.error("地图载入完成的事件已经从ready改为了load, 请手动修改"), R.call(
+      this,
+      this.map,
+      /* excludes: */
+      ["load"]
+    ), this.$emit("load", this.map), "update:center" in this.$listeners) {
+      const s = () => this.$emit("update:center", e.getCenter());
+      e.addEventListener("center-changed", () => {
+        this.centerSyncDelay > 0 ? (clearTimeout(this.centerSyncTimeoutId), this.centerSyncTimeoutId = setTimeout(s, this.centerSyncDelay)) : s();
+      });
+    }
+    "update:current-center" in this.$listeners && (this.$emit("update:current-center", this.center), e.addEventListener("center-changed", () => {
+      this.$emit("update:current-center", e.getCenter());
+    })), "update:zoom" in this.$listeners && e.addEventListener("zoom-changed", () => {
+      this.$emit("update:zoom", e.getZoom());
+    });
+    const t = "update:map-type" in this.$listeners, r = "update:map-type-id" in this.$listeners;
+    (t || r) && e.addEventListener("map-type-changed", () => {
+      const s = e.getMapType();
+      t && this.$emit("update:map-type", s), r && this.$emit("update:map-type-id", s.id);
+    });
+  },
+  destroyed() {
+    this.isDestroyed = !0, this.map && ("update:last-center" in this.$listeners && this.$emit("update:last-center", this.map.getCenter()), "update:center" in this.$listeners && (clearTimeout(this.centerSyncTimeoutId), this.$emit("update:center", this.map.getCenter())));
+  },
+  methods: {}
+});
+const G = (i, e) => {
+  const t = i.__vccOpts || i;
+  for (const [r, s] of e)
+    t[r] = s;
+  return t;
+}, Wr = { class: "tg-map" }, Vr = {
+  ref: "map",
+  class: "tg-map__map"
+};
+function Hr(i, e, t, r, s, o) {
+  return D(), Z("div", Wr, [
+    Ft("div", Vr, null, 512),
+    dt("", !0),
+    i.map ? A(i.$slots, "default", { key: 1 }) : dt("", !0),
+    A(i.$slots, "overlay")
+  ]);
+}
+const Nt = /* @__PURE__ */ G(jr, [["render", Hr]]);
+function Fr(i) {
+  if (i == null)
+    return null;
+  let e;
+  if (typeof i == "string") {
+    if (e = +i, Number.isNaN(e))
+      return i;
+  } else
+    e = i;
+  return `${e}px`;
+}
+const Ur = C({
+  name: "tg-map-widget",
+  props: {
+    left: {
+      type: [Number, String],
+      default: null
+    },
+    top: {
+      type: [Number, String],
+      default: null
+    },
+    right: {
+      type: [Number, String],
+      default: null
+    },
+    bottom: {
+      type: [Number, String],
+      default: null
+    }
+  },
+  computed: {
+    topValue() {
+      return this.top == null && this.bottom == null ? 0 : this.top;
+    }
+  },
+  methods: {
+    dimen: Fr
+  }
+});
+function Yr(i, e, t, r, s, o) {
+  return D(), Z("div", {
+    class: q(i.$options.name),
+    style: Ut({ left: i.dimen(i.left), top: i.dimen(i.topValue), right: i.dimen(i.right), bottom: i.dimen(i.bottom) })
+  }, [
+    A(i.$slots, "default")
+  ], 6);
+}
+const Kr = /* @__PURE__ */ G(Ur, [["render", Yr]]), qr = C({
+  name: "tg-custom-control",
+  mixins: [w],
+  props: {
+    position: V(x, x.RIGHT_BOTTOM)
+  },
+  setup() {
+    return {
+      control: void 0
+    };
+  },
+  watch: {
+    position() {
+      this.recreate();
+    }
+  },
+  onCreate() {
+    re(this.$parent, Nt) || console.warn("请将tg-custom-control放到tg-map中");
+    const { $el: i } = this, e = class extends kr {
+      onCreateElement() {
+        return i;
+      }
+    };
+    this.control = new e(this.position), this.$map.addCustomControl(this.control);
+  },
+  onDestroy() {
+    this.$map.removeCustomControl(this.control);
+  }
+});
+function Xr(i, e, t, r, s, o) {
+  return D(), Z("div", {
+    class: q(i.$options.name)
+  }, [
+    A(i.$slots, "default")
+  ], 2);
+}
+const Jr = /* @__PURE__ */ G(qr, [["render", Xr]]), Qr = C({
+  name: "tg-map-type-control",
+  mixins: [w],
+  props: {
+    position: V(x, x.TOP_LEFT),
+    type: V(Bt),
+    mapTypes: m(Array)
+  },
+  setup() {
+    return {
+      control: void 0
+    };
+  },
+  watch: {
+    position(i) {
+      this.control.setPosition(i);
+    },
+    type() {
+      this.recreate();
+    },
+    mapTypes() {
+      this.recreate();
+    }
+  },
+  onCreate() {
+    this.control = this.$map.createMapTypeControl(this), this.$map.addControl(this.control);
+  },
+  onDestroy() {
+    this.$map.removeControl(this.control);
+  }
+}), ei = C({
+  name: "tg-scale-control",
+  mixins: [w],
+  props: {
+    position: V(x, x.BOTTOM_RIGHT)
+  },
+  setup() {
+    return {
+      control: void 0
+    };
+  },
+  watch: {
+    position(i) {
+      this.control.setPosition(i);
+    }
+  },
+  onCreate() {
+    this.control = this.$map.createScaleControl(this), this.$map.addControl(this.control);
+  },
+  onDestroy() {
+    this.$map.removeControl(this.control);
+  }
+}), ti = C({
+  name: "tg-zoom-control",
+  mixins: [w],
+  props: {
+    position: V(x, x.RIGHT_BOTTOM)
+  },
+  setup() {
+    return {
+      control: void 0
+    };
+  },
+  watch: {
+    position(i) {
+      this.control.setPosition(i);
+    }
+  },
+  onCreate() {
+    this.control = this.$map.createZoomControl(this), this.$map.addControl(this.control);
+  },
+  onDestroy() {
+    this.$map.removeControl(this.control);
+  }
+}), ri = C({
+  name: "tg-label",
+  mixins: [w],
+  props: {
+    position: m(y),
+    offset: m(Object),
+    zIndex: m(Number)
+  },
+  setup() {
+    return {
+      overlay: void 0
+    };
+  },
+  methods: {
+    content() {
+      return this.$el;
+    },
+    marker() {
+      var i;
+      return (i = this.$marker()) == null ? void 0 : i.marker;
+    },
+    $marker() {
+      return re(this.$parent, de);
+    },
+    getOptions() {
+      return {
+        content: this.content(),
+        position: this.position,
+        offset: this.offset,
+        zIndex: this.zIndex
+      };
+    }
+  },
+  watch: {
+    position(i) {
+      this.overlay.setPosition(i);
+    },
+    offset(i) {
+      this.overlay.setOffset(i);
+    },
+    zIndex(i) {
+      this.overlay.setZIndex(i);
+    },
+    visible(i) {
+      this.overlay.setVisible(i);
+    }
+  },
+  onCreate() {
+    this.overlay = this.$map.createLabel(this.getOptions()), R.call(this, this.overlay), this.$marker() ? this.$marker().onAddLabel(this.overlay) : this.$map.addOverlay(this.overlay), R.call(this, this.overlay);
+  },
+  onDestroy() {
+    this.$marker() ? this.$marker().onRemoveLabel(this.overlay) : this.$map.removeOverlay(this.overlay);
+  }
+});
+function ii(i, e, t, r, s, o) {
+  return D(), Z("div", {
+    class: q(i.$options.name)
+  }, [
+    A(i.$slots, "default")
+  ], 2);
+}
+const Rt = /* @__PURE__ */ G(ri, [["render", ii]]), si = C({
+  name: "tg-info-window",
+  mixins: [w],
+  model: {
+    prop: "show",
+    event: "update:show"
+  },
+  props: {
+    show: z(Boolean),
+    position: m(y),
+    maxWidth: m(Number),
+    offset: m(Object),
+    disableAutoPan: m(Boolean)
+  },
+  setup() {
+    return {
+      overlay: void 0
+    };
+  },
+  methods: {
+    content() {
+      return this.$el;
+    },
+    $marker() {
+      return re(this.$parent, de);
+    },
+    getOptions() {
+      return {
+        content: this.content(),
+        position: this.position,
+        maxWidth: this.maxWidth,
+        offset: this.offset,
+        disableAutoPan: this.disableAutoPan
+      };
+    }
+  },
+  watch: {
+    show(i) {
+      this.$marker() ? this.$marker().onInfoShowChanged(this, i) : i ? this.overlay.open() : this.overlay.close();
+    },
+    position(i) {
+      this.overlay.setPosition(i);
+    },
+    maxWidth() {
+      this.recreate();
+    },
+    offset() {
+      this.recreate();
+    },
+    disableAutoPan() {
+      this.recreate();
+    }
+  },
+  onCreate() {
+    this.overlay = this.$map.createInfoWindow(this.getOptions()), this.$marker() ? this.$marker().onAddInfo(this) : this.show && this.overlay.open(), this.overlay.addEventListener("open", () => {
+      this.$emit("update:show", !0);
+    }), this.overlay.addEventListener("close", () => {
+      this.$emit("update:show", !1);
+    }), R.call(this, this.overlay);
+  },
+  onDestroy() {
+    this.$marker() ? this.$marker().onRemoveInfo(this) : this.overlay.close();
+  }
+});
+function oi(i, e, t, r, s, o) {
+  return Yt((D(), Z("div", {
+    class: q(i.$options.name)
+  }, [
+    A(i.$slots, "default")
+  ], 2)), [
+    [Kt, i.show]
+  ]);
+}
+const Dt = /* @__PURE__ */ G(si, [["render", oi]]), ni = C({
+  name: "tg-info-box",
+  mixins: [w],
+  model: {
+    prop: "show",
+    event: "update:show"
+  },
+  props: {
+    show: z(Boolean),
+    position: m(y),
+    offset: m(Object),
+    maxWidth: m(Number),
+    borderClass: m(String),
+    zIndex: m(Number)
+  },
+  setup() {
+    return {
+      overlay: void 0
+    };
+  },
+  watch: {
+    show(i) {
+      this.$marker() ? this.$marker().onInfoShowChanged(this, i) : i ? this.overlay.open() : this.overlay.close();
+    },
+    position(i) {
+      this.overlay.setPosition(i);
+    },
+    offset() {
+      this.recreate();
+    },
+    maxWidth(i) {
+      this.overlay.setMaxWidth(i);
+    },
+    borderClass() {
+      this.recreate();
+    },
+    zIndex(i) {
+      this.overlay.setZIndex(i);
+    }
+  },
+  onCreate() {
+    this.overlay = this.$map.createInfoBox(this.getOptions()), this.$marker() ? this.$marker().onAddInfo(this) : this.show && this.overlay.open(), "update:show" in this.$listeners && this.overlay.addEventListener("closeclick", () => {
+      this.$emit("update:show", !1);
+    }), R.call(this, this.overlay);
+  },
+  onDestroy() {
+    this.$marker() ? this.$marker().onRemoveInfo(this) : this.overlay.close();
+  },
+  methods: {
+    getOptions() {
+      return {
+        content: this.content(),
+        position: this.position,
+        offset: this.offset,
+        zIndex: this.zIndex,
+        maxWidth: this.maxWidth,
+        borderClass: this.borderClass
+      };
+    },
+    content() {
+      return this.$el;
+    },
+    $marker() {
+      return re(this.$parent, de);
+    },
+    open(i) {
+      this.overlay.open(i);
+    },
+    close() {
+      this.overlay.close();
+    }
+  }
+});
+function ai(i, e, t, r, s, o) {
+  return D(), Z("div", {
+    class: q(i.$options.name)
+  }, [
+    A(i.$slots, "default")
+  ], 2);
+}
+const Zt = /* @__PURE__ */ G(ni, [["render", ai]]), li = C({
+  name: "tg-marker",
+  mixins: [w],
+  props: {
+    position: z(y),
+    title: m(String),
+    icon: m(Object),
+    clickable: m(Boolean),
+    draggable: m(Boolean),
+    crossOnDrag: m(Boolean),
+    cursor: m(String),
+    zIndex: m(Number),
+    visible: m(Boolean)
+  },
+  setup() {
+    return {
+      marker: void 0
+    };
+  },
+  watch: {
+    position(i) {
+      this.marker.setPosition(i);
+    },
+    title(i) {
+      this.marker.setTitle(i);
+    },
+    icon(i) {
+      i ? this.marker.setIcon(i) : this.recreate();
+    },
+    clickable(i) {
+      this.marker instanceof he ? this.recreate() : this.marker.setClickable(i);
+    },
+    draggable(i) {
+      this.marker.setDraggable(i);
+    },
+    crossOnDrag() {
+      this.recreate();
+    },
+    cursor() {
+      this.recreate();
+    },
+    zIndex(i) {
+      this.marker instanceof he ? this.recreate() : this.marker.setZIndex(i);
+    },
+    visible(i) {
+      this.marker.setVisible(i);
+    }
+  },
+  onCreate() {
+    const i = we(this.$children, Rt), e = we(this.$children, Zt), t = we(this.$children, Dt);
+    this.marker = this.$map.createMarker(this), i && this.marker.setLabel(i.overlay), e && e.show && e.overlay.open(this.marker), this.$clusterer() ? this.$clusterer().onAddMarker(this.marker) : this.$map.addOverlay(this.marker), t && t.show && t.overlay.open(this.marker), R.call(this, this.marker);
+  },
+  onDestroy() {
+    this.$clusterer() ? this.$clusterer().onRemoveMarker(this.marker) : this.$map.removeOverlay(this.marker);
+  },
+  methods: {
+    $clusterer() {
+      return re(this.$parent, Gt);
+    },
+    onAddLabel(i) {
+      this.marker && this.marker.setLabel(i);
+    },
+    onRemoveLabel(i) {
+      this.marker.setLabel(void 0);
+    },
+    onAddInfo(i) {
+      this.marker && i.show && i.overlay.open(this.marker);
+    },
+    onRemoveInfo(i) {
+      i.overlay.close();
+    },
+    onInfoShowChanged(i, e) {
+      e ? i.overlay.open(this.marker) : i.overlay.close();
+    }
+  }
+});
+function hi(i, e, t, r, s, o) {
+  return D(), Z("div", {
+    class: q(i.$options.name)
+  }, [
+    A(i.$slots, "default")
+  ], 2);
+}
+const de = /* @__PURE__ */ G(li, [["render", hi]]), ci = C({
+  name: "tg-marker-clusterer",
+  mixins: [w],
+  // markers从this.$children中读取, 故需要省略(Omit)
+  props: {
+    gridSize: m(Number),
+    maxZoom: m(Number),
+    minClusterSize: m(Number),
+    averageCenter: m(Boolean),
+    styles: m(Array),
+    stylesIndexCalculator: m(Function),
+    zIndex: m(Number)
+  },
+  setup() {
+    return {
+      clusterer: void 0
+    };
+  },
+  watch: {
+    gridSize() {
+      this.recreate();
+    },
+    maxZoom() {
+      this.recreate();
+    },
+    minClusterSize() {
+      this.recreate();
+    },
+    averageCenter() {
+      this.recreate();
+    },
+    styles() {
+      this.recreate();
+    },
+    stylesIndexCalculator() {
+      this.recreate();
+    },
+    zIndex() {
+      this.recreate();
+    }
+  },
+  onCreate() {
+    this.clusterer = this.$map.createMarkerClusterer(this.getOptions());
+  },
+  onDestroy() {
+    this.clusterer.clearMarkers();
+  },
+  methods: {
+    getOptions() {
+      return {
+        markers: this.markers(),
+        gridSize: this.gridSize,
+        maxZoom: this.maxZoom,
+        minClusterSize: this.minClusterSize,
+        averageCenter: this.averageCenter,
+        styles: this.styles,
+        stylesIndexCalculator: this.stylesIndexCalculator,
+        zIndex: this.zIndex
+      };
+    },
+    /** TgMarker有可能在该组件未初始化之前调用, 需要通过该方法判断 */
+    isInitiated() {
+      return this.clusterer != null;
+    },
+    markers() {
+      return this.$children.map((e) => re(e, de)).filter(Qt).map((e) => e.marker);
+    },
+    onAddMarker(i) {
+      this.isInitiated() && this.clusterer.addMarker(i);
+    },
+    onRemoveMarker(i) {
+      this.isInitiated() && this.clusterer.removeMarker(i);
+    }
+  }
+});
+function di(i, e, t, r, s, o) {
+  return D(), Z("div", {
+    class: q(i.$options.name)
+  }, [
+    A(i.$slots, "default")
+  ], 2);
+}
+const Gt = /* @__PURE__ */ G(ci, [["render", di]]), pi = C({
+  name: "tg-traffic-layer",
+  mixins: [w],
+  props: {
+    // 请直接使用v-if来控制它的显隐
+  },
+  setup() {
+    return {
+      layer: void 0
+    };
+  },
+  watch: {},
+  onCreate() {
+    this.layer = new Ir(), this.$map.addLayer(this.layer);
+  },
+  onDestroy() {
+    this.$map.removeLayer(this.layer);
+  }
+}), ui = C({
+  name: "tg-circle",
+  mixins: [w],
+  props: {
+    center: z(y),
+    radius: z(Number),
+    clickable: m(Boolean),
+    editable: m(Boolean),
+    strokeColor: m(String),
+    strokeOpacity: m(Number),
+    strokeWeight: m(Number),
+    visible: m(Boolean),
+    fillColor: m(String),
+    fillOpacity: m(Number)
+  },
+  setup() {
+    return {
+      overlay: void 0
+    };
+  },
+  watch: {
+    center(i) {
+      this.overlay.setCenter(i);
+    },
+    radius(i) {
+      this.overlay.setRadius(i);
+    },
+    clickable() {
+      this.recreate();
+    },
+    editable(i) {
+      this.overlay.setEditable(i);
+    },
+    strokeColor(i) {
+      this.overlay.setStrokeColor(i);
+    },
+    strokeOpacity(i) {
+      this.overlay.setStrokeOpacity(i);
+    },
+    strokeWeight(i) {
+      this.overlay.setStrokeWeight(i);
+    },
+    fillColor(i) {
+      this.overlay.setFillColor(i);
+    },
+    fillOpacity(i) {
+      this.overlay.setFillOpacity(i);
+    },
+    visible(i) {
+      this.overlay.setVisible(i);
+    }
+  },
+  onCreate() {
+    this.overlay = this.$map.createCircle(this), this.$map.addOverlay(this.overlay), R.call(this, this.overlay);
+  },
+  onDestroy() {
+    this.$map.removeOverlay(this.overlay);
+  }
+});
+var Ne = /* @__PURE__ */ ((i) => (i.map = "map", i.overlay = "overlay", i.overlayMouseTarget = "overlayMouseTarget", i.float = "float", i))(Ne || {});
+class gi {
+  constructor(e, t) {
+    h(this, "baidu");
+    h(this, "google");
+    h(this, "projection");
+    h(this, "element", void 0);
+    h(this, "mapPane");
+    this.map = e, this.mapPane = t.mapPane;
+  }
+  create() {
+    return this.element = this.onCreate(), this.element.className += " element-overlay", this.element;
+  }
+  draw() {
+    this.projection && this.onDraw(this.projection);
+  }
+  getProjection() {
+    return this.projection;
+  }
+  asBaidu() {
+    if (!this.baidu) {
+      const e = this;
+      $t();
+      class t extends BMap.OverlayV3 {
+        initialize(o) {
+          const a = e.create(), g = o.getPanes();
+          let n;
+          switch (e.mapPane) {
+            case "float":
+              n = g.floatPane;
+              break;
+            case "overlayMouseTarget":
+              n = g.markerMouseTarget;
+              break;
+            case "overlay":
+              n = g.markerPane;
+              break;
+            case "map":
+              n = g.mapPane;
+              break;
+            default:
+              pt(e.mapPane);
+              break;
+          }
+          return n == null || n.appendChild(a), a;
+        }
+        draw() {
+          e.draw();
+        }
+      }
+      this.baidu = new t();
+      const r = e.map.innerMap;
+      this.projection = {
+        fromLatLngToOverlayPoint(s) {
+          return r.pointToOverlayPixel(s.toBaidu(e.map.coordType));
+        },
+        fromOverlayPointToLatLng(s) {
+          return y.fromBaidu(r.overlayPixelToPoint(new BMap.Pixel(s.x, s.y)), e.map.coordType);
+        }
+      };
+    }
+    return this.baidu;
+  }
+  asGoogle() {
+    if (!this.google) {
+      const e = this;
+      class t extends google.maps.OverlayView {
+        onAdd() {
+          const s = e.create(), o = this.getPanes();
+          let a;
+          switch (e.mapPane) {
+            case "float":
+              a = o.floatPane;
+              break;
+            case "overlayMouseTarget":
+              a = o.overlayMouseTarget;
+              break;
+            case "overlay":
+              a = o.overlayLayer;
+              break;
+            case "map":
+              a = o.mapPane;
+              break;
+            default:
+              pt(e.mapPane);
+              break;
+          }
+          a.appendChild(s);
+        }
+        draw() {
+          e.draw();
+        }
+        onRemove() {
+          var s;
+          (s = e.element.parentNode) == null || s.removeChild(e.element);
+        }
+      }
+      this.google = new t(), this.projection = {
+        fromLatLngToOverlayPoint(r) {
+          return e.google.getProjection().fromLatLngToDivPixel(r.toGoogle(e.map.coordType));
+        },
+        fromOverlayPointToLatLng(r) {
+          return y.fromGoogle(e.google.getProjection().fromDivPixelToLatLng(new google.maps.Point(r.x, r.y)), e.map.coordType);
+        }
+      };
+    }
+    return this.google;
+  }
+}
+class mi extends gi {
+  constructor(e, t, r, s) {
+    super(e, t), this.content = r, this.position = s;
+  }
+  onCreate() {
+    return this.content;
+  }
+  onDraw(e) {
+    const t = e.fromLatLngToOverlayPoint(this.position);
+    this.content.style.left = t.x + "px", this.content.style.top = t.y + "px";
+  }
+  setPosition(e) {
+    this.position = e, this.draw();
+  }
+}
+const fi = C({
+  name: "tg-element-overlay",
+  mixins: [w],
+  props: {
+    mapPane: V(Ne, Ne.overlayMouseTarget),
+    position: z(y)
+  },
+  setup() {
+    return {
+      overlay: void 0
+    };
+  },
+  methods: {
+    content() {
+      return this.$el;
+    }
+  },
+  watch: {
+    position(i) {
+      this.overlay.setPosition(i);
+    },
+    mapPane() {
+      this.recreate();
+    }
+  },
+  onCreate() {
+    this.overlay = new mi(this.$map, this, this.content(), this.position), this.$map.addElementOverlay(this.overlay);
+  },
+  onDestroy() {
+    this.$map.removeElementOverlay(this.overlay);
+  }
+});
+function yi(i, e, t, r, s, o) {
+  return D(), Z("div", qt({
+    class: i.$options.name
+  }, Xt(i.$listeners, !0)), [
+    A(i.$slots, "default")
+  ], 16);
+}
+const vi = /* @__PURE__ */ G(fi, [["render", yi]]), _i = C({
+  name: "tg-polygon",
+  mixins: [w],
+  props: {
+    paths: z(Array),
+    clickable: m(Boolean),
+    editable: m(Boolean),
+    strokeColor: m(String),
+    strokeOpacity: m(Number),
+    strokeWeight: m(Number),
+    visible: m(Boolean),
+    fillColor: m(String),
+    fillOpacity: m(Number)
+  },
+  setup() {
+    return {
+      polygon: void 0
+    };
+  },
+  watch: {
+    paths(i) {
+      this.polygon.setPaths(i);
+    },
+    clickable() {
+      this.recreate();
+    },
+    editable(i) {
+      this.polygon.setEditable(i);
+    },
+    strokeColor(i) {
+      this.polygon.setStrokeColor(i);
+    },
+    strokeOpacity(i) {
+      this.polygon.setStrokeOpacity(i);
+    },
+    strokeWeight(i) {
+      this.polygon.setStrokeWeight(i);
+    },
+    fillColor(i) {
+      this.polygon.setFillColor(i);
+    },
+    fillOpacity(i) {
+      this.polygon.setFillOpacity(i);
+    },
+    visible(i) {
+      this.polygon.setVisible(i);
+    }
+  },
+  onCreate() {
+    this.polygon = this.$map.createPolygon(this), this.$map.addOverlay(this.polygon), R.call(this, this.polygon);
+  },
+  onDestroy() {
+    this.$map.removeOverlay(this.polygon);
+  }
+}), Mi = C({
+  name: "tg-polyline",
+  mixins: [w],
+  props: {
+    path: z(Array),
+    clickable: m(Boolean),
+    editable: m(Boolean),
+    strokeColor: m(String),
+    strokeOpacity: m(Number),
+    strokeWeight: m(Number),
+    visible: m(Boolean)
+  },
+  setup() {
+    return {
+      polyline: void 0
+    };
+  },
+  watch: {
+    path(i) {
+      this.polyline.setPath(i);
+    },
+    clickable() {
+      this.recreate();
+    },
+    editable(i) {
+      this.polyline.setEditable(i);
+    },
+    strokeColor(i) {
+      this.polyline.setStrokeColor(i);
+    },
+    strokeOpacity(i) {
+      this.polyline.setStrokeOpacity(i);
+    },
+    strokeWeight(i) {
+      this.polyline.setStrokeWeight(i);
+    },
+    visible(i) {
+      this.polyline.setVisible(i);
+    }
+  },
+  onCreate() {
+    this.polyline = this.$map.createPolyline(this), this.$map.addOverlay(this.polyline), R.call(this, this.polyline);
+  },
+  onDestroy() {
+    this.$map.removeOverlay(this.polyline);
+  }
+}), bi = ["beforeUpdate", "updated"], Ai = {
+  install(i, e = {}) {
+    if (e.enable !== !1) {
+      const t = C({
+        methods: {
+          __life(r) {
+            this.__life_impl(r);
+          }
+        },
+        beforeCreate() {
+          const r = this.$options.name || this.$options._componentTag || "", o = (e.nameRegex || /^[A-Z]/).test(r) ? (a) => {
+            e.hookNames ? e.hookNames.includes(a) && console.debug("[lifecycle]", r, a) : bi.includes(a) || console.debug("[lifecycle]", r, a);
+          } : fe;
+          o("beforeCreate"), this.__life_impl = o;
+        },
+        created() {
+          this.__life("created");
+        },
+        beforeMount() {
+          this.__life("beforeMount");
+        },
+        mounted() {
+          this.__life("mounted");
+        },
+        onCreate() {
+          this.__life("onCreate");
+        },
+        onDestroy() {
+          this.__life("onDestroy");
+        },
+        beforeUpdate() {
+          this.__life("beforeUpdate");
+        },
+        updated() {
+          this.__life("updated");
+        },
+        beforeDestroy() {
+          this.__life("beforeDestroy");
+        },
+        destroyed() {
+          this.__life("destroyed");
+        }
+      });
+      i.mixin(t);
+    }
+  }
+}, zi = {
+  install(i, e) {
+    Nr(e);
+    const t = /* @__PURE__ */ Object.assign({ "./TgMap.vue": Nt, "./TgMapWidget.vue": Kr, "./controls/TgCustomControl.vue": Jr, "./controls/TgMapTypeControl.vue": Qr, "./controls/TgScaleControl.vue": ei, "./controls/TgZoomControl.vue": ti, "./extra/TgMarkerClusterer.vue": Gt, "./layers/TgTrafficLayer.vue": pi, "./overlays/TgCircle.vue": ui, "./overlays/TgElementOverlay.vue": vi, "./overlays/TgInfoBox.vue": Zt, "./overlays/TgInfoWindow.vue": Dt, "./overlays/TgLabel.vue": Rt, "./overlays/TgMarker.vue": de, "./overlays/TgPolygon.vue": _i, "./overlays/TgPolyline.vue": Mi });
+    Object.keys(t).forEach((s) => {
+      var a;
+      const o = t[s];
+      i.component(((a = o.options) == null ? void 0 : a.name) ?? o.name, o);
+    });
+    const r = i.config.optionMergeStrategies;
+    r[Ie] = r[Pe] = r.created;
+  }
+};
+export {
+  Lt as AbstractControl,
+  Re as AbstractMap,
+  Se as Arrays,
+  Ue as BaiduCircle,
+  Ke as BaiduControl,
+  lt as BaiduInfoBoxOverlay,
+  st as BaiduInfoWindow,
+  Xe as BaiduMapTypeControl,
+  he as BaiduMarker,
+  Tr as BaiduMarkerClusterer,
+  Oe as BaiduOverlay,
+  He as BaiduPolygon,
+  We as BaiduPolyline,
+  et as BaiduScaleControl,
+  Je as BaiduZoomControl,
+  yt as CachedValue,
+  x as ControlPosition,
+  P as ControlPositionConverter,
+  Y as CoordType,
+  kr as CustomControl,
+  Er as FastFindValues,
+  Ye as GoogleCircle,
+  qe as GoogleControl,
+  ht as GoogleInfoBoxOverlay,
+  ot as GoogleInfoWindow,
+  me as GoogleMapTypeControl,
+  rt as GoogleMarker,
+  Or as GoogleMarkerClusterer,
+  Ze as GoogleOverlay,
+  Fe as GooglePolygon,
+  Ve as GooglePolyline,
+  tt as GoogleScaleControl,
+  Qe as GoogleZoomControl,
+  ee as Icon,
+  it as InfoWindow,
+  ft as KeyValue,
+  y as LatLng,
+  W as LatLngBounds,
+  Ai as LifecycleLogPlugin,
+  Ie as MIXIN_HOOK_CREATE,
+  Pe as MIXIN_HOOK_DESTROY,
+  _t as MIXIN_MAP_NAME,
+  Me as MVCArrays,
+  w as MapMixin,
+  Bt as MapTypeControlType,
+  kt as MarkerClusterer,
+  le as Objects,
+  Pt as Overlay,
+  ce as Point,
+  ye as Strings,
+  Zt as TgInfoBox,
+  Nt as TgMap,
+  ze as TgMapFactory,
+  $ as TgMapType,
+  ue as callHook,
+  xi as computedSaveOnThis,
+  rr as createEmptyVNode,
+  tr as createPropertyObject,
+  Ei as createPropertyObjectTyped,
+  wi as debug,
+  zi as default,
+  ki as eventLogMethods,
+  we as findByComponentType,
+  zt as getTgMapConfig,
+  Qt as isDef,
+  Li as isInstanceOf,
+  Ii as lateinit,
+  fe as noop,
+  m as optionalProp,
+  z as requiredProp,
+  Bi as safeAs,
+  re as safeAsComponent,
+  Nr as setTgMapConfig,
+  V as stringEnumProp,
+  er as stringEnumPropFromArray,
+  I as throwError,
+  Jt as throwUnsupported,
+  Ci as todo,
+  Pi as typed
+};
+//# sourceMappingURL=tg-map.js.map