up

dist/libs/openlayers/ol3-echarts/1.3.6/ol3Echarts.js

@@ -0,0 +1,681 @@
+/*!
+ * author: FDD <smileFDD@gmail.com> 
+ * ol3-echarts v1.3.6
+ * build-time: 2018-12-22 14:19
+ * LICENSE: MIT
+ * (c) 2017-2018 https://sakitam-fdd.github.io/ol3Echarts
+ */
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('echarts'), require('openlayers')) :
+  typeof define === 'function' && define.amd ? define(['echarts', 'openlayers'], factory) :
+  (global.ol3Echarts = factory(global.echarts,global.ol));
+}(this, (function (echarts,ol) { 'use strict';
+
+  echarts = echarts && echarts.hasOwnProperty('default') ? echarts['default'] : echarts;
+  ol = ol && ol.hasOwnProperty('default') ? ol['default'] : ol;
+
+  var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
+    return typeof obj;
+  } : function (obj) {
+    return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+  };
+
+  var classCallCheck = function (instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+      throw new TypeError("Cannot call a class as a function");
+    }
+  };
+
+  var inherits = function (subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+      throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+    }
+
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+      constructor: {
+        value: subClass,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+    if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
+  };
+
+  var possibleConstructorReturn = function (self, call) {
+    if (!self) {
+      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+
+    return call && (typeof call === "object" || typeof call === "function") ? call : self;
+  };
+
+  var isObject = function isObject(value) {
+    var type = typeof value === 'undefined' ? 'undefined' : _typeof(value);
+    return value !== null && (type === 'object' || type === 'function');
+  };
+
+  var merge = function merge(a, b) {
+    for (var key in b) {
+      if (isObject(b[key]) && isObject(a[key])) {
+        merge(a[key], b[key]);
+      } else {
+        a[key] = b[key];
+      }
+    }
+    return a;
+  };
+
+  var getTarget = function getTarget(selector) {
+    var doc = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : document;
+
+    var dom = function () {
+      var found = void 0;
+      return doc && /^#([\w-]+)$/.test(selector) ? (found = doc.getElementById(RegExp.$1)) ? [found] : [] : Array.prototype.slice.call(/^\.([\w-]+)$/.test(selector) ? doc.getElementsByClassName(RegExp.$1) : /^[\w-]+$/.test(selector) ? doc.getElementsByTagName(selector) : doc.querySelectorAll(selector));
+    }();
+    return dom;
+  };
+
+  var map = function map(obj, cb, context) {
+    if (!(obj && cb)) {
+      return;
+    }
+    if (obj.map && obj.map === Array.prototype.map) {
+      return obj.map(cb, context);
+    } else {
+      var result = [];
+      for (var i = 0, len = obj.length; i < len; i++) {
+        result.push(cb.call(context, obj[i], i, obj));
+      }
+      return result;
+    }
+  };
+
+  var bind = function bind(func, context) {
+    var args = Array.prototype.slice.call(arguments, 2);
+    return function () {
+      return func.apply(context, args.concat(Array.prototype.slice.call(arguments)));
+    };
+  };
+
+  var arrayAdd = function arrayAdd(array, item) {
+    var i = 0;
+    var index = void 0;
+    var length = array.length;
+    for (; i < length; i++) {
+      if (array[i]['seriesIndex'] === item['seriesIndex']) {
+        index = i;
+      }
+    }
+    if (index === undefined) {
+      array.push(item);
+    } else {
+      array[index] = item;
+    }
+    return array;
+  };
+
+  var checkDecoded = function checkDecoded(json) {
+    if (json.UTF8Encoding) {
+      return false;
+    } else {
+      return true;
+    }
+  };
+
+  var decode = function decode(json) {
+    if (checkDecoded(json)) {
+      return json;
+    }
+    var encodeScale = json.UTF8Scale;
+    if (encodeScale == null) {
+      encodeScale = 1024;
+    }
+    var features = json.features;
+    for (var f = 0; f < features.length; f++) {
+      var feature = features[f];
+      var geometry = feature.geometry;
+      var _ref = [geometry.coordinates, geometry.encodeOffsets],
+          coordinates = _ref[0],
+          encodeOffsets = _ref[1];
+
+      for (var c = 0; c < coordinates.length; c++) {
+        var coordinate = coordinates[c];
+        if (geometry.type === 'Polygon') {
+          coordinates[c] = decodePolygon(coordinate, encodeOffsets[c], encodeScale);
+        } else if (geometry.type === 'MultiPolygon') {
+          for (var c2 = 0; c2 < coordinate.length; c2++) {
+            var polygon = coordinate[c2];
+            coordinate[c2] = decodePolygon(polygon, encodeOffsets[c][c2], encodeScale);
+          }
+        }
+      }
+    }
+
+    json.UTF8Encoding = false;
+    return json;
+  };
+
+  var decodePolygon = function decodePolygon(coordinate, encodeOffsets, encodeScale) {
+    var _ref2 = [[], encodeOffsets[0], encodeOffsets[1]],
+        result = _ref2[0],
+        prevX = _ref2[1],
+        prevY = _ref2[2];
+
+    for (var i = 0; i < coordinate.length; i += 2) {
+      var x = coordinate.charCodeAt(i) - 64;
+      var y = coordinate.charCodeAt(i + 1) - 64;
+
+      x = x >> 1 ^ -(x & 1);
+      y = y >> 1 ^ -(y & 1);
+
+      x += prevX;
+      y += prevY;
+      prevX = x;
+      prevY = y;
+
+      result.push([x / encodeScale, y / encodeScale]);
+    }
+    return result;
+  };
+
+  function formatGeoJSON (json) {
+    var geoJson = decode(json);
+    var _features = echarts.util.map(echarts.util.filter(geoJson.features, function (featureObj) {
+      return featureObj.geometry && featureObj.properties && featureObj.geometry.coordinates.length > 0;
+    }), function (featureObj) {
+      var properties = featureObj.properties;
+      var geo = featureObj.geometry;
+      var coordinates = geo.coordinates;
+      var geometries = [];
+      if (geo.type === 'Polygon') {
+        geometries.push(coordinates[0]);
+      }
+      if (geo.type === 'MultiPolygon') {
+        echarts.util.each(coordinates, function (item) {
+          if (item[0]) {
+            geometries.push(item[0]);
+          }
+        });
+      }
+      return {
+        type: 'Feature',
+        geometry: {
+          type: 'Polygon',
+          coordinates: geometries
+        },
+        properties: properties
+      };
+    });
+    return {
+      type: 'FeatureCollection',
+      crs: {},
+      features: _features
+    };
+  }
+
+  var _getCoordinateSystem = function _getCoordinateSystem(map$$1) {
+    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+    var RegisterCoordinateSystem = function RegisterCoordinateSystem() {
+      this._mapOffset = [0, 0];
+      this.dimensions = ['lng', 'lat'];
+      this.projCode_ = this._getProjectionCode();
+    };
+
+    RegisterCoordinateSystem.prototype.dimensions = ['lng', 'lat'];
+
+    RegisterCoordinateSystem.dimensions = RegisterCoordinateSystem.prototype.dimensions;
+
+    RegisterCoordinateSystem.prototype.getZoom = function () {
+      return map$$1.getView().getZoom();
+    };
+
+    RegisterCoordinateSystem.prototype.setZoom = function (zoom) {
+      return map$$1.getView().setZoom(zoom);
+    };
+
+    RegisterCoordinateSystem.prototype.getViewRectAfterRoam = function () {
+      return this.getViewRect().clone();
+    };
+
+    RegisterCoordinateSystem.prototype.setMapOffset = function (mapOffset) {
+      this._mapOffset = mapOffset;
+    };
+
+    RegisterCoordinateSystem.prototype.dataToPoint = function (coords) {
+      if (coords && Array.isArray(coords) && coords.length > 0) {
+        coords = coords.map(function (item) {
+          if (typeof item === 'string') {
+            item = Number(item);
+          }
+          return item;
+        });
+      }
+      var source = options['source'] || 'EPSG:4326';
+      var destination = options['destination'] || this.projCode_;
+      var pixel = map$$1.getPixelFromCoordinate(ol.proj.transform(coords, source, destination));
+      var mapOffset = this._mapOffset;
+      return [pixel[0] - mapOffset[0], pixel[1] - mapOffset[1]];
+    };
+
+    RegisterCoordinateSystem.prototype._getProjectionCode = function () {
+      var code = '';
+      if (map$$1) {
+        code = map$$1.getView() && map$$1.getView().getProjection().getCode();
+      } else {
+        code = 'EPSG:3857';
+      }
+      return code;
+    };
+
+    RegisterCoordinateSystem.prototype.pointToData = function (pixel) {
+      var mapOffset = this._mapOffset;
+      return map$$1.getCoordinateFromPixel([pixel[0] + mapOffset[0], pixel[1] + mapOffset[1]]);
+    };
+
+    RegisterCoordinateSystem.prototype.getViewRect = function () {
+      var size = map$$1.getSize();
+      return new echarts.graphic.BoundingRect(0, 0, size[0], size[1]);
+    };
+
+    RegisterCoordinateSystem.prototype.getRoamTransform = function () {
+      return echarts.matrix.create();
+    };
+
+    RegisterCoordinateSystem.prototype.prepareCustoms = function (data) {
+      var rect = this.getViewRect();
+      return {
+        coordSys: {
+          type: 'openlayers',
+          x: rect.x,
+          y: rect.y,
+          width: rect.width,
+          height: rect.height
+        },
+        api: {
+          coord: bind(this.dataToPoint, this),
+          size: bind(RegisterCoordinateSystem.dataToCoordSize, this)
+        }
+      };
+    };
+
+    RegisterCoordinateSystem.dataToCoordSize = function (dataSize, dataItem) {
+      dataItem = dataItem || [0, 0];
+      return map([0, 1], function (dimIdx) {
+        var val = dataItem[dimIdx];
+        var halfSize = dataSize[dimIdx] / 2;
+        var p1 = [],
+            p2 = [];
+
+        p1[dimIdx] = val - halfSize;
+        p2[dimIdx] = val + halfSize;
+        p1[1 - dimIdx] = p2[1 - dimIdx] = dataItem[1 - dimIdx];
+        return Math.abs(this.dataToPoint(p1)[dimIdx] - this.dataToPoint(p2)[dimIdx]);
+      }, this);
+    };
+
+    RegisterCoordinateSystem.create = function (echartModel, api) {
+      echartModel.eachSeries(function (seriesModel) {
+        if (seriesModel.get('coordinateSystem') === 'openlayers') {
+          seriesModel.coordinateSystem = new RegisterCoordinateSystem(map$$1);
+        }
+      });
+    };
+
+    return RegisterCoordinateSystem;
+  };
+
+  var pie = function pie(options, serie, coordinateSystem) {
+    serie.center = coordinateSystem.dataToPoint(serie.coordinates);
+    return serie;
+  };
+
+  var bar = function bar(options, serie, coordinateSystem) {
+    if (isObject(options.grid) && !Array.isArray(options.grid)) {
+      console.log(options);
+    } else if (Array.isArray(options.grid)) {
+      options.grid = options.grid.map(function (gri, index) {
+        var coorPixel = coordinateSystem.dataToPoint(options.series[index].coordinates);
+        gri.left = coorPixel[0] - parseFloat(gri.width) / 2;
+        gri.top = coorPixel[1] - parseFloat(gri.height) / 2;
+        return gri;
+      });
+    }
+    return serie;
+  };
+
+
+
+  var charts = /*#__PURE__*/Object.freeze({
+    pie: pie,
+    bar: bar
+  });
+
+  var _options = {
+    forcedRerender: false,
+    forcedPrecomposeRerender: false,
+    hideOnZooming: false,
+    hideOnMoving: false,
+    hideOnRotating: false,
+    convertTypes: ['pie', 'line', 'bar']
+  };
+
+  var ol3Echarts = function (_ol$Object) {
+    inherits(ol3Echarts, _ol$Object);
+
+    function ol3Echarts(chartOptions) {
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      var map$$1 = arguments[2];
+      classCallCheck(this, ol3Echarts);
+
+      var _this = possibleConstructorReturn(this, _ol$Object.call(this));
+
+      _this.$options = merge(_options, options);
+
+      _this.$chartOptions = chartOptions;
+
+      _this.$chart = null;
+
+      _this.$Map = null;
+
+      _this._isRegistered = false;
+
+      _this._incremental = [];
+
+      _this._coordinateSystem = null;
+
+      if (map$$1) _this.appendTo(map$$1);
+      return _this;
+    }
+
+    ol3Echarts.prototype.appendTo = function appendTo(map$$1) {
+      if (map$$1 && map$$1 instanceof ol.Map) {
+        this.$Map = map$$1;
+        this.$Map.once('postrender', this.render, this);
+        this.$Map.renderSync();
+        this._unRegisterEvents();
+        this._registerEvents();
+      } else {
+        throw new Error('not map object');
+      }
+    };
+
+    ol3Echarts.prototype.getChartOptions = function getChartOptions() {
+      return this.$chartOptions;
+    };
+
+    ol3Echarts.prototype.setChartOptions = function setChartOptions() {
+      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+      this.$chartOptions = options;
+      this.$Map.once('postrender', this.render, this);
+      this.$Map.renderSync();
+      return this;
+    };
+
+    ol3Echarts.prototype.appendData = function appendData(data) {
+      var save = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+
+      if (data) {
+        if (save) {
+          this._incremental = arrayAdd(this._incremental, {
+            data: data.data,
+            seriesIndex: data.seriesIndex
+          });
+        }
+
+        this.$chart.appendData({
+          data: data.data.copyWithin(),
+          seriesIndex: data.seriesIndex
+        });
+      }
+      return this;
+    };
+
+    ol3Echarts.prototype.clear = function clear() {
+      this._incremental = [];
+      this.$chart.clear();
+    };
+
+    ol3Echarts.prototype.getMap = function getMap() {
+      return this.$Map;
+    };
+
+    ol3Echarts.prototype._isVisible = function _isVisible() {
+      return this.$container && this.$container.style.display === '';
+    };
+
+    ol3Echarts.prototype.show = function show() {
+      if (this.$container) {
+        this.$container.style.display = '';
+      }
+    };
+
+    ol3Echarts.prototype.hide = function hide() {
+      if (this.$container) {
+        this.$container.style.display = 'none';
+      }
+    };
+
+    ol3Echarts.prototype.remove = function remove() {
+      this.$chart.clear();
+      this.$chart.dispose();
+      this._unRegisterEvents();
+      this._incremental = [];
+      delete this.$chart;
+      delete this.$Map;
+      this.$container.parentNode.removeChild(this.$container);
+    };
+
+    ol3Echarts.prototype.showLoading = function showLoading() {
+      if (this.$chart) {
+        this.$chart.showLoading();
+      }
+    };
+
+    ol3Echarts.prototype.hideLoading = function hideLoading() {
+      if (this.$chart) {
+        this.$chart.hideLoading();
+      }
+    };
+
+    ol3Echarts.prototype._createLayerContainer = function _createLayerContainer(map$$1, options) {
+      var viewPort = map$$1.getViewport();
+      var container = this.$container = document.createElement('div');
+      container.style.position = 'absolute';
+      container.style.top = '0px';
+      container.style.left = '0px';
+      container.style.right = '0px';
+      container.style.bottom = '0px';
+      var _target = getTarget(options['target'], viewPort);
+      if (_target && _target[0] && _target[0] instanceof Element) {
+        _target[0].appendChild(container);
+      } else {
+        var _target2 = getTarget('.ol-overlaycontainer', viewPort);
+        if (_target2 && _target2[0] && _target2[0] instanceof Element) {
+          _target2[0].appendChild(container);
+        } else {
+          viewPort.appendChild(container);
+        }
+      }
+    };
+
+    ol3Echarts.prototype._resizeContainer = function _resizeContainer() {
+      var size = this.getMap().getSize();
+      this.$container.style.height = size[1] + 'px';
+      this.$container.style.width = size[0] + 'px';
+    };
+
+    ol3Echarts.prototype._clearAndRedraw = function _clearAndRedraw() {
+      if (!this.$chart || this.$container && this.$container.style.display === 'none') {
+        return;
+      }
+      this.dispatchEvent({
+        type: 'redraw',
+        source: this
+      });
+      if (this.$options.forcedRerender) {
+        this.$chart.clear();
+      }
+      this.$chart.resize();
+      if (this.$chartOptions) {
+        this._registerMap();
+        this.$chart.setOption(this.reConverData(this.$chartOptions), false);
+        if (this._incremental && this._incremental.length > 0) {
+          for (var i = 0; i < this._incremental.length; i++) {
+            this.appendData(this._incremental[i], false);
+          }
+        }
+      }
+    };
+
+    ol3Echarts.prototype.onResize = function onResize() {
+      this._resizeContainer();
+      this._clearAndRedraw();
+      this.dispatchEvent({
+        type: 'change:size',
+        source: this
+      });
+    };
+
+    ol3Echarts.prototype.onZoomEnd = function onZoomEnd() {
+      this.$options['hideOnZooming'] && this.show();
+      this._clearAndRedraw();
+      this.dispatchEvent({
+        type: 'zoomend',
+        source: this
+      });
+    };
+
+    ol3Echarts.prototype.onDragRotateEnd = function onDragRotateEnd() {
+      this.$options['hideOnRotating'] && this.show();
+      this._clearAndRedraw();
+      this.dispatchEvent({
+        type: 'change:rotation',
+        source: this
+      });
+    };
+
+    ol3Echarts.prototype.onMoveStart = function onMoveStart() {
+      this.$options['hideOnMoving'] && this.hide();
+      this.dispatchEvent({
+        type: 'movestart',
+        source: this
+      });
+    };
+
+    ol3Echarts.prototype.onMoveEnd = function onMoveEnd() {
+      this.$options['hideOnMoving'] && this.show();
+      this._clearAndRedraw();
+      this.dispatchEvent({
+        type: 'moveend',
+        source: this
+      });
+    };
+
+    ol3Echarts.prototype.onCenterChange = function onCenterChange(event) {
+      this._clearAndRedraw();
+      this.dispatchEvent({
+        type: 'change:center',
+        source: this
+      });
+    };
+
+    ol3Echarts.prototype._registerEvents = function _registerEvents() {
+      var Map = this.$Map;
+      var view = Map.getView();
+      if (this.$options.forcedPrecomposeRerender) {
+        Map.on('precompose', this.reRender, this);
+      }
+      Map.on('change:size', this.onResize, this);
+      view.on('change:resolution', this.onZoomEnd, this);
+      view.on('change:center', this.onCenterChange, this);
+      view.on('change:rotation', this.onDragRotateEnd, this);
+      Map.on('movestart', this.onMoveStart, this);
+      Map.on('moveend', this.onMoveEnd, this);
+    };
+
+    ol3Echarts.prototype._unRegisterEvents = function _unRegisterEvents() {
+      var Map = this.$Map;
+      var view = Map.getView();
+      Map.un('change:size', this.onResize, this);
+      if (this.$options.forcedPrecomposeRerender) {
+        Map.un('precompose', this.reRender, this);
+      }
+      view.un('change:resolution', this.onZoomEnd, this);
+      view.un('change:center', this.onCenterChange, this);
+      view.un('change:rotation', this.onDragRotateEnd, this);
+      Map.un('movestart', this.onMoveStart, this);
+      Map.un('moveend', this.onMoveEnd, this);
+    };
+
+    ol3Echarts.prototype._registerMap = function _registerMap() {
+      if (!this._isRegistered) {
+        echarts.registerCoordinateSystem('openlayers', _getCoordinateSystem(this.getMap(), this.$options));
+        this._isRegistered = true;
+      }
+      var series = this.$chartOptions.series;
+      if (series && isObject(series)) {
+        for (var i = series.length - 1; i >= 0; i--) {
+          if (!(this.$options.convertTypes.indexOf(series[i]['type']) > -1)) {
+            series[i]['coordinateSystem'] = 'openlayers';
+          }
+          series[i]['animation'] = false;
+        }
+      }
+    };
+
+    ol3Echarts.prototype.reConverData = function reConverData(options) {
+      var series = options['series'];
+      if (series && series.length > 0) {
+        if (!this._coordinateSystem) {
+          var _cs = _getCoordinateSystem(this.getMap(), this.$options);
+          this._coordinateSystem = new _cs();
+        }
+        if (series && isObject(series)) {
+          for (var i = series.length - 1; i >= 0; i--) {
+            if (this.$options.convertTypes.indexOf(series[i]['type']) > -1) {
+              if (series[i] && series[i].hasOwnProperty('coordinates')) {
+                series[i] = charts[series[i]['type']](options, series[i], this._coordinateSystem);
+              }
+            }
+          }
+        }
+      }
+      return options;
+    };
+
+    ol3Echarts.prototype.render = function render() {
+      if (!this.$container) {
+        this._createLayerContainer(this.$Map, this.$options);
+        this._resizeContainer();
+      }
+      if (!this.$chart) {
+        this.$chart = echarts.init(this.$container);
+        if (this.$chartOptions) {
+          this._registerMap();
+          this.$chart.setOption(this.reConverData(this.$chartOptions), false);
+        }
+      } else if (this._isVisible()) {
+        this.$chart.resize();
+        this.reRender();
+      }
+    };
+
+    ol3Echarts.prototype.reRender = function reRender() {
+      this._clearAndRedraw();
+    };
+
+    return ol3Echarts;
+  }(ol.Object);
+
+  ol3Echarts.getTarget = getTarget;
+  ol3Echarts.merge = merge;
+  ol3Echarts.map = map;
+  ol3Echarts.bind = bind;
+  ol3Echarts.formatGeoJSON = formatGeoJSON;
+
+  return ol3Echarts;
+
+})));

