提交代码

.browserslistrc

@@ -0,0 +1,3 @@
+> 1%
+last 2 versions
+not dead

.editorconfig

@@ -0,0 +1,5 @@
+[*.{js,jsx,ts,tsx,vue}]
+indent_style = space
+indent_size = 2
+trim_trailing_whitespace = true
+insert_final_newline = true

.env.development

@@ -0,0 +1,8 @@
+# 标志
+ENV='development'
+
+# base api
+# VUE_APP_BASE_API = '/api'
+VUE_APP_GATEWAY_API = '/mosty-api/mosty-base'
+VUE_APP_GATEWAY_BASE_URL = 'http://123.60.110.230'
+VUE_APP_GATEWAY_HOST = '123.60.110.230'

.env.production

@@ -0,0 +1,8 @@
+# 生产环境
+ENV = 'production'
+
+# base api
+# VUE_APP_BASE_API = '/api'
+VUE_APP_GATEWAY_API = '/mosty-api/mosty-base'
+VUE_APP_GATEWAY_BASE_URL = 'http://123.60.67.142'
+VUE_APP_GATEWAY_HOST = '123.60.67.142'

.eslintignore

@@ -0,0 +1 @@
+src/

.eslintrc.js

@@ -0,0 +1,49 @@
+// ESLint 配置文件遵循 commonJS 的导出规则，所导出的对象就是 ESLint 的配置对象
+// 文档：https://eslint.bootcss.com/docs/user-guide/configuring
+module.exports = {
+  // 表示当前目录即为根目录，ESLint 规则将被限制到该目录下
+  root: true,
+  // env 表示启用 ESLint 检测的环境
+  env: {
+    // 在 node 环境下启动 ESLint 检测
+    node: false
+  },
+  // ESLint 中基础配置需要继承的配置
+  extends: ['plugin:vue/vue3-essential', '@vue/standard'],
+  // 解析器
+  parserOptions: {
+    parser: 'babel-eslint'
+  },
+  // 启用的规则及其各自的错误级别
+  /**
+   * 错误级别分为三种：
+   * "off" 或 0 - 关闭规则
+   * "warn" 或 1 - 开启规则，使用警告级别的错误：warn (不会导致程序退出)
+   * "error" 或 2 - 开启规则，使用错误级别的错误：error (当被触发的时候，程序会退出)
+   */
+  rules: {
+    'no-console': process.env.NODE_ENV === 'production' ? 'warn' : 'off',
+    'no-debugger': process.env.NODE_ENV === 'production' ? 'warn' : 'off',
+    'space-before-function-paren': 'off',
+    'semi': 'off',
+    'spaced-comment': 'off',
+    'quotes': 'off',
+    'prefer-const': 'off',
+    'import/first': 'off',
+    'no-unused-vars':'off',
+    "no-tabs":"off",
+    "no-undef":"off",
+    "no-multi-spaces":"off",
+    "no-irregular-whitespace":"off",
+    "no-unreachable":"off",
+    "comma-spacing":"off",
+    "one-var":"off",
+    "no-useless-escape":"off",
+    "vue/no-mutating-props":"off",
+    "quote-props":"off",
+    "vue/require-valid-default-prop":"off",
+    "eqeqeq":"off",
+    "camelcase":"off",
+    "no-redeclare":"off"
+  }
+};

.gitignore

@@ -0,0 +1,22 @@
+.DS_Store
+node_modules
+/dist
+
+# local env files
+.env.local
+.env.*.local
+
+# Log files
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+
+# Editor directories and files
+.idea
+.vscode
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?

.prettierrc

@@ -0,0 +1,6 @@
+{
+  "semi":true,
+  "singleQuote": false,
+  "trailingComma": "none",
+  "spaced-comment":2
+}

babel.config.js

@@ -0,0 +1,8 @@
+module.exports = {
+  presets: [
+    '@vue/cli-plugin-babel/preset'
+  ],
+  plugins: [
+    "@babel/plugin-proposal-optional-chaining"
+  ]
+}

node.js

@@ -0,0 +1,5 @@
+const express = require('express')
+const app = express()
+app.get('/', (req, res) => res.send('Hello World!'))
+app.use(express.static('./www'))
+app.listen(3000, () => console.log('Example app listening on port 3000!'))

