office-viewer 0.3.11 → 0.3.13

package/esm/node_modules/echarts/lib/coord/geo/GeoSVGResource.js

@@ -0,0 +1,292 @@
+import { parseSVG, makeViewBoxTransform } from '../../../../zrender/lib/tool/parseSVG.js';
+import Group from '../../../../zrender/lib/graphic/Group.js';
+import Rect from '../../../../zrender/lib/graphic/shape/Rect.js';
+import { createHashMap, assert, each } from '../../../../zrender/lib/core/util.js';
+import BoundingRect from '../../../../zrender/lib/core/BoundingRect.js';
+import { parseXML } from '../../../../zrender/lib/tool/parseXML.js';
+import { GeoSVGRegion } from './Region.js';
+
+/**
+ * "region available" means that: enable users to set attribute `name="xxx"` on those tags
+ * to make it be a region.
+ * 1. region styles and its label styles can be defined in echarts opton:
+ * ```js
+ * geo: {
+ *     regions: [{
+ *         name: 'xxx',
+ *         itemStyle: { ... },
+ *         label: { ... }
+ *     }, {
+ *         ...
+ *     },
+ *     ...]
+ * };
+ * ```
+ * 2. name can be duplicated in different SVG tag. All of the tags with the same name share
+ * a region option. For exampel if there are two <path> representing two lung lobes. They have
+ * no common parents but both of them need to display label "lung" inside.
+ */
+var REGION_AVAILABLE_SVG_TAG_MAP = createHashMap(['rect', 'circle', 'line', 'ellipse', 'polygon', 'polyline', 'path',
+// <text> <tspan> are also enabled because some SVG might paint text itself,
+// but still need to trigger events or tooltip.
+'text', 'tspan',
+// <g> is also enabled because this case: if multiple tags share one name
+// and need label displayed, every tags will display the name, which is not
+// expected. So we can put them into a <g name="xxx">. Thereby only one label
+// displayed and located based on the bounding rect of the <g>.
+'g']);
+var GeoSVGResource = /** @class */function () {
+  function GeoSVGResource(mapName, svg) {
+    this.type = 'geoSVG';
+    // All used graphics. key: hostKey, value: root
+    this._usedGraphicMap = createHashMap();
+    // All unused graphics.
+    this._freedGraphics = [];
+    this._mapName = mapName;
+    // Only perform parse to XML object here, which might be time
+    // consiming for large SVG.
+    // Although convert XML to zrender element is also time consiming,
+    // if we do it here, the clone of zrender elements has to be
+    // required. So we do it once for each geo instance, util real
+    // performance issues call for optimizing it.
+    this._parsedXML = parseXML(svg);
+  }
+  GeoSVGResource.prototype.load = function /* nameMap: NameMap */
+  () {
+    // In the "load" stage, graphic need to be built to
+    // get boundingRect for geo coordinate system.
+    var firstGraphic = this._firstGraphic;
+    // Create the return data structure only when first graphic created.
+    // Because they will be used in geo coordinate system update stage,
+    // and `regions` will be mounted at `geo` coordinate system,
+    // in which there is no "view" info, so that it should better not to
+    // make references to graphic elements.
+    if (!firstGraphic) {
+      firstGraphic = this._firstGraphic = this._buildGraphic(this._parsedXML);
+      this._freedGraphics.push(firstGraphic);
+      this._boundingRect = this._firstGraphic.boundingRect.clone();
+      // PENDING: `nameMap` will not be supported until some real requirement come.
+      // if (nameMap) {
+      //     named = applyNameMap(named, nameMap);
+      // }
+      var _a = createRegions(firstGraphic.named),
+        regions = _a.regions,
+        regionsMap = _a.regionsMap;
+      this._regions = regions;
+      this._regionsMap = regionsMap;
+    }
+    return {
+      boundingRect: this._boundingRect,
+      regions: this._regions,
+      regionsMap: this._regionsMap
+    };
+  };
+  GeoSVGResource.prototype._buildGraphic = function (svgXML) {
+    var result;
+    var rootFromParse;
+    try {
+      result = svgXML && parseSVG(svgXML, {
+        ignoreViewBox: true,
+        ignoreRootClip: true
+      }) || {};
+      rootFromParse = result.root;
+      assert(rootFromParse != null);
+    } catch (e) {
+      throw new Error('Invalid svg format\n' + e.message);
+    }
+    // Note: we keep the covenant that the root has no transform. So always add an extra root.
+    var root = new Group();
+    root.add(rootFromParse);
+    root.isGeoSVGGraphicRoot = true;
+    // [THE_RULE_OF_VIEWPORT_AND_VIEWBOX]
+    //
+    // Consider: `<svg width="..." height="..." viewBox="...">`
+    // - the `width/height` we call it `svgWidth/svgHeight` for short.
+    // - `(0, 0, svgWidth, svgHeight)` defines the viewport of the SVG, or say,
+    //   "viewport boundingRect", or `boundingRect` for short.
+    // - `viewBox` defines the transform from the real content ot the viewport.
+    //   `viewBox` has the same unit as the content of SVG.
+    //   If `viewBox` exists, a transform is defined, so the unit of `svgWidth/svgHeight` become
+    //   different from the content of SVG. Otherwise, they are the same.
+    //
+    // If both `svgWidth/svgHeight/viewBox` are specified in a SVG file, the transform rule will be:
+    // 0. `boundingRect` is `(0, 0, svgWidth, svgHeight)`. Set it to Geo['_rect'] (View['_rect']).
+    // 1. Make a transform from `viewBox` to `boundingRect`.
+    //    Note: only support `preserveAspectRatio 'xMidYMid'` here. That is, this transform will preserve
+    //    the aspect ratio.
+    // 2. Make a transform from boundingRect to Geo['_viewRect'] (View['_viewRect'])
+    //    (`Geo`/`View` will do this job).
+    //    Note: this transform might not preserve aspect radio, which depending on how users specify
+    //    viewRect in echarts option (e.g., `geo.left/top/width/height` will not preserve aspect ratio,
+    //    but `geo.layoutCenter/layoutSize` will preserve aspect ratio).
+    //
+    // If `svgWidth/svgHeight` not specified, we use `viewBox` as the `boundingRect` to make the SVG
+    // layout look good.
+    //
+    // If neither `svgWidth/svgHeight` nor `viewBox` are not specified, we calculate the boundingRect
+    // of the SVG content and use them to make SVG layout look good.
+    var svgWidth = result.width;
+    var svgHeight = result.height;
+    var viewBoxRect = result.viewBoxRect;
+    var boundingRect = this._boundingRect;
+    if (!boundingRect) {
+      var bRectX = void 0;
+      var bRectY = void 0;
+      var bRectWidth = void 0;
+      var bRectHeight = void 0;
+      if (svgWidth != null) {
+        bRectX = 0;
+        bRectWidth = svgWidth;
+      } else if (viewBoxRect) {
+        bRectX = viewBoxRect.x;
+        bRectWidth = viewBoxRect.width;
+      }
+      if (svgHeight != null) {
+        bRectY = 0;
+        bRectHeight = svgHeight;
+      } else if (viewBoxRect) {
+        bRectY = viewBoxRect.y;
+        bRectHeight = viewBoxRect.height;
+      }
+      // If both viewBox and svgWidth/svgHeight not specified,
+      // we have to determine how to layout those element to make them look good.
+      if (bRectX == null || bRectY == null) {
+        var calculatedBoundingRect = rootFromParse.getBoundingRect();
+        if (bRectX == null) {
+          bRectX = calculatedBoundingRect.x;
+          bRectWidth = calculatedBoundingRect.width;
+        }
+        if (bRectY == null) {
+          bRectY = calculatedBoundingRect.y;
+          bRectHeight = calculatedBoundingRect.height;
+        }
+      }
+      boundingRect = this._boundingRect = new BoundingRect(bRectX, bRectY, bRectWidth, bRectHeight);
+    }
+    if (viewBoxRect) {
+      var viewBoxTransform = makeViewBoxTransform(viewBoxRect, boundingRect);
+      // Only support `preserveAspectRatio 'xMidYMid'`
+      rootFromParse.scaleX = rootFromParse.scaleY = viewBoxTransform.scale;
+      rootFromParse.x = viewBoxTransform.x;
+      rootFromParse.y = viewBoxTransform.y;
+    }
+    // SVG needs to clip based on `viewBox`. And some SVG files really rely on this feature.
+    // They do not strictly confine all of the content inside a display rect, but deliberately
+    // use a `viewBox` to define a displayable rect.
+    // PENDING:
+    // The drawback of the `setClipPath` here is: the region label (genereted by echarts) near the
+    // edge might also be clipped, because region labels are put as `textContent` of the SVG path.
+    root.setClipPath(new Rect({
+      shape: boundingRect.plain()
+    }));
+    var named = [];
+    each(result.named, function (namedItem) {
+      if (REGION_AVAILABLE_SVG_TAG_MAP.get(namedItem.svgNodeTagLower) != null) {
+        named.push(namedItem);
+        setSilent(namedItem.el);
+      }
+    });
+    return {
+      root: root,
+      boundingRect: boundingRect,
+      named: named
+    };
+  };
+  /**
+   * Consider:
+   * (1) One graphic element can not be shared by different `geoView` running simultaneously.
+   *     Notice, also need to consider multiple echarts instances share a `mapRecord`.
+   * (2) Converting SVG to graphic elements is time consuming.
+   * (3) In the current architecture, `load` should be called frequently to get boundingRect,
+   *     and it is called without view info.
+   * So we maintain graphic elements in this module, and enables `view` to use/return these
+   * graphics from/to the pool with it's uid.
+   */
+  GeoSVGResource.prototype.useGraphic = function (hostKey /* , nameMap: NameMap */) {
+    var usedRootMap = this._usedGraphicMap;
+    var svgGraphic = usedRootMap.get(hostKey);
+    if (svgGraphic) {
+      return svgGraphic;
+    }
+    svgGraphic = this._freedGraphics.pop()
+    // use the first boundingRect to avoid duplicated boundingRect calculation.
+    || this._buildGraphic(this._parsedXML);
+    usedRootMap.set(hostKey, svgGraphic);
+    // PENDING: `nameMap` will not be supported until some real requirement come.
+    // `nameMap` can only be obtained from echarts option.
+    // The original `named` must not be modified.
+    // if (nameMap) {
+    //     svgGraphic = extend({}, svgGraphic);
+    //     svgGraphic.named = applyNameMap(svgGraphic.named, nameMap);
+    // }
+    return svgGraphic;
+  };
+  GeoSVGResource.prototype.freeGraphic = function (hostKey) {
+    var usedRootMap = this._usedGraphicMap;
+    var svgGraphic = usedRootMap.get(hostKey);
+    if (svgGraphic) {
+      usedRootMap.removeKey(hostKey);
+      this._freedGraphics.push(svgGraphic);
+    }
+  };
+  return GeoSVGResource;
+}();
+function setSilent(el) {
+  // Only named element has silent: false, other elements should
+  // act as background and has no user interaction.
+  el.silent = false;
+  // text|tspan will be converted to group.
+  if (el.isGroup) {
+    el.traverse(function (child) {
+      child.silent = false;
+    });
+  }
+}
+function createRegions(named) {
+  var regions = [];
+  var regionsMap = createHashMap();
+  // Create resions only for the first graphic.
+  each(named, function (namedItem) {
+    // Region has feature to calculate center for tooltip or other features.
+    // If there is a <g name="xxx">, the center should be the center of the
+    // bounding rect of the g.
+    if (namedItem.namedFrom != null) {
+      return;
+    }
+    var region = new GeoSVGRegion(namedItem.name, namedItem.el);
+    // PENDING: if `nameMap` supported, this region can not be mounted on
+    // `this`, but can only be created each time `load()` called.
+    regions.push(region);
+    // PENDING: if multiple tag named with the same name, only one will be
+    // found by `_regionsMap`. `_regionsMap` is used to find a coordinate
+    // by name. We use `region.getCenter()` as the coordinate.
+    regionsMap.set(namedItem.name, region);
+  });
+  return {
+    regions: regions,
+    regionsMap: regionsMap
+  };
+}
+// PENDING: `nameMap` will not be supported until some real requirement come.
+// /**
+//  * Use the alias in geoNameMap.
+//  * The input `named` must not be modified.
+//  */
+// function applyNameMap(
+//     named: GeoSVGGraphicRecord['named'],
+//     nameMap: NameMap
+// ): GeoSVGGraphicRecord['named'] {
+//     const result = [] as GeoSVGGraphicRecord['named'];
+//     for (let i = 0; i < named.length; i++) {
+//         let regionGraphic = named[i];
+//         const name = regionGraphic.name;
+//         if (nameMap && nameMap.hasOwnProperty(name)) {
+//             regionGraphic = extend({}, regionGraphic);
+//             regionGraphic.name = name;
+//         }
+//         result.push(regionGraphic);
+//     }
+//     return result;
+// }
+
+export { GeoSVGResource };