dist/libs/openlayers/ol3-echarts/2.0.6/ol3Echarts.js

@@ -0,0 +1,853 @@
+/*!
+ * author: sakitam-fdd <smilefdd@gmail.com> 
+ * ol3-echarts v2.0.5
+ * build-time: 2022-1-6 15:31
+ * LICENSE: MIT
+ * (c) 2017-2022 https://sakitam-fdd.github.io/ol3Echarts
+ */
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('openlayers'), require('echarts')) :
+    typeof define === 'function' && define.amd ? define(['openlayers', 'echarts'], factory) :
+    (global = global || self, global.ol3Echarts = factory(global.ol, global.echarts));
+}(this, function (ol, echarts) { 'use strict';
+
+    ol = ol && ol.hasOwnProperty('default') ? ol['default'] : ol;
+    echarts = echarts && echarts.hasOwnProperty('default') ? echarts['default'] : echarts;
+
+    /*! *****************************************************************************
+    Copyright (c) Microsoft Corporation. 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
+
+    THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+    WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+    MERCHANTABLITY OR NON-INFRINGEMENT.
+
+    See the Apache Version 2.0 License for specific language governing permissions
+    and limitations under the License.
+    ***************************************************************************** */
+    /* global Reflect, Promise */
+
+    var extendStatics = function(d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+
+    function __extends(d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    }
+
+    var isObject = function (value) {
+        var type = typeof value;
+        return value !== null && (type === 'object' || type === 'function');
+    };
+    var merge = function (a, b) {
+        Object.keys(b).forEach(function (key) {
+            if (isObject(b[key]) && isObject(a[key])) {
+                merge(a[key], b[key]);
+            }
+            else {
+                a[key] = b[key];
+            }
+        });
+        return a;
+    };
+    var bind = function (func, context) {
+        var arguments$1 = arguments;
+
+        var args = [];
+        for (var _i = 2; _i < arguments.length; _i++) {
+            args[_i - 2] = arguments$1[_i];
+        }
+        return function () {
+            var arguments$1 = arguments;
+
+            var innerArgs = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                innerArgs[_i] = arguments$1[_i];
+            }
+            return func.apply(context, args.concat(Array.prototype.slice.call(innerArgs)));
+        };
+    };
+    var arrayAdd = function (array, item) {
+        var i = 0;
+        var index;
+        var length = array.length;
+        for (; i < length; i++) {
+            if (array[i].index === item.index) {
+                index = i;
+                break;
+            }
+        }
+        if (index === undefined) {
+            array.push(item);
+        }
+        else {
+            array[index] = item;
+        }
+        return array;
+    };
+    var uuid = function () {
+        function rd(a) {
+            return a ? (a ^ Math.random() * 16 >> a / 4).toString(16)
+                : ([1e7] + -[1e3] + -4e3 + -8e3 + -1e11).replace(/[018]/g, rd);
+        }
+        return rd();
+    };
+    function bindAll(fns, context) {
+        fns.forEach(function (fn) {
+            if (!context[fn]) {
+                return;
+            }
+            context[fn] = context[fn].bind(context);
+        });
+    }
+    function removeNode(node) {
+        return node && node.parentNode ? node.parentNode.removeChild(node) : null;
+    }
+    function mockEvent(type, event) {
+        var e = new MouseEvent(type, {
+            bubbles: true,
+            cancelable: true,
+            button: event.pointerEvent.button,
+            buttons: event.pointerEvent.buttons,
+            clientX: event.pointerEvent.clientX,
+            clientY: event.pointerEvent.clientY,
+            zrX: event.pointerEvent.offsetX,
+            zrY: event.pointerEvent.offsetY,
+            movementX: event.pointerEvent.movementX,
+            movementY: event.pointerEvent.movementY,
+            relatedTarget: event.pointerEvent.relatedTarget,
+            screenX: event.pointerEvent.screenX,
+            screenY: event.pointerEvent.screenY,
+            view: window,
+        });
+        e.zrX = event.pointerEvent.offsetX;
+        e.zrY = event.pointerEvent.offsetY;
+        e.event = e;
+        return e;
+    }
+
+    var checkDecoded = function (json) { return !json.UTF8Encoding; };
+    var decodePolygon = function (coordinate, encodeOffsets, encodeScale) {
+        var result = [];
+        var _a = [encodeOffsets[0], encodeOffsets[1]], prevX = _a[0], prevY = _a[1];
+        for (var i = 0; i < coordinate.length; i += 2) {
+            var x = coordinate.charCodeAt(i) - 64;
+            var y = coordinate.charCodeAt(i + 1) - 64;
+            x = (x >> 1) ^ -(x & 1);
+            y = (y >> 1) ^ -(y & 1);
+            x += prevX;
+            y += prevY;
+            prevX = x;
+            prevY = y;
+            result.push([x / encodeScale, y / encodeScale]);
+        }
+        return result;
+    };
+    var decode = function (json) {
+        if (checkDecoded(json)) {
+            return json;
+        }
+        var encodeScale = json.UTF8Scale;
+        if (encodeScale == null) {
+            encodeScale = 1024;
+        }
+        var features = json.features;
+        for (var f = 0; f < features.length; f++) {
+            var feature = features[f];
+            var geometry = feature.geometry;
+            var _a = [geometry.coordinates, geometry.encodeOffsets], coordinates = _a[0], encodeOffsets = _a[1];
+            for (var c = 0; c < coordinates.length; c++) {
+                var coordinate = coordinates[c];
+                if (geometry.type === 'Polygon') {
+                    coordinates[c] = decodePolygon(coordinate, encodeOffsets[c], encodeScale);
+                }
+                else if (geometry.type === 'MultiPolygon') {
+                    for (var c2 = 0; c2 < coordinate.length; c2++) {
+                        var polygon = coordinate[c2];
+                        coordinate[c2] = decodePolygon(polygon, encodeOffsets[c][c2], encodeScale);
+                    }
+                }
+            }
+        }
+        json.UTF8Encoding = false;
+        return json;
+    };
+    function formatGeoJSON (json) {
+        var geoJson = decode(json);
+        var _features = echarts.util.map(echarts.util.filter(geoJson.features, function (featureObj) {
+            return featureObj.geometry && featureObj.properties && featureObj.geometry.coordinates.length > 0;
+        }), function (featureObj) {
+            var properties = featureObj.properties;
+            var geo = featureObj.geometry;
+            var coordinates = geo.coordinates;
+            var geometries = [];
+            if (geo.type === 'Polygon') {
+                geometries.push(coordinates[0]);
+            }
+            if (geo.type === 'MultiPolygon') {
+                echarts.util.each(coordinates, function (item) {
+                    if (item[0]) {
+                        geometries.push(item[0]);
+                    }
+                });
+            }
+            return {
+                properties: properties,
+                type: 'Feature',
+                geometry: {
+                    type: 'Polygon',
+                    coordinates: geometries,
+                },
+            };
+        });
+        return {
+            type: 'FeatureCollection',
+            crs: {},
+            features: _features,
+        };
+    }
+
+    var pie = function (_options, serie, coordinateSystem) {
+        serie.center = coordinateSystem.dataToPoint(serie.coordinates);
+        return serie;
+    };
+
+    var bar = function (options, serie, coordinateSystem) {
+        if (isObject(options.grid) && !Array.isArray(options.grid)) {
+            console.log(options);
+        }
+        else if (Array.isArray(options.grid)) {
+            options.grid = options.grid.map(function (gri, index) {
+                var coorPixel = coordinateSystem.dataToPoint(options.series[index].coordinates);
+                gri.left = coorPixel[0] - parseFloat(gri.width) / 2;
+                gri.top = coorPixel[1] - parseFloat(gri.height) / 2;
+                return gri;
+            });
+        }
+        return serie;
+    };
+
+    var line = function (options, serie, coordinateSystem) {
+        if (isObject(options.grid) && !Array.isArray(options.grid)) {
+            console.log(options);
+        }
+        else if (Array.isArray(options.grid)) {
+            options.grid = options.grid.map(function (gri, index) {
+                var coorPixel = coordinateSystem.dataToPoint(options.series[index].coordinates);
+                gri.left = coorPixel[0] - parseFloat(gri.width) / 2;
+                gri.top = coorPixel[1] - parseFloat(gri.height) / 2;
+                return gri;
+            });
+        }
+        return serie;
+    };
+
+
+
+    var charts = /*#__PURE__*/Object.freeze({
+        pie: pie,
+        bar: bar,
+        line: line
+    });
+
+    var Map = ol.Map;
+    var obj = ol.Object;
+    var transform = ol.proj.transform;
+    if (!Map.prototype.getOverlayContainer) {
+        Map.prototype.getOverlayContainer = function (className) {
+            className = className || 'ol-overlaycontainer';
+            var viewport = this.getViewport();
+            if (viewport) {
+                var overlays = viewport.getElementsByClassName(className);
+                return overlays && overlays.length > 0 ? overlays[0] : null;
+            }
+            return null;
+        };
+    }
+    if (!Map.prototype.getOverlayContainerStopEvent) {
+        Map.prototype.getOverlayContainerStopEvent = function (className) {
+            className = className || 'ol-overlaycontainer-stopevent';
+            var viewport = this.getViewport();
+            if (viewport) {
+                var overlays = viewport.getElementsByClassName(className);
+                return overlays && overlays.length > 0 ? overlays[0] : null;
+            }
+            return null;
+        };
+    }
+    var _options = {
+        forcedRerender: false,
+        forcedPrecomposeRerender: false,
+        hideOnZooming: false,
+        hideOnMoving: false,
+        hideOnRotating: false,
+        convertTypes: ['pie', 'line', 'bar'],
+        insertFirst: false,
+        stopEvent: false,
+        polyfillEvents: false,
+    };
+    var EChartsLayer = (function (_super) {
+        __extends(EChartsLayer, _super);
+        function EChartsLayer(chartOptions, options, map) {
+            var _this = this;
+            var opts = Object.assign(_options, options);
+            _this = _super.call(this, opts) || this;
+            _this._options = opts;
+            _this._chartOptions = chartOptions;
+            _this.set('chartOptions', chartOptions);
+            _this.$chart = null;
+            _this.$container = undefined;
+            _this._isRegistered = false;
+            _this._initEvent = false;
+            _this._incremental = [];
+            _this._coordinateSystem = null;
+            _this.coordinateSystemId = '';
+            _this.prevVisibleState = '';
+            bindAll([
+                'redraw', 'onResize', 'onZoomEnd', 'onCenterChange',
+                'onDragRotateEnd', 'onMoveStart', 'onMoveEnd',
+                'mouseDown', 'mouseUp', 'onClick', 'mouseMove' ], _this);
+            if (map)
+                { _this.setMap(map); }
+            return _this;
+        }
+        EChartsLayer.prototype.appendTo = function (map, forceIgnore) {
+            if (forceIgnore === void 0) { forceIgnore = false; }
+            this.setMap(map, forceIgnore);
+        };
+        EChartsLayer.prototype.getMap = function () {
+            return this._map;
+        };
+        EChartsLayer.prototype.setMap = function (map, forceIgnore) {
+            var _this = this;
+            if (forceIgnore === void 0) { forceIgnore = false; }
+            if (map && (forceIgnore || map instanceof Map)) {
+                this._map = map;
+                this._map.once('postrender', function () {
+                    _this.handleMapChanged();
+                });
+                this._map.renderSync();
+            }
+            else {
+                throw new Error('not ol map object');
+            }
+        };
+        EChartsLayer.prototype.getChartOptions = function () {
+            return this.get('chartOptions');
+        };
+        EChartsLayer.prototype.setChartOptions = function (options) {
+            if (options === void 0) { options = {}; }
+            this._chartOptions = options;
+            this.set('chartOptions', options);
+            this.clearAndRedraw();
+            return this;
+        };
+        EChartsLayer.prototype.appendData = function (data, save) {
+            if (save === void 0) { save = true; }
+            if (data) {
+                if (save) {
+                    this._incremental = arrayAdd(this._incremental, {
+                        index: this._incremental.length,
+                        data: data.data,
+                        seriesIndex: data.seriesIndex,
+                    });
+                }
+                this.$chart.appendData({
+                    data: data.data.copyWithin(),
+                    seriesIndex: data.seriesIndex,
+                });
+            }
+            return this;
+        };
+        EChartsLayer.prototype.clear = function (keep) {
+            if (!keep) {
+                this._incremental = [];
+            }
+            if (this.$chart) {
+                this.$chart.clear();
+            }
+        };
+        EChartsLayer.prototype.remove = function () {
+            this.clear();
+            if (this.$chart) {
+                this.$chart.dispose();
+            }
+            if (this._initEvent && this.$container) {
+                this.$container && removeNode(this.$container);
+                this.unBindEvent();
+            }
+            delete this.$chart;
+            delete this._map;
+        };
+        EChartsLayer.prototype.show = function () {
+            this.setVisible(true);
+        };
+        EChartsLayer.prototype.innerShow = function () {
+            if (this.$container) {
+                this.$container.style.display = this.prevVisibleState;
+                this.prevVisibleState = '';
+            }
+        };
+        EChartsLayer.prototype.hide = function () {
+            this.setVisible(false);
+        };
+        EChartsLayer.prototype.innerHide = function () {
+            if (this.$container) {
+                this.prevVisibleState = this.$container.style.display;
+                this.$container.style.display = 'none';
+            }
+        };
+        EChartsLayer.prototype.isVisible = function () {
+            return this.$container && this.$container.style.display !== 'none';
+        };
+        EChartsLayer.prototype.showLoading = function () {
+            if (this.$chart) {
+                this.$chart.showLoading();
+            }
+        };
+        EChartsLayer.prototype.hideLoading = function () {
+            if (this.$chart) {
+                this.$chart.hideLoading();
+            }
+        };
+        EChartsLayer.prototype.setZIndex = function (zIndex) {
+            if (this.$container) {
+                if (typeof zIndex === 'number') {
+                    zIndex = String(zIndex);
+                }
+                this.$container.style.zIndex = zIndex;
+            }
+        };
+        EChartsLayer.prototype.getZIndex = function () {
+            return this.$container && this.$container.style.zIndex;
+        };
+        EChartsLayer.prototype.setVisible = function (visible) {
+            if (visible) {
+                if (this.$container) {
+                    this.$container.style.display = '';
+                }
+                this._chartOptions = this.getChartOptions();
+                this.clearAndRedraw();
+            }
+            else {
+                if (this.$container) {
+                    this.$container.style.display = 'none';
+                }
+                this.clear(true);
+                this._chartOptions = {};
+                this.clearAndRedraw();
+            }
+        };
+        EChartsLayer.prototype.render = function () {
+            if (!this.$chart && this.$container) {
+                this.$chart = echarts.init(this.$container);
+                if (this._chartOptions) {
+                    this.registerMap();
+                    this.$chart.setOption(this.convertData(this._chartOptions), false);
+                }
+                this.dispatchEvent({
+                    type: 'load',
+                    source: this,
+                    value: this.$chart,
+                });
+            }
+            else if (this.isVisible()) {
+                this.redraw();
+            }
+        };
+        EChartsLayer.prototype.redraw = function () {
+            this.clearAndRedraw();
+        };
+        EChartsLayer.prototype.updateViewSize = function (size) {
+            if (!this.$container)
+                { return; }
+            this.$container.style.width = size[0] + "px";
+            this.$container.style.height = size[1] + "px";
+            this.$container.setAttribute('width', String(size[0]));
+            this.$container.setAttribute('height', String(size[1]));
+        };
+        EChartsLayer.prototype.onResize = function (event) {
+            var map = this.getMap();
+            if (map) {
+                var size = map.getSize();
+                this.updateViewSize(size);
+                this.clearAndRedraw();
+                if (event) {
+                    this.dispatchEvent({
+                        type: 'change:size',
+                        source: this,
+                        value: size,
+                    });
+                }
+            }
+        };
+        EChartsLayer.prototype.onZoomEnd = function () {
+            this._options.hideOnZooming && this.innerShow();
+            var map = this.getMap();
+            if (map && map.getView()) {
+                this.clearAndRedraw();
+                this.dispatchEvent({
+                    type: 'zoomend',
+                    source: this,
+                    value: map.getView().getZoom(),
+                });
+            }
+        };
+        EChartsLayer.prototype.onDragRotateEnd = function () {
+            this._options.hideOnRotating && this.innerShow();
+            var map = this.getMap();
+            if (map && map.getView()) {
+                this.clearAndRedraw();
+                this.dispatchEvent({
+                    type: 'change:rotation',
+                    source: this,
+                    value: map.getView().getRotation(),
+                });
+            }
+        };
+        EChartsLayer.prototype.onMoveStart = function () {
+            this._options.hideOnMoving && this.innerHide();
+            var map = this.getMap();
+            if (map && map.getView()) {
+                this.dispatchEvent({
+                    type: 'movestart',
+                    source: this,
+                    value: map.getView().getCenter(),
+                });
+            }
+        };
+        EChartsLayer.prototype.onMoveEnd = function () {
+            this._options.hideOnMoving && this.innerShow();
+            var map = this.getMap();
+            if (map && map.getView()) {
+                this.clearAndRedraw();
+                this.dispatchEvent({
+                    type: 'moveend',
+                    source: this,
+                    value: map.getView().getCenter(),
+                });
+            }
+        };
+        EChartsLayer.prototype.onClick = function (event) {
+            if (this.$chart) {
+                this.$chart.getZr().painter.getViewportRoot().dispatchEvent(mockEvent('click', event));
+            }
+        };
+        EChartsLayer.prototype.mouseDown = function (event) {
+            if (this.$chart) {
+                this.$chart.getZr().painter.getViewportRoot().dispatchEvent(mockEvent('mousedown', event));
+            }
+        };
+        EChartsLayer.prototype.mouseUp = function (event) {
+            if (this.$chart) {
+                this.$chart.getZr().painter.getViewportRoot().dispatchEvent(mockEvent('mouseup', event));
+            }
+        };
+        EChartsLayer.prototype.mouseMove = function (event) {
+            if (this.$chart) {
+                var target = event.originalEvent.target;
+                while (target) {
+                    if (target.className === 'ol-overlaycontainer-stopevent') {
+                        this.$chart.getZr().painter.getViewportRoot().dispatchEvent(mockEvent('mousemove', event));
+                        return;
+                    }
+                    target = target.parentElement;
+                }
+            }
+        };
+        EChartsLayer.prototype.onCenterChange = function () {
+            var map = this.getMap();
+            if (map && map.getView()) {
+                this.clearAndRedraw();
+                this.dispatchEvent({
+                    type: 'change:center',
+                    source: this,
+                    value: map.getView().getCenter(),
+                });
+            }
+        };
+        EChartsLayer.prototype.handleMapChanged = function () {
+            var map = this.getMap();
+            if (this._initEvent && this.$container) {
+                this.$container && removeNode(this.$container);
+                this.unBindEvent();
+            }
+            if (!this.$container) {
+                this.createLayerContainer();
+                this.onResize(false);
+            }
+            if (map) {
+                var container = this._options.stopEvent ? map.getOverlayContainerStopEvent() : map.getOverlayContainer();
+                if (this._options.insertFirst) {
+                    container.insertBefore(this.$container, container.childNodes[0] || null);
+                }
+                else {
+                    container.appendChild(this.$container);
+                }
+                this.render();
+                this.bindEvent(map);
+            }
+        };
+        EChartsLayer.prototype.createLayerContainer = function () {
+            this.$container = document.createElement('div');
+            this.$container.style.position = 'absolute';
+            this.$container.style.top = '0px';
+            this.$container.style.left = '0px';
+            this.$container.style.right = '0px';
+            this.$container.style.bottom = '0px';
+        };
+        EChartsLayer.prototype.bindEvent = function (map) {
+            var view = map.getView();
+            if (this._options.forcedPrecomposeRerender) {
+                map.on('precompose', this.redraw);
+            }
+            map.on('change:size', this.onResize);
+            view.on('change:resolution', this.onZoomEnd);
+            view.on('change:center', this.onCenterChange);
+            view.on('change:rotation', this.onDragRotateEnd);
+            map.on('movestart', this.onMoveStart);
+            map.on('moveend', this.onMoveEnd);
+            if (this._options.polyfillEvents) {
+                map.on('pointerdown', this.mouseDown);
+                map.on('pointerup', this.mouseUp);
+                map.on('pointermove', this.mouseMove);
+                map.on('click', this.onClick);
+            }
+            this._initEvent = true;
+        };
+        EChartsLayer.prototype.unBindEvent = function () {
+            var map = this.getMap();
+            if (!map)
+                { return; }
+            var view = map.getView();
+            if (!view)
+                { return; }
+            map.un('precompose', this.redraw);
+            map.un('change:size', this.onResize);
+            view.un('change:resolution', this.onZoomEnd);
+            view.un('change:center', this.onCenterChange);
+            view.un('change:rotation', this.onDragRotateEnd);
+            map.un('movestart', this.onMoveStart);
+            map.un('moveend', this.onMoveEnd);
+            if (this._options.polyfillEvents) {
+                map.un('pointerdown', this.mouseDown);
+                map.un('pointerup', this.mouseUp);
+                map.un('pointermove', this.mouseMove);
+                map.un('click', this.onClick);
+            }
+            this._initEvent = false;
+        };
+        EChartsLayer.prototype.clearAndRedraw = function () {
+            if (!this.$chart || !this.isVisible())
+                { return; }
+            if (this._options.forcedRerender) {
+                this.$chart.clear();
+            }
+            this.$chart.resize();
+            if (this._chartOptions) {
+                this.registerMap();
+                this.$chart.setOption(this.convertData(this._chartOptions), false);
+                if (this._incremental && this._incremental.length > 0) {
+                    for (var i = 0; i < this._incremental.length; i++) {
+                        this.appendData(this._incremental[i], false);
+                    }
+                }
+            }
+            this.dispatchEvent({
+                type: 'redraw',
+                source: this,
+            });
+        };
+        EChartsLayer.prototype.registerMap = function () {
+            if (!this._isRegistered) {
+                this.coordinateSystemId = "openlayers_" + uuid();
+                echarts.registerCoordinateSystem(this.coordinateSystemId, this.getCoordinateSystem(this._options));
+                this._isRegistered = true;
+            }
+            if (this._chartOptions) {
+                var series = this._chartOptions.series;
+                if (series && isObject(series)) {
+                    var convertTypes = this._options.convertTypes;
+                    if (convertTypes) {
+                        for (var i = series.length - 1; i >= 0; i--) {
+                            if (!(convertTypes.indexOf(series[i].type) > -1)) {
+                                series[i].coordinateSystem = this.coordinateSystemId;
+                            }
+                            series[i].animation = false;
+                        }
+                    }
+                }
+            }
+        };
+        EChartsLayer.prototype.convertData = function (options) {
+            var series = options.series;
+            if (series && series.length > 0) {
+                if (!this._coordinateSystem) {
+                    var Rc = this.getCoordinateSystem(this._options);
+                    this._coordinateSystem = new Rc(this.getMap());
+                }
+                if (series && isObject(series)) {
+                    var convertTypes = this._options.convertTypes;
+                    if (convertTypes) {
+                        for (var i = series.length - 1; i >= 0; i--) {
+                            if (convertTypes.indexOf(series[i].type) > -1) {
+                                if (series[i] && series[i].hasOwnProperty('coordinates')) {
+                                    series[i] = charts[series[i].type](options, series[i], this._coordinateSystem);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            return options;
+        };
+        EChartsLayer.prototype.getCoordinateSystem = function (options) {
+            var map = this.getMap();
+            var coordinateSystemId = this.coordinateSystemId;
+            var RegisterCoordinateSystem = function (map) {
+                this.map = map;
+                this._mapOffset = [0, 0];
+                this.dimensions = ['lng', 'lat'];
+                this.projCode = RegisterCoordinateSystem.getProjectionCode(this.map);
+            };
+            RegisterCoordinateSystem.dimensions = RegisterCoordinateSystem.prototype.dimensions || ['lng', 'lat'];
+            RegisterCoordinateSystem.prototype.getZoom = function () {
+                return this.map.getView().getZoom();
+            };
+            RegisterCoordinateSystem.prototype.setZoom = function (zoom) {
+                return this.map.getView().setZoom(zoom);
+            };
+            RegisterCoordinateSystem.prototype.getViewRectAfterRoam = function () {
+                return this.getViewRect().clone();
+            };
+            RegisterCoordinateSystem.prototype.setMapOffset = function (mapOffset) {
+                this._mapOffset = mapOffset;
+            };
+            RegisterCoordinateSystem.prototype.dataToPoint = function (data) {
+                var coords;
+                if (data && Array.isArray(data) && data.length > 0) {
+                    coords = data.map(function (item) {
+                        var res = 0;
+                        if (typeof item === 'string') {
+                            res = Number(item);
+                        }
+                        else {
+                            res = item;
+                        }
+                        return res;
+                    });
+                    var source = (options && options.source) || 'EPSG:4326';
+                    var destination = (options && options.destination) || this.projCode;
+                    var pixel = this.map.getPixelFromCoordinate(transform(coords, source, destination));
+                    var mapOffset = this._mapOffset;
+                    return [pixel[0] - mapOffset[0], pixel[1] - mapOffset[1]];
+                }
+                return [0, 0];
+            };
+            RegisterCoordinateSystem.prototype.pointToData = function (pixel) {
+                var mapOffset = this._mapOffset;
+                return this.map.getCoordinateFromPixel([pixel[0] + mapOffset[0], pixel[1] + mapOffset[1]]);
+            };
+            RegisterCoordinateSystem.prototype.getViewRect = function () {
+                var size = this.map.getSize();
+                return new echarts.graphic.BoundingRect(0, 0, size[0], size[1]);
+            };
+            RegisterCoordinateSystem.prototype.getRoamTransform = function () {
+                return echarts.matrix.create();
+            };
+            RegisterCoordinateSystem.prototype.prepareCustoms = function () {
+                var rect = this.getViewRect();
+                return {
+                    coordSys: {
+                        type: coordinateSystemId,
+                        x: rect.x,
+                        y: rect.y,
+                        width: rect.width,
+                        height: rect.height,
+                    },
+                    api: {
+                        coord: bind(this.dataToPoint, this),
+                        size: bind(RegisterCoordinateSystem.dataToCoordsSize, this),
+                    },
+                };
+            };
+            RegisterCoordinateSystem.create = function (echartsModel) {
+                echartsModel.eachSeries(function (seriesModel) {
+                    if (seriesModel.get('coordinateSystem') === coordinateSystemId) {
+                        seriesModel.coordinateSystem = new RegisterCoordinateSystem(map);
+                    }
+                });
+            };
+            RegisterCoordinateSystem.getProjectionCode = function (map) {
+                var code = '';
+                if (map) {
+                    code = map.getView()
+                        && map
+                            .getView()
+                            .getProjection()
+                            .getCode();
+                }
+                else {
+                    code = 'EPSG:3857';
+                }
+                return code;
+            };
+            RegisterCoordinateSystem.dataToCoordsSize = function (dataSize, dataItem) {
+                var _this = this;
+                if (dataItem === void 0) { dataItem = [0, 0]; }
+                return [0, 1].map(function (dimIdx) {
+                    var val = dataItem[dimIdx];
+                    var p1 = [];
+                    var p2 = [];
+                    var halfSize = dataSize[dimIdx] / 2;
+                    p1[dimIdx] = val - halfSize;
+                    p2[dimIdx] = val + halfSize;
+                    p1[1 - dimIdx] = dataItem[1 - dimIdx];
+                    p2[1 - dimIdx] = dataItem[1 - dimIdx];
+                    var offset = _this.dataToPoint(p1)[dimIdx] - _this.dataToPoint(p2)[dimIdx];
+                    return Math.abs(offset);
+                }, this);
+            };
+            return RegisterCoordinateSystem;
+        };
+        EChartsLayer.prototype.dispatchEvent = function (event) {
+            return _super.prototype.dispatchEvent.call(this, event);
+        };
+        EChartsLayer.prototype.set = function (key, value, optSilent) {
+            return _super.prototype.set.call(this, key, value, optSilent);
+        };
+        EChartsLayer.prototype.get = function (key) {
+            return _super.prototype.get.call(this, key);
+        };
+        EChartsLayer.prototype.unset = function (key, optSilent) {
+            return _super.prototype.unset.call(this, key, optSilent);
+        };
+        EChartsLayer.prototype.on = function (type, listener, optThis) {
+            return _super.prototype.on.call(this, type, listener, optThis);
+        };
+        EChartsLayer.prototype.un = function (type, listener, optThis) {
+            return _super.prototype.un.call(this, type, listener, optThis);
+        };
+        EChartsLayer.formatGeoJSON = formatGeoJSON;
+        EChartsLayer.bind = bind;
+        EChartsLayer.merge = merge;
+        EChartsLayer.uuid = uuid;
+        EChartsLayer.bindAll = bindAll;
+        EChartsLayer.arrayAdd = arrayAdd;
+        EChartsLayer.removeNode = removeNode;
+        EChartsLayer.isObject = isObject;
+        return EChartsLayer;
+    }(obj));
+
+    return EChartsLayer;
+
+}));
+//# sourceMappingURL=ol3Echarts.js.map