package.json

@@ -0,0 +1,72 @@
+{
+  "name": "mosty-admin",
+  "version": "0.1.0",
+  "private": true,
+  "scripts": {
+    "dev": "vue-cli-service serve",
+    "build": "vue-cli-service build",
+    "build:test": "vue-cli-service build --mode test",
+    "lint": "vue-cli-service lint"
+  },
+  "dependencies": {
+    "@fullcalendar/core": "^5.9.0",
+    "@fullcalendar/daygrid": "^5.9.0",
+    "@fullcalendar/interaction": "^5.9.0",
+    "@fullcalendar/list": "^5.9.0",
+    "@fullcalendar/timegrid": "^5.9.0",
+    "@fullcalendar/vue3": "^5.9.0",
+    "@types/video.js": "^7.3.42",
+    "axios": "^0.26.0",
+    "core-js": "^3.6.5",
+    "echarts": "^5.3.3",
+    "echarts-gl": "^2.0.9",
+    "element-plus": "2.0.2",
+    "gifler": "^0.1.0",
+    "lodash": "^4.17.21",
+    "mitt": "^3.0.0",
+    "ol": "^6.14.1",
+    "pinia": "^3.0.1",
+    "vue": "^3.2.8",
+    "vue-router": "^4.0.11",
+    "vuex": "^4.0.2",
+    "xlsx": "^0.18.5"
+  },
+  "devDependencies": {
+    "@element-plus/icons": "^0.0.11",
+    "@toast-ui/editor": "^3.0.2",
+    "@vue/cli-plugin-babel": "~4.5.0",
+    "@vue/cli-plugin-eslint": "~4.5.0",
+    "@vue/cli-plugin-router": "~4.5.0",
+    "@vue/cli-plugin-vuex": "~4.5.0",
+    "@vue/cli-service": "~4.5.0",
+    "@vue/compiler-sfc": "^3.0.0",
+    "@vue/eslint-config-standard": "^5.1.2",
+    "babel-eslint": "^10.1.0",
+    "base-64": "^1.0.0",
+    "css-color-function": "^1.3.3",
+    "default-passive-events": "^2.0.0",
+    "eslint": "^6.7.2",
+    "eslint-plugin-import": "^2.20.2",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-promise": "^4.2.1",
+    "eslint-plugin-standard": "^4.0.0",
+    "eslint-plugin-vue": "^7.0.0",
+    "express": "^4.17.3",
+    "fuse.js": "^6.4.6",
+    "lint-staged": "^9.5.0",
+    "rgb-hex": "^4.0.0",
+    "sass": "^1.26.5",
+    "sass-loader": "^8.0.2",
+    "svg-sprite-loader": "^6.0.9",
+    "vue-cli-plugin-element-plus": "0.0.13"
+  },
+  "gitHooks": {
+    "pre-commit": "lint-staged"
+  },
+  "lint-staged": {
+    "src/**/*.{js,vue}": [
+      "eslint --fix",
+      "git add"
+    ]
+  }
+}

public/Heatmap_min.js