package/esm/node_modules/echarts/lib/coord/geo/Region.js

@@ -0,0 +1,241 @@
+import { __extends } from 'tslib';
+import BoundingRect from '../../../../zrender/lib/core/BoundingRect.js';
+import { applyTransform, min, max } from '../../../../zrender/lib/core/vector.js';
+import { contain } from '../../../../zrender/lib/contain/polygon.js';
+import { identity, mul, invert } from '../../../../zrender/lib/core/matrix.js';
+import { each } from '../../../../zrender/lib/core/util.js';
+
+var TMP_TRANSFORM = [];
+function transformPoints(points, transform) {
+  for (var p = 0; p < points.length; p++) {
+    applyTransform(points[p], points[p], transform);
+  }
+}
+function updateBBoxFromPoints(points, min$1, max$1, projection) {
+  for (var i = 0; i < points.length; i++) {
+    var p = points[i];
+    if (projection) {
+      // projection may return null point.
+      p = projection.project(p);
+    }
+    if (p && isFinite(p[0]) && isFinite(p[1])) {
+      min(min$1, min$1, p);
+      max(max$1, max$1, p);
+    }
+  }
+}
+function centroid(points) {
+  var signedArea = 0;
+  var cx = 0;
+  var cy = 0;
+  var len = points.length;
+  var x0 = points[len - 1][0];
+  var y0 = points[len - 1][1];
+  // Polygon should been closed.
+  for (var i = 0; i < len; i++) {
+    var x1 = points[i][0];
+    var y1 = points[i][1];
+    var a = x0 * y1 - x1 * y0;
+    signedArea += a;
+    cx += (x0 + x1) * a;
+    cy += (y0 + y1) * a;
+    x0 = x1;
+    y0 = y1;
+  }
+  return signedArea ? [cx / signedArea / 3, cy / signedArea / 3, signedArea] : [points[0][0] || 0, points[0][1] || 0];
+}
+var Region = /** @class */function () {
+  function Region(name) {
+    this.name = name;
+  }
+  Region.prototype.setCenter = function (center) {
+    this._center = center;
+  };
+  /**
+   * Get center point in data unit. That is,
+   * for GeoJSONRegion, the unit is lat/lng,
+   * for GeoSVGRegion, the unit is SVG local coord.
+   */
+  Region.prototype.getCenter = function () {
+    var center = this._center;
+    if (!center) {
+      // In most cases there are no need to calculate this center.
+      // So calculate only when called.
+      center = this._center = this.calcCenter();
+    }
+    return center;
+  };
+  return Region;
+}();
+var GeoJSONPolygonGeometry = /** @class */function () {
+  function GeoJSONPolygonGeometry(exterior, interiors) {
+    this.type = 'polygon';
+    this.exterior = exterior;
+    this.interiors = interiors;
+  }
+  return GeoJSONPolygonGeometry;
+}();
+var GeoJSONLineStringGeometry = /** @class */function () {
+  function GeoJSONLineStringGeometry(points) {
+    this.type = 'linestring';
+    this.points = points;
+  }
+  return GeoJSONLineStringGeometry;
+}();
+var GeoJSONRegion = /** @class */function (_super) {
+  __extends(GeoJSONRegion, _super);
+  function GeoJSONRegion(name, geometries, cp) {
+    var _this = _super.call(this, name) || this;
+    _this.type = 'geoJSON';
+    _this.geometries = geometries;
+    _this._center = cp && [cp[0], cp[1]];
+    return _this;
+  }
+  GeoJSONRegion.prototype.calcCenter = function () {
+    var geometries = this.geometries;
+    var largestGeo;
+    var largestGeoSize = 0;
+    for (var i = 0; i < geometries.length; i++) {
+      var geo = geometries[i];
+      var exterior = geo.exterior;
+      // Simple trick to use points count instead of polygon area as region size.
+      // Ignore linestring
+      var size = exterior && exterior.length;
+      if (size > largestGeoSize) {
+        largestGeo = geo;
+        largestGeoSize = size;
+      }
+    }
+    if (largestGeo) {
+      return centroid(largestGeo.exterior);
+    }
+    // from bounding rect by default.
+    var rect = this.getBoundingRect();
+    return [rect.x + rect.width / 2, rect.y + rect.height / 2];
+  };
+  GeoJSONRegion.prototype.getBoundingRect = function (projection) {
+    var rect = this._rect;
+    // Always recalculate if using projection.
+    if (rect && !projection) {
+      return rect;
+    }
+    var min = [Infinity, Infinity];
+    var max = [-Infinity, -Infinity];
+    var geometries = this.geometries;
+    each(geometries, function (geo) {
+      if (geo.type === 'polygon') {
+        // Doesn't consider hole
+        updateBBoxFromPoints(geo.exterior, min, max, projection);
+      } else {
+        each(geo.points, function (points) {
+          updateBBoxFromPoints(points, min, max, projection);
+        });
+      }
+    });
+    // Normalie invalid bounding.
+    if (!(isFinite(min[0]) && isFinite(min[1]) && isFinite(max[0]) && isFinite(max[1]))) {
+      min[0] = min[1] = max[0] = max[1] = 0;
+    }
+    rect = new BoundingRect(min[0], min[1], max[0] - min[0], max[1] - min[1]);
+    if (!projection) {
+      this._rect = rect;
+    }
+    return rect;
+  };
+  GeoJSONRegion.prototype.contain = function (coord) {
+    var rect = this.getBoundingRect();
+    var geometries = this.geometries;
+    if (!rect.contain(coord[0], coord[1])) {
+      return false;
+    }
+    loopGeo: for (var i = 0, len = geometries.length; i < len; i++) {
+      var geo = geometries[i];
+      // Only support polygon.
+      if (geo.type !== 'polygon') {
+        continue;
+      }
+      var exterior = geo.exterior;
+      var interiors = geo.interiors;
+      if (contain(exterior, coord[0], coord[1])) {
+        // Not in the region if point is in the hole.
+        for (var k = 0; k < (interiors ? interiors.length : 0); k++) {
+          if (contain(interiors[k], coord[0], coord[1])) {
+            continue loopGeo;
+          }
+        }
+        return true;
+      }
+    }
+    return false;
+  };
+  /**
+   * Transform the raw coords to target bounding.
+   * @param x
+   * @param y
+   * @param width
+   * @param height
+   */
+  GeoJSONRegion.prototype.transformTo = function (x, y, width, height) {
+    var rect = this.getBoundingRect();
+    var aspect = rect.width / rect.height;
+    if (!width) {
+      width = aspect * height;
+    } else if (!height) {
+      height = width / aspect;
+    }
+    var target = new BoundingRect(x, y, width, height);
+    var transform = rect.calculateTransform(target);
+    var geometries = this.geometries;
+    for (var i = 0; i < geometries.length; i++) {
+      var geo = geometries[i];
+      if (geo.type === 'polygon') {
+        transformPoints(geo.exterior, transform);
+        each(geo.interiors, function (interior) {
+          transformPoints(interior, transform);
+        });
+      } else {
+        each(geo.points, function (points) {
+          transformPoints(points, transform);
+        });
+      }
+    }
+    rect = this._rect;
+    rect.copy(target);
+    // Update center
+    this._center = [rect.x + rect.width / 2, rect.y + rect.height / 2];
+  };
+  GeoJSONRegion.prototype.cloneShallow = function (name) {
+    name == null && (name = this.name);
+    var newRegion = new GeoJSONRegion(name, this.geometries, this._center);
+    newRegion._rect = this._rect;
+    newRegion.transformTo = null; // Simply avoid to be called.
+    return newRegion;
+  };
+  return GeoJSONRegion;
+}(Region);
+var GeoSVGRegion = /** @class */function (_super) {
+  __extends(GeoSVGRegion, _super);
+  function GeoSVGRegion(name, elOnlyForCalculate) {
+    var _this = _super.call(this, name) || this;
+    _this.type = 'geoSVG';
+    _this._elOnlyForCalculate = elOnlyForCalculate;
+    return _this;
+  }
+  GeoSVGRegion.prototype.calcCenter = function () {
+    var el = this._elOnlyForCalculate;
+    var rect = el.getBoundingRect();
+    var center = [rect.x + rect.width / 2, rect.y + rect.height / 2];
+    var mat = identity(TMP_TRANSFORM);
+    var target = el;
+    while (target && !target.isGeoSVGGraphicRoot) {
+      mul(mat, target.getLocalTransform(), mat);
+      target = target.parent;
+    }
+    invert(mat, mat);
+    applyTransform(center, center, mat);
+    return center;
+  };
+  return GeoSVGRegion;
+}(Region);
+
+export { GeoJSONLineStringGeometry, GeoJSONPolygonGeometry, GeoJSONRegion, GeoSVGRegion, Region };

