react-map4d-map 1.2.5 → 1.2.7

package/dist/index.js

@@ -781,19 +781,15 @@ var MFMap = function MFMap(props) {
 
     var createCallback = function createCallback() {
       window[callback.current] = function () {
-        if (mapDomRef.current) {
-          var options = props.options;
-          mapRef.current = new window.map4d.Map(mapDomRef.current, options);
+        var options = props.options;
+        mapRef.current = new window.map4d.Map(mapDomRef.current, options);
 
-          if (props.onMapReady) {
-            props.onMapReady(mapRef.current, id);
-          }
-
-          registerEvent();
-          setMap(mapRef.current);
-        } else {
-          console.error("MFMap: map element is NOT found");
+        if (props.onMapReady) {
+          props.onMapReady(mapRef.current, id);
         }
+
+        registerEvent();
+        setMap(mapRef.current);
       };
     };
 
@@ -836,7 +832,7 @@ var MFMap = function MFMap(props) {
 
       destroy();
     };
-  }, [props.environment, props.version, props.accessKey]);
+  }, [props.environment, props.version, props.accessKey, props.options]);
 
   var registerEvent = function registerEvent() {
     var _mapRef$current2, _mapRef$current3, _mapRef$current4, _mapRef$current5, _mapRef$current6, _mapRef$current7, _mapRef$current8, _mapRef$current9, _mapRef$current10, _mapRef$current11, _mapRef$current12, _mapRef$current13, _mapRef$current14, _mapRef$current15, _mapRef$current16, _mapRef$current17, _mapRef$current18, _mapRef$current19, _mapRef$current20;
@@ -1024,21 +1020,16 @@ var MFMap = function MFMap(props) {
   var newContext = {
     map: map
   };
-
-  var refDiv = function refDiv(r) {
-    mapDomRef.current = r;
-  };
-
-  return React__default.createElement(Map4dContext.Provider, {
-    value: newContext
-  }, React__default.createElement("div", {
+  return React__default.createElement(React.Fragment, null, React__default.createElement("div", {
     style: {
       width: '100%',
       height: '100%',
       display: 'block'
     },
-    ref: refDiv
-  }), props.children);
+    ref: mapDomRef
+  }), React__default.createElement(Map4dContext.Provider, {
+    value: newContext
+  }, props.children));
 };
 
 var MFMarker = function MFMarker(props) {
@@ -1964,6 +1955,1250 @@ var MFTileOverlay = function MFTileOverlay(props) {
   return null;
 };
 
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, descriptor.key, descriptor);
+  }
+}
+
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  Object.defineProperty(Constructor, "prototype", {
+    writable: false
+  });
+  return Constructor;
+}
+
+function _inheritsLoose(subClass, superClass) {
+  subClass.prototype = Object.create(superClass.prototype);
+  subClass.prototype.constructor = subClass;
+
+  _setPrototypeOf(subClass, superClass);
+}
+
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+  return _setPrototypeOf(o, p);
+}
+
+var Vector2 = /*#__PURE__*/function () {
+  function Vector2(x, y) {
+    if (x === void 0) {
+      x = 0.0;
+    }
+
+    if (y === void 0) {
+      y = 0.0;
+    }
+
+    this.x = x;
+    this.y = y;
+  }
+
+  var _proto = Vector2.prototype;
+
+  _proto.clone = function clone() {
+    return new Vector2(this.x, this.y);
+  };
+
+  _proto.normalize = function normalize() {
+    var length = this.length;
+    var x = 0.0;
+    var y = 0.0;
+
+    if (length > 0) {
+      x = this.x / length;
+      y = this.y / length;
+    }
+
+    return new Vector2(x, y);
+  };
+
+  _proto.set = function set(a) {
+    this.x = a.x;
+    this.y = a.y;
+  };
+
+  _proto.invert = function invert() {
+    return new Vector2(-this.x, -this.y);
+  };
+
+  _proto.rotate90 = function rotate90() {
+    return new Vector2(this.y, -this.x);
+  };
+
+  _proto.add = function add(a) {
+    return new Vector2(a.x + this.x, a.y + this.y);
+  };
+
+  _proto.subtract = function subtract(a) {
+    if (!a) {
+      return this.clone();
+    }
+
+    return new Vector2(this.x - a.x, this.y - a.y);
+  };
+
+  _proto.multiply = function multiply(a) {
+    return new Vector2(a * this.x, a * this.y);
+  };
+
+  _proto.rotateBy = function rotateBy(a) {
+    var cos = Math.cos(a * Math.PI / 180);
+    var sin = Math.sin(a * Math.PI / 180);
+    return new Vector2(this.x * cos - this.y * sin, this.x * sin + this.y * cos);
+  };
+
+  _proto.rotateByRadian = function rotateByRadian(a) {
+    var cos = Math.cos(a);
+    var sin = Math.sin(a);
+    return new Vector2(this.x * cos - this.y * sin, this.x * sin + this.y * cos);
+  };
+
+  _proto.cross = function cross(a) {
+    return this.x * a.y - this.y * a.x;
+  };
+
+  _proto.dot = function dot(a) {
+    return a.x * this.x + a.y * this.y;
+  };
+
+  Vector2.perp = function perp(v1, v2) {
+    return new Vector2(v2[1] - v1[1], v1[0] - v2[0]);
+  };
+
+  Vector2.neg = function neg(v) {
+    return new Vector2(-v.x, -v.y);
+  };
+
+  _createClass(Vector2, [{
+    key: "length",
+    get: function get() {
+      return Math.sqrt(this.x * this.x + this.y * this.y);
+    }
+  }, {
+    key: "lengthSq",
+    get: function get() {
+      return this.x * this.x + this.y * this.y;
+    }
+  }]);
+
+  return Vector2;
+}();
+
+var MathUtils = /*#__PURE__*/function () {
+  function MathUtils() {}
+
+  MathUtils.clamp = function clamp(value, min, max) {
+    return value < min ? min : value > max ? max : value;
+  };
+
+  MathUtils.toRadians = function toRadians(angleDegrees) {
+    return angleDegrees * Math.PI / 180.0;
+  };
+
+  MathUtils.distance = function distance(p1, p2) {
+    return Math.sqrt((p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y));
+  };
+
+  MathUtils.findNextPowerOf2 = function findNextPowerOf2(n) {
+    n = n - 1;
+    var lg = Math.log2(n);
+    return 1 << lg + 1;
+  };
+
+  MathUtils.findPreviousPowerOf2 = function findPreviousPowerOf2(n) {
+    return 1 << 31 - Math.clz32(n);
+  };
+
+  return MathUtils;
+}();
+
+var Vector3 = /*#__PURE__*/function () {
+  function Vector3(x, y, z) {
+    if (x === void 0) {
+      x = 0.0;
+    }
+
+    if (y === void 0) {
+      y = 0.0;
+    }
+
+    if (z === void 0) {
+      z = 0.0;
+    }
+
+    this.x = x;
+    this.y = y;
+    this.z = z;
+  }
+
+  var _proto = Vector3.prototype;
+
+  _proto.clone = function clone() {
+    return new Vector3(this.x, this.y, this.z);
+  };
+
+  _proto.buffer = function buffer() {
+    return new Float32Array([this.x, this.y, this.z]);
+  };
+
+  _proto.normalize = function normalize() {
+    var length = this.length;
+    var x = 0.0;
+    var y = 0.0;
+    var z = 0.0;
+
+    if (length > 0) {
+      x = this.x / length;
+      y = this.y / length;
+      z = this.z / length;
+    }
+
+    return new Vector3(x, y, z);
+  };
+
+  _proto.set = function set(a) {
+    this.x = a.x;
+    this.y = a.y;
+    this.z = a.z;
+  };
+
+  _proto.invert = function invert() {
+    return new Vector3(-this.x, -this.y, -this.z);
+  };
+
+  _proto.rotate90 = function rotate90() {
+    return new Vector3(this.y, -this.x, this.z);
+  };
+
+  _proto.add = function add(a) {
+    return new Vector3(a.x + this.x, a.y + this.y, a.z + this.z);
+  };
+
+  _proto.subtract = function subtract(a) {
+    if (!a) {
+      return this.clone();
+    }
+
+    return new Vector3(this.x - a.x, this.y - a.y, this.z - a.z);
+  };
+
+  _proto.multiply = function multiply(a) {
+    return new Vector3(a * this.x, a * this.y, a * this.z);
+  };
+
+  _proto.rotateBy = function rotateBy(a) {
+    var cos = Math.cos(a * Math.PI / 180);
+    var sin = Math.sin(a * Math.PI / 180);
+    return new Vector3(this.x * cos - this.y * sin, this.x * sin + this.y * cos);
+  };
+
+  _proto.cross = function cross(a) {
+    return new Vector3(this.y * a.z - this.z * a.y, this.z * a.x - this.x * a.z, this.x * a.y - this.y * a.x);
+  };
+
+  _proto.dot = function dot(a) {
+    return a.x * this.x + a.y * this.y + a.z * this.z;
+  };
+
+  Vector3.perp = function perp(v1, v2) {
+    return new Vector3(v2[1] - v1[1], v1[0] - v2[0]);
+  };
+
+  Vector3.neg = function neg(v) {
+    return new Vector3(-v.x, -v.y, -v.z);
+  };
+
+  _createClass(Vector3, [{
+    key: "length",
+    get: function get() {
+      return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
+    }
+  }, {
+    key: "lengthSq",
+    get: function get() {
+      return this.x * this.x + this.y * this.y + this.z * this.z;
+    }
+  }]);
+
+  return Vector3;
+}();
+
+var Matrix4 = /*#__PURE__*/function () {
+  function Matrix4(data) {
+    if (data === void 0) {
+      data = new Float32Array([1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0]);
+    }
+
+    this.data = data;
+  }
+
+  var _proto = Matrix4.prototype;
+
+  _proto.setIdentity = function setIdentity(x, y, z) {
+    if (x === void 0) {
+      x = 1.0;
+    }
+
+    if (y === void 0) {
+      y = 1.0;
+    }
+
+    if (z === void 0) {
+      z = 1.0;
+    }
+
+    this.data[0] = x;
+    this.data[1] = 0;
+    this.data[2] = 0;
+    this.data[3] = 0;
+    this.data[4] = 0;
+    this.data[5] = y;
+    this.data[6] = 0;
+    this.data[7] = 0;
+    this.data[8] = 0;
+    this.data[9] = 0;
+    this.data[10] = z;
+    this.data[11] = 0;
+    this.data[12] = 0;
+    this.data[13] = 0;
+    this.data[14] = 0;
+    this.data[15] = 1.0;
+    return this;
+  };
+
+  _proto.copy = function copy(other) {
+    this.data[0] = other.data[0];
+    this.data[1] = other.data[1];
+    this.data[2] = other.data[2];
+    this.data[3] = other.data[3];
+    this.data[4] = other.data[4];
+    this.data[5] = other.data[5];
+    this.data[6] = other.data[6];
+    this.data[7] = other.data[7];
+    this.data[8] = other.data[8];
+    this.data[9] = other.data[9];
+    this.data[10] = other.data[10];
+    this.data[11] = other.data[11];
+    this.data[12] = other.data[12];
+    this.data[13] = other.data[13];
+    this.data[14] = other.data[14];
+    this.data[15] = other.data[15];
+    return this;
+  };
+
+  Matrix4.translate = function translate(x, y, z) {
+    if (z === void 0) {
+      z = 0.0;
+    }
+
+    return new Matrix4(new Float32Array([1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0., 0.0, 0.0, 1.0, 0.0, x, y, z, 1.0]));
+  };
+
+  _proto.translate = function translate(x, y, z) {
+    if (z === void 0) {
+      z = 0.0;
+    }
+
+    this.data[12] += x;
+    this.data[13] += y;
+    this.data[14] += z;
+    return this;
+  };
+
+  Matrix4.rotateX = function rotateX(alpha) {
+    alpha *= Math.PI / 180.0;
+    var sinA = Math.sin(alpha);
+    var cosA = Math.cos(alpha);
+    return new Matrix4(new Float32Array([1.0, 0.0, 0.0, 0.0, 0.0, cosA, sinA, 0.0, 0.0, -sinA, cosA, 0.0, 0.0, 0.0, 0.0, 1.0]));
+  };
+
+  _proto.setRotationX = function setRotationX(alpha) {
+    alpha *= Math.PI / 180.0;
+    var sinA = Math.sin(alpha);
+    var cosA = Math.cos(alpha);
+    this.setIdentity();
+    this.data[5] = cosA;
+    this.data[6] = sinA;
+    this.data[9] = -sinA;
+    this.data[10] = cosA;
+    return this;
+  };
+
+  _proto.rotateX = function rotateX(alpha) {
+    alpha *= Math.PI / 180.0;
+    var sinA = Math.sin(alpha);
+    var cosA = Math.cos(alpha);
+    var r1 = this.data[1];
+    var r2 = this.data[2];
+    this.data[1] = r1 * cosA - r2 * sinA;
+    this.data[2] = r1 * sinA + r2 * cosA;
+    r1 = this.data[5];
+    r2 = this.data[6];
+    this.data[5] = r1 * cosA - r2 * sinA;
+    this.data[6] = r1 * sinA + r2 * cosA;
+    r1 = this.data[9];
+    r2 = this.data[10];
+    this.data[9] = r1 * cosA - r2 * sinA;
+    this.data[10] = r1 * sinA + r2 * cosA;
+    r1 = this.data[13];
+    r2 = this.data[14];
+    this.data[13] = r1 * cosA - r2 * sinA;
+    this.data[14] = r1 * sinA + r2 * cosA;
+    return this;
+  };
+
+  Matrix4.rotateY = function rotateY(alpha) {
+    alpha *= Math.PI / 180.0;
+    var sinA = Math.sin(alpha);
+    var cosA = Math.cos(alpha);
+    return new Matrix4(new Float32Array([cosA, 0.0, sinA, 0.0, 0.0, 1.0, 0.0, 0.0, -sinA, 0.0, cosA, 0.0, 0.0, 0.0, 0.0, 1.0]));
+  };
+
+  _proto.setRotationY = function setRotationY(alpha) {
+    alpha *= Math.PI / 180.0;
+    var sinA = Math.sin(alpha);
+    var cosA = Math.cos(alpha);
+    this.setIdentity();
+    this.data[0] = cosA;
+    this.data[2] = sinA;
+    this.data[8] = -sinA;
+    this.data[10] = cosA;
+    return this;
+  };
+
+  _proto.rotateY = function rotateY(alpha) {
+    alpha *= Math.PI / 180.0;
+    var sinA = Math.sin(alpha);
+    var cosA = Math.cos(alpha);
+    var r0 = this.data[0];
+    var r2 = this.data[2];
+    this.data[0] = r0 * cosA - r2 * sinA;
+    this.data[2] = r0 * sinA + r2 * cosA;
+    r0 = this.data[4];
+    r2 = this.data[6];
+    this.data[4] = r0 * cosA - r2 * sinA;
+    this.data[6] = r0 * sinA + r2 * cosA;
+    r0 = this.data[8];
+    r2 = this.data[10];
+    this.data[8] = r0 * cosA - r2 * sinA;
+    this.data[10] = r0 * sinA + r2 * cosA;
+    r0 = this.data[12];
+    r2 = this.data[14];
+    this.data[12] = r0 * cosA - r2 * sinA;
+    this.data[14] = r0 * sinA + r2 * cosA;
+    return this;
+  };
+
+  Matrix4.rotateZ = function rotateZ(alpha) {
+    alpha *= Math.PI / 180.0;
+    var sinA = Math.sin(alpha);
+    var cosA = Math.cos(alpha);
+    return new Matrix4(new Float32Array([cosA, sinA, 0.0, 0.0, -sinA, cosA, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0]));
+  };
+
+  _proto.setRotationZ = function setRotationZ(alpha) {
+    alpha *= Math.PI / 180.0;
+    var sinA = Math.sin(alpha);
+    var cosA = Math.cos(alpha);
+    this.setIdentity();
+    this.data[0] = cosA;
+    this.data[1] = sinA;
+    this.data[4] = -sinA;
+    this.data[5] = cosA;
+    return this;
+  };
+
+  _proto.rotateZ = function rotateZ(alpha) {
+    alpha *= Math.PI / 180.0;
+    var sinA = Math.sin(alpha);
+    var cosA = Math.cos(alpha);
+    var r0 = this.data[0];
+    var r1 = this.data[1];
+    this.data[0] = r0 * cosA - r1 * sinA;
+    this.data[1] = r0 * sinA + r1 * cosA;
+    r0 = this.data[4];
+    r1 = this.data[5];
+    this.data[4] = r0 * cosA - r1 * sinA;
+    this.data[5] = r0 * sinA + r1 * cosA;
+    r0 = this.data[8];
+    r1 = this.data[9];
+    this.data[8] = r0 * cosA - r1 * sinA;
+    this.data[9] = r0 * sinA + r1 * cosA;
+    r0 = this.data[12];
+    r1 = this.data[13];
+    this.data[12] = r0 * cosA - r1 * sinA;
+    this.data[13] = r0 * sinA + r1 * cosA;
+    return this;
+  };
+
+  _proto.multiply = function multiply(matrix) {
+    var result = new Matrix4(new Float32Array([0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]));
+
+    if (matrix == null) {
+      return result;
+    }
+
+    for (var i = 0; i < 4; ++i) {
+      for (var j = 0; j < 4; ++j) {
+        for (var k = 0; k < 4; ++k) {
+          result.data[i * 4 + k] += this.data[i * 4 + j] * matrix.data[j * 4 + k];
+        }
+      }
+    }
+
+    return result;
+  };
+
+  Matrix4.ortho = function ortho(left, right, bottom, top, near, far) {
+    if (near === void 0) {
+      near = -100.0;
+    }
+
+    if (far === void 0) {
+      far = 100.0;
+    }
+
+    return new Matrix4(new Float32Array([2.0 / (right - left), 0.0, 0.0, 0.0, 0.0, 2.0 / (top - bottom), 0.0, 0.0, 0.0, 0.0, -2.0 / (far - near), 0.0, -(left + right) / (right - left), -(top + bottom) / (top - bottom), -(near + far) / (near - far), 1.0]));
+  };
+
+  _proto.setOrtho = function setOrtho(left, right, bottom, top, near, far) {
+    if (near === void 0) {
+      near = -100.0;
+    }
+
+    if (far === void 0) {
+      far = 100.0;
+    }
+
+    this.data[0] = 2.0 / (right - left);
+    this.data[1] = 0;
+    this.data[2] = 0;
+    this.data[3] = 0;
+    this.data[4] = 0;
+    this.data[5] = 2.0 / (top - bottom);
+    this.data[6] = 0;
+    this.data[7] = 0;
+    this.data[8] = 0;
+    this.data[9] = 0;
+    this.data[10] = -2.0 / (far - near);
+    this.data[11] = -1;
+    this.data[12] = -(left + right) / (right - left);
+    this.data[13] = -(top + bottom) / (top - bottom);
+    this.data[14] = -(near + far) / (near - far);
+    this.data[15] = 1.0;
+    return this;
+  };
+
+  Matrix4.perspective = function perspective(fov, aspect, near, far) {
+    var y = Math.tan(fov / 2.0) * near;
+    var x = y * aspect;
+    return Matrix4.frustum(-x, x, -y, y, near, far);
+  };
+
+  _proto.setPerspective = function setPerspective(fov, aspect, near, far) {
+    var y = Math.tan(fov / 2.0) * near;
+    var x = y * aspect;
+    return this.setFrustum(-x, x, -y, y, near, far);
+  };
+
+  Matrix4.frustum = function frustum(left, right, bottom, top, near, far) {
+    if (near === void 0) {
+      near = -100.0;
+    }
+
+    if (far === void 0) {
+      far = 100.0;
+    }
+
+    return new Matrix4(new Float32Array([2 * near / (right - left), 0, 0, 0, 0, 2 * near / (top - bottom), 0, 0, (right + left) / (right - left), (top + bottom) / (top - bottom), -(far + near) / (far - near), -1, 0, 0, -2 * near * far / (far - near), 0]));
+  };
+
+  _proto.setFrustum = function setFrustum(left, right, bottom, top, near, far) {
+    if (near === void 0) {
+      near = -100.0;
+    }
+
+    if (far === void 0) {
+      far = 100.0;
+    }
+
+    this.data[0] = 2 * near / (right - left);
+    this.data[1] = 0;
+    this.data[2] = 0;
+    this.data[3] = 0;
+    this.data[4] = 0;
+    this.data[5] = 2 * near / (top - bottom);
+    this.data[6] = 0;
+    this.data[7] = 0;
+    this.data[8] = (right + left) / (right - left);
+    this.data[9] = (top + bottom) / (top - bottom);
+    this.data[10] = -(far + near) / (far - near);
+    this.data[11] = -1;
+    this.data[12] = 0;
+    this.data[13] = 0;
+    this.data[14] = -2 * near * far / (far - near);
+    this.data[15] = 0;
+  };
+
+  _proto.transform = function transform(vector, w) {
+    if (w === void 0) {
+      w = 0.0;
+    }
+
+    var x = this.data[0 * 4 + 0] * vector.x + this.data[1 * 4 + 0] * vector.y + this.data[2 * 4 + 0] * vector.z + this.data[3 * 4 + 0] * w;
+    var y = this.data[0 * 4 + 1] * vector.x + this.data[1 * 4 + 1] * vector.y + this.data[2 * 4 + 1] * vector.z + this.data[3 * 4 + 1] * w;
+    var z = this.data[0 * 4 + 2] * vector.x + this.data[1 * 4 + 2] * vector.y + this.data[2 * 4 + 2] * vector.z + this.data[3 * 4 + 2] * w;
+    w = this.data[0 * 4 + 3] * vector.x + this.data[1 * 4 + 3] * vector.y + this.data[2 * 4 + 3] * vector.z + this.data[3 * 4 + 3] * w;
+
+    if (w == 0) {
+      w = 1;
+    }
+
+    return new Vector3(x / w, y / w, z / w);
+  };
+
+  _proto.buffer = function buffer() {
+    return this.data;
+  };
+
+  _proto.inverse = function inverse() {
+    var rows = 4;
+    var cols = 4;
+    var A = this.data.slice();
+    var B = new Float32Array([1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0]);
+
+    for (var c = 0; c < cols; ++c) {
+      var r = c;
+
+      while (r < rows && A[r * 4 + c] == 0) {
+        ++r;
+      }
+
+      if (r == rows || A[r * 4 + c] == 0) {
+        console.log("Cannot calculate inverse, determinant is zero");
+        return this;
+      }
+
+      if (r != c) {
+        var _Ac = A.slice(c * rows, (c + 1) * rows);
+
+        var Ar = A.slice(r * rows, (r + 1) * rows);
+        A.set(Ar, c * rows);
+        A.set(_Ac, r * rows);
+
+        var _Bc = B.slice(c * rows, (c + 1) * rows);
+
+        var Br = B.slice(r * rows, (r + 1) * rows);
+        B.set(Br, c * rows);
+        B.set(_Bc, r * rows);
+      }
+
+      var Ac = A.slice(c * rows, (c + 1) * rows);
+      var Bc = B.slice(c * rows, (c + 1) * rows);
+
+      for (r = 0; r < rows; ++r) {
+        var _Ar = A.slice(r * rows, (r + 1) * rows);
+
+        var _Br = B.slice(r * rows, (r + 1) * rows);
+
+        if (r != c) {
+          if (_Ar[c] != 0) {
+            var f = -_Ar[c] / Ac[c];
+
+            for (var s = c; s < cols; ++s) {
+              _Ar[s] = _Ar[s] + f * Ac[s];
+            }
+
+            A.set(_Ar, r * rows);
+
+            for (var _s = 0; _s < cols; ++_s) {
+              _Br[_s] = _Br[_s] + f * Bc[_s];
+            }
+
+            B.set(_Br, r * rows);
+          }
+        } else {
+          var _f = Ac[c];
+
+          if (_f == 0) {
+            console.log("Cannot calculate inverse, determinant is zero");
+            return this;
+          }
+
+          for (var _s2 = c; _s2 < cols; ++_s2) {
+            _Ar[_s2] = _Ar[_s2] / _f;
+          }
+
+          A.set(_Ar, r * rows);
+
+          for (var _s3 = 0; _s3 < cols; ++_s3) {
+            _Br[_s3] = _Br[_s3] / _f;
+          }
+
+          B.set(_Br, r * rows);
+        }
+      }
+    }
+
+    return new Matrix4(B);
+  };
+
+  _createClass(Matrix4, [{
+    key: "position",
+    get: function get() {
+      return new Vector3(this.data[12], this.data[13], this.data[14]);
+    }
+  }]);
+
+  return Matrix4;
+}();
+
+var Color = /*#__PURE__*/function () {
+  function Color(red, green, blue, alpha) {
+    if (red === void 0) {
+      red = 0.0;
+    }
+
+    if (green === void 0) {
+      green = 0.0;
+    }
+
+    if (blue === void 0) {
+      blue = 0.0;
+    }
+
+    if (alpha === void 0) {
+      alpha = 1.0;
+    }
+
+    this.alpha = alpha;
+    this._buffer = new Float32Array([red, green, blue]);
+  }
+
+  var _proto = Color.prototype;
+
+  _proto.rgbBuffer = function rgbBuffer() {
+    return this._buffer;
+  };
+
+  _proto.buffer = function buffer() {
+    return new Float32Array([this.red, this.green, this.blue, this.alpha]);
+  };
+
+  Color.fromHex = function fromHex(hexString) {
+    if (hexString === void 0) {
+      hexString = "000000";
+    }
+
+    if (hexString.length == 4 || hexString.length == 7 || hexString.length == 9) {
+      hexString = hexString.substring(1, hexString.length);
+    }
+
+    if (hexString.length == 3) {
+      hexString = hexString.split("").map(function (x) {
+        return x + x;
+      }).join("");
+    }
+
+    var colorCode = parseInt(hexString, 16);
+
+    if (hexString.length == 6) {
+      return new Color((colorCode >> 16) / 255, (colorCode >> 8 & 255) / 255, (colorCode & 255) / 255);
+    } else {
+      return new Color((colorCode >> 24 & 255) / 255, (colorCode >> 16 & 255) / 255, (colorCode >> 8 & 255) / 255, (colorCode & 255) / 255);
+    }
+  };
+
+  Color.fromInt = function fromInt(colorCode) {
+    if (colorCode === void 0) {
+      colorCode = 0;
+    }
+
+    if (colorCode < 0) {
+      colorCode = 0;
+    }
+
+    return new Color((colorCode >> 16 & 255) / 255, (colorCode >> 8 & 255) / 255, (colorCode & 255) / 255);
+  };
+
+  Color.fromVec3 = function fromVec3(color) {
+    return new Color(color.x, color.y, color.z);
+  };
+
+  Color.mix = function mix(a, b, factor) {
+    return new Color(a.red * factor + b.red * (1 - factor), a.green * factor + b.green * (1 - factor), a.blue * factor + b.blue * (1 - factor), a.alpha * factor + b.alpha * (1 - factor));
+  };
+
+  Color.isValid = function isValid(colorString) {
+    return /^#?([0-9A-Fa-f]){6,8}$/i.test(colorString);
+  };
+
+  _createClass(Color, [{
+    key: "red",
+    get: function get() {
+      return this._buffer[0];
+    }
+  }, {
+    key: "green",
+    get: function get() {
+      return this._buffer[1];
+    }
+  }, {
+    key: "blue",
+    get: function get() {
+      return this._buffer[2];
+    }
+  }, {
+    key: "rgba",
+    get: function get() {
+      return "rgba(" + this.red * 255 + "," + this.green * 255 + "," + this.blue * 255 + "," + this.alpha + ")";
+    }
+  }, {
+    key: "code",
+    get: function get() {
+      var float2hex = function float2hex(f) {
+        var hex = Math.floor(f * 255).toString(16);
+        hex = hex.length == 1 ? "0" + hex : hex;
+        hex = hex.length > 2 ? hex.substr(0, 2) : hex;
+        return hex;
+      };
+
+      return "#" + float2hex(this.red) + float2hex(this.green) + float2hex(this.blue) + float2hex(this.alpha);
+    }
+  }]);
+
+  return Color;
+}();
+
+var MapConstants = /*#__PURE__*/function () {
+  function MapConstants() {}
+
+  _createClass(MapConstants, null, [{
+    key: "placeFontSize",
+    get: function get() {
+      return 12;
+    }
+  }, {
+    key: "maxTiltIntersectWithScreen",
+    get: function get() {
+      return 90.0 - CameraConstants.fov * MathConstants.rad2Deg;
+    }
+  }]);
+
+  return MapConstants;
+}();
+MapConstants.none = -1.0;
+MapConstants.baseTileSize = 256;
+MapConstants.minLatitude = -85.051128779806604;
+MapConstants.maxLatitude = 85.051128779806604;
+MapConstants.maxLongitude = 180;
+MapConstants.minLongitude = -180;
+MapConstants.maxDegrees = 360;
+MapConstants.radiusEarthMeters = 6378137.0;
+MapConstants.halfEarthCircumFerenceInMeter = MapConstants.radiusEarthMeters * Math.PI;
+MapConstants.earthCircumFerenceInMeter = MapConstants.halfEarthCircumFerenceInMeter * 2;
+MapConstants.tileCacheSize = 512;
+MapConstants.baseMapLowestOrder = Number.MIN_SAFE_INTEGER;
+MapConstants.baseMapMiddleOrder = -1.0E6;
+MapConstants.buildingLayerOrder = 0;
+MapConstants.userPOILayerOrder = 1.0;
+MapConstants.pointGeoJsonWidth = 32;
+MapConstants.pointGeoJsonHeight = 32;
+MapConstants.placeSelectedIdPrefix = "maplink-selected-place-";
+MapConstants.placeWidth = 26;
+MapConstants.placeHeight = 32;
+MapConstants.spritePadding = 2.;
+MapConstants.poiFontWeight = "normal";
+MapConstants.poiMaxWidth = 120;
+MapConstants.poiNumLine = 2;
+MapConstants.poiDefaultColor = new Color(0.5, 0.6, 0.7);
+MapConstants.pointGeoJsonAnchor = [0.5, 1.0];
+MapConstants.infoWindowPadding = 2;
+MapConstants.flingMinVelocity = -10000.0;
+MapConstants.flingMaxVelocity = 10000.0;
+MapConstants.flingTimeConstant = 150.0;
+MapConstants.flingSpeedMultiply = 15;
+MapConstants.zoomSpeedMouseWheel = 15;
+MapConstants.minDurationFlyTo = 1000;
+MapConstants.maxDurationFlyTo = 13000;
+MapConstants.maxBearingAngle = 720;
+MapConstants.defaultMinZoom = 3;
+MapConstants.defaultMinZoom3d = 17;
+MapConstants.defaultMaxZoom = 22;
+MapConstants.defaultMaxNativeZoom = 19;
+MapConstants.geoJsonMinNativeZoom = 20;
+MapConstants.vectorBuildingsMinZoom = 17;
+MapConstants.tileExtend = 4096.0;
+MapConstants.defaultAnimationDuration = 300;
+MapConstants.defaultFlyZoom = 17.0;
+MapConstants.minTilt = 0.0;
+MapConstants.maxTilt2D = 40.0;
+MapConstants.maxTilt3D = 87.0;
+MapConstants.minTiltReduceFog = 75.0;
+MapConstants.minTimeMoving = 150.0;
+MapConstants.minTimeDoubleZoom = 500.0;
+MapConstants.minTimeSpanTo = 500.0;
+MapConstants.maxTimeSpanTo = 4000.0;
+MapConstants.skyboxMapBorderMinimum = 0.001;
+MapConstants.metersPerPixelAtLatitude = 0.0;
+MapConstants.mapBackgroundColor2D = Color.fromHex("#f2efe9");
+MapConstants.mapBackgroundColor3D = Color.fromHex("#e1e1e1");
+MapConstants.satellitePOIColor = new Color(1.0, 1.0, 1.0);
+MapConstants.satellitePOIHalo = new Color(0.0, 0.0, 0.0);
+MapConstants.mapBackgroundScaleRatio = 20000.0;
+MapConstants.clusterMaxPointCount = 1000000;
+MapConstants.biasMatrix = new Matrix4(new Float32Array([0.5, 0.0, 0.0, 0.0, 0.0, 0.5, 0.0, 0.0, 0.0, 0.0, 0.5, 0.0, 0.5, 0.5, 0.5, 1.0]));
+MapConstants.FPS = 1000.0 / 15.0;
+MapConstants.buildingOverlayIdPrefix = "_overlay";
+MapConstants.customBuildingType = "custom_building";
+MapConstants.touchBoxSize = 8.0;
+MapConstants.zoomStep = 0.25;
+MapConstants.distanceRatioToForceMoveCamera = 3.0;
+MapConstants.gridIndexExtent = 4096;
+MapConstants.gridIndexN = 4;
+MapConstants.gridIndexPadding = 0;
+var MathConstants = function MathConstants() {};
+MathConstants.rad2Deg = 180 / Math.PI;
+MathConstants.deg2Rad = Math.PI / 180.0;
+MathConstants.epsilon = 1e-6;
+var CameraConstants = function CameraConstants() {};
+CameraConstants.fov = 30 * MathConstants.deg2Rad;
+CameraConstants.nearPlane = 0.1;
+CameraConstants.farPlane = 1000;
+CameraConstants.height = 15.5;
+var ColorConstants = /*#__PURE__*/function () {
+  function ColorConstants() {}
+
+  ColorConstants.getSkyColor = function getSkyColor(name) {
+    return ColorConstants.skyColors[name];
+  };
+
+  ColorConstants.getFogColor = function getFogColor(name) {
+    return ColorConstants.fogColors[name];
+  };
+
+  ColorConstants.getLightColor = function getLightColor(name) {
+    return ColorConstants.lightColors[name];
+  };
+
+  return ColorConstants;
+}();
+ColorConstants.skyColors = {
+  "Morning": Color.fromHex("cdf9ff"),
+  "Noon": Color.fromHex("0783f4"),
+  "AfterNoon": Color.fromHex("243a8b"),
+  "Evening": Color.fromHex("182863")
+};
+ColorConstants.fogColors = {
+  "Morning": Color.fromHex("FAD8C4"),
+  "Noon": Color.fromHex("FAFAFA"),
+  "AfterNoon": Color.fromHex("FAA899"),
+  "Evening": Color.fromHex("141c36")
+};
+ColorConstants.lightColors = {
+  "Morning": Color.fromHex("#DE8989"),
+  "Noon": Color.fromHex("#F8F8F8"),
+  "AfterNoon": Color.fromHex("#BE321A"),
+  "Evening": Color.fromHex("#1E0032")
+};
+
+var ClassType;
+
+(function (ClassType) {
+  ClassType[ClassType["MARKER"] = 0] = "MARKER";
+  ClassType[ClassType["CIRCLE"] = 1] = "CIRCLE";
+  ClassType[ClassType["POLYLINE"] = 2] = "POLYLINE";
+  ClassType[ClassType["POLYGON"] = 3] = "POLYGON";
+  ClassType[ClassType["POI"] = 4] = "POI";
+  ClassType[ClassType["BUILDING"] = 5] = "BUILDING";
+  ClassType[ClassType["VECTOR_TILE_LAYER"] = 6] = "VECTOR_TILE_LAYER";
+  ClassType[ClassType["BUILDING_QUERY_RESULT"] = 7] = "BUILDING_QUERY_RESULT";
+  ClassType[ClassType["POLYLINE_DATA"] = 8] = "POLYLINE_DATA";
+  ClassType[ClassType["POLYGON_DATA"] = 9] = "POLYGON_DATA";
+  ClassType[ClassType["ICON"] = 10] = "ICON";
+  ClassType[ClassType["LATLNG"] = 11] = "LATLNG";
+  ClassType[ClassType["POINT"] = 12] = "POINT";
+  ClassType[ClassType["CAMERA_POSITION"] = 13] = "CAMERA_POSITION";
+  ClassType[ClassType["LATLNG_BOUNDS"] = 14] = "LATLNG_BOUNDS";
+  ClassType[ClassType["MARKER_LABEL"] = 15] = "MARKER_LABEL";
+  ClassType[ClassType["FEATURE"] = 16] = "FEATURE";
+  ClassType[ClassType["TILE_FEATURE"] = 17] = "TILE_FEATURE";
+  ClassType[ClassType["VECTOR_TILE_FEATURE"] = 18] = "VECTOR_TILE_FEATURE";
+})(ClassType || (ClassType = {}));
+
+var Map4dObject = /*#__PURE__*/function () {
+  function Map4dObject(classType) {
+    this.classType = classType;
+  }
+
+  Map4dObject.isClassType = function isClassType(mapObject, classType) {
+    var mfClassType = (mapObject || {}).classType;
+    return mfClassType == classType;
+  };
+
+  return Map4dObject;
+}();
+
+var LatLng = /*#__PURE__*/function (_Map4dObject) {
+  _inheritsLoose(LatLng, _Map4dObject);
+
+  function LatLng(lat, lng) {
+    var _this;
+
+    _this = _Map4dObject.call(this, ClassType.LATLNG) || this;
+    _this.lat = lat;
+    _this.lng = lng;
+    return _this;
+  }
+
+  var _proto = LatLng.prototype;
+
+  _proto.equals = function equals(other) {
+    return this.lat == other.lat && this.lng == other.lng;
+  };
+
+  _proto.valid = function valid() {
+    return isFinite(this.lat) && Math.abs(this.lat) <= 90;
+  };
+
+  _proto.toString = function toString() {
+    return "(" + this.lat + ", " + this.lng + ")";
+  };
+
+  LatLng.convert = function convert(input) {
+    if (Map4dObject.isClassType(input, ClassType.LATLNG)) {
+      return input;
+    }
+
+    if (Array.isArray(input) && input.length === 2) {
+      return new LatLng(Number(input[1]), Number(input[0]));
+    }
+
+    if (!Array.isArray(input) && typeof input === "object" && input !== null && "lat" in input && "lng" in input) {
+      return new LatLng(Number(input.lat), Number(input.lng));
+    }
+
+    throw new Error("`ILngLat` argument must be specified as a LngLat instance, an object " + "{lat: <lat>, lng: <lng>}, or an array of [<lng>, <lat>]");
+  };
+
+  _proto.distanceTo = function distanceTo(target) {
+    if (target == null) {
+      return 0;
+    }
+
+    var desc = LatLng.convert(target);
+    var latStartRadian = MathConstants.deg2Rad * this.lat;
+    var longStartRadian = MathConstants.deg2Rad * this.lng;
+    var latDescRadian = MathConstants.deg2Rad * desc.lat;
+    var longDescRadian = MathConstants.deg2Rad * desc.lng;
+    var u = Math.sin((latDescRadian - latStartRadian) / 2);
+    var v = Math.sin((longDescRadian - longStartRadian) / 2);
+    return 2.0 * MapConstants.radiusEarthMeters * Math.asin(Math.sqrt(u * u + Math.cos(latStartRadian) * Math.cos(latDescRadian) * v * v));
+  };
+
+  _proto.normalize = function normalize() {
+    var sign = this.lat > 0 ? -1 : 1;
+    var lat = (this.lat - sign * 90) % 180 + 90 * sign;
+    sign = this.lng > 0 ? -1 : 1;
+    var lng = (this.lng - sign * 180) % 380 + 180 * sign;
+    return new LatLng(lat, lng);
+  };
+
+  _proto.add = function add(a) {
+    return new LatLng(this.lat + a.lat, this.lng + a.lng).normalize();
+  };
+
+  _proto.subtract = function subtract(a) {
+    if (!a) {
+      return this;
+    }
+
+    return new LatLng(this.lat - a.lat, this.lng - a.lng).normalize();
+  };
+
+  return LatLng;
+}(Map4dObject);
+
+var ProjectionMercator = /*#__PURE__*/function () {
+  function ProjectionMercator() {}
+
+  ProjectionMercator.projectInternal = function projectInternal(latLng, worldSize) {
+    var latitude = MathUtils.clamp(latLng.lat, MapConstants.minLatitude, MapConstants.maxLatitude);
+    return new Vector2(MapConstants.maxLongitude + latLng.lng, MapConstants.maxLongitude - MathConstants.rad2Deg * Math.log(Math.tan(Math.PI / 4 + latitude * Math.PI / MapConstants.maxDegrees))).multiply(worldSize / MapConstants.maxDegrees);
+  };
+
+  ProjectionMercator.convertToMeterFromLatLng = function convertToMeterFromLatLng(latLng) {
+    var constrainedLatitude = MathUtils.clamp(latLng.lat, MapConstants.minLatitude, MapConstants.maxLatitude);
+    var constrainedLongitude = latLng.lng;
+    var m = 1 - 1e-15;
+    var f = MathUtils.clamp(Math.sin(MathConstants.deg2Rad * constrainedLatitude), -m, m);
+    var easting = MapConstants.radiusEarthMeters * constrainedLongitude * MathConstants.deg2Rad;
+    var northing = 0.5 * MapConstants.radiusEarthMeters * Math.log((1 + f) / (1 - f));
+    return new Vector2(easting, northing);
+  };
+
+  ProjectionMercator.convertToLatLngFromMeter = function convertToLatLngFromMeter(meters) {
+    var latitude = (2 * Math.atan(Math.exp(meters.y / MapConstants.radiusEarthMeters)) - Math.PI / 2.0) * MathConstants.rad2Deg;
+    var longitude = meters.x * MathConstants.rad2Deg / MapConstants.radiusEarthMeters;
+    return new LatLng(latitude, longitude);
+  };
+
+  ProjectionMercator.projectZoom = function projectZoom(latLng, zoom) {
+    return this.projectInternal(latLng, 1 << zoom);
+  };
+
+  return ProjectionMercator;
+}();
+
+var CoordinateTransformer = /*#__PURE__*/function () {
+  function CoordinateTransformer(coordinates) {
+    this.coordinates = [];
+    this.coordinates = coordinates.map(function (coordinate) {
+      return LatLng.convert(coordinate);
+    });
+  }
+
+  var _proto = CoordinateTransformer.prototype;
+
+  _proto.setCoordinates = function setCoordinates(coordinates) {
+    this.coordinates = coordinates.map(function (coordinate) {
+      return LatLng.convert(coordinate);
+    });
+  };
+
+  _proto.addCoordinates = function addCoordinates(coordinates) {
+    var _this = this;
+
+    coordinates.forEach(function (coordinate) {
+      return _this.coordinates.push(LatLng.convert(coordinate));
+    });
+  };
+
+  _proto.rotate = function rotate(degree, anchor) {
+    if (anchor === void 0) {
+      anchor = null;
+    }
+
+    if (this.coordinates.length <= 1) {
+      return this.coordinates.slice();
+    }
+
+    var center = null;
+
+    if (anchor != null) {
+      center = LatLng.convert(center);
+    } else {
+      center = this.center;
+    }
+
+    var centerInMeters = ProjectionMercator.convertToMeterFromLatLng(center);
+    var transformedCoordinates = [];
+    var degreeInRadians = MathUtils.toRadians(degree);
+    this.coordinates.forEach(function (coordinate) {
+      var point = ProjectionMercator.convertToMeterFromLatLng(coordinate);
+      point.x -= centerInMeters.x;
+      point.y -= centerInMeters.y;
+      var x = point.x;
+      var y = point.y;
+      point.x = x * Math.cos(degreeInRadians) - y * Math.sin(degreeInRadians);
+      point.y = x * Math.sin(degreeInRadians) + y * Math.cos(degreeInRadians);
+      transformedCoordinates.push(ProjectionMercator.convertToLatLngFromMeter(new Vector2(centerInMeters.x + point.x, centerInMeters.y + point.y)));
+    });
+    return transformedCoordinates;
+  };
+
+  _proto.translate = function translate(target, anchor) {
+    if (anchor === void 0) {
+      anchor = null;
+    }
+
+    if (this.coordinates.length <= 0) {
+      return [];
+    }
+
+    var newCenter = LatLng.convert(target);
+    var oldCenter = null;
+
+    if (anchor != null) {
+      oldCenter = LatLng.convert(anchor);
+    } else {
+      oldCenter = this.center;
+    }
+
+    var transformedCoordinates = [];
+    var translateVectorX = newCenter.lng - oldCenter.lng;
+    var translateVectorY = newCenter.lat - oldCenter.lat;
+    this.coordinates.forEach(function (coordinate) {
+      transformedCoordinates.push(new LatLng(coordinate.lat + translateVectorY, coordinate.lng + translateVectorX));
+    });
+    return transformedCoordinates;
+  };
+
+  _proto.scale = function scale(_scale, anchor) {
+    if (anchor === void 0) {
+      anchor = null;
+    }
+
+    if (this.coordinates.length <= 1) {
+      return this.coordinates.slice();
+    }
+
+    var center = null;
+
+    if (anchor != null) {
+      center = LatLng.convert(anchor);
+    } else {
+      center = this.center;
+    }
+
+    var centerInMeters = ProjectionMercator.convertToMeterFromLatLng(center);
+    var transformedCoordinates = [];
+    this.coordinates.forEach(function (coordinate) {
+      var point = ProjectionMercator.convertToMeterFromLatLng(coordinate);
+      point.x -= centerInMeters.x;
+      point.y -= centerInMeters.y;
+      point.x *= _scale;
+      point.y *= _scale;
+      transformedCoordinates.push(ProjectionMercator.convertToLatLngFromMeter(new Vector2(centerInMeters.x + point.x, centerInMeters.y + point.y)));
+    });
+    return transformedCoordinates;
+  };
+
+  _createClass(CoordinateTransformer, [{
+    key: "center",
+    get: function get() {
+      if (this.coordinates.length == 0) {
+        return null;
+      }
+
+      var center = new LatLng(0, 0);
+
+      for (var i = 0; i < this.coordinates.length; ++i) {
+        center.lat += this.coordinates[i].lat;
+        center.lng += this.coordinates[i].lng;
+      }
+
+      center.lat /= this.coordinates.length;
+      center.lng /= this.coordinates.length;
+      return center;
+    }
+  }]);
+
+  return CoordinateTransformer;
+}();
+
+exports.CoordinateTransformer = CoordinateTransformer;
+exports.LatLng = LatLng;
 exports.MFBuilding = MFBuilding;
 exports.MFBuildingOverlay = MFBuildingOverlay;
 exports.MFCircle = MFCircle;