@@ -0,0 +1,738 @@
+(function(b, c, a) {
+	c[b] = a()
+})("h337", this, function() {
+	var c = {
+		defaultRadius: 40,
+		defaultRenderer: "canvas2d",
+		defaultGradient: {
+			0.35: "rgb(0,0,255)",
+			0.45: "rgb(0,255,255)",
+			0.75: "rgb(0,255,0)",
+			0.85: "yellow",
+			1: "rgb(255,0,0)"
+		},
+		defaultMaxOpacity: 1,
+		defaultMinOpacity: 0,
+		defaultBlur: 0.85,
+		defaultXField: "x",
+		defaultYField: "y",
+		defaultValueField: "value",
+		plugins: {}
+	};
+	var g = (function l() {
+		var n = function n(o) {
+			this._coordinator = {};
+			this._data = [];
+			this._radi = [];
+			this._min = 0;
+			this._max = 1;
+			this._xField = o.xField || o.defaultXField;
+			this._yField = o.yField || o.defaultYField;
+			this._valueField = o.valueField || o.defaultValueField;
+			if (o.radius) {
+				this._cfgRadius = o.radius
+			}
+		};
+		var m = c.defaultRadius;
+		n.prototype = {
+			_organiseData: function(o, q) {
+				var u = o[this._xField];
+				var s = o[this._yField];
+				var z = this._radi;
+				var w = this._data;
+				var t = this._max;
+				var p = this._min;
+				var v = o[this._valueField] || 1;
+				var r = o.radius || this._cfgRadius || m;
+				if (!w[u]) {
+					w[u] = [];
+					z[u] = []
+				}
+				if (!w[u][s]) {
+					w[u][s] = v;
+					z[u][s] = r
+				} else {
+					w[u][s] += v
+				}
+				if (w[u][s] > t) {
+					if (!q) {
+						this._max = w[u][s]
+					} else {
+						this.setDataMax(w[u][s])
+					}
+					return false
+				} else {
+					return {
+						x: u,
+						y: s,
+						value: v,
+						radius: r,
+						min: p,
+						max: t
+					}
+				}
+			},
+			_unOrganizeData: function() {
+				var r = [];
+				var q = this._data;
+				var p = this._radi;
+				for (var o in q) {
+					for (var s in q[o]) {
+						r.push({
+							x: o,
+							y: s,
+							radius: p[o][s],
+							value: q[o][s]
+						})
+					}
+				}
+				return {
+					min: this._min,
+					max: this._max,
+					data: r
+				}
+			},
+			_onExtremaChange: function() {
+				this._coordinator.emit("extremachange", {
+					min: this._min,
+					max: this._max
+				})
+			},
+			addData: function() {
+				if (arguments[0].length > 0) {
+					var p = arguments[0];
+					var o = p.length;
+					while (o--) {
+						this.addData.call(this, p[o])
+					}
+				} else {
+					var q = this._organiseData(arguments[0], true);
+					if (q) {
+						this._coordinator.emit("renderpartial", {
+							min: this._min,
+							max: this._max,
+							data: [q]
+						})
+					}
+				}
+				return this
+			},
+			setData: function(q) {
+				var p = q.data;
+				var r = p.length;
+				this._data = [];
+				this._radi = [];
+				for (var o = 0; o < r; o++) {
+					this._organiseData(p[o], false)
+				}
+				this._max = q.max;
+				this._min = q.min || 0;
+				this._onExtremaChange();
+				this._coordinator.emit("renderall", this._getInternalData());
+				return this
+			},
+			removeData: function() {},
+			setDataMax: function(o) {
+				this._max = o;
+				this._onExtremaChange();
+				this._coordinator.emit("renderall", this._getInternalData());
+				return this
+			},
+			setDataMin: function(o) {
+				this._min = o;
+				this._onExtremaChange();
+				this._coordinator.emit("renderall", this._getInternalData());
+				return this
+			},
+			setCoordinator: function(o) {
+				this._coordinator = o
+			},
+			_getInternalData: function() {
+				return {
+					max: this._max,
+					min: this._min,
+					data: this._data,
+					radi: this._radi
+				}
+			},
+			getData: function() {
+				return this._unOrganizeData()
+			}
+		};
+		return n
+	})();
+	var h = (function j() {
+		var p = function(q) {
+			var s = q.gradient || q.defaultGradient;
+			var v = document.createElement("canvas");
+			var u = v.getContext("2d");
+			v.width = 256;
+			v.height = 1;
+			var t = u.createLinearGradient(0, 0, 256, 1);
+			for (var r in s) {
+				t.addColorStop(r, s[r])
+			}
+			u.fillStyle = t;
+			u.fillRect(0, 0, 256, 1);
+			return u.getImageData(0, 0, 256, 1).data
+		};
+		var o = function(s, t) {
+			var v = document.createElement("canvas");
+			var r = v.getContext("2d");
+			var q = s;
+			var w = s;
+			v.width = v.height = s * 2;
+			if (t == 1) {
+				r.beginPath();
+				r.arc(q, w, s, 0, 2 * Math.PI, false);
+				r.fillStyle = "rgba(0,0,0,1)";
+				r.fill()
+			} else {
+				var u = r.createRadialGradient(q, w, s * t, q, w, s);
+				u.addColorStop(0, "rgba(0,0,0,1)");
+				u.addColorStop(1, "rgba(0,0,0,0)");
+				r.fillStyle = u;
+				r.fillRect(0, 0, 2 * s, 2 * s)
+			}
+			return v
+		};
+		var n = function(u) {
+			var B = [];
+			var t = u.min;
+			var x = u.max;
+			var C = u.radi;
+			var u = u.data;
+			var q = Object.keys(u);
+			var r = q.length;
+			while (r--) {
+				var s = q[r];
+				var y = Object.keys(u[s]);
+				var A = y.length;
+				while (A--) {
+					var w = y[A];
+					var z = u[s][w];
+					var v = C[s][w];
+					B.push({
+						x: s,
+						y: w,
+						value: z,
+						radius: v
+					})
+				}
+			}
+			return {
+				min: t,
+				max: x,
+				data: B
+			}
+		};
+
+		function m(t) {
+			var q = t.element;
+			var u = this.shadowCanvas = document.createElement("canvas");
+			var s = this.canvas = t.canvas || document.createElement("canvas");
+			var r = this._renderBoundaries = [10000, 10000, 0, 0];
+			var v = getComputedStyle(t.element) || {};
+			s.className = "heatmap-canvas";
+			this._width = s.width = u.width = +(v.width.replace(/px/, ""));
+			this._height = s.height = u.height = +(v.height.replace(/px/, ""));
+			this.shadowCtx = u.getContext("2d");
+			this.ctx = s.getContext("2d");
+			s.style.cssText = u.style.cssText = "position:absolute;left:0;top:0;";
+			q.style.position = "relative";
+			q.appendChild(s);
+			this._palette = p(t);
+			this._templates = {};
+			this._setStyles(t)
+		}
+		m.prototype = {
+			renderPartial: function(q) {
+				this._drawAlpha(q);
+				this._colorize()
+			},
+			renderAll: function(q) {
+				this._clear();
+				this._drawAlpha(n(q));
+				this._colorize()
+			},
+			_updateGradient: function(q) {
+				this._palette = p(q)
+			},
+			updateConfig: function(q) {
+				if (q.gradient) {
+					this._updateGradient(q)
+				}
+				this._setStyles(q)
+			},
+			setDimensions: function(r, q) {
+				this._width = r;
+				this._height = q;
+				this.canvas.width = this.shadowCanvas.width = r;
+				this.canvas.height = this.shadowCanvas.height = q
+			},
+			_clear: function() {
+				this.shadowCtx.clearRect(0, 0, this._width, this._height);
+				this.ctx.clearRect(0, 0, this._width, this._height)
+			},
+			_setStyles: function(q) {
+				this._blur = (q.blur == 0) ? 0 : (q.blur || q.defaultBlur);
+				if (q.backgroundColor) {
+					this.canvas.style.backgroundColor = q.backgroundColor
+				}
+				this._opacity = (q.opacity || 0) * 255;
+				this._maxOpacity = (q.maxOpacity || q.defaultMaxOpacity) * 255;
+				this._minOpacity = (q.minOpacity || q.defaultMinOpacity) * 255;
+				this._useGradientOpacity = !!q.useGradientOpacity
+			},
+			_drawAlpha: function(v) {
+				var u = this._min = v.min;
+				var B = this._max = v.max;
+				var v = v.data || [];
+				var s = v.length;
+				var t = 1 - this._blur;
+				while (s--) {
+					var F = v[s];
+					var D = F.x;
+					var A = F.y;
+					var z = F.radius;
+					var E = Math.min(F.value, B);
+					var r = D - z;
+					var q = A - z;
+					var C = this.shadowCtx;
+					var w;
+					if (!this._templates[z]) {
+						this._templates[z] = w = o(z, t)
+					} else {
+						w = this._templates[z]
+					}
+					C.globalAlpha = (E - u) / (B - u);
+					C.drawImage(w, r, q);
+					if (r < this._renderBoundaries[0]) {
+						this._renderBoundaries[0] = r
+					}
+					if (q < this._renderBoundaries[1]) {
+						this._renderBoundaries[1] = q
+					}
+					if (r + 2 * z > this._renderBoundaries[2]) {
+						this._renderBoundaries[2] = r + 2 * z
+					}
+					if (q + 2 * z > this._renderBoundaries[3]) {
+						this._renderBoundaries[3] = q + 2 * z
+					}
+				}
+			},
+			_colorize: function() {
+				var w = this._renderBoundaries[0];
+				var u = this._renderBoundaries[1];
+				var B = this._renderBoundaries[2] - w;
+				var z = this._renderBoundaries[3] - u;
+				var G = this._width;
+				var A = this._height;
+				var r = this._opacity;
+				var I = this._maxOpacity;
+				var C = this._minOpacity;
+				var v = this._useGradientOpacity;
+				if (w < 0) {
+					w = 0
+				}
+				if (u < 0) {
+					u = 0
+				}
+				if (w + B > G) {
+					B = G - w
+				}
+				if (u + z > A) {
+					z = A - u
+				}
+				var J = this.shadowCtx.getImageData(w, u, B, z);
+				var H = J.data;
+				var E = H.length;
+				var F = this._palette;
+				for (var D = 3; D < E; D += 4) {
+					var s = H[D];
+					var t = s * 4;
+					if (!t) {
+						continue
+					}
+					var q;
+					if (r > 0) {
+						q = r
+					} else {
+						if (s < I) {
+							if (s < C) {
+								q = C
+							} else {
+								q = s
+							}
+						} else {
+							q = I
+						}
+					}
+					H[D - 3] = F[t];
+					H[D - 2] = F[t + 1];
+					H[D - 1] = F[t + 2];
+					H[D] = v ? F[t + 3] : q
+				}
+				J.data = H;
+				this.ctx.putImageData(J, w, u);
+				this._renderBoundaries = [1000, 1000, 0, 0]
+			},
+			getValueAt: function(r) {
+				var w;
+				var t = this.shadowCtx;
+				var s = t.getImageData(r.x, r.y, 1, 1);
+				var v = s.data[3];
+				var q = this._max;
+				var u = this._min;
+				w = (Math.abs(q - u) * (v / 255)) >> 0;
+				return w
+			},
+			getDataURL: function() {
+				return this.canvas.toDataURL()
+			}
+		};
+		return m
+	})();
+	var e = (function b() {
+		var m = false;
+		if (c.defaultRenderer === "canvas2d") {
+			m = h
+		}
+		return m
+	})();
+	var i = {
+		merge: function() {
+			var m = {};
+			var n = arguments.length;
+			for (var p = 0; p < n; p++) {
+				var q = arguments[p];
+				for (var o in q) {
+					m[o] = q[o]
+				}
+			}
+			return m
+		}
+	};
+	var f = (function k() {
+		var m = (function o() {
+			function q() {
+				this.cStore = {}
+			}
+			q.prototype = {
+				on: function(s, u, r) {
+					var t = this.cStore;
+					if (!t[s]) {
+						t[s] = []
+					}
+					t[s].push((function(v) {
+						return u.call(r, v)
+					}))
+				},
+				emit: function(u, t) {
+					var w = this.cStore;
+					if (w[u]) {
+						var r = w[u].length;
+						for (var s = 0; s < r; s++) {
+							var v = w[u][s];
+							v(t)
+						}
+					}
+				}
+			};
+			return q
+		})();
+		var p = function(r) {
+			var s = r._renderer;
+			var t = r._coordinator;
+			var q = r._store;
+			t.on("renderpartial", s.renderPartial, s);
+			t.on("renderall", s.renderAll, s);
+			t.on("extremachange", function(u) {
+				r._config.onExtremaChange && r._config.onExtremaChange({
+					min: u.min,
+					max: u.max,
+					gradient: r._config.gradient || r._config.defaultGradient
+				})
+			});
+			q.setCoordinator(t)
+		};
+
+		function n() {
+			var q = this._config = i.merge(c, arguments[0] || {});
+			this._coordinator = new m();
+			if (q.plugin) {
+				var s = q.plugin;
+				if (!c.plugins[s]) {
+					throw new Error("Plugin '" + s + "' not found. Maybe it was not registered.")
+				} else {
+					var r = c.plugins[s];
+					this._renderer = new r.renderer(q);
+					this._store = new r.store(q)
+				}
+			} else {
+				this._renderer = new e(q);
+				this._store = new g(q)
+			}
+			p(this)
+		}
+		n.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(q) {
+				this._config = i.merge(this._config, q);
+				this._renderer.updateConfig(this._config);
+				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(q) {
+				if (this._store.getValueAt) {
+					return this._store.getValueAt(q)
+				} else {
+					if (this._renderer.getValueAt) {
+						return this._renderer.getValueAt(q)
+					} else {
+						return null
+					}
+				}
+			}
+		};
+		return n
+	})();
+	var a = {
+		create: function(m) {
+			return new f(m)
+		},
+		register: function(n, m) {
+			c.plugins[n] = m
+		}
+	};
+	return a
+});
+var BMapLib = window.BMapLib = BMapLib || {};
+(function() {
+	var a = BMapLib.HeatmapOverlay = function(c) {
+		this.conf = c;
+		this.conf.visible = c.visible === undefined ? true : c.visible;
+		this.heatmap = null;
+		this.latlngs = [];
+		this.bounds = null
+	};
+	a.prototype = new BMapGL.Overlay();
+	a.prototype.initialize = function(f) {
+		this._map = f;
+		var c = document.createElement("div");
+		c.style.position = "absolute";
+		c.style.top = 0;
+		c.style.left = 0;
+		c.style.border = 0;
+		c.style.width = this._map.getSize().width + "px";
+		c.style.height = this._map.getSize().height + "px";
+		this.conf.element = c;
+		if (!b()) {
+			return c
+		}
+		f.getPanes().floatPane.appendChild(c);
+		this.conf.valueField = this.conf.valueField || "count";
+		this.heatmap = h337.create(this.conf);
+		var e = this;
+		f.addEventListener("resize", function(h) {
+			var g = h.size;
+			c.style.width = g.width + "px";
+			c.style.height = g.height + "px";
+			e.heatmap._renderer.setDimensions(g.width, g.height);
+			e.draw()
+		});
+		this._div = c;
+		return c
+	};
+	a.prototype.draw = function() {
+		if (!b()) {
+			return
+		}
+		var k = this._map.getBounds();
+		if (k.equals(this.bounds)) {
+			return
+		}
+		this.bounds = k;
+		var j = this._map.pointToOverlayPixel(k.getNorthEast()),
+			p = this._map.pointToOverlayPixel(k.getSouthWest()),
+			c = j.y,
+			i = p.x,
+			l = p.y - j.y,
+			o = j.x - p.x;
+		this.conf.element.style.left = i + "px";
+		this.conf.element.style.top = c + "px";
+		this.conf.element.style.width = o + "px";
+		this.conf.element.style.height = l + "px";
+		if (this.latlngs.length > 0) {
+			this.heatmap.removeData();
+			var n = this.latlngs.length;
+			d = {
+				max: this.heatmap._store.getData().max,
+				data: []
+			};
+			while (n--) {
+				var f = this.latlngs[n].latlng;
+				if (!k.containsPoint(f)) {
+					continue
+				}
+				var g = this._map.pointToOverlayPixel(f),
+					i = this._map.pointToOverlayPixel(k.getSouthWest()).x,
+					c = this._map.pointToOverlayPixel(k.getNorthEast()).y,
+					e = new BMapGL.Pixel(g.x - i, g.y - c);
+				var m = this.pixelTransform(e);
+				d.data.push({
+					x: m.x,
+					y: m.y,
+					count: this.latlngs[n].c
+				})
+			}
+			if (this.conf.radiusChangeByZoom) {
+				this.heatmap._store._cfgRadius = this.conf.radiusChangeByZoom(this._map.getZoom())
+			}
+			this.heatmap.setData(d)
+		}
+	};
+	a.prototype.pixelTransform = function(f) {
+		var c = this.heatmap.width,
+			e = this.heatmap.height;
+		while (f.x < 0) {
+			f.x += c
+		}
+		while (f.x > c) {
+			f.x -= c
+		}
+		while (f.y < 0) {
+			f.y += e
+		}
+		while (f.y > e) {
+			f.y -= e
+		}
+		f.x = (f.x >> 0);
+		f.y = (f.y >> 0);
+		return f
+	};
+	a.prototype.setDataSet = function(j) {
+		this.data = j;
+		if (!b()) {
+			return
+		}
+		var i = this._map.getBounds();
+		var l = {
+			max: j.max,
+			data: []
+		};
+		var m = j.data,
+			k = m.length;
+		this.latlngs = [];
+		this.heatmap.removeData();
+		if (this.conf.radiusChangeByZoom) {
+			this.heatmap._store._cfgRadius = this.conf.radiusChangeByZoom(this._map.getZoom())
+		}
+		while (k--) {
+			var f = new BMapGL.Point(m[k].lng, m[k].lat);
+			this.latlngs.push({
+				latlng: f,
+				c: m[k].count
+			});
+			if (!i.containsPoint(f)) {
+				continue
+			}
+			var g = this._map.pointToOverlayPixel(f),
+				h = this._map.pointToOverlayPixel(i.getSouthWest()).x,
+				c = this._map.pointToOverlayPixel(i.getNorthEast()).y,
+				e = new BMapGL.Pixel(g.x - h, g.y - c);
+			var n = this.pixelTransform(e);
+			l.data.push({
+				x: n.x,
+				y: n.y,
+				count: m[k].count
+			})
+		}
+		this.heatmap.setData(l)
+	};
+	a.prototype.addDataPoint = function(e, g, f) {
+		if (!b()) {
+			return
+		}
+		if (this.data && this.data.data) {
+			this.data.data.push({
+				lng: e,
+				lat: g,
+				count: f
+			})
+		}
+		var h = new BMapGL.Point(e, g),
+			c = this.pixelTransform(this._map.pointToOverlayPixel(h));
+		this.heatmap.store.addDataPoint(c.x, c.y, f);
+		this.latlngs.push({
+			latlng: h,
+			c: f
+		})
+	};
+	a.prototype.toggle = function() {
+		if (!b()) {
+			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"
+		}
+	};
+	a.prototype.setOptions = function(c) {
+		if (!b()) {
+			return
+		}
+		for (var e in c) {
+			if (e == "radius") {
+				this.heatmap._store._cfgRadius = c[e]
+			}
+			if (e == "opacity") {
+				c[e] = c[e] / 100
+			}
+		}
+		this.heatmap.configure(c);
+		if (this.data) {
+			this.setDataSet(this.data)
+		}
+	};
+
+	function b() {
+		var c = document.createElement("canvas");
+		return !!(c.getContext && c.getContext("2d"))
+	}
+})();