package/esm/node_modules/echarts/lib/coord/geo/fix/diaoyuIsland.js

@@ -0,0 +1,57 @@
+/*
+* Licensed to the Apache Software Foundation (ASF) under one
+* or more contributor license agreements.  See the NOTICE file
+* distributed with this work for additional information
+* regarding copyright ownership.  The ASF licenses this file
+* to you 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.
+*/
+
+
+/**
+ * AUTO-GENERATED FILE. DO NOT MODIFY.
+ */
+
+/*
+* Licensed to the Apache Software Foundation (ASF) under one
+* or more contributor license agreements.  See the NOTICE file
+* distributed with this work for additional information
+* regarding copyright ownership.  The ASF licenses this file
+* to you 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.
+*/
+// Fix for 钓鱼岛
+// let Region = require('../Region');
+// let zrUtil = require('zrender/lib/core/util');
+// let geoCoord = [126, 25];
+var points = [[[123.45165252685547, 25.73527164402261], [123.49731445312499, 25.73527164402261], [123.49731445312499, 25.750734064600884], [123.45165252685547, 25.750734064600884], [123.45165252685547, 25.73527164402261]]];
+function fixDiaoyuIsland(mapType, region) {
+  if (mapType === 'china' && region.name === '台湾') {
+    region.geometries.push({
+      type: 'polygon',
+      exterior: points[0]
+    });
+  }
+}
+
+export { fixDiaoyuIsland as default };

