tg-map-core 4.1.3 → 4.1.4

package/dist/tg-map-core.cjs

@@ -4,9 +4,6 @@ var maptalks = require('maptalks');
 var tgCommons = require('tg-commons');
 var coordtransform = require('coordtransform');
 var deepmerge = require('deepmerge');
-var BHeatMapOverlay = require('bmaplib.heatmap');
-var GMarkerClusterer = require('@google/markerclusterer');
-var BMarkerClusterer = require('bmaplib.markerclusterer');
 var isPlainObject = require('is-plain-object');
 require('maptalks/dist/maptalks.css');
 
@@ -33,9 +30,6 @@ function _interopNamespace(e) {
 var maptalks__namespace = /*#__PURE__*/_interopNamespace(maptalks);
 var coordtransform__default = /*#__PURE__*/_interopDefault(coordtransform);
 var deepmerge__default = /*#__PURE__*/_interopDefault(deepmerge);
-var BHeatMapOverlay__default = /*#__PURE__*/_interopDefault(BHeatMapOverlay);
-var GMarkerClusterer__default = /*#__PURE__*/_interopDefault(GMarkerClusterer);
-var BMarkerClusterer__default = /*#__PURE__*/_interopDefault(BMarkerClusterer);
 var isPlainObject__default = /*#__PURE__*/_interopDefault(isPlainObject);
 
 function bindEvents(listeners, target, excludes) {
@@ -1568,6 +1562,1023 @@ class BaiduAutocomplete extends Autocomplete {
     }
 }
 
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+var bmaplib_heatmap$1 = {exports: {}};
+
+/*
+ * heatmap.js v2.0.0 | JavaScript Heatmap Library
+ *
+ * Copyright 2008-2014 Patrick Wied <heatmapjs@patrick-wied.at> - All rights reserved.
+ * Dual licensed under MIT and Beerware license 
+ *
+ * :: 2014-10-31 21:16
+ */
+var bmaplib_heatmap = bmaplib_heatmap$1.exports;
+
+var hasRequiredBmaplib_heatmap;
+
+function requireBmaplib_heatmap () {
+	if (hasRequiredBmaplib_heatmap) return bmaplib_heatmap$1.exports;
+	hasRequiredBmaplib_heatmap = 1;
+	(function (module, exports) {
+		(function (root, factory) {
+		  {
+		    module.exports = factory();
+		  }
+		})(bmaplib_heatmap, function () {
+		  const heatmapFactory = (function () {
+		    // Heatmap Config stores default values and will be merged with instance config
+		    var HeatmapConfig = {
+		      defaultRadius: 40,
+		      defaultRenderer: 'canvas2d',
+		      defaultGradient: { 0.45: "rgb(0,0,255)", 0.55: "rgb(0,255,255)", 0.65: "rgb(0,255,0)", 0.95: "yellow", 1.0: "rgb(255,0,0)" },
+		      defaultMaxOpacity: 1,
+		      defaultMinOpacity: 0,
+		      defaultBlur: .85,
+		      defaultXField: 'x',
+		      defaultYField: 'y',
+		      defaultValueField: 'value',
+		      plugins: {}
+		    };
+		    var Store = (function StoreClosure() {
+
+		      var Store = function Store(config) {
+		        this._coordinator = {};
+		        this._data = [];
+		        this._radi = [];
+		        this._min = 0;
+		        this._max = 1;
+		        this._xField = config['xField'] || config.defaultXField;
+		        this._yField = config['yField'] || config.defaultYField;
+		        this._valueField = config['valueField'] || config.defaultValueField;
+
+		        if (config["radius"]) {
+		          this._cfgRadius = config["radius"];
+		        }
+		      };
+
+		      var defaultRadius = HeatmapConfig.defaultRadius;
+
+		      Store.prototype = {
+		        // when forceRender = false -> called from setData, omits renderall event
+		        _organiseData: function (dataPoint, forceRender) {
+		          var x = dataPoint[this._xField];
+		          var y = dataPoint[this._yField];
+		          var radi = this._radi;
+		          var store = this._data;
+		          var max = this._max;
+		          var min = this._min;
+		          var value = dataPoint[this._valueField] || 1;
+		          var radius = dataPoint.radius || this._cfgRadius || defaultRadius;
+
+		          if (!store[x]) {
+		            store[x] = [];
+		            radi[x] = [];
+		          }
+
+		          if (!store[x][y]) {
+		            store[x][y] = value;
+		            radi[x][y] = radius;
+		          } else {
+		            store[x][y] += value;
+		          }
+
+		          if (store[x][y] > max) {
+		            if (!forceRender) {
+		              this._max = store[x][y];
+		            } else {
+		              this.setDataMax(store[x][y]);
+		            }
+		            return false;
+		          } else {
+		            return {
+		              x: x,
+		              y: y,
+		              value: value,
+		              radius: radius,
+		              min: min,
+		              max: max
+		            };
+		          }
+		        },
+		        _unOrganizeData: function () {
+		          var unorganizedData = [];
+		          var data = this._data;
+		          var radi = this._radi;
+
+		          for (var x in data) {
+		            for (var y in data[x]) {
+
+		              unorganizedData.push({
+		                x: x,
+		                y: y,
+		                radius: radi[x][y],
+		                value: data[x][y]
+		              });
+
+		            }
+		          }
+		          return {
+		            min: this._min,
+		            max: this._max,
+		            data: unorganizedData
+		          };
+		        },
+		        _onExtremaChange: function () {
+		          this._coordinator.emit('extremachange', {
+		            min: this._min,
+		            max: this._max
+		          });
+		        },
+		        addData: function () {
+		          if (arguments[0].length > 0) {
+		            var dataArr = arguments[0];
+		            var dataLen = dataArr.length;
+		            while (dataLen--) {
+		              this.addData.call(this, dataArr[dataLen]);
+		            }
+		          } else {
+		            // add to store  
+		            var organisedEntry = this._organiseData(arguments[0], true);
+		            if (organisedEntry) {
+		              this._coordinator.emit('renderpartial', {
+		                min: this._min,
+		                max: this._max,
+		                data: [organisedEntry]
+		              });
+		            }
+		          }
+		          return this;
+		        },
+		        setData: function (data) {
+		          var dataPoints = data.data;
+		          var pointsLen = dataPoints.length;
+
+
+		          // reset data arrays
+		          this._data = [];
+		          this._radi = [];
+
+		          for (var i = 0; i < pointsLen; i++) {
+		            this._organiseData(dataPoints[i], false);
+		          }
+		          this._max = data.max;
+		          this._min = data.min || 0;
+
+		          this._onExtremaChange();
+		          this._coordinator.emit('renderall', this._getInternalData());
+		          return this;
+		        },
+		        removeData: function () {
+		          // TODO: implement
+		        },
+		        setDataMax: function (max) {
+		          this._max = max;
+		          this._onExtremaChange();
+		          this._coordinator.emit('renderall', this._getInternalData());
+		          return this;
+		        },
+		        setDataMin: function (min) {
+		          this._min = min;
+		          this._onExtremaChange();
+		          this._coordinator.emit('renderall', this._getInternalData());
+		          return this;
+		        },
+		        setCoordinator: function (coordinator) {
+		          this._coordinator = coordinator;
+		        },
+		        _getInternalData: function () {
+		          return {
+		            max: this._max,
+		            min: this._min,
+		            data: this._data,
+		            radi: this._radi
+		          };
+		        },
+		        getData: function () {
+		          return this._unOrganizeData();
+		        }/*,
+
+		        // TODO: rethink.
+		        getValueAt: function (point) {
+		          var value;
+		          var radius = 100;
+		          var x = point.x;
+		          var y = point.y;
+		          var data = this._data;
+
+		          if (data[x] && data[x][y]) {
+		            return data[x][y];
+		          } else {
+		            var values = [];
+		            // radial search for datapoints based on default radius
+		            for (var distance = 1; distance < radius; distance++) {
+		              var neighbors = distance * 2 + 1;
+		              var startX = x - distance;
+		              var startY = y - distance;
+
+		              for (var i = 0; i < neighbors; i++) {
+		                for (var o = 0; o < neighbors; o++) {
+		                  if ((i == 0 || i == neighbors - 1) || (o == 0 || o == neighbors - 1)) {
+		                    if (data[startY + i] && data[startY + i][startX + o]) {
+		                      values.push(data[startY + i][startX + o]);
+		                    }
+		                  } else {
+		                    continue;
+		                  }
+		                }
+		              }
+		            }
+		            if (values.length > 0) {
+		              return Math.max.apply(Math, values);
+		            }
+		          }
+		          return false;
+		        }*/
+		      };
+
+
+		      return Store;
+		    })();
+
+		    var Canvas2dRenderer = (function Canvas2dRendererClosure() {
+
+		      var _getColorPalette = function (config) {
+		        var gradientConfig = config.gradient || config.defaultGradient;
+		        var paletteCanvas = document.createElement('canvas');
+		        var paletteCtx = paletteCanvas.getContext('2d');
+
+		        paletteCanvas.width = 256;
+		        paletteCanvas.height = 1;
+
+		        var gradient = paletteCtx.createLinearGradient(0, 0, 256, 1);
+		        for (var key in gradientConfig) {
+		          gradient.addColorStop(key, gradientConfig[key]);
+		        }
+
+		        paletteCtx.fillStyle = gradient;
+		        paletteCtx.fillRect(0, 0, 256, 1);
+
+		        return paletteCtx.getImageData(0, 0, 256, 1).data;
+		      };
+
+		      var _getPointTemplate = function (radius, blurFactor) {
+		        var tplCanvas = document.createElement('canvas');
+		        var tplCtx = tplCanvas.getContext('2d');
+		        var x = radius;
+		        var y = radius;
+		        tplCanvas.width = tplCanvas.height = radius * 2;
+
+		        if (blurFactor == 1) {
+		          tplCtx.beginPath();
+		          tplCtx.arc(x, y, radius, 0, 2 * Math.PI, false);
+		          tplCtx.fillStyle = 'rgba(0,0,0,1)';
+		          tplCtx.fill();
+		        } else {
+		          var gradient = tplCtx.createRadialGradient(x, y, radius * blurFactor, x, y, radius);
+		          gradient.addColorStop(0, 'rgba(0,0,0,1)');
+		          gradient.addColorStop(1, 'rgba(0,0,0,0)');
+		          tplCtx.fillStyle = gradient;
+		          tplCtx.fillRect(0, 0, 2 * radius, 2 * radius);
+		        }
+
+
+
+		        return tplCanvas;
+		      };
+
+		      var _prepareData = function (data) {
+		        var renderData = [];
+		        var min = data.min;
+		        var max = data.max;
+		        var radi = data.radi;
+		        var data = data.data;
+
+		        var xValues = Object.keys(data);
+		        var xValuesLen = xValues.length;
+
+		        while (xValuesLen--) {
+		          var xValue = xValues[xValuesLen];
+		          var yValues = Object.keys(data[xValue]);
+		          var yValuesLen = yValues.length;
+		          while (yValuesLen--) {
+		            var yValue = yValues[yValuesLen];
+		            var value = data[xValue][yValue];
+		            var radius = radi[xValue][yValue];
+		            renderData.push({
+		              x: xValue,
+		              y: yValue,
+		              value: value,
+		              radius: radius
+		            });
+		          }
+		        }
+
+		        return {
+		          min: min,
+		          max: max,
+		          data: renderData
+		        };
+		      };
+
+
+		      function Canvas2dRenderer(config) {
+		        var container = config.element;
+		        var shadowCanvas = this.shadowCanvas = document.createElement('canvas');
+		        var canvas = this.canvas = config.canvas || document.createElement('canvas');
+		        this._renderBoundaries = [10000, 10000, 0, 0];
+
+		        var computed = getComputedStyle(config.element) || {};
+
+		        canvas.className = 'heatmap-canvas';
+
+		        this._width = canvas.width = shadowCanvas.width = +(computed.width.replace(/px/, ''));
+		        this._height = canvas.height = shadowCanvas.height = +(computed.height.replace(/px/, ''));
+
+		        this.shadowCtx = shadowCanvas.getContext('2d');
+		        this.ctx = canvas.getContext('2d');
+
+		        // @TODO:
+		        // conditional wrapper
+
+		        canvas.style.cssText = shadowCanvas.style.cssText = 'position:absolute;left:0;top:0;';
+
+		        container.style.position = 'relative';
+		        container.appendChild(canvas);
+
+		        this._palette = _getColorPalette(config);
+		        this._templates = {};
+
+		        this._setStyles(config);
+		      }
+		      Canvas2dRenderer.prototype = {
+		        renderPartial: function (data) {
+		          this._drawAlpha(data);
+		          this._colorize();
+		        },
+		        renderAll: function (data) {
+		          // reset render boundaries
+		          this._clear();
+		          this._drawAlpha(_prepareData(data));
+		          this._colorize();
+		        },
+		        _updateGradient: function (config) {
+		          this._palette = _getColorPalette(config);
+		        },
+		        updateConfig: function (config, oldConfig) {
+		          if (config.gradient !== oldConfig.gradient) {
+		            this._updateGradient(config);
+		          }
+		          this._setStyles(config);
+		        },
+		        setDimensions: function (width, height) {
+		          this._width = width;
+		          this._height = height;
+		          this.canvas.width = this.shadowCanvas.width = width;
+		          this.canvas.height = this.shadowCanvas.height = height;
+		        },
+		        _clear: function () {
+		          this.shadowCtx.clearRect(0, 0, this._width, this._height);
+		          this.ctx.clearRect(0, 0, this._width, this._height);
+		        },
+		        _setStyles: function (config) {
+		          this._blur = (config.blur == 0) ? 0 : (config.blur || config.defaultBlur);
+
+		          if (config.backgroundColor) {
+		            this.canvas.style.backgroundColor = config.backgroundColor;
+		          }
+
+		          this._opacity = (config.opacity || 0) * 255;
+		          this._maxOpacity = (config.maxOpacity || config.defaultMaxOpacity) * 255;
+		          this._minOpacity = (config.minOpacity || config.defaultMinOpacity) * 255;
+		          this._useGradientOpacity = !!config.useGradientOpacity;
+		        },
+		        _drawAlpha: function (data) {
+		          var min = this._min = data.min;
+		          var max = this._max = data.max;
+		          var data = data.data || [];
+		          var dataLen = data.length;
+		          // on a point basis?
+		          var blur = 1 - this._blur;
+
+		          while (dataLen--) {
+
+		            var point = data[dataLen];
+
+		            var x = point.x;
+		            var y = point.y;
+		            var radius = point.radius;
+		            // if value is bigger than max
+		            // use max as value
+		            var value = Math.min(point.value, max);
+		            var rectX = x - radius;
+		            var rectY = y - radius;
+		            var shadowCtx = this.shadowCtx;
+
+
+
+
+		            var tpl;
+		            if (!this._templates[radius]) {
+		              this._templates[radius] = tpl = _getPointTemplate(radius, blur);
+		            } else {
+		              tpl = this._templates[radius];
+		            }
+		            // value from minimum / value range
+		            // => [0, 1]
+		            shadowCtx.globalAlpha = (value - min) / (max - min);
+
+		            shadowCtx.drawImage(tpl, rectX, rectY);
+
+		            // update renderBoundaries
+		            if (rectX < this._renderBoundaries[0]) {
+		              this._renderBoundaries[0] = rectX;
+		            }
+		            if (rectY < this._renderBoundaries[1]) {
+		              this._renderBoundaries[1] = rectY;
+		            }
+		            if (rectX + 2 * radius > this._renderBoundaries[2]) {
+		              this._renderBoundaries[2] = rectX + 2 * radius;
+		            }
+		            if (rectY + 2 * radius > this._renderBoundaries[3]) {
+		              this._renderBoundaries[3] = rectY + 2 * radius;
+		            }
+
+		          }
+		        },
+		        _colorize: function () {
+		          var x = this._renderBoundaries[0];
+		          var y = this._renderBoundaries[1];
+		          var width = this._renderBoundaries[2] - x;
+		          var height = this._renderBoundaries[3] - y;
+		          var maxWidth = this._width;
+		          var maxHeight = this._height;
+		          var opacity = this._opacity;
+		          var maxOpacity = this._maxOpacity;
+		          var minOpacity = this._minOpacity;
+		          var useGradientOpacity = this._useGradientOpacity;
+
+		          if (x < 0) {
+		            x = 0;
+		          }
+		          if (y < 0) {
+		            y = 0;
+		          }
+		          if (x + width > maxWidth) {
+		            width = maxWidth - x;
+		          }
+		          if (y + height > maxHeight) {
+		            height = maxHeight - y;
+		          }
+
+		          var img = this.shadowCtx.getImageData(x, y, width, height);
+		          var imgData = img.data;
+		          var len = imgData.length;
+		          var palette = this._palette;
+
+
+		          for (var i = 3; i < len; i += 4) {
+		            var alpha = imgData[i];
+		            var offset = alpha * 4;
+
+
+		            if (!offset) {
+		              continue;
+		            }
+
+		            var finalAlpha;
+		            if (opacity > 0) {
+		              finalAlpha = opacity;
+		            } else {
+		              if (alpha < maxOpacity) {
+		                if (alpha < minOpacity) {
+		                  finalAlpha = minOpacity;
+		                } else {
+		                  finalAlpha = alpha;
+		                }
+		              } else {
+		                finalAlpha = maxOpacity;
+		              }
+		            }
+
+		            imgData[i - 3] = palette[offset];
+		            imgData[i - 2] = palette[offset + 1];
+		            imgData[i - 1] = palette[offset + 2];
+		            imgData[i] = useGradientOpacity ? palette[offset + 3] : finalAlpha;
+
+		          }
+
+		          this.ctx.putImageData(img, x, y);
+
+		          this._renderBoundaries = [1000, 1000, 0, 0];
+
+		        },
+		        getValueAt: function (point) {
+		          var value;
+		          var shadowCtx = this.shadowCtx;
+		          var img = shadowCtx.getImageData(point.x, point.y, 1, 1);
+		          var data = img.data[3];
+		          var max = this._max;
+		          var min = this._min;
+
+		          value = (Math.abs(max - min) * (data / 255)) >> 0;
+
+		          return value;
+		        },
+		        getDataURL: function () {
+		          return this.canvas.toDataURL();
+		        }
+		      };
+
+
+		      return Canvas2dRenderer;
+		    })();
+
+		    var Renderer = (function RendererClosure() {
+
+		      var rendererFn = false;
+
+		      if (HeatmapConfig['defaultRenderer'] === 'canvas2d') {
+		        rendererFn = Canvas2dRenderer;
+		      }
+
+		      return rendererFn;
+		    })();
+
+
+		    var Util = {
+		      merge: function () {
+		        var merged = {};
+		        var argsLen = arguments.length;
+		        for (var i = 0; i < argsLen; i++) {
+		          var obj = arguments[i];
+		          for (var key in obj) {
+		            merged[key] = obj[key];
+		          }
+		        }
+		        return merged;
+		      }
+		    };
+		    // Heatmap Constructor
+		    var Heatmap = (function HeatmapClosure() {
+
+		      var Coordinator = (function CoordinatorClosure() {
+
+		        function Coordinator() {
+		          this.cStore = {};
+		        }
+		        Coordinator.prototype = {
+		          on: function (evtName, callback, scope) {
+		            var cStore = this.cStore;
+
+		            if (!cStore[evtName]) {
+		              cStore[evtName] = [];
+		            }
+		            cStore[evtName].push((function (data) {
+		              return callback.call(scope, data);
+		            }));
+		          },
+		          emit: function (evtName, data) {
+		            var cStore = this.cStore;
+		            if (cStore[evtName]) {
+		              var len = cStore[evtName].length;
+		              for (var i = 0; i < len; i++) {
+		                var callback = cStore[evtName][i];
+		                callback(data);
+		              }
+		            }
+		          }
+		        };
+
+		        return Coordinator;
+		      })();
+
+
+		      var _connect = function (scope) {
+		        var renderer = scope._renderer;
+		        var coordinator = scope._coordinator;
+		        var store = scope._store;
+
+		        coordinator.on('renderpartial', renderer.renderPartial, renderer);
+		        coordinator.on('renderall', renderer.renderAll, renderer);
+		        coordinator.on('extremachange', function (data) {
+		          scope._config.onExtremaChange &&
+		            scope._config.onExtremaChange({
+		              min: data.min,
+		              max: data.max,
+		              gradient: scope._config['gradient'] || scope._config['defaultGradient']
+		            });
+		        });
+		        store.setCoordinator(coordinator);
+		      };
+
+
+		      function Heatmap() {
+		        var config = this._config = Util.merge(HeatmapConfig, arguments[0] || {});
+		        this._coordinator = new Coordinator();
+		        if (config['plugin']) {
+		          var pluginToLoad = config['plugin'];
+		          if (!HeatmapConfig.plugins[pluginToLoad]) {
+		            throw new Error('Plugin \'' + pluginToLoad + '\' not found. Maybe it was not registered.');
+		          } else {
+		            var plugin = HeatmapConfig.plugins[pluginToLoad];
+		            // set plugin renderer and store
+		            this._renderer = new plugin.renderer(config);
+		            this._store = new plugin.store(config);
+		          }
+		        } else {
+		          this._renderer = new Renderer(config);
+		          this._store = new Store(config);
+		        }
+		        _connect(this);
+		      }
+		      // @TODO:
+		      // add API documentation
+		      Heatmap.prototype = {
+		        addData: function () {
+		          this._store.addData.apply(this._store, arguments);
+		          return this;
+		        },
+		        removeData: function () {
+		          this._store.removeData && this._store.removeData.apply(this._store, arguments);
+		          return this;
+		        },
+		        setData: function () {
+		          this._store.setData.apply(this._store, arguments);
+		          return this;
+		        },
+		        setDataMax: function () {
+		          this._store.setDataMax.apply(this._store, arguments);
+		          return this;
+		        },
+		        setDataMin: function () {
+		          this._store.setDataMin.apply(this._store, arguments);
+		          return this;
+		        },
+		        configure: function (config) {
+		          const oldConfig = this._config;
+		          this._config = Util.merge(this._config, config);
+		          this._renderer.updateConfig(this._config, oldConfig);
+		          this._coordinator.emit('renderall', this._store._getInternalData());
+		          return this;
+		        },
+		        repaint: function () {
+		          this._coordinator.emit('renderall', this._store._getInternalData());
+		          return this;
+		        },
+		        getData: function () {
+		          return this._store.getData();
+		        },
+		        getDataURL: function () {
+		          return this._renderer.getDataURL();
+		        },
+		        getValueAt: function (point) {
+
+		          if (this._store.getValueAt) {
+		            return this._store.getValueAt(point);
+		          } else if (this._renderer.getValueAt) {
+		            return this._renderer.getValueAt(point);
+		          } else {
+		            return null;
+		          }
+		        }
+		      };
+
+		      return Heatmap;
+
+		    })();
+
+
+		    // core
+		    var heatmapFactory = {
+		      create: function (config) {
+		        return new Heatmap(config);
+		      },
+		      register: function (pluginKey, plugin) {
+		        HeatmapConfig.plugins[pluginKey] = plugin;
+		      }
+		    };
+
+		    return heatmapFactory;
+
+
+		  })();
+
+
+
+
+
+
+		  /*==============================以上部分为heatmap.js的核心代码,只负责热力图的展现====================================*/
+
+
+		  /*==============================以下部分为专为百度地图打造的覆盖物===================================================*/
+		  /**
+		   * @fileoverview 百度地图的热力图功能,对外开放。
+		   * 主要基于http://www.patrick-wied.at/static/heatmapjs/index.html 修改而得
+		   
+		   * 主入口类是<a href="symbols/BMapLib.Heatmap.html">Heatmap</a>，
+		   * 基于Baidu Map API 2.0。
+		   *
+		   * @author Baidu Map Api Group
+		   * @version 1.0
+		   */
+
+		  /**
+		   * 热力图的覆盖物
+		   * @class 热力图的覆盖物
+		   * 实例化该类后，使用map.addOverlay即可以添加热力图
+		   * 
+		   * @constructor
+		   * @param {Json Object} opts 可选的输入参数，非必填项。可输入选项包括：<br />
+		   * {"<b>radius</b>" : {String} 热力图的半径,
+		   * <br />"<b>visible</b>" : {Number} 热力图是否显示,
+		   * <br />"<b>gradient</b>" : {JSON} 热力图的渐变区间,
+		   * <br />"<b>opacity</b>" : {Number} 热力的透明度,
+		   *
+		   * @example <b>参考示例：</b><br />
+		   * var map = new BMap.Map("container");<br />map.centerAndZoom(new BMap.Point(116.404, 39.915), 15);<br />var heatmapOverlay = new BMapLib.HeatmapOverlay({"radius":10, "visible":true, "opacity":70});<br />heatmapOverlay.setDataSet(data);//data是热力图的详细数据
+		   */
+
+		  var HeatmapOverlay = function (opts) {
+		    if (Reflect.getPrototypeOf(HeatmapOverlay.prototype) !== BMap.Overlay.prototype) {
+		      // 保证让HeatmapOverlay继承BMap.Overlay
+		      // 根据文档, 修改原型链会降低访问属性的速度, 但这种写法对代码的修改最少, 故采用
+		      // @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/setPrototypeOf
+		      Reflect.setPrototypeOf(HeatmapOverlay.prototype, BMap.Overlay.prototype);
+		    }
+		    this.conf = opts;
+		    this.conf.visible = opts.visible === undefined ? true : opts.visible;
+		    this.heatmap = null;
+		    this.latlngs = [];
+		    this.bounds = null;
+		  };
+
+		  HeatmapOverlay.prototype = Object.create(typeof BMap === 'undefined' ? null : BMap.Overlay.prototype);
+
+		  HeatmapOverlay.prototype.initialize = function (map) {
+
+		    this._map = map;
+		    var el = document.createElement("div");
+		    el.style.position = "absolute";
+		    el.style.top = 0;
+		    el.style.left = 0;
+		    el.style.border = 0;
+		    el.style.width = this._map.getSize().width + "px";
+		    el.style.height = this._map.getSize().height + "px";
+		    this.conf.element = el;
+
+
+		    if (!isSupportCanvas()) {//判断是否支持Canvas.
+		      return el;
+		    }
+		    map.getPanes().mapPane.appendChild(el);
+		    this.conf.valueField = this.conf.valueField || "count";
+		    this.heatmap = heatmapFactory.create(this.conf);
+
+		    var that = this;
+		    map.addEventListener('resize', function (e) {
+		      var size = e.size;
+		      el.style.width = size.width + "px";
+		      el.style.height = size.height + "px";
+		      that.heatmap._renderer.setDimensions(size.width, size.height);
+		      that.draw();
+		    });
+
+		    this._div = el;
+		    return el;
+		  };
+
+		  HeatmapOverlay.prototype.draw = function () {
+		    if (!isSupportCanvas()) {//判断是否支持Canvas.
+		      return;
+		    }
+		    var currentBounds = this._map.getBounds();
+
+		    if (currentBounds.equals(this.bounds)) {
+		      return;
+		    }
+		    this.bounds = currentBounds;
+
+		    var ne = this._map.pointToOverlayPixel(currentBounds.getNorthEast()),
+		      sw = this._map.pointToOverlayPixel(currentBounds.getSouthWest()),
+		      topY = ne.y,
+		      leftX = sw.x,
+		      h = sw.y - ne.y,
+		      w = ne.x - sw.x;
+
+		    this.conf.element.style.left = leftX + 'px';
+		    this.conf.element.style.top = topY + 'px';
+		    this.conf.element.style.width = w + 'px';
+		    this.conf.element.style.height = h + 'px';
+		    //this.heatmap.store.get("heatmap").resize();
+
+		    if (this.latlngs.length > 0) {
+		      this.heatmap.removeData();
+
+		      var len = this.latlngs.length;
+		      const d = {
+		        max: this.heatmap._store.getData().max,
+		        data: []
+		      };
+
+		      while (len--) {
+		        var latlng = this.latlngs[len].latlng;
+
+		        if (!currentBounds.containsPoint(latlng)) {
+		          continue;
+		        }
+
+		        var divPixel = this._map.pointToOverlayPixel(latlng),
+		          leftX = this._map.pointToOverlayPixel(currentBounds.getSouthWest()).x,
+		          topY = this._map.pointToOverlayPixel(currentBounds.getNorthEast()).y,
+		          screenPixel = new BMap.Pixel(divPixel.x - leftX, divPixel.y - topY);
+		        var roundedPoint = this.pixelTransform(screenPixel);
+		        d.data.push({
+		          x: roundedPoint.x,
+		          y: roundedPoint.y,
+		          count: this.latlngs[len].c
+		        });
+		      }
+
+		      if (this.conf.radiusChangeByZoom) {
+		        this.heatmap._store._cfgRadius = this.conf.radiusChangeByZoom(this._map.getZoom());
+		      }
+		      this.heatmap.setData(d);
+		    }
+		  };
+
+
+		  //内部使用的坐标转化
+		  HeatmapOverlay.prototype.pixelTransform = function (p) {
+		    var w = this.heatmap.width,
+		      h = this.heatmap.height;
+
+		    while (p.x < 0) {
+		      p.x += w;
+		    }
+
+		    while (p.x > w) {
+		      p.x -= w;
+		    }
+
+		    while (p.y < 0) {
+		      p.y += h;
+		    }
+
+		    while (p.y > h) {
+		      p.y -= h;
+		    }
+
+		    p.x = (p.x >> 0);
+		    p.y = (p.y >> 0);
+
+		    return p;
+		  };
+
+		  /**
+		   * 设置热力图展现的详细数据, 实现之后,即可以立刻展现 
+		   * @param {Json Object } data
+		   * {"<b>max</b>" : {Number} 权重的最大值,
+		   * <br />"<b>data</b>" : {Array} 坐标详细数据,格式如下 <br/>
+		   * {"lng":116.421969,"lat":39.913527,"count":3}, 其中<br/>
+		   * lng lat分别为经纬度, count权重值
+		   */
+		  HeatmapOverlay.prototype.setDataSet = function (data) {
+		    this.data = data;
+		    if (!isSupportCanvas()) {//判断是否支持Canvas.
+		      return;
+		    }
+		    var currentBounds = this._map.getBounds();
+		    var mapdata = {
+		      max: data.max,
+		      data: []
+		    };
+		    var d = data.data,
+		      dlen = d.length;
+
+
+		    this.latlngs = [];
+		    this.heatmap.removeData();
+
+		    if (this.conf.radiusChangeByZoom) {
+		      this.heatmap._store._cfgRadius = this.conf.radiusChangeByZoom(this._map.getZoom());
+		    }
+
+		    while (dlen--) {
+		      var latlng = new BMap.Point(d[dlen].lng, d[dlen].lat);
+		      this.latlngs.push({
+		        latlng: latlng,
+		        c: d[dlen].count
+		      });
+
+		      if (!currentBounds.containsPoint(latlng)) {
+		        continue;
+		      }
+
+		      var divPixel = this._map.pointToOverlayPixel(latlng),
+		        leftX = this._map.pointToOverlayPixel(currentBounds.getSouthWest()).x,
+		        topY = this._map.pointToOverlayPixel(currentBounds.getNorthEast()).y,
+		        screenPixel = new BMap.Pixel(divPixel.x - leftX, divPixel.y - topY);
+		      var point = this.pixelTransform(screenPixel);
+
+		      mapdata.data.push({
+		        x: point.x,
+		        y: point.y,
+		        count: d[dlen].count
+		      });
+		    }
+		    this.heatmap.setData(mapdata);
+		  };
+
+		  /**
+		   * 添加热力图的详细坐标点
+		   * @param {Number} lng 经度坐标
+		   * @param {Number} lat 纬度坐标
+		   * @param {Number} count 权重
+		   */
+		  HeatmapOverlay.prototype.addDataPoint = function (lng, lat, count) {
+
+		    if (!isSupportCanvas()) {
+		      return;
+		    }
+		    if (this.data && this.data.data) {
+		      this.data.data.push({
+		        lng: lng,
+		        lat: lat,
+		        count: count
+		      });
+		    }
+
+		    var latlng = new BMap.Point(lng, lat),
+		      point = this.pixelTransform(this._map.pointToOverlayPixel(latlng));
+
+		    this.heatmap.store.addDataPoint(point.x, point.y, count);
+		    this.latlngs.push({
+		      latlng: latlng,
+		      c: count
+		    });
+		  };
+
+		  /**
+		   * 更改热力图的展现或者关闭
+		   */
+
+		  HeatmapOverlay.prototype.toggle = function () {
+		    if (!isSupportCanvas()) {//判断是否支持Canvas.
+		      return;
+		    }
+		    if (this.conf.visible === true) {
+		      this.conf.visible = false;
+		    } else {
+		      this.conf.visible = true;
+		    }		    if (this.conf.visible) {
+		      this.conf.element.style.display = "block";
+		    } else {
+		      this.conf.element.style.display = "none";
+		    }
+		  };
+		  /**
+		   * 设置热力图展现的配置
+		   * @param {Json Object} options 可选的输入参数，非必填项。可输入选项包括：<br />
+		   * {"<b>radius</b>" : {String} 热力图的半径,
+		   * <br />"<b>visible</b>" : {Number} 热力图是否显示,
+		   * <br />"<b>gradient</b>" : {JSON} 热力图的渐变区间,
+		   * <br />"<b>opacity</b>" : {Number} 热力的透明度,}
+		   */
+		  HeatmapOverlay.prototype.setOptions = function (options) {
+		    if (!isSupportCanvas()) {//判断是否支持Canvas.
+		      return;
+		    }
+		    for (var key in options) {
+		      if (key == "radius") {
+		        this.heatmap._store._cfgRadius = options[key];
+		      }
+		    }
+		    this.heatmap.configure(options);
+		    if (this.data) {
+		      this.setDataSet(this.data);//重新渲染
+		    }
+		  };
+
+
+		  function isSupportCanvas() {
+		    var elem = document.createElement('canvas');
+		    return !!(elem.getContext && elem.getContext('2d'));
+		  }
+
+		  return HeatmapOverlay
+		}); 
+	} (bmaplib_heatmap$1));
+	return bmaplib_heatmap$1.exports;
+}
+
+var bmaplib_heatmapExports = requireBmaplib_heatmap();
+var BHeatMapOverlay = /*@__PURE__*/getDefaultExportFromCjs(bmaplib_heatmapExports);
+
 /** 默认半径 */
 const RADIUS_DEFAULT = 10;
 const HeatmapOptions = {
@@ -1648,7 +2659,7 @@ class BaiduHeatmap extends Heatmap {
         super();
         this.map = map;
         const opts = HeatmapOptions.toBaidu(options, this.map.coordType, options.maxIntensity);
-        this.inner = new BHeatMapOverlay__default.default(opts);
+        this.inner = new BHeatMapOverlay(opts);
         // 直接添加到地图上
         map.innerMap.addOverlay(this.inner);
         // 添加到地图上之后, 才能调用setDataSet
@@ -1871,6 +2882,3027 @@ class BaiduMapUrls extends MapUrls {
     }
 }
 
+/**
+ * Copyright 2019 Google LLC. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @name MarkerClusterer for Google Maps v3
+ * @author Luke Mahe
+ * @fileoverview
+ * The library creates and manages per-zoom-level clusters for large amounts of
+ * markers.
+ */
+
+/**
+ * A Marker Clusterer that clusters markers.
+ *
+ * @param {google.maps.Map} map The Google map to attach to.
+ * @param {Array.<google.maps.Marker>=} opt_markers Optional markers to add to
+ *   the cluster.
+ * @param {Object=} opt_options support the following options:
+ *     'gridSize': (number) The grid size of a cluster in pixels.
+ *     'maxZoom': (number) The maximum zoom level that a marker can be part of a
+ *                cluster.
+ *     'zoomOnClick': (boolean) Whether the default behaviour of clicking on a
+ *                    cluster is to zoom into it.
+ *     'imagePath': (string) The base URL where the images representing
+ *                  clusters will be found. The full URL will be:
+ *                  {imagePath}[1-5].{imageExtension}
+ *                  Default: '../images/m'.
+ *     'imageExtension': (string) The suffix for images URL representing
+ *                       clusters will be found. See _imagePath_ for details.
+ *                       Default: 'png'.
+ *     'averageCenter': (boolean) Whether the center of each cluster should be
+ *                      the average of all markers in the cluster.
+ *     'minimumClusterSize': (number) The minimum number of markers to be in a
+ *                           cluster before the markers are hidden and a count
+ *                           is shown.
+ *     'zIndex': (number) the z-index of a cluster.
+ *               Default: google.maps.Marker.MAX_ZINDEX + 1
+ *     'styles': (Array.<Object>) An Array of single object that has style properties for all cluster:
+ *       'url': (string) The image url.
+ *       'height': (number) The image height.
+ *       'width': (number) The image width.
+ *       'anchor': (Array) The anchor position of the label text.
+ *       'textColor': (string) The text color.
+ *       'textSize': (number) The text size.
+ *       'backgroundPosition': (string) The position of the backgound x, y.
+ * @constructor
+ * @extends google.maps.OverlayView
+ */
+
+let MarkerClusterer$2 = class MarkerClusterer {
+  constructor(map, opt_markers, opt_options) {
+    this.extend(MarkerClusterer, google.maps.OverlayView);
+    this.map_ = map;
+
+    /**
+     * The marker cluster image path.
+     *
+     * @type {string}
+     * @private
+     */
+    this.MARKER_CLUSTER_IMAGE_PATH_ = "../images/m";
+
+    /**
+     * The marker cluster image path.
+     *
+     * @type {string}
+     * @private
+     */
+    this.MARKER_CLUSTER_IMAGE_EXTENSION_ = "png";
+    /**
+     * @type {Array.<google.maps.Marker>}
+     * @private
+     */
+    this.markers_ = [];
+
+    /**
+     *  @type {Array.<Cluster>}
+     */
+    this.clusters_ = [];
+
+    this.sizes = [53, 56, 66, 78, 90];
+
+    /**
+     * @type {Array.<Object>}
+     * @private
+     */
+    this.styles_ = [];
+
+    /**
+     * @type {boolean}
+     * @private
+     */
+    this.ready_ = false;
+
+    var options = opt_options || {};
+
+    /**
+     * @type {number}
+     */
+    this.zIndex_ = options["zIndex"] || google.maps.Marker.MAX_ZINDEX + 1;
+
+    /**
+     * @type {number}
+     * @private
+     */
+    this.gridSize_ = options["gridSize"] || 60;
+
+    /**
+     * @private
+     */
+    this.minClusterSize_ = options["minimumClusterSize"] || 2;
+
+    /**
+     * @type {?number}
+     * @private
+     */
+    this.maxZoom_ = options["maxZoom"] || null;
+
+    this.styles_ = options["styles"] || [];
+
+    /**
+     * @type {string}
+     * @private
+     */
+    this.imagePath_ = options["imagePath"] || this.MARKER_CLUSTER_IMAGE_PATH_;
+
+    /**
+     * @type {string}
+     * @private
+     */
+    this.imageExtension_ =
+      options["imageExtension"] || this.MARKER_CLUSTER_IMAGE_EXTENSION_;
+
+    /**
+     * @type {boolean}
+     * @private
+     */
+    this.zoomOnClick_ = true;
+
+    if (options["zoomOnClick"] != undefined) {
+      this.zoomOnClick_ = options["zoomOnClick"];
+    }
+
+    /**
+     * @type {boolean}
+     * @private
+     */
+    this.averageCenter_ = false;
+
+    if (options["averageCenter"] != undefined) {
+      this.averageCenter_ = options["averageCenter"];
+    }
+
+    this.setupStyles_();
+
+    this.setMap(map);
+
+    /**
+     * @type {number}
+     * @private
+     */
+    this.prevZoom_ = this.map_.getZoom();
+
+    // Add the map event listeners
+    var that = this;
+    google.maps.event.addListener(this.map_, "zoom_changed", function() {
+      // Determines map type and prevent illegal zoom levels
+      var zoom = that.map_.getZoom();
+      var minZoom = that.map_.minZoom || 0;
+      var maxZoom = Math.min(
+        that.map_.maxZoom || 100,
+        that.map_.mapTypes[that.map_.getMapTypeId()].maxZoom
+      );
+      zoom = Math.min(Math.max(zoom, minZoom), maxZoom);
+
+      if (that.prevZoom_ != zoom) {
+        that.prevZoom_ = zoom;
+        that.resetViewport();
+      }
+    });
+
+    google.maps.event.addListener(this.map_, "idle", function() {
+      that.redraw();
+    });
+
+    // Finally, add the markers
+    if (
+      opt_markers &&
+      (opt_markers.length || Object.keys(opt_markers).length)
+    ) {
+      this.addMarkers(opt_markers, false);
+    }
+  }
+
+  /**
+   * 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(obj1, obj2) {
+    return function(object) {
+      for (var property in object.prototype) {
+        this.prototype[property] = object.prototype[property];
+      }
+      return this;
+    }.apply(obj1, [obj2]);
+  }
+
+  /**
+   * Implementaion of the interface method.
+   * @ignore
+   */
+  onAdd() {
+    this.setReady_(true);
+  }
+
+  /**
+   * Implementaion of the interface method.
+   * @ignore
+   */
+  draw() {}
+
+  /**
+   * Sets up the styles object.
+   *
+   * @private
+   */
+  setupStyles_() {
+    if (this.styles_.length) {
+      return;
+    }
+
+    for (var i = 0, size; (size = this.sizes[i]); i++) {
+      this.styles_.push({
+        url: this.imagePath_ + (i + 1) + "." + this.imageExtension_,
+        height: size,
+        width: size
+      });
+    }
+  }
+
+  /**
+   *  Fit the map to the bounds of the markers in the clusterer.
+   */
+  fitMapToMarkers() {
+    var markers = this.getMarkers();
+    var bounds = new google.maps.LatLngBounds();
+    for (var i = 0, marker; (marker = markers[i]); i++) {
+      bounds.extend(marker.getPosition());
+    }
+
+    this.map_.fitBounds(bounds);
+  }
+
+  /**
+   * @param {number} zIndex
+   */
+  setZIndex(zIndex) {
+    this.zIndex_ = zIndex;
+  }
+
+  /**
+   * @return {number}
+   */
+  getZIndex() {
+    return this.zIndex_;
+  }
+
+  /**
+   *  Sets the styles.
+   *
+   *  @param {Object} styles The style to set.
+   */
+  setStyles(styles) {
+    this.styles_ = styles;
+  }
+
+  /**
+   *  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(maxZoom) {
+    this.maxZoom_ = maxZoom;
+  }
+
+  /**
+   *  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_(markers, numStyles) {
+    var index = 0;
+    var count = markers.length;
+    var dv = count;
+    while (dv !== 0) {
+      dv = parseInt(dv / 10, 10);
+      index++;
+    }
+
+    index = Math.min(index, numStyles);
+    return {
+      text: count,
+      index: index
+    };
+  }
+
+  /**
+   * 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(calculator) {
+    this.calculator_ = calculator;
+  }
+
+  /**
+   * 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(markers, opt_nodraw) {
+    if (markers.length) {
+      for (let i = 0, marker; (marker = markers[i]); i++) {
+        this.pushMarkerTo_(marker);
+      }
+    } else if (Object.keys(markers).length) {
+      for (let marker in markers) {
+        this.pushMarkerTo_(markers[marker]);
+      }
+    }
+    if (!opt_nodraw) {
+      this.redraw();
+    }
+  }
+
+  /**
+   * Pushes a marker to the clusterer.
+   *
+   * @param {google.maps.Marker} marker The marker to add.
+   * @private
+   */
+  pushMarkerTo_(marker) {
+    marker.isAdded = false;
+    if (marker["draggable"]) {
+      // If the marker is draggable add a listener so we update the clusters on
+      // the drag end.
+      var that = this;
+      google.maps.event.addListener(marker, "dragend", function() {
+        marker.isAdded = false;
+        that.repaint();
+      });
+    }
+    this.markers_.push(marker);
+  }
+
+  /**
+   * 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(marker, opt_nodraw) {
+    this.pushMarkerTo_(marker);
+    if (!opt_nodraw) {
+      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_(marker) {
+    var index = -1;
+    if (this.markers_.indexOf) {
+      index = this.markers_.indexOf(marker);
+    } else {
+      for (var i = 0, m; (m = this.markers_[i]); i++) {
+        if (m == marker) {
+          index = i;
+          break;
+        }
+      }
+    }
+
+    if (index == -1) {
+      // Marker is not in our list of markers.
+      return false;
+    }
+
+    marker.setMap(null);
+
+    this.markers_.splice(index, 1);
+
+    return true;
+  }
+
+  /**
+   * 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(marker, opt_nodraw) {
+    var removed = this.removeMarker_(marker);
+
+    if (!opt_nodraw && removed) {
+      this.resetViewport();
+      this.redraw();
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  /**
+   * 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(markers, opt_nodraw) {
+    // create a local copy of markers if required
+    // (removeMarker_ modifies the getMarkers() array in place)
+    var markersCopy = markers === this.getMarkers() ? markers.slice() : markers;
+    var removed = false;
+
+    for (var i = 0, marker; (marker = markersCopy[i]); i++) {
+      var r = this.removeMarker_(marker);
+      removed = removed || r;
+    }
+
+    if (!opt_nodraw && removed) {
+      this.resetViewport();
+      this.redraw();
+      return true;
+    }
+  }
+
+  /**
+   * Sets the clusterer's ready state.
+   *
+   * @param {boolean} ready The state.
+   * @private
+   */
+  setReady_(ready) {
+    if (!this.ready_) {
+      this.ready_ = ready;
+      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(map) {
+    this.map_ = map;
+  }
+
+  /**
+   * 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(size) {
+    this.gridSize_ = size;
+  }
+
+  /**
+   * 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(size) {
+    this.minClusterSize_ = size;
+  }
+
+  /**
+   * 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(bounds) {
+    var projection = this.getProjection();
+
+    // Turn the bounds into latlng.
+    var tr = new google.maps.LatLng(
+      bounds.getNorthEast().lat(),
+      bounds.getNorthEast().lng()
+    );
+    var bl = new google.maps.LatLng(
+      bounds.getSouthWest().lat(),
+      bounds.getSouthWest().lng()
+    );
+
+    // Convert the points to pixels and the extend out by the grid size.
+    var trPix = projection.fromLatLngToDivPixel(tr);
+    trPix.x += this.gridSize_;
+    trPix.y -= this.gridSize_;
+
+    var blPix = projection.fromLatLngToDivPixel(bl);
+    blPix.x -= this.gridSize_;
+    blPix.y += this.gridSize_;
+
+    // Convert the pixel points back to LatLng
+    var ne = projection.fromDivPixelToLatLng(trPix);
+    var sw = projection.fromDivPixelToLatLng(blPix);
+
+    // Extend the bounds to contain the new bounds.
+    bounds.extend(ne);
+    bounds.extend(sw);
+
+    return bounds;
+  }
+
+  /**
+   * 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_(marker, bounds) {
+    return bounds.contains(marker.getPosition());
+  }
+
+  /**
+   * Clears all clusters and markers from the clusterer.
+   */
+  clearMarkers() {
+    this.resetViewport(true);
+
+    // Set the markers a empty array.
+    this.markers_ = [];
+  }
+
+  /**
+   * Clears all existing clusters and recreates them.
+   * @param {boolean} opt_hide To also hide the marker.
+   */
+  resetViewport(opt_hide) {
+    // Remove all the clusters
+    for (let i = 0, cluster; (cluster = this.clusters_[i]); i++) {
+      cluster.remove();
+    }
+
+    // Reset the markers to not be added and to be invisible.
+    for (let i = 0, marker; (marker = this.markers_[i]); i++) {
+      marker.isAdded = false;
+      if (opt_hide) {
+        marker.setMap(null);
+      }
+    }
+
+    this.clusters_ = [];
+  }
+
+  /**
+   *
+   */
+  repaint() {
+    var oldClusters = this.clusters_.slice();
+    this.clusters_.length = 0;
+    this.resetViewport();
+    this.redraw();
+
+    // Remove the old clusters.
+    // Do it in a timeout so the other clusters have been drawn first.
+    setTimeout(function() {
+      for (var i = 0, cluster; (cluster = oldClusters[i]); i++) {
+        cluster.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_(p1, p2) {
+    if (!p1 || !p2) {
+      return 0;
+    }
+
+    var R = 6371; // Radius of the Earth in km
+    var dLat = ((p2.lat() - p1.lat()) * Math.PI) / 180;
+    var dLon = ((p2.lng() - p1.lng()) * Math.PI) / 180;
+    var a =
+      Math.sin(dLat / 2) * Math.sin(dLat / 2) +
+      Math.cos((p1.lat() * Math.PI) / 180) *
+        Math.cos((p2.lat() * Math.PI) / 180) *
+        Math.sin(dLon / 2) *
+        Math.sin(dLon / 2);
+    var c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+    var d = R * c;
+    return d;
+  }
+
+  /**
+   * Add a marker to a cluster, or creates a new cluster.
+   *
+   * @param {google.maps.Marker} marker The marker to add.
+   * @private
+   */
+  addToClosestCluster_(marker) {
+    var distance = 40000; // Some large number
+    var clusterToAddTo = null;
+    for (var i = 0, cluster; (cluster = this.clusters_[i]); i++) {
+      var center = cluster.getCenter();
+      if (center) {
+        var d = this.distanceBetweenPoints_(center, marker.getPosition());
+        if (d < distance) {
+          distance = d;
+          clusterToAddTo = cluster;
+        }
+      }
+    }
+
+    if (clusterToAddTo && clusterToAddTo.isMarkerInClusterBounds(marker)) {
+      clusterToAddTo.addMarker(marker);
+    } else {
+      var newCluster = new Cluster$1(this);
+      newCluster.addMarker(marker);
+      this.clusters_.push(newCluster);
+    }
+  }
+
+  /**
+   * Creates the clusters.
+   *
+   * @private
+   */
+  createClusters_() {
+    if (!this.ready_) {
+      return;
+    }
+
+    // Get our current map view bounds.
+    // Create a new bounds object so we don't affect the map.
+    var mapBounds = new google.maps.LatLngBounds(
+      this.map_.getBounds().getSouthWest(),
+      this.map_.getBounds().getNorthEast()
+    );
+    var bounds = this.getExtendedBounds(mapBounds);
+
+    for (var i = 0, marker; (marker = this.markers_[i]); i++) {
+      if (!marker.isAdded && this.isMarkerInBounds_(marker, bounds)) {
+        this.addToClosestCluster_(marker);
+      }
+    }
+  }
+};
+
+/**
+ * A cluster that contains markers.
+ *
+ * @param {MarkerClusterer} markerClusterer The markerclusterer that this
+ *     cluster is associated with.
+ * @constructor
+ * @ignore
+ */
+let Cluster$1 = class Cluster {
+  constructor(markerClusterer) {
+    this.markerClusterer_ = markerClusterer;
+    this.map_ = markerClusterer.getMap();
+    this.gridSize_ = markerClusterer.getGridSize();
+    this.minClusterSize_ = markerClusterer.getMinClusterSize();
+    this.averageCenter_ = markerClusterer.isAverageCenter();
+    this.center_ = null;
+    this.markers_ = [];
+    this.bounds_ = null;
+    this.clusterIcon_ = new ClusterIcon(
+      this,
+      markerClusterer.getStyles(),
+      markerClusterer.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(marker) {
+    if (this.markers_.indexOf) {
+      return this.markers_.indexOf(marker) != -1;
+    } else {
+      for (var i = 0, m; (m = this.markers_[i]); i++) {
+        if (m == marker) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Add a marker the cluster.
+   *
+   * @param {google.maps.Marker} marker The marker to add.
+   * @return {boolean} True if the marker was added.
+   */
+  addMarker(marker) {
+    if (this.isMarkerAlreadyAdded(marker)) {
+      return false;
+    }
+
+    if (!this.center_) {
+      this.center_ = marker.getPosition();
+      this.calculateBounds_();
+    } else {
+      if (this.averageCenter_) {
+        var l = this.markers_.length + 1;
+        var lat =
+          (this.center_.lat() * (l - 1) + marker.getPosition().lat()) / l;
+        var lng =
+          (this.center_.lng() * (l - 1) + marker.getPosition().lng()) / l;
+        this.center_ = new google.maps.LatLng(lat, lng);
+        this.calculateBounds_();
+      }
+    }
+
+    marker.isAdded = true;
+    this.markers_.push(marker);
+
+    var len = this.markers_.length;
+    if (len < this.minClusterSize_ && marker.getMap() != this.map_) {
+      // Min cluster size not reached so show the marker.
+      marker.setMap(this.map_);
+    }
+
+    if (len == this.minClusterSize_) {
+      // Hide the markers that were showing.
+      for (var i = 0; i < len; i++) {
+        this.markers_[i].setMap(null);
+      }
+    }
+
+    if (len >= this.minClusterSize_) {
+      marker.setMap(null);
+    }
+
+    this.updateIcon();
+    return true;
+  }
+
+  /**
+   * 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() {
+    var bounds = new google.maps.LatLngBounds(this.center_, this.center_);
+    var markers = this.getMarkers();
+    for (var i = 0, marker; (marker = markers[i]); i++) {
+      bounds.extend(marker.getPosition());
+    }
+    return bounds;
+  }
+
+  /**
+   * 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 bounds = new google.maps.LatLngBounds(this.center_, this.center_);
+    this.bounds_ = this.markerClusterer_.getExtendedBounds(bounds);
+  }
+
+  /**
+   * 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(marker) {
+    return this.bounds_.contains(marker.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 zoom = this.map_.getZoom();
+    var mz = this.markerClusterer_.getMaxZoom();
+
+    if (mz && zoom > mz) {
+      // The zoom is greater than our max zoom so show all the markers in cluster.
+      for (var i = 0, marker; (marker = this.markers_[i]); i++) {
+        marker.setMap(this.map_);
+      }
+      return;
+    }
+
+    if (this.markers_.length < this.minClusterSize_) {
+      // Min cluster size not yet reached.
+      this.clusterIcon_.hide();
+      return;
+    }
+
+    var numStyles = this.markerClusterer_.getStyles().length;
+    var sums = this.markerClusterer_.getCalculator()(this.markers_, numStyles);
+    this.clusterIcon_.setCenter(this.center_);
+    this.clusterIcon_.setSums(sums);
+    this.clusterIcon_.show();
+  }
+};
+
+/**
+ * A cluster icon
+ *
+ * @param {Cluster} cluster The cluster to be associated with.
+ * @param {Object} styles An object that has style properties:
+ *     'url': (string) The image url.
+ *     'height': (number) The image height.
+ *     'width': (number) The image width.
+ *     'anchor': (Array) The anchor position of the label text.
+ *     'textColor': (string) The text color.
+ *     'textSize': (number) The text size.
+ *     'backgroundPosition: (string) The background postition x, y.
+ * @param {number=} opt_padding Optional padding to apply to the cluster icon.
+ * @constructor
+ * @extends google.maps.OverlayView
+ * @ignore
+ */
+class ClusterIcon {
+  constructor(cluster, styles, opt_padding) {
+    cluster.getMarkerClusterer().extend(ClusterIcon, google.maps.OverlayView);
+
+    this.styles_ = styles;
+    this.padding_ = opt_padding || 0;
+    this.cluster_ = cluster;
+    this.center_ = null;
+    this.map_ = cluster.getMap();
+    this.div_ = null;
+    this.sums_ = null;
+    this.visible_ = false;
+
+    this.setMap(this.map_);
+  }
+
+  /**
+   * Triggers the clusterclick event and zoom's if the option is set.
+   */
+  triggerClusterClick() {
+    var clusterBounds = this.cluster_.getBounds();
+    var markerClusterer = this.cluster_.getMarkerClusterer();
+
+    // Trigger the clusterclick event.
+    google.maps.event.trigger(
+      markerClusterer.map_,
+      "clusterclick",
+      this.cluster_
+    );
+
+    if (markerClusterer.isZoomOnClick()) {
+      // Zoom into the cluster.
+      this.map_.fitBounds(clusterBounds);
+      this.map_.setCenter(clusterBounds.getCenter());
+    }
+  }
+
+  /**
+   * Adding the cluster icon to the dom.
+   * @ignore
+   */
+  onAdd() {
+    this.div_ = document.createElement("DIV");
+    if (this.visible_) {
+      var pos = this.getPosFromLatLng_(this.center_);
+      this.div_.style.cssText = this.createCss(pos);
+      this.div_.innerHTML = this.sums_.text;
+    }
+
+    var panes = this.getPanes();
+    panes.overlayMouseTarget.appendChild(this.div_);
+
+    var that = this;
+    google.maps.event.addDomListener(this.div_, "click", function() {
+      that.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_(latlng) {
+    var pos = this.getProjection().fromLatLngToDivPixel(latlng);
+    pos.x -= parseInt(this.width_ / 2, 10);
+    pos.y -= parseInt(this.height_ / 2, 10);
+    return pos;
+  }
+
+  /**
+   * Draw the icon.
+   * @ignore
+   */
+  draw() {
+    if (this.visible_) {
+      var pos = this.getPosFromLatLng_(this.center_);
+      this.div_.style.top = pos.y + "px";
+      this.div_.style.left = pos.x + "px";
+    }
+  }
+
+  /**
+   * Hide the icon.
+   */
+  hide() {
+    if (this.div_) {
+      this.div_.style.display = "none";
+    }
+    this.visible_ = false;
+  }
+
+  /**
+   * Position and show the icon.
+   */
+  show() {
+    if (this.div_) {
+      var pos = this.getPosFromLatLng_(this.center_);
+      this.div_.style.cssText = this.createCss(pos);
+      this.div_.style.display = "";
+    }
+    this.visible_ = true;
+  }
+
+  /**
+   * Remove the icon from the map
+   */
+  remove() {
+    this.setMap(null);
+  }
+
+  /**
+   * Implementation of the onRemove interface.
+   * @ignore
+   */
+  onRemove() {
+    if (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(sums) {
+    this.sums_ = sums;
+    this.text_ = sums.text;
+    this.index_ = sums.index;
+    if (this.div_) {
+      this.div_.innerHTML = sums.text;
+    }
+
+    this.useStyle();
+  }
+
+  /**
+   * Sets the icon to the the styles.
+   */
+  useStyle() {
+    var index = Math.max(0, this.sums_.index - 1);
+    index = Math.min(this.styles_.length - 1, index);
+    var style = this.styles_[index];
+    this.url_ = style["url"];
+    this.height_ = style["height"];
+    this.width_ = style["width"];
+    this.textColor_ = style["textColor"];
+    this.anchor_ = style["anchor"];
+    this.textSize_ = style["textSize"];
+    this.backgroundPosition_ = style["backgroundPosition"];
+  }
+
+  /**
+   * Sets the center of the icon.
+   *
+   * @param {google.maps.LatLng} center The latlng to set as the center.
+   */
+  setCenter(center) {
+    this.center_ = center;
+  }
+
+  /**
+   * 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(pos) {
+    var style = [];
+    style.push("z-index:" + this.cluster_.markerClusterer_.getZIndex() + ";");
+    style.push("background-image:url(" + this.url_ + ");");
+    var backgroundPosition = this.backgroundPosition_
+      ? this.backgroundPosition_
+      : "0 0";
+    style.push("background-position:" + backgroundPosition + ";");
+
+    if (typeof this.anchor_ === "object") {
+      if (
+        typeof this.anchor_[0] === "number" &&
+        this.anchor_[0] > 0 &&
+        this.anchor_[0] < this.height_
+      ) {
+        style.push(
+          "height:" +
+            (this.height_ - this.anchor_[0]) +
+            "px; padding-top:" +
+            this.anchor_[0] +
+            "px;"
+        );
+      } else {
+        style.push(
+          "height:" + this.height_ + "px; line-height:" + this.height_ + "px;"
+        );
+      }
+      if (
+        typeof this.anchor_[1] === "number" &&
+        this.anchor_[1] > 0 &&
+        this.anchor_[1] < this.width_
+      ) {
+        style.push(
+          "width:" +
+            (this.width_ - this.anchor_[1]) +
+            "px; padding-left:" +
+            this.anchor_[1] +
+            "px;"
+        );
+      } else {
+        style.push("width:" + this.width_ + "px; text-align:center;");
+      }
+    } else {
+      style.push(
+        "height:" +
+          this.height_ +
+          "px; line-height:" +
+          this.height_ +
+          "px; width:" +
+          this.width_ +
+          "px; text-align:center;"
+      );
+    }
+
+    var txtColor = this.textColor_ ? this.textColor_ : "black";
+    var txtSize = this.textSize_ ? this.textSize_ : 11;
+
+    style.push(
+      "cursor:pointer; top:" +
+        pos.y +
+        "px; left:" +
+        pos.x +
+        "px; color:" +
+        txtColor +
+        "; position:absolute; font-size:" +
+        txtSize +
+        "px; font-family:Arial,sans-serif; font-weight:bold"
+    );
+    return style.join("");
+  }
+}
+
+var bmaplib_texticonoverlay$1 = {exports: {}};
+
+var bmaplib_texticonoverlay = bmaplib_texticonoverlay$1.exports;
+
+var hasRequiredBmaplib_texticonoverlay;
+
+function requireBmaplib_texticonoverlay () {
+	if (hasRequiredBmaplib_texticonoverlay) return bmaplib_texticonoverlay$1.exports;
+	hasRequiredBmaplib_texticonoverlay = 1;
+	(function (module, exports) {
+		(function (root, factory) {  
+		    {  
+		        module.exports = factory();
+		    }  
+		})(bmaplib_texticonoverlay, function() {
+		    var T,
+		    baidu = T = baidu || {version: "1.3.8"}; 
+		    var context = {};
+		    //提出guid，防止在与老版本Tangram混用时
+		    //在下一行错误的修改context[undefined]
+		    baidu.guid = "$BAIDU$";
+
+		    //Tangram可能被放在闭包中
+		    //一些页面级别唯一的属性，需要挂载在context[baidu.guid]上
+		    context[baidu.guid] = context[baidu.guid] || {};
+
+		    /**         
+		    * @ignore
+		    * @namespace baidu.dom 操作dom的方法。
+		    */
+		    baidu.dom = baidu.dom || {};
+
+		    
+		    /**
+		     * 从文档中获取指定的DOM元素
+		     * @name baidu.dom.g
+		     * @function
+		     * @grammar baidu.dom.g(id)
+		     * @param {string|HTMLElement} id 元素的id或DOM元素
+		     * @shortcut g,T.G
+		     * @meta standard
+		     * @see baidu.dom.q
+		     *             
+		     * @returns {HTMLElement|null} 获取的元素，查找不到时返回null,如果参数不合法，直接返回参数
+		     */
+		    baidu.dom.g = function (id) {
+		        if ('string' == typeof id || id instanceof String) {
+		            return document.getElementById(id);
+		        } else if (id && id.nodeName && (id.nodeType == 1 || id.nodeType == 9)) {
+		            return id;
+		        }
+		        return null;
+		    };
+
+		    // 声明快捷方法
+		    baidu.g = baidu.G = baidu.dom.g;
+
+		    /**
+		     * 获取目标元素所属的document对象
+		     * @name baidu.dom.getDocument
+		     * @function
+		     * @grammar baidu.dom.getDocument(element)
+		     * @param {HTMLElement|string} element 目标元素或目标元素的id
+		     * @meta standard
+		     * @see baidu.dom.getWindow
+		     *             
+		     * @returns {HTMLDocument} 目标元素所属的document对象
+		     */
+		    baidu.dom.getDocument = function (element) {
+		        element = baidu.dom.g(element);
+		        return element.nodeType == 9 ? element : element.ownerDocument || element.document;
+		    };
+
+		    /**
+		         * @ignore
+		     * @namespace baidu.lang 对语言层面的封装，包括类型判断、模块扩展、继承基类以及对象自定义事件的支持。
+		    */
+		    baidu.lang = baidu.lang || {};
+
+		    /**
+		     * 判断目标参数是否string类型或String对象
+		     * @name baidu.lang.isString
+		     * @function
+		     * @grammar baidu.lang.isString(source)
+		     * @param {Any} source 目标参数
+		     * @shortcut isString
+		     * @meta standard
+		     * @see baidu.lang.isObject,baidu.lang.isNumber,baidu.lang.isArray,baidu.lang.isElement,baidu.lang.isBoolean,baidu.lang.isDate
+		     *             
+		     * @returns {boolean} 类型判断结果
+		     */
+		    baidu.lang.isString = function (source) {
+		        return '[object String]' == Object.prototype.toString.call(source);
+		    };
+
+		    // 声明快捷方法
+		    baidu.isString = baidu.lang.isString;
+
+		    /**
+		     * 从文档中获取指定的DOM元素
+		     * **内部方法**
+		     * 
+		     * @param {string|HTMLElement} id 元素的id或DOM元素
+		     * @meta standard
+		     * @return {HTMLElement} DOM元素，如果不存在，返回null，如果参数不合法，直接返回参数
+		     */
+		    baidu.dom._g = function (id) {
+		        if (baidu.lang.isString(id)) {
+		            return document.getElementById(id);
+		        }
+		        return id;
+		    };
+
+		    // 声明快捷方法
+		    baidu._g = baidu.dom._g;
+
+		    /**
+		     * @ignore
+		     * @namespace baidu.browser 判断浏览器类型和特性的属性。
+		     */
+		    baidu.browser = baidu.browser || {};
+
+		    if (/msie (\d+\.\d)/i.test(navigator.userAgent)) {
+		        //IE 8下，以documentMode为准
+		        //在百度模板中，可能会有$，防止冲突，将$1 写成 \x241
+		        /**
+		         * 判断是否为ie浏览器
+		         * @property ie ie版本号
+		         * @grammar baidu.browser.ie
+		         * @meta standard
+		         * @shortcut ie
+		         * @see baidu.browser.firefox,baidu.browser.safari,baidu.browser.opera,baidu.browser.chrome,baidu.browser.maxthon 
+		         */
+		        baidu.browser.ie = baidu.ie = document.documentMode || + RegExp['\x241'];
+		    }
+
+		    /**
+		     * 获取目标元素的computed style值。如果元素的样式值不能被浏览器计算，则会返回空字符串（IE）
+		     *
+		     * @author berg
+		     * @name baidu.dom.getComputedStyle
+		     * @function
+		     * @grammar baidu.dom.getComputedStyle(element, key)
+		     * @param {HTMLElement|string} element 目标元素或目标元素的id
+		     * @param {string} key 要获取的样式名
+		     *
+		     * @see baidu.dom.getStyle
+		     *             
+		     * @returns {string} 目标元素的computed style值
+		     */
+
+		    baidu.dom.getComputedStyle = function(element, key){
+		        element = baidu.dom._g(element);
+		        var doc = baidu.dom.getDocument(element),
+		            styles;
+		        if (doc.defaultView && doc.defaultView.getComputedStyle) {
+		            styles = doc.defaultView.getComputedStyle(element, null);
+		            if (styles) {
+		                return styles[key] || styles.getPropertyValue(key);
+		            }
+		        }
+		        return ''; 
+		    };
+
+		    /**
+		     * 提供给setStyle与getStyle使用
+		     */
+		    baidu.dom._styleFixer = baidu.dom._styleFixer || {};
+
+		    /**
+		     * 提供给setStyle与getStyle使用
+		     */
+		    baidu.dom._styleFilter = baidu.dom._styleFilter || [];
+
+		    /**
+		     * 为获取和设置样式的过滤器
+		     * @private
+		     * @meta standard
+		     */
+		    baidu.dom._styleFilter.filter = function (key, value, method) {
+		        for (var i = 0, filters = baidu.dom._styleFilter, filter; filter = filters[i]; i++) {
+		            if (filter = filter[method]) {
+		                value = filter(key, value);
+		            }
+		        }
+		        return value;
+		    };
+
+		    /**
+		         * @ignore
+		     * @namespace baidu.string 操作字符串的方法。
+		     */
+		    baidu.string = baidu.string || {};
+
+		    /**
+		     * 将目标字符串进行驼峰化处理
+		     * @name baidu.string.toCamelCase
+		     * @function
+		     * @grammar baidu.string.toCamelCase(source)
+		     * @param {string} source 目标字符串
+		     * @remark
+		     * 支持单词以“-_”分隔
+		     * @meta standard
+		     *             
+		     * @returns {string} 驼峰化处理后的字符串
+		     */
+		    baidu.string.toCamelCase = function (source) {
+		        //提前判断，提高getStyle等的效率 thanks xianwei
+		        if (source.indexOf('-') < 0 && source.indexOf('_') < 0) {
+		            return source;
+		        }
+		        return source.replace(/[-_][^-_]/g, function (match) {
+		            return match.charAt(1).toUpperCase();
+		        });
+		    };
+
+		    /**
+		     * 获取目标元素的样式值
+		     * @name baidu.dom.getStyle
+		     * @function
+		     * @grammar baidu.dom.getStyle(element, key)
+		     * @param {HTMLElement|string} element 目标元素或目标元素的id
+		     * @param {string} key 要获取的样式名
+		     * @remark
+		     * 
+		     * 为了精简代码，本模块默认不对任何浏览器返回值进行归一化处理（如使用getStyle时，不同浏览器下可能返回rgb颜色或hex颜色），也不会修复浏览器的bug和差异性（如设置IE的float属性叫styleFloat，firefox则是cssFloat）。<br />
+		     * baidu.dom._styleFixer和baidu.dom._styleFilter可以为本模块提供支持。<br />
+		     * 其中_styleFilter能对颜色和px进行归一化处理，_styleFixer能对display，float，opacity，textOverflow的浏览器兼容性bug进行处理。	
+		     * @shortcut getStyle
+		     * @meta standard
+		     * @see baidu.dom.setStyle,baidu.dom.setStyles, baidu.dom.getComputedStyle
+		     *             
+		     * @returns {string} 目标元素的样式值
+		     */
+		    baidu.dom.getStyle = function (element, key) {
+		        var dom = baidu.dom;
+
+		        element = dom.g(element);
+		        key = baidu.string.toCamelCase(key);
+		        //computed style, then cascaded style, then explicitly set style.
+		        var value = element.style[key] ||
+		                    (element.currentStyle ? element.currentStyle[key] : "") || 
+		                    dom.getComputedStyle(element, key);
+
+		        // 在取不到值的时候，用fixer进行修正
+		        if (!value) {
+		            var fixer = dom._styleFixer[key];
+		            if(fixer){
+		                value = fixer.get ? fixer.get(element) : baidu.dom.getStyle(element, fixer);
+		            }
+		        }
+
+		        /* 检查结果过滤器 */
+		        if (fixer = dom._styleFilter) {
+		            value = fixer.filter(key, value, 'get');
+		        }
+
+		        return value;
+		    };
+
+		    // 声明快捷方法
+		    baidu.getStyle = baidu.dom.getStyle;
+
+
+		    if (/opera\/(\d+\.\d)/i.test(navigator.userAgent)) {
+		    /**
+		     * 判断是否为opera浏览器
+		     * @property opera opera版本号
+		     * @grammar baidu.browser.opera
+		     * @meta standard
+		     * @see baidu.browser.ie,baidu.browser.firefox,baidu.browser.safari,baidu.browser.chrome 
+		     */
+		        baidu.browser.opera = + RegExp['\x241'];
+		    }
+
+		    /**
+		     * 判断是否为webkit内核
+		     * @property isWebkit 
+		     * @grammar baidu.browser.isWebkit
+		     * @meta standard
+		     * @see baidu.browser.isGecko
+		     */
+		    baidu.browser.isWebkit = /webkit/i.test(navigator.userAgent);
+
+		    /**
+		     * 判断是否为gecko内核
+		     * @property isGecko 
+		     * @grammar baidu.browser.isGecko
+		     * @meta standard
+		     * @see baidu.browser.isWebkit
+		     */
+		    baidu.browser.isGecko = /gecko/i.test(navigator.userAgent) && !/like gecko/i.test(navigator.userAgent);
+
+		    /**
+		     * 判断是否严格标准的渲染模式
+		     * @property isStrict 
+		     * @grammar baidu.browser.isStrict
+		     * @meta standard
+		     */
+		    baidu.browser.isStrict = document.compatMode == "CSS1Compat";
+
+		    /**
+		     * 获取目标元素相对于整个文档左上角的位置
+		     * @name baidu.dom.getPosition
+		     * @function
+		     * @grammar baidu.dom.getPosition(element)
+		     * @param {HTMLElement|string} element 目标元素或目标元素的id
+		     * @meta standard
+		     *             
+		     * @returns {Object} 目标元素的位置，键值为top和left的Object。
+		     */
+		    baidu.dom.getPosition = function (element) {
+		        element = baidu.dom.g(element);
+		        var doc = baidu.dom.getDocument(element), 
+		            browser = baidu.browser,
+		            getStyle = baidu.dom.getStyle;
+		        // Gecko 1.9版本以下用getBoxObjectFor计算位置
+		        // 但是某些情况下是有bug的
+		        // 对于这些有bug的情况
+		        // 使用递归查找的方式
+		            browser.isGecko > 0 && 
+		                                        doc.getBoxObjectFor &&
+		                                        getStyle(element, 'position') == 'absolute' &&
+		                                        (element.style.top === '' || element.style.left === '');
+		            var pos = {"left":0,"top":0},
+		            viewport = (browser.ie && !browser.isStrict) ? doc.body : doc.documentElement,
+		            parent,
+		            box;
+
+		        if(element == viewport){
+		            return pos;
+		        }
+
+		        if(element.getBoundingClientRect){ // IE and Gecko 1.9+
+		    
+		            //当HTML或者BODY有border width时, 原生的getBoundingClientRect返回值是不符合预期的
+		            //考虑到通常情况下 HTML和BODY的border只会设成0px,所以忽略该问题.
+		            box = element.getBoundingClientRect();
+
+		            pos.left = Math.floor(box.left) + Math.max(doc.documentElement.scrollLeft, doc.body.scrollLeft);
+		            pos.top  = Math.floor(box.top)  + Math.max(doc.documentElement.scrollTop,  doc.body.scrollTop);
+		    
+		            // IE会给HTML元素添加一个border，默认是medium（2px）
+		            // 但是在IE 6 7 的怪异模式下，可以被html { border: 0; } 这条css规则覆盖
+		            // 在IE7的标准模式下，border永远是2px，这个值通过clientLeft 和 clientTop取得
+		            // 但是。。。在IE 6 7的怪异模式，如果用户使用css覆盖了默认的medium
+		            // clientTop和clientLeft不会更新
+		            pos.left -= doc.documentElement.clientLeft;
+		            pos.top  -= doc.documentElement.clientTop;
+		    
+		            var htmlDom = doc.body,
+		                // 在这里，不使用element.style.borderLeftWidth，只有computedStyle是可信的
+		                htmlBorderLeftWidth = parseInt(getStyle(htmlDom, 'borderLeftWidth')),
+		                htmlBorderTopWidth = parseInt(getStyle(htmlDom, 'borderTopWidth'));
+		            if(browser.ie && !browser.isStrict){
+		                pos.left -= isNaN(htmlBorderLeftWidth) ? 2 : htmlBorderLeftWidth;
+		                pos.top  -= isNaN(htmlBorderTopWidth) ? 2 : htmlBorderTopWidth;
+		            }
+		        } else { 
+		            // safari/opera/firefox
+		            parent = element;
+
+		            do {
+		                pos.left += parent.offsetLeft;
+		                pos.top  += parent.offsetTop;
+		    
+		                // safari里面，如果遍历到了一个fixed的元素，后面的offset都不准了
+		                if (browser.isWebkit > 0 && getStyle(parent, 'position') == 'fixed') {
+		                    pos.left += doc.body.scrollLeft;
+		                    pos.top  += doc.body.scrollTop;
+		                    break;
+		                }
+		        
+		                parent = parent.offsetParent;
+		            } while (parent && parent != element);
+
+		            // 对body offsetTop的修正
+		            if(browser.opera > 0 || (browser.isWebkit > 0 && getStyle(element, 'position') == 'absolute')){
+		                pos.top  -= doc.body.offsetTop;
+		            }
+
+		            // 计算除了body的scroll
+		            parent = element.offsetParent;
+		            while (parent && parent != doc.body) {
+		                pos.left -= parent.scrollLeft;
+		                // see https://bugs.opera.com/show_bug.cgi?id=249965
+		                if (!browser.opera || parent.tagName != 'TR') {
+		                    pos.top -= parent.scrollTop;
+		                }
+		                parent = parent.offsetParent;
+		            }
+		        }
+
+		        return pos;
+		    };
+
+		    /**
+		     * @ignore
+		     * @namespace baidu.event 屏蔽浏览器差异性的事件封装。
+		     * @property target 	事件的触发元素
+		     * @property pageX 		鼠标事件的鼠标x坐标
+		     * @property pageY 		鼠标事件的鼠标y坐标
+		     * @property keyCode 	键盘事件的键值
+		     */
+		    baidu.event = baidu.event || {};
+
+		    /**
+		     * 事件监听器的存储表
+		     * @private
+		     * @meta standard
+		     */
+		    baidu.event._listeners = baidu.event._listeners || [];
+
+		    /**
+		     * 为目标元素添加事件监听器
+		     * @name baidu.event.on
+		     * @function
+		     * @grammar baidu.event.on(element, type, listener)
+		     * @param {HTMLElement|string|window} element 目标元素或目标元素id
+		     * @param {string} type 事件类型
+		     * @param {Function} listener 需要添加的监听器
+		     * @remark
+		     * 
+		    1. 不支持跨浏览器的鼠标滚轮事件监听器添加<br>
+		    2. 改方法不为监听器灌入事件对象，以防止跨iframe事件挂载的事件对象获取失败
+
+		        * @shortcut on
+		        * @meta standard
+		        * @see baidu.event.un
+		        *             
+		        * @returns {HTMLElement|window} 目标元素
+		        */
+		    baidu.event.on = function (element, type, listener) {
+		        type = type.replace(/^on/i, '');
+		        element = baidu.dom._g(element);
+
+		        var realListener = function (ev) {
+		                // 1. 这里不支持EventArgument,  原因是跨frame的事件挂载
+		                // 2. element是为了修正this
+		                listener.call(element, ev);
+		            },
+		            lis = baidu.event._listeners,
+		            filter = baidu.event._eventFilter,
+		            afterFilter,
+		            realType = type;
+		        type = type.toLowerCase();
+		        // filter过滤
+		        if(filter && filter[type]){
+		            afterFilter = filter[type](element, type, realListener);
+		            realType = afterFilter.type;
+		            realListener = afterFilter.listener;
+		        }
+
+		        // 事件监听器挂载
+		        if (element.addEventListener) {
+		            element.addEventListener(realType, realListener, false);
+		        } else if (element.attachEvent) {
+		            element.attachEvent('on' + realType, realListener);
+		        }
+
+		        // 将监听器存储到数组中
+		        lis[lis.length] = [element, type, listener, realListener, realType];
+		        return element;
+		    };
+
+		    // 声明快捷方法
+		    baidu.on = baidu.event.on;
+
+		    /**
+		     * 返回一个当前页面的唯一标识字符串。
+		     * @name baidu.lang.guid
+		     * @function
+		     * @grammar baidu.lang.guid()
+		     * @version 1.1.1
+		     * @meta standard
+		     *             
+		     * @returns {String} 当前页面的唯一标识字符串
+		     */
+
+		    (function(){
+		        //不直接使用window，可以提高3倍左右性能
+		        var guid = context[baidu.guid];
+
+		        baidu.lang.guid = function() {
+		            return "TANGRAM__" + (guid._counter ++).toString(36);
+		        };
+
+		        guid._counter = guid._counter || 1;
+		    })();
+
+		    /**
+		     * 所有类的实例的容器
+		     * key为每个实例的guid
+		     * @meta standard
+		     */
+
+		    context[baidu.guid]._instances = context[baidu.guid]._instances || {};
+
+		    /**
+		     * 判断目标参数是否为function或Function实例
+		     * @name baidu.lang.isFunction
+		     * @function
+		     * @grammar baidu.lang.isFunction(source)
+		     * @param {Any} source 目标参数
+		     * @version 1.2
+		     * @see baidu.lang.isString,baidu.lang.isObject,baidu.lang.isNumber,baidu.lang.isArray,baidu.lang.isElement,baidu.lang.isBoolean,baidu.lang.isDate
+		     * @meta standard
+		     * @returns {boolean} 类型判断结果
+		     */
+		    baidu.lang.isFunction = function (source) {
+		        // chrome下,'function' == typeof /a/ 为true.
+		        return '[object Function]' == Object.prototype.toString.call(source);
+		    };
+
+		    /**
+		     *    
+		     * @ignore
+		     * @class  Tangram继承机制提供的一个基类，用户可以通过继承baidu.lang.Class来获取它的属性及方法。
+		     * @name 	baidu.lang.Class
+		     * @grammar baidu.lang.Class(guid)
+		     * @param 	{string}	guid	对象的唯一标识
+		     * @meta standard
+		     * @remark baidu.lang.Class和它的子类的实例均包含一个全局唯一的标识guid。guid是在构造函数中生成的，因此，继承自baidu.lang.Class的类应该直接或者间接调用它的构造函数。<br>baidu.lang.Class的构造函数中产生guid的方式可以保证guid的唯一性，及每个实例都有一个全局唯一的guid。
+		     * @meta standard
+		     * @see baidu.lang.inherits,baidu.lang.Event
+		     */
+		    baidu.lang.Class = function(guid) {
+		        this.guid = guid || baidu.lang.guid();
+		        context[baidu.guid]._instances[this.guid] = this;
+		    };
+		    context[baidu.guid]._instances = context[baidu.guid]._instances || {};
+
+		    /**
+		     * 释放对象所持有的资源，主要是自定义事件。
+		     * @name dispose
+		     * @grammar obj.dispose()
+		     */
+		    baidu.lang.Class.prototype.dispose = function(){
+		        delete context[baidu.guid]._instances[this.guid];
+
+		        for(var property in this){
+		            if (!baidu.lang.isFunction(this[property])) {
+		                delete this[property];
+		            }
+		        }
+		        this.disposed = true;
+		    };
+
+		    /**
+		     * 重载了默认的toString方法，使得返回信息更加准确一些。
+		     * @return {string} 对象的String表示形式
+		     */
+		    baidu.lang.Class.prototype.toString = function(){
+		        return "[object " + (this._className || "Object" ) + "]";
+		    };
+
+		    /**
+		     * @ignore
+		     * @class   自定义的事件对象。
+		     * @name 	baidu.lang.Event
+		     * @grammar baidu.lang.Event(type[, target])
+		     * @param 	{string} type	 事件类型名称。为了方便区分事件和一个普通的方法，事件类型名称必须以"on"(小写)开头。
+		     * @param 	{Object} [target]触发事件的对象
+		     * @meta standard
+		     * @remark 引入该模块，会自动为Class引入3个事件扩展方法：addEventListener、removeEventListener和dispatchEvent。
+		     * @meta standard
+		     * @see baidu.lang.Class
+		     */
+		    baidu.lang.Event = function (type, target) {
+		        this.type = type;
+		        this.returnValue = true;
+		        this.target = target || null;
+		        this.currentTarget = null;
+		    };
+
+		    /**
+		     * 注册对象的事件监听器。引入baidu.lang.Event后，Class的子类实例才会获得该方法。
+		     * @grammar obj.addEventListener(type, handler[, key])
+		     * @param 	{string}   type         自定义事件的名称
+		     * @param 	{Function} handler      自定义事件被触发时应该调用的回调函数
+		     * @param 	{string}   [key]		为事件监听函数指定的名称，可在移除时使用。如果不提供，方法会默认为它生成一个全局唯一的key。
+		     * @remark 	事件类型区分大小写。如果自定义事件名称不是以小写"on"开头，该方法会给它加上"on"再进行判断，即"click"和"onclick"会被认为是同一种事件。 
+		     */
+		    baidu.lang.Class.prototype.addEventListener = function (type, handler, key) {
+		        if (!baidu.lang.isFunction(handler)) {
+		            return;
+		        }
+
+		        !this.__listeners && (this.__listeners = {});
+
+		        var t = this.__listeners, id;
+		        if (typeof key == "string" && key) {
+		            if (/[^\w\-]/.test(key)) {
+		                throw("nonstandard key:" + key);
+		            } else {
+		                handler.hashCode = key; 
+		                id = key;
+		            }
+		        }
+		        type.indexOf("on") != 0 && (type = "on" + type);
+
+		        typeof t[type] != "object" && (t[type] = {});
+		        id = id || baidu.lang.guid();
+		        handler.hashCode = id;
+		        t[type][id] = handler;
+		    };
+
+		    /**
+		     * 移除对象的事件监听器。引入baidu.lang.Event后，Class的子类实例才会获得该方法。
+		     * @grammar obj.removeEventListener(type, handler)
+		     * @param {string}   type     事件类型
+		     * @param {Function|string} handler  要移除的事件监听函数或者监听函数的key
+		     * @remark 	如果第二个参数handler没有被绑定到对应的自定义事件中，什么也不做。
+		     */
+		    baidu.lang.Class.prototype.removeEventListener = function (type, handler) {
+		        if (typeof handler != "undefined") {
+		            if ( (baidu.lang.isFunction(handler) && ! (handler = handler.hashCode))
+		                || (! baidu.lang.isString(handler))
+		            ){
+		                return;
+		            }
+		        }
+
+		        !this.__listeners && (this.__listeners = {});
+
+		        type.indexOf("on") != 0 && (type = "on" + type);
+
+		        var t = this.__listeners;
+		        if (!t[type]) {
+		            return;
+		        }
+		        if (typeof handler != "undefined") {
+		            t[type][handler] && delete t[type][handler];
+		        } else {
+		            for(var guid in t[type]){
+		                delete t[type][guid];
+		            }
+		        }
+		    };
+
+		    /**
+		     * 派发自定义事件，使得绑定到自定义事件上面的函数都会被执行。引入baidu.lang.Event后，Class的子类实例才会获得该方法。
+		     * @grammar obj.dispatchEvent(event, options)
+		     * @param {baidu.lang.Event|String} event 	Event对象，或事件名称(1.1.1起支持)
+		     * @param {Object} 					options 扩展参数,所含属性键值会扩展到Event对象上(1.2起支持)
+		     * @remark 处理会调用通过addEventListenr绑定的自定义事件回调函数之外，还会调用直接绑定到对象上面的自定义事件。例如：<br>
+		    myobj.onMyEvent = function(){}<br>
+		    myobj.addEventListener("onMyEvent", function(){});
+		        */
+		    baidu.lang.Class.prototype.dispatchEvent = function (event, options) {
+		        if (baidu.lang.isString(event)) {
+		            event = new baidu.lang.Event(event);
+		        }
+		        !this.__listeners && (this.__listeners = {});
+
+		        // 20100603 添加本方法的第二个参数，将 options extend到event中去传递
+		        options = options || {};
+		        for (var i in options) {
+		            event[i] = options[i];
+		        }
+
+		        var i, t = this.__listeners, p = event.type;
+		        event.target = event.target || this;
+		        event.currentTarget = this;
+
+		        p.indexOf("on") != 0 && (p = "on" + p);
+
+		        baidu.lang.isFunction(this[p]) && this[p].apply(this, arguments);
+
+		        if (typeof t[p] == "object") {
+		            for (i in t[p]) {
+		                t[p][i].apply(this, arguments);
+		            }
+		        }
+		        return event.returnValue;
+		    };
+
+
+		    baidu.lang.inherits = function (subClass, superClass, className) {
+		        var key, proto,
+		            selfProps = subClass.prototype,
+		            clazz = new Function();
+
+		        clazz.prototype = superClass.prototype;
+		        proto = subClass.prototype = new clazz();
+		        for (key in selfProps) {
+		            proto[key] = selfProps[key];
+		        }
+		        subClass.prototype.constructor = subClass;
+		        subClass.superClass = superClass.prototype;
+
+		        // 类名标识，兼容Class的toString，基本没用
+		        if ("string" == typeof className) {
+		            proto._className = className;
+		        }
+		    };
+		    // 声明快捷方法
+		    baidu.inherits = baidu.lang.inherits;
+
+
+		    /**
+		    
+		     * 图片的路径
+
+		     * @private
+		     * @type {String}
+		    
+		     */
+		    var _IMAGE_PATH = 'http://api.map.baidu.com/library/TextIconOverlay/1.2/src/images/m';
+
+		    /**
+		    
+		     * 图片的后缀名
+
+		      * @private
+		     * @type {String}
+		    
+		     */
+		    var _IMAGE_EXTENSION  = 'png';
+
+		    /**
+		     *@exports TextIconOverlay as BMapLib.TextIconOverlay
+		     */
+		    
+		    /**
+		    * TextIconOverlay
+		    * @class 此类表示地图上的一个覆盖物，该覆盖物由文字和图标组成，从Overlay继承。文字通常是数字（0-9）或字母（A-Z ），而文字与图标之间有一定的映射关系。
+		    * 该覆盖物适用于以下类似的场景：需要在地图上添加一系列覆盖物，这些覆盖物之间用不同的图标和文字来区分，文字可能表示了该覆盖物的某一属性值，根据该文字和一定的映射关系，自动匹配相应颜色和大小的图标。
+		    *
+		    * @constructor
+		    * @param {Point} position 表示一个经纬度坐标位置。
+		    * @param {string} text 表示该覆盖物显示的文字信息。
+		    * @param {TextIconOverlayOptions=} options 选项。
+		    *
+		    * @typedef {object} TextIconOverlayOptions
+		    * @property {IconStyle[]=} styles 一组图标风格。
+		    * @property {number=} zIndex 等同与CSS中的z-index属性
+		    * 
+		    * @typedef {object} IconStyle
+		    * @property {string} url 图片的url地址。
+		    * @property {Size} size 图片的大小。
+		    * @property {Size=} anchor 图标定位在地图上的位置相对于图标左上角的偏移值，默认偏移值为图标的中心位置。
+		    * @property {Size=} offset 图片相对于可视区域的偏移值，此功能的作用等同于CSS中的background-position属性。
+		    * @property {number=} [textSize=10] 文字的大小。
+		    * @property {string} [textColor='black'] 文字的颜色。
+		    */
+		    var TextIconOverlay = function(position, text, options){
+		        try {
+		            BMap;
+		        } catch (e) {
+		            throw Error('Baidu Map JS API is not ready yet!');
+		        }
+		        T.lang.inherits(TextIconOverlay, BMap.Overlay, "TextIconOverlay");
+		        this._position = position;
+		        this._text = text;
+		        this._options = options || {};
+		        this._styles = this._options['styles'] || [];
+		        /** @type {number | undefined} */
+		        this._zIndex = this._options['zIndex'];
+		        (!this._styles.length) && this._setupDefaultStyles();                  
+		    };
+
+
+		    TextIconOverlay.prototype._setupDefaultStyles = function(){  
+		        var sizes = [53, 56, 66, 78, 90];
+		        for(var i = 0, size; size = sizes[i]; i++){
+		            this._styles.push({
+		                url:_IMAGE_PATH + i + '.' + _IMAGE_EXTENSION,
+		                size: new BMap.Size(size, size)
+		            });
+		        }//for循环的简洁写法
+		    };
+
+		    /**
+		    *继承Overlay的intialize方法，自定义覆盖物时必须。
+		    *@param {Map} map BMap.Map的实例化对象。
+		    *@return {HTMLElement} 返回覆盖物对应的HTML元素。
+		    */
+		    TextIconOverlay.prototype.initialize = function(map){
+		        this._map = map;
+		    
+		        this._domElement = document.createElement('div');     
+		        this._updateCss();    
+		        this._updateText();
+		        this._updatePosition(); 
+		        
+		        this._bind();
+
+		        this._map.getPanes().markerMouseTarget.appendChild(this._domElement);
+		        return this._domElement;   
+		    };
+
+		    /**
+		    *继承Overlay的draw方法，自定义覆盖物时必须。
+		    *@return 无返回值。
+		    */
+		    TextIconOverlay.prototype.draw = function(){
+		        this._map && this._updatePosition();
+		    };
+		    
+		    /**
+		    *获取该覆盖物上的文字。
+		    *@return {String} 该覆盖物上的文字。
+		    */
+		    TextIconOverlay.prototype.getText = function(){
+		        return this._text;
+		    };
+
+		    /**
+		    *设置该覆盖物上的文字。
+		    *@param {String} text 要设置的文字，通常是字母A-Z或数字0-9。
+		    *@return 无返回值。
+		    */
+		    TextIconOverlay.prototype.setText = function(text){
+		        if(text && (!this._text || (this._text.toString() != text.toString()))){
+		            this._text = text;
+		            this._updateText();
+		            this._updateCss();
+		            this._updatePosition(); 
+		        }
+		    };
+
+		    /**
+		    *获取该覆盖物的位置。
+		    *@return {Point} 该覆盖物的经纬度坐标。
+		    */
+		    TextIconOverlay.prototype.getPosition = function () {
+		        return this._position;
+		    };
+		   
+		    /**
+		    *设置该覆盖物的位置。
+		    *@param {Point}  position 要设置的经纬度坐标。
+		    *@return 无返回值。
+		    */
+		    TextIconOverlay.prototype.setPosition = function (position) {
+		        if(position && (!this._position || !this._position.equals(position))){
+		            this._position = position;  
+		            this._updatePosition();
+		        }
+		    };
+
+		    /**
+		    *由文字信息获取风格数组的对应索引值。
+		    *内部默认的对应函数为文字转换为数字除以10的结果，比如文字8返回索引0，文字25返回索引2.
+		    *如果需要自定义映射关系，请覆盖该函数。
+		    *@param {String} text  文字。
+		    *@param {Array<IconStyle>}  styles 一组图标风格。
+		    *@return {Number} 对应的索引值。
+		    */
+		    TextIconOverlay.prototype.getStyleByText = function(text, styles){
+		        var count = parseInt(text);
+		        var index = parseInt(count / 10);
+		        index = Math.max(0, index);
+		        index = Math.min(index, styles.length - 1);
+		        return styles[index]; 
+		    };
+
+		    /**
+		    *更新相应的CSS。
+		    *@return 无返回值。
+		    */
+		    TextIconOverlay.prototype._updateCss = function(){
+		        if (!this._domElement) {
+		            return
+		        }
+		        var style = this.getStyleByText(this._text, this._styles);
+		        this._domElement.style.cssText = this._buildCssText(style);
+		    };
+
+		    /**
+		    *更新覆盖物的显示文字。
+		    *@return 无返回值。
+		    */
+		    TextIconOverlay.prototype._updateText = function(){
+		        if (this._domElement) {
+		            this._domElement.innerHTML = this._text;
+		        }
+		    };
+
+		    /**
+		    *调整覆盖物在地图上的位置更新覆盖物的显示文字。
+		    *@return 无返回值。
+		    */
+		    TextIconOverlay.prototype._updatePosition = function(){
+		        if (this._domElement && this._position) {
+		            var style = this._domElement.style;
+		            var pixelPosition= this._map.pointToOverlayPixel(this._position); 
+		            pixelPosition.x -= Math.ceil(parseInt(style.width) / 2);
+		            pixelPosition.y -= Math.ceil(parseInt(style.height) / 2);       
+		            style.left = pixelPosition.x + "px";
+		            style.top = pixelPosition.y + "px";
+		        }
+		    };
+		    
+		    /**
+		    * 为该覆盖物的HTML元素构建CSS
+		    * @param {IconStyle}  一个图标的风格。
+		    * @return {String} 构建完成的CSSTEXT。
+		    */
+		    TextIconOverlay.prototype._buildCssText = function(style) {    
+		        //根据style来确定一些默认值
+		        var url = style['url'];
+		        var size = style['size'];
+		        var anchor = style['anchor'];
+		        var offset = style['offset'];
+		        var textColor = style['textColor'] || 'black';
+		        var textSize = style['textSize'] || 10;
+
+		        var csstext = [];
+		        if (this._zIndex) {
+		            csstext.push('z-index:' + this._zIndex + ';');
+		        }
+		        if (T.browser["ie"] < 7) {
+		            csstext.push('filter:progid:DXImageTransform.Microsoft.AlphaImageLoader(' +
+		                'sizingMethod=scale,src="' + url + '");');
+		        } else {
+		            csstext.push('background-image:url(' + url + ');');
+		            var backgroundPosition = '0 0';
+		            (offset instanceof BMap.Size) && (backgroundPosition = offset.width + 'px' + ' ' + offset.height + 'px');          
+		            csstext.push('background-position:' + backgroundPosition + ';');
+		        }
+
+		        if (size instanceof BMap.Size){
+		            if (anchor instanceof BMap.Size) {
+		                if (anchor.height > 0 && anchor.height < size.height) {
+		                      csstext.push('height:' + (size.height - anchor.height) + 'px; padding-top:' + anchor.height + 'px;');
+		                }
+		                if(anchor.width > 0 && anchor.width < size.width){
+		                    csstext.push('width:' + (size.width - anchor.width) + 'px; padding-left:' + anchor.width + 'px;');                
+		                }
+		            } else {
+		                csstext.push('height:' + size.height + 'px; line-height:' + size.height + 'px;');
+		                csstext.push('width:' + size.width + 'px; text-align:center;');
+		            }
+		        }
+		   
+		        csstext.push('cursor:pointer; color:' + textColor + '; position:absolute; font-size:' +
+		            textSize + 'px; font-family:Arial,sans-serif; font-weight:bold');
+		        return csstext.join('');
+		    };
+
+
+		    /**
+		    
+		     * 当鼠标点击该覆盖物时会触发该事件
+
+		     * @name TextIconOverlay#click
+
+		     * @event
+
+		     * @param {Event Object} e 回调函数会返回event参数，包括以下返回值：
+		    
+		     * <br />"<b>type</b> : {String} 事件类型
+
+		     * <br />"<b>target</b>：{BMapLib.TextIconOverlay} 事件目标
+
+		     *
+
+		     */
+
+		    /**
+
+		     * 当鼠标进入该覆盖物区域时会触发该事件
+
+		     * @name TextIconOverlay#mouseover
+
+		     * @event
+		     * @param {Event Object} e 回调函数会返回event参数，包括以下返回值：
+		    
+		     * <br />"<b>type</b> : {String} 事件类型
+
+		     * <br />"<b>target</b>：{BMapLib.TextIconOverlay} 事件目标
+
+		     * <br />"<b>point</b> : {BMap.Point} 最新添加上的节点BMap.Point对象
+
+		     * <br />"<b>pixel</b>：{BMap.pixel} 最新添加上的节点BMap.Pixel对象
+
+		     *
+
+		     * @example <b>参考示例：</b><br />
+
+		     * myTextIconOverlay.addEventListener("mouseover", function(e) {  alert(e.point);  });
+
+		     */
+
+		    /**
+
+		     * 当鼠标离开该覆盖物区域时会触发该事件
+
+		     * @name TextIconOverlay#mouseout
+
+		     * @event
+
+		     * @param {Event Object} e 回调函数会返回event参数，包括以下返回值：
+
+		     * <br />"<b>type</b> : {String} 事件类型
+
+		     * <br />"<b>target</b>：{BMapLib.TextIconOverlay} 事件目标
+
+		     * <br />"<b>point</b> : {BMap.Point} 最新添加上的节点BMap.Point对象
+
+		     * <br />"<b>pixel</b>：{BMap.pixel} 最新添加上的节点BMap.Pixel对象
+
+		     *
+
+		     * @example <b>参考示例：</b><br />
+
+		     * myTextIconOverlay.addEventListener("mouseout", function(e) {  alert(e.point);  });
+
+		     */
+
+
+		    /**
+		    * 为该覆盖物绑定一系列事件
+		    * 当前支持click mouseover mouseout
+		    * @return 无返回值。
+		    */
+		    TextIconOverlay.prototype._bind = function(){
+		        if (!this._domElement){
+		            return;
+		        }
+
+		        var me = this;
+		        var map = this._map;
+
+		        var BaseEvent = T.lang.Event;
+		        function eventExtend(e, be){
+		            var elem = e.srcElement || e.target;
+		            var x = e.clientX || e.pageX;
+		            var y = e.clientY || e.pageY;
+		            if (e && be && x && y && elem){
+		                var offset = T.dom.getPosition(map.getContainer());
+		                be.pixel = new BMap.Pixel(x - offset.left, y - offset.top);
+		                be.point = map.pixelToPoint(be.pixel);
+		            }
+		            return be;
+		        }//给事件参数增加pixel和point两个值
+
+		        T.event.on(this._domElement,"mouseover", function(e){
+		            me.dispatchEvent(eventExtend(e, new BaseEvent("onmouseover")));
+		        });
+		        T.event.on(this._domElement,"mouseout", function(e){
+		            me.dispatchEvent(eventExtend(e, new BaseEvent("onmouseout")));
+		        });
+		        T.event.on(this._domElement,"click", function(e){
+		            me.dispatchEvent(eventExtend(e, new BaseEvent("onclick")));
+		        });
+		    };
+
+		    return TextIconOverlay;
+		}); 
+	} (bmaplib_texticonoverlay$1));
+	return bmaplib_texticonoverlay$1.exports;
+}
+
+var bmaplib_texticonoverlayExports = requireBmaplib_texticonoverlay();
+var TextIconOverlay = /*@__PURE__*/getDefaultExportFromCjs(bmaplib_texticonoverlayExports);
+
+/**
+ * 获取一个扩展的视图范围，把上下左右都扩大一样的像素值。
+ * @param {BMap.Map} map BMap.Map的实例化对象
+ * @param {BMap.Bounds} bounds BMap.Bounds的实例化对象
+ * @param {Number} gridSize 要扩大的像素值
+ *
+ * @return {BMap.Bounds} 返回扩大后的视图范围。
+ */
+var getExtendedBounds = function(map, bounds, gridSize){
+    bounds = cutBoundsInRange(bounds);
+    var pixelNE = map.pointToPixel(bounds.getNorthEast());
+    var pixelSW = map.pointToPixel(bounds.getSouthWest()); 
+    pixelNE.x += gridSize;
+    pixelNE.y -= gridSize;
+    pixelSW.x -= gridSize;
+    pixelSW.y += gridSize;
+    var newNE = map.pixelToPoint(pixelNE);
+    var newSW = map.pixelToPoint(pixelSW);
+    return new BMap.Bounds(newSW, newNE);
+};
+
+/**
+ * 按照百度地图支持的世界范围对bounds进行边界处理
+ * @param {BMap.Bounds} bounds BMap.Bounds的实例化对象
+ *
+ * @return {BMap.Bounds} 返回不越界的视图范围
+ */
+var cutBoundsInRange = function (bounds) {
+    var maxX = getRange(bounds.getNorthEast().lng, -180, 180);
+    var minX = getRange(bounds.getSouthWest().lng, -180, 180);
+    var maxY = getRange(bounds.getNorthEast().lat, -74, 74);
+    var minY = getRange(bounds.getSouthWest().lat, -74, 74);
+    return new BMap.Bounds(new BMap.Point(minX, minY), new BMap.Point(maxX, maxY));
+}; 
+
+/**
+ * 对单个值进行边界处理。
+ * @param {Number} i 要处理的数值
+ * @param {Number} min 下边界值
+ * @param {Number} max 上边界值
+ * 
+ * @return {Number} 返回不越界的数值
+ */
+var getRange = function (i, mix, max) {
+    mix && (i = Math.max(i, mix));
+    max && (i = Math.min(i, max));
+    return i;
+};
+
+/**
+ * 判断给定的对象是否为数组
+ * @param {Object} source 要测试的对象
+ *
+ * @return {Boolean} 如果是数组返回true，否则返回false
+ */
+var isArray = function (source) {
+    return '[object Array]' === Object.prototype.toString.call(source);
+};
+
+/**
+ * 返回item在source中的索引位置
+ * @param {Object} item 要测试的对象
+ * @param {Array} source 数组
+ *
+ * @return {Number} 如果在数组内，返回索引，否则返回-1
+ */
+var indexOf = function(item, source){
+    var index = -1;
+    if(isArray(source)){
+        if (source.indexOf) {
+            index = source.indexOf(item);
+        } else {
+            for (var i = 0, m; m = source[i]; i++) {
+                if (m === item) {
+                    index = i;
+                    break;
+                }
+            }
+        }
+    }        
+    return index;
+};
+
+/**
+ *@exports MarkerClusterer as BMapLib.MarkerClusterer
+ */
+
+/**
+ * MarkerClusterer
+ * @class 用来解决加载大量点要素到地图上产生覆盖现象的问题，并提高性能
+ * @constructor
+ * @param {BMap.Map} map 地图的一个实例。
+ * @param {MarkerClustererOptions=} options 可选参数
+ * 
+ * @typedef {object} MarkerClustererOptions
+ * @property {Marker[]=} markers 要聚合的标记数组
+ * @property {number=} [gridSize=60] 聚合计算时网格的像素大小，默认60
+ * @property {number=} maxZoom 最大的聚合级别，大于该级别就不进行相应的聚合
+ * @property {number=} [minClusterSize=2] 最小的聚合数量，小于该数量的不能成为一个聚合，默认为2
+ * @property {boolean=} [isAverageCenter=false] 聚合点的落脚位置是否是所有聚合在内点的平均值，默认为否，落脚在聚合内的第一个点
+ * @property {IconStyle[]=} styles 自定义聚合后的图标风格，请参考TextIconOverlay类
+ * @property {number=} zIndex 聚合图标的z-index
+ */
+var MarkerClusterer$1  = function(map, options){
+    try {
+        BMap;
+    } catch (e) {
+        throw Error('Baidu Map JS API is not ready yet!');
+    }
+    if (!map){
+        return;
+    }
+    this._map = map;
+    this._markers = [];
+    this._clusters = [];
+    
+    var opts = options || {};
+    this._zIndex = opts["zIndex"];
+    this._gridSize = opts["gridSize"] || 60;
+    this._maxZoom = opts["maxZoom"] || 18;
+    this._minClusterSize = opts["minClusterSize"] || 2;           
+    this._isAverageCenter = false;
+    if (opts['isAverageCenter'] != undefined) {
+        this._isAverageCenter = opts['isAverageCenter'];
+    }    
+    this._styles = opts["styles"] || [];
+
+    var that = this;
+    this._map.addEventListener("zoomend",function(){
+        that._redraw();     
+    });
+
+    this._map.addEventListener("moveend",function(){
+        that._redraw();     
+    });
+
+    var mkrs = opts["markers"];
+    isArray(mkrs) && this.addMarkers(mkrs);
+};
+
+/**
+ * 添加要聚合的标记数组。
+ * @param {Array<Marker>} markers 要聚合的标记数组
+ *
+ * @return 无返回值。
+ */
+MarkerClusterer$1.prototype.addMarkers = function(markers){
+    if (!markers.length) {
+        return
+    }
+    for(var i = 0, len = markers.length; i <len ; i++){
+        this._pushMarkerTo(markers[i]);
+    }
+    this._createClusters();   
+};
+
+/**
+ * 把一个标记添加到要聚合的标记数组中
+ * @param {BMap.Marker} marker 要添加的标记
+ *
+ * @return 无返回值。
+ */
+MarkerClusterer$1.prototype._pushMarkerTo = function(marker){
+    var index = indexOf(marker, this._markers);
+    if(index === -1){
+        marker.isInCluster = false;
+        this._markers.push(marker);//Marker拖放后enableDragging不做变化，忽略
+    }
+};
+
+/**
+ * 添加一个聚合的标记。
+ * @param {BMap.Marker} marker 要聚合的单个标记。
+ * @return 无返回值。
+ */
+MarkerClusterer$1.prototype.addMarker = function(marker) {
+    this._pushMarkerTo(marker);
+    this._createClusters();
+};
+
+/**
+ * 根据所给定的标记，创建聚合点
+ * @return 无返回值
+ */
+MarkerClusterer$1.prototype._createClusters = function(){
+    var mapBounds = this._map.getBounds();
+    if (!mapBounds.getCenter()) {
+        return
+    }
+    var extendedBounds = getExtendedBounds(this._map, mapBounds, this._gridSize);
+    for(var i = 0, marker; marker = this._markers[i]; i++){
+        if(!marker.isInCluster && extendedBounds.containsPoint(marker.getPosition()) ){ 
+            this._addToClosestCluster(marker);
+        }
+    }
+    var len = this._markers.length;
+    for (var i = 0; i < len; i++) {
+        if(this._clusters[i]){
+            this._clusters[i].render();
+        }
+    } 
+};
+
+/**
+ * 根据标记的位置，把它添加到最近的聚合中
+ * @param {BMap.Marker} marker 要进行聚合的单个标记
+ *
+ * @return 无返回值。
+ */
+MarkerClusterer$1.prototype._addToClosestCluster = function (marker){
+    var distance = 4000000;
+    var clusterToAddTo = null;
+    marker.getPosition();
+    for(var i = 0, cluster; cluster = this._clusters[i]; i++){
+        var center = cluster.getCenter();
+        if(center){
+            var d = this._map.getDistance(center, marker.getPosition());
+            if(d < distance){
+                distance = d;
+                clusterToAddTo = cluster;
+            }
+        }
+    }
+
+    if (clusterToAddTo && clusterToAddTo.isMarkerInClusterBounds(marker)){
+        clusterToAddTo.addMarker(marker);
+    } else {
+        var cluster = new Cluster(this);
+        cluster.addMarker(marker);            
+        this._clusters.push(cluster);
+    }    
+};
+
+/**
+ * 清除上一次的聚合的结果
+ * @return 无返回值。
+ */
+MarkerClusterer$1.prototype._clearLastClusters = function(){
+    for(var i = 0, cluster; cluster = this._clusters[i]; i++){            
+        cluster.remove();
+    }
+    this._clusters = [];//置空Cluster数组
+    this._removeMarkersFromCluster();//把Marker的cluster标记设为false
+};
+
+/**
+ * 清除某个聚合中的所有标记
+ * @return 无返回值
+ */
+MarkerClusterer$1.prototype._removeMarkersFromCluster = function(){
+    for(var i = 0, marker; marker = this._markers[i]; i++){
+        marker.isInCluster = false;
+    }
+};
+
+/**
+ * 把所有的标记从地图上清除
+ * @return 无返回值
+ */
+MarkerClusterer$1.prototype._removeMarkersFromMap = function(){
+    for(var i = 0, marker; marker = this._markers[i]; i++){
+        marker.isInCluster = false;
+        var label = marker.getLabel();
+        this._map.removeOverlay(marker);
+        marker.setLabel(label);
+    }
+};
+
+/**
+ * 删除单个标记
+ * @param {BMap.Marker} marker 需要被删除的marker
+ *
+ * @return {Boolean} 删除成功返回true，否则返回false
+ */
+MarkerClusterer$1.prototype._removeMarker = function(marker) {
+    var index = indexOf(marker, this._markers);
+    if (index === -1) {
+        return false;
+    }
+    this._map.removeOverlay(marker);
+    this._markers.splice(index, 1);
+    return true;
+};
+
+/**
+ * 删除单个标记
+ * @param {BMap.Marker} marker 需要被删除的marker
+ *
+ * @return {Boolean} 删除成功返回true，否则返回false
+ */
+MarkerClusterer$1.prototype.removeMarker = function(marker) {
+    var success = this._removeMarker(marker);
+    if (success) {
+        this._clearLastClusters();
+        this._createClusters();
+    }
+    return success;
+};
+
+/**
+ * 删除一组标记
+ * @param {Array<BMap.Marker>} markers 需要被删除的marker数组
+ *
+ * @return {Boolean} 删除成功返回true，否则返回false
+ */
+MarkerClusterer$1.prototype.removeMarkers = function(markers) {
+    var success = false;
+    for (var i = 0; i < markers.length; i++) {
+        var r = this._removeMarker(markers[i]);
+        success = success || r; 
+    }
+
+    if (success) {
+        this._clearLastClusters();
+        this._createClusters();
+    }
+    return success;
+};
+
+/**
+ * 从地图上彻底清除所有的标记
+ * @return 无返回值
+ */
+MarkerClusterer$1.prototype.clearMarkers = function() {
+    this._clearLastClusters();
+    this._removeMarkersFromMap();
+    this._markers = [];
+};
+
+/**
+ * 重新生成，比如改变了属性等
+ * @return 无返回值
+ */
+MarkerClusterer$1.prototype._redraw = function () {
+    this._clearLastClusters();
+    this._createClusters();
+};
+
+/**
+ * 获取网格大小
+ * @return {Number} 网格大小
+ */
+MarkerClusterer$1.prototype.getGridSize = function() {
+    return this._gridSize;
+};
+
+/**
+ * 设置网格大小
+ * @param {Number} size 网格大小
+ * @return 无返回值
+ */
+MarkerClusterer$1.prototype.setGridSize = function(size) {
+    this._gridSize = size;
+    this._redraw();
+};
+
+/**
+ * 获取聚合的最大缩放级别。
+ * @return {Number} 聚合的最大缩放级别。
+ */
+MarkerClusterer$1.prototype.getMaxZoom = function() {
+    return this._maxZoom;       
+};
+
+/**
+ * 设置聚合的最大缩放级别
+ * @param {Number} maxZoom 聚合的最大缩放级别
+ * @return 无返回值
+ */
+MarkerClusterer$1.prototype.setMaxZoom = function(maxZoom) {
+    this._maxZoom = maxZoom;
+    this._redraw();
+};
+
+/**
+ * 获取聚合图标的z-index
+ * @return {number | undefined}
+ */
+MarkerClusterer$1.prototype.getZIndex = function () {
+    return this._zIndex;
+};
+
+/**
+ * 设置聚合图标的z-index
+ * @param {number} zIndex
+ */
+MarkerClusterer$1.prototype.setZIndex = function (zIndex) {
+    if (this._zIndex != zIndex) {
+        this.zIndex = zIndex;
+        this._redraw();
+    }
+};
+
+/**
+ * 获取聚合的样式风格集合
+ * @return {Array<IconStyle>} 聚合的样式风格集合
+ */
+MarkerClusterer$1.prototype.getStyles = function() {
+    return this._styles;
+};
+
+/**
+ * 设置聚合的样式风格集合
+ * @param {Array<IconStyle>} styles 样式风格数组
+ * @return 无返回值
+ */
+MarkerClusterer$1.prototype.setStyles = function(styles) {
+    this._styles = styles;
+    this._redraw();
+};
+
+/**
+ * 获取单个聚合的最小数量。
+ * @return {Number} 单个聚合的最小数量。
+ */
+MarkerClusterer$1.prototype.getMinClusterSize = function() {
+    return this._minClusterSize;
+};
+
+/**
+ * 设置单个聚合的最小数量。
+ * @param {Number} size 单个聚合的最小数量。
+ * @return 无返回值。
+ */
+MarkerClusterer$1.prototype.setMinClusterSize = function(size) {
+    this._minClusterSize = size;
+    this._redraw();
+};
+
+/**
+ * 获取单个聚合的落脚点是否是聚合内所有标记的平均中心。
+ * @return {Boolean} true或false。
+ */
+MarkerClusterer$1.prototype.isAverageCenter = function() {
+    return this._isAverageCenter;
+};
+
+/**
+ * 获取聚合的Map实例。
+ * @return {BMap.Map} Map的示例。
+ */
+MarkerClusterer$1.prototype.getMap = function() {
+    return this._map;
+};
+
+/**
+ * 获取所有的标记数组。
+ * @return {Array<Marker>} 标记数组。
+ */
+MarkerClusterer$1.prototype.getMarkers = function() {
+    return this._markers;
+};
+
+/**
+ * 获取聚合的总数量。
+ * @return {Number} 聚合的总数量。
+ */
+MarkerClusterer$1.prototype.getClustersCount = function() {
+    var count = 0;
+    for(var i = 0, cluster; cluster = this._clusters[i]; i++){
+        cluster.isReal() && count++;     
+    }
+    return count;
+};
+
+/**
+ * 用于计算cluster的文本
+ * @param {Array<BMap.Marker>} markers cluster的markers
+ * @return {String}
+ */
+MarkerClusterer$1.prototype._textCalculator = function(markers){
+    return markers.length.toString();
+};
+
+/**
+ * 用于计算cluster的styles的索引
+ * @param {Array<BMap.Marker>} markers cluster的markers
+ * @param {Number} stylesLength styles的总长度
+ * @return {Number} styles的索引
+ */
+MarkerClusterer$1.prototype._stylesIndexCalculator = null;/* function(markers, stylesLength){
+    return -1;
+}*/
+
+/**
+ * 设置计算cluster的文本的计算函数
+ * @param {function(Array<BMap.Marker>)} calculator
+ */
+MarkerClusterer$1.prototype.setTextCalculator = function(calculator){
+    this._textCalculator = calculator;
+};
+
+/**
+ * 设置计算cluster的styles的索引的计算函数
+ * @param {function(Array<BMap.Marker>, Number)} calculator
+ */
+MarkerClusterer$1.prototype.setStylesIndexCalculator = function(calculator){
+    this._stylesIndexCalculator = calculator;
+};
+
+/**
+ * @ignore
+ * Cluster
+ * @class 表示一个聚合对象，该聚合，包含有N个标记，这N个标记组成的范围，并有予以显示在Map上的TextIconOverlay等。
+ * @constructor
+ * @param {MarkerClusterer} markerClusterer 一个标记聚合器示例。
+ */
+function Cluster(markerClusterer){
+    var that = this;
+    this._markerClusterer = markerClusterer;
+    this._map = markerClusterer.getMap();
+    this._minClusterSize = markerClusterer.getMinClusterSize();
+    this._isAverageCenter = markerClusterer.isAverageCenter();
+    this._center = null;//落脚位置
+    this._markers = [];//这个Cluster中所包含的markers
+    this._gridBounds = null;//以中心点为准，向四边扩大gridSize个像素的范围，也即网格范围
+    this._isReal = false; //真的是个聚合
+
+    this._clusterMarker = new TextIconOverlay(this._center, this._markers.length, {
+        "styles": this._markerClusterer.getStyles(),
+        zIndex: markerClusterer._zIndex
+    });
+    this._clusterMarker.getStyleByText = function (text, styles) {
+        if (that._markerClusterer._stylesIndexCalculator) {
+            var index = that._markerClusterer._stylesIndexCalculator(that._markers, styles.length);
+            return styles[index];
+        }
+        return TextIconOverlay.prototype.getStyleByText.call(this, text, styles);
+    };
+    //this._map.addOverlay(this._clusterMarker);
+    this._clusterMarker.addEventListener && this._clusterMarker.addEventListener("click", function (event) {
+        that._map.setViewport(that.getBounds());
+    });
+}
+
+/**
+ * 向该聚合添加一个标记。
+ * @param {Marker} marker 要添加的标记。
+ * @return 无返回值。
+ */
+Cluster.prototype.addMarker = function(marker){
+    if(this.isMarkerInCluster(marker)){
+        return false;
+    }//也可用marker.isInCluster判断,外面判断OK，这里基本不会命中
+
+    if (!this._center){
+        this._center = marker.getPosition();
+        this.updateGridBounds();//
+    } else {
+        if(this._isAverageCenter){
+            var l = this._markers.length + 1;
+            var lat = (this._center.lat * (l - 1) + marker.getPosition().lat) / l;
+            var lng = (this._center.lng * (l - 1) + marker.getPosition().lng) / l;
+            this._center = new BMap.Point(lng, lat);
+            this.updateGridBounds();
+        }//计算新的Center
+    }
+
+    marker.isInCluster = true;
+    this._markers.push(marker);
+
+    // var len = this._markers.length;
+    // if(len < this._minClusterSize ){     
+    //     this._map.addOverlay(marker);
+    //     //this.updateClusterMarker();
+    //     return true;
+    // } else if (len === this._minClusterSize) {
+    //     for (var i = 0; i < len; i++) {
+    //         var label = this._markers[i].getLabel();
+    //         this._markers[i].getMap() && this._map.removeOverlay(this._markers[i]);
+    //         this._markers[i].setLabel(label);
+    //     }
+        
+    // } 
+    // this._map.addOverlay(this._clusterMarker);
+    // this._isReal = true;
+    // this.updateClusterMarker();
+    return true;
+};
+
+Cluster.prototype.render = function(){
+    var len = this._markers.length;
+         
+    if (len < this._minClusterSize) {
+            for (var i = 0; i < len; i++) {
+                this._map.addOverlay(this._markers[i]);
+            }
+    } else {
+            this._map.addOverlay(this._clusterMarker);
+            this._isReal = true;
+            this.updateClusterMarker();
+    }
+};
+
+/**
+ * 判断一个标记是否在该聚合中。
+ * @param {Marker} marker 要判断的标记。
+ * @return {Boolean} true或false。
+ */
+Cluster.prototype.isMarkerInCluster= function(marker){
+    if (this._markers.indexOf) {
+        return this._markers.indexOf(marker) != -1;
+    } else {
+        for (var i = 0, m; m = this._markers[i]; i++) {
+            if (m === marker) {
+                return true;
+            }
+        }
+    }
+    return false;
+};
+
+/**
+ * 判断一个标记是否在该聚合网格范围中。
+ * @param {Marker} marker 要判断的标记。
+ * @return {Boolean} true或false。
+ */
+Cluster.prototype.isMarkerInClusterBounds = function(marker) {
+    return this._gridBounds.containsPoint(marker.getPosition());
+};
+
+Cluster.prototype.isReal = function(marker) {
+    return this._isReal;
+};
+
+/**
+ * 更新该聚合的网格范围。
+ * @return 无返回值。
+ */
+Cluster.prototype.updateGridBounds = function() {
+    var bounds = new BMap.Bounds(this._center, this._center);
+    this._gridBounds = getExtendedBounds(this._map, bounds, this._markerClusterer.getGridSize());
+};
+
+/**
+ * 更新该聚合的显示样式，也即TextIconOverlay。
+ * @return 无返回值。
+ */
+Cluster.prototype.updateClusterMarker = function () {
+    if (this._map.getZoom() > this._markerClusterer.getMaxZoom()) {
+        this._clusterMarker && this._map.removeOverlay(this._clusterMarker);
+        for (var i = 0, marker; marker = this._markers[i]; i++) {
+            this._map.addOverlay(marker);
+        }
+        return;
+    }
+
+    if (this._markers.length < this._minClusterSize) {
+        this._clusterMarker.hide();
+        return;
+    }
+
+    this._clusterMarker.setPosition(this._center);
+    
+    this._clusterMarker.setText(this._markerClusterer._textCalculator(this._markers));
+};
+
+/**
+ * 删除该聚合。
+ * @return 无返回值。
+ */
+Cluster.prototype.remove = function(){
+    for (var i = 0, m; m = this._markers[i]; i++) {
+        var label = this._markers[i].getLabel();
+        this._markers[i].getMap() && this._map.removeOverlay(this._markers[i]);
+        this._markers[i].setLabel(label);
+    }//清除散的标记点
+    this._map.removeOverlay(this._clusterMarker);
+    this._markers.length = 0;
+    delete this._markers;
+};
+
+/**
+ * 获取该聚合所包含的所有标记的最小外接矩形的范围。
+ * @return {BMap.Bounds} 计算出的范围。
+ */
+Cluster.prototype.getBounds = function() {
+    var bounds = new BMap.Bounds(this._center,this._center);
+    for (var i = 0, marker; marker = this._markers[i]; i++) {
+        bounds.extend(marker.getPosition());
+    }
+    return bounds;
+};
+
+/**
+ * 获取该聚合的落脚点。
+ * @return {BMap.Point} 该聚合的落脚点。
+ */
+Cluster.prototype.getCenter = function() {
+    return this._center;
+};
+
 // cspell: ignore bmaplib, markerclusterer, texticonoverlay
 var ClusterIconStyle;
 (function (ClusterIconStyle) {
@@ -1958,7 +5990,7 @@ class BaiduMarkerClusterer extends MarkerClusterer {
         // ## vite:
         // import导入是异步的, 故无法写在这里, 改成在模块顶部直接导入
         // TODO: 2023/03/16 ipcjs 会不会有初始化时机的问题?
-        this.inner = new BMarkerClusterer__default.default(map.innerMap, {
+        this.inner = new MarkerClusterer$1(map.innerMap, {
             // baidu的构造器中的markers, 会触发重绘, 会导致使用旧的calculator计算cluster
             // markers: options.markers?.map(it => (it as BaiduMarker).innerOverlay),
             gridSize: options.gridSize,
@@ -1987,7 +6019,7 @@ class GoogleMarkerClusterer extends MarkerClusterer {
     inner;
     constructor(map, options) {
         super(map);
-        this.inner = new GMarkerClusterer__default.default(map.innerMap, 
+        this.inner = new MarkerClusterer$2(map.innerMap, 
         // google的构造器中的markers,不会触发重绘, 第一次绘制通过监听地图的'idle'事件触发, 可以直接设置
         options.markers?.map(it => it.innerOverlay), {
             gridSize: options.gridSize,