public/fonts/Microsoft YaHei/10240-10495.pbf

@@ -0,0 +1,3 @@
+
+
+Microsoft YaHei10240-10495

public/fonts/Microsoft YaHei/10496-10751.pbf

@@ -0,0 +1,3 @@
+
+
+Microsoft YaHei10496-10751

public/fonts/Microsoft YaHei/10752-11007.pbf

@@ -0,0 +1,3 @@
+
+
+Microsoft YaHei10752-11007

public/fonts/Microsoft YaHei/11008-11263.pbf

@@ -0,0 +1,3 @@
+
+
+Microsoft YaHei11008-11263

public/fonts/Microsoft YaHei/11264-11519.pbf

@@ -0,0 +1,3 @@
+
+
+Microsoft YaHei11264-11519

public/fonts/Microsoft YaHei/11520-11775.pbf

@@ -0,0 +1,3 @@
+
+
+Microsoft YaHei11520-11775

public/fonts/Microsoft YaHei/1280-1535.pbf

@@ -0,0 +1,3 @@
+
+
+Microsoft YaHei	1280-1535

public/fonts/Microsoft YaHei/1536-1791.pbf

@@ -0,0 +1,3 @@
+
+
+Microsoft YaHei	1536-1791

public/fonts/Microsoft YaHei/1792-2047.pbf

@@ -0,0 +1,3 @@
+
+
+Microsoft YaHei	1792-2047

public/fonts/Microsoft YaHei/2048-2303.pbf

@@ -0,0 +1,3 @@
+
+
+Microsoft YaHei	2048-2303

public/fonts/Microsoft YaHei/2304-2559.pbf

@@ -0,0 +1,3 @@
+
+
+Microsoft YaHei	2304-2559

public/fonts/Microsoft YaHei/2560-2815.pbf

@@ -0,0 +1,3 @@
+
+
+Microsoft YaHei	2560-2815

public/fonts/Microsoft YaHei/2816-3071.pbf

@@ -0,0 +1,3 @@
+
+
+Microsoft YaHei	2816-3071