package/esm/node_modules/echarts/lib/coord/geo/fix/nanhai.js

@@ -0,0 +1,32 @@
+import { map } from '../../../../../zrender/lib/core/util.js';
+import { GeoJSONRegion } from '../Region.js';
+
+var geoCoord = [126, 25];
+var nanhaiName = '南海诸岛';
+var points = [[[0, 3.5], [7, 11.2], [15, 11.9], [30, 7], [42, 0.7], [52, 0.7], [56, 7.7], [59, 0.7], [64, 0.7], [64, 0], [5, 0], [0, 3.5]], [[13, 16.1], [19, 14.7], [16, 21.7], [11, 23.1], [13, 16.1]], [[12, 32.2], [14, 38.5], [15, 38.5], [13, 32.2], [12, 32.2]], [[16, 47.6], [12, 53.2], [13, 53.2], [18, 47.6], [16, 47.6]], [[6, 64.4], [8, 70], [9, 70], [8, 64.4], [6, 64.4]], [[23, 82.6], [29, 79.8], [30, 79.8], [25, 82.6], [23, 82.6]], [[37, 70.7], [43, 62.3], [44, 62.3], [39, 70.7], [37, 70.7]], [[48, 51.1], [51, 45.5], [53, 45.5], [50, 51.1], [48, 51.1]], [[51, 35], [51, 28.7], [53, 28.7], [53, 35], [51, 35]], [[52, 22.4], [55, 17.5], [56, 17.5], [53, 22.4], [52, 22.4]], [[58, 12.6], [62, 7], [63, 7], [60, 12.6], [58, 12.6]], [[0, 3.5], [0, 93.1], [64, 93.1], [64, 0], [63, 0], [63, 92.4], [1, 92.4], [1, 3.5], [0, 3.5]]];
+for (var i = 0; i < points.length; i++) {
+  for (var k = 0; k < points[i].length; k++) {
+    points[i][k][0] /= 10.5;
+    points[i][k][1] /= -10.5 / 0.75;
+    points[i][k][0] += geoCoord[0];
+    points[i][k][1] += geoCoord[1];
+  }
+}
+function fixNanhai(mapType, regions) {
+  if (mapType === 'china') {
+    for (var i = 0; i < regions.length; i++) {
+      // Already exists.
+      if (regions[i].name === nanhaiName) {
+        return;
+      }
+    }
+    regions.push(new GeoJSONRegion(nanhaiName, map(points, function (exterior) {
+      return {
+        type: 'polygon',
+        exterior: exterior
+      };
+    }), geoCoord));
+  }
+}
+
+export { fixNanhai as default };

package/esm/node_modules/echarts/lib/coord/geo/fix/textCoord.js

@@ -0,0 +1,64 @@
+/*
+* Licensed to the Apache Software Foundation (ASF) under one
+* or more contributor license agreements.  See the NOTICE file
+* distributed with this work for additional information
+* regarding copyright ownership.  The ASF licenses this file
+* to you 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.
+*/
+
+
+/**
+ * AUTO-GENERATED FILE. DO NOT MODIFY.
+ */
+
+/*
+* Licensed to the Apache Software Foundation (ASF) under one
+* or more contributor license agreements.  See the NOTICE file
+* distributed with this work for additional information
+* regarding copyright ownership.  The ASF licenses this file
+* to you 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.
+*/
+var coordsOffsetMap = {
+  '南海诸岛': [32, 80],
+  // 全国
+  '广东': [0, -10],
+  '香港': [10, 5],
+  '澳门': [-10, 10],
+  // '北京': [-10, 0],
+  '天津': [5, 5]
+};
+function fixTextCoords(mapType, region) {
+  if (mapType === 'china') {
+    var coordFix = coordsOffsetMap[region.name];
+    if (coordFix) {
+      var cp = region.getCenter();
+      cp[0] += coordFix[0] / 10.5;
+      cp[1] += -coordFix[1] / (10.5 / 0.75);
+      region.setCenter(cp);
+    }
+  }
+}
+
+export { fixTextCoords as default };