dgeoutils 2.4.0 → 2.4.1

package/dist/cjs/DPoint.js

@@ -1,106 +1,75 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DPoint = exports.DEGREE_TO_PI = exports.PI_TO_DEGREE = exports.DOUBLE_PI_IN_DEGREE = exports.PI_IN_DEGREE = exports.HALF_PI_IN_DEGREE = exports.EARTH_RADIUS_IN_METERS = void 0;
-var DLine_1 = require("./DLine");
-var DPolygon_1 = require("./DPolygon");
-var utils_1 = require("./utils");
-var diff = 0;
-var radiansPolygon = new DPolygon_1.DPolygon();
-var pseudoMercatorPolygon = new DPolygon_1.DPolygon();
-var worldGeodeticPolygon = new DPolygon_1.DPolygon();
+const DLine_1 = require("./DLine");
+const DPolygon_1 = require("./DPolygon");
+const utils_1 = require("./utils");
+const diff = 0;
+const radiansPolygon = new DPolygon_1.DPolygon();
+const pseudoMercatorPolygon = new DPolygon_1.DPolygon();
+const worldGeodeticPolygon = new DPolygon_1.DPolygon();
 exports.EARTH_RADIUS_IN_METERS = 6371008.8;
-var EARTH_IN_MITERS = 20037508.34;
-var DEGREES_IN_EARTH = 180;
-var MITERS_IN_ONE_DEGREE = EARTH_IN_MITERS / DEGREES_IN_EARTH;
-var DEGREES_IN_ONE_MITER = DEGREES_IN_EARTH / EARTH_IN_MITERS;
+const EARTH_IN_MITERS = 20037508.34;
+const DEGREES_IN_EARTH = 180;
+const MITERS_IN_ONE_DEGREE = EARTH_IN_MITERS / DEGREES_IN_EARTH;
+const DEGREES_IN_ONE_MITER = DEGREES_IN_EARTH / EARTH_IN_MITERS;
 exports.HALF_PI_IN_DEGREE = 90;
 exports.PI_IN_DEGREE = 180;
 exports.DOUBLE_PI_IN_DEGREE = 360;
 exports.PI_TO_DEGREE = Math.PI / exports.PI_IN_DEGREE;
 exports.DEGREE_TO_PI = exports.PI_IN_DEGREE / Math.PI;
-var DPoint = (function () {
-    function DPoint(x, y, z) {
-        if (x === void 0) { x = 0; }
-        if (y === void 0) { y = x; }
+class DPoint {
+    constructor(x = 0, y = x, z) {
         this.x = x;
         this.y = y;
         this.z = z;
         this.properties = {};
     }
-    DPoint.zero = function () {
+    static zero() {
         return new DPoint();
-    };
-    DPoint.parse = function (c) {
-        var _a = c, lat = _a.lat, lng = _a.lng;
+    }
+    static parse(c) {
+        const { lat, lng } = c;
         if (lat && lng) {
             return new DPoint(lat, lng, 0);
         }
-        var _b = __read(c, 3), x = _b[0], y = _b[1], z = _b[2];
+        const [x, y, z] = c;
         return new DPoint(x, y, z);
-    };
-    DPoint.parseFromWKT = function (wkt) {
-        var regexp = /POINT \((?<data>(?:(?!\)).)*?)\)$/miu;
-        var data = wkt.trim().toUpperCase();
-        var res = regexp.exec(data);
-        var _a = __read(res.groups.data.split(' ').map(Number), 3), x = _a[0], y = _a[1], z = _a[2];
+    }
+    static parseFromWKT(wkt) {
+        const regexp = /POINT \((?<data>(?:(?!\)).)*?)\)$/miu;
+        const data = wkt.trim().toUpperCase();
+        const res = regexp.exec(data);
+        const [x, y, z] = res.groups.data.split(' ').map(Number);
         return new DPoint(x, y, z);
-    };
-    DPoint.random = function () {
+    }
+    static random() {
         return new DPoint(Math.random(), Math.random());
-    };
-    DPoint.prototype.getTileFromCoords = function (zoom) {
-        if (zoom === void 0) { zoom = this.z; }
+    }
+    getTileFromCoords(zoom = this.z) {
         (0, utils_1.checkFunction)('getTileFromCoords')
             .checkArgument('this')
             .shouldBeDegree(this);
-        var x = Math.floor((this.x + exports.PI_IN_DEGREE) / exports.DOUBLE_PI_IN_DEGREE * (Math.pow(2, zoom)));
-        var y = Math.floor((1 - Math.log(Math.tan(this.y * exports.PI_TO_DEGREE) + 1 / Math.cos(this.y * exports.PI_TO_DEGREE)) / Math.PI) / 2 * (Math.pow(2, zoom)));
+        const x = Math.floor((this.x + exports.PI_IN_DEGREE) / exports.DOUBLE_PI_IN_DEGREE * (Math.pow(2, zoom)));
+        const y = Math.floor((1 - Math.log(Math.tan(this.y * exports.PI_TO_DEGREE) + 1 / Math.cos(this.y * exports.PI_TO_DEGREE)) / Math.PI) / 2 * (Math.pow(2, zoom)));
         return new DPoint(x, y, zoom);
-    };
-    DPoint.prototype.getCoordsFromTile = function (zoom) {
-        if (zoom === void 0) { zoom = this.z; }
+    }
+    getCoordsFromTile(zoom = this.z) {
         (0, utils_1.checkFunction)('getCoordsFromTile')
             .checkArgument('this')
             .shouldBeUInt(this);
-        var n = Math.PI - 2 * Math.PI * this.y / (Math.pow(2, zoom));
-        var x = this.x / (Math.pow(2, zoom)) * exports.DOUBLE_PI_IN_DEGREE - exports.PI_IN_DEGREE;
-        var y = exports.PI_IN_DEGREE / Math.PI * Math.atan((Math.exp(n) - Math.exp(-n)) / 2);
+        const n = Math.PI - 2 * Math.PI * this.y / (Math.pow(2, zoom));
+        const x = this.x / (Math.pow(2, zoom)) * exports.DOUBLE_PI_IN_DEGREE - exports.PI_IN_DEGREE;
+        const y = exports.PI_IN_DEGREE / Math.PI * Math.atan((Math.exp(n) - Math.exp(-n)) / 2);
         return new DPoint(x, y, zoom);
-    };
-    DPoint.prototype.toCoords = function () {
+    }
+    toCoords() {
         if (this.z === undefined) {
             return [this.x, this.y];
         }
         return [this.x, this.y, this.z];
-    };
-    DPoint.prototype.findLine = function (p) {
+    }
+    findLine(p) {
         (0, utils_1.checkFunction)('findLine')
             .checkArgument('this')
             .shouldBeMeters(this)
@@ -109,9 +78,9 @@ var DPoint = (function () {
         if (this.equal(p)) {
             return this.findLine(p.clone().move(0, 1));
         }
-        var a = this.y - p.y - diff;
-        var b = p.x - this.x - diff;
-        var c = this.x * p.y - p.x * this.y - diff;
+        const a = this.y - p.y - diff;
+        const b = p.x - this.x - diff;
+        const c = this.x * p.y - p.x * this.y - diff;
         if (a === 0) {
             return new DLine_1.DLine(0, 1, c / b, this, p);
         }
@@ -119,8 +88,8 @@ var DPoint = (function () {
             return new DLine_1.DLine(1, 0, c / a, this, p);
         }
         return new DLine_1.DLine(a, b, c, this, p);
-    };
-    DPoint.prototype.findInnerAngle = function (p1, p3) {
+    }
+    findInnerAngle(p1, p3) {
         (0, utils_1.checkFunction)('findInnerAngle')
             .checkArgument('this')
             .shouldBeMeters(this)
@@ -128,38 +97,38 @@ var DPoint = (function () {
             .shouldBeMeters(p1)
             .checkArgument('p3')
             .shouldBeMeters(p3);
-        var a1 = this.findLine(p1).getFi();
-        var a2 = this.findLine(p3).getFi();
+        const a1 = this.findLine(p1).getFi();
+        const a2 = this.findLine(p3).getFi();
         if (a2 >= a1) {
             return a2 - a1;
         }
         return a2 + Math.PI * 2 - a1;
-    };
-    DPoint.prototype.toString = function () {
-        return this.x + " " + this.y;
-    };
-    DPoint.prototype.getValue = function () {
+    }
+    toString() {
+        return `${this.x} ${this.y}`;
+    }
+    getValue() {
         return [this.x, this.y];
-    };
-    DPoint.prototype.height = function (z) {
+    }
+    height(z) {
         this.z = z;
         return this;
-    };
-    DPoint.prototype.toWKT = function () {
-        var _a = this, x = _a.x, y = _a.y;
-        return "POINT (" + x + " " + y + ")";
-    };
-    DPoint.prototype.distance = function (p) {
+    }
+    toWKT() {
+        const { x, y } = this;
+        return `POINT (${x} ${y})`;
+    }
+    distance(p) {
         (0, utils_1.checkFunction)('distance')
             .checkArgument('this')
             .shouldBeMeters(this)
             .checkArgument('p')
             .shouldBeMeters(p);
-        var dx = p.x - this.x;
-        var dy = p.y - this.y;
+        const dx = p.x - this.x;
+        const dy = p.y - this.y;
         return Math.sqrt(dx * dx + dy * dy);
-    };
-    DPoint.prototype.distance3d = function (p) {
+    }
+    distance3d(p) {
         (0, utils_1.checkFunction)('distance3d')
             .checkArgument('this')
             .shouldBeMeters(this)
@@ -169,70 +138,69 @@ var DPoint = (function () {
             .shouldExist(this.z)
             .checkArgument('p.z')
             .shouldExist(p.z);
-        var dx = p.x - this.x;
-        var dy = p.y - this.y;
-        var dz = p.z - this.z;
+        const dx = p.x - this.x;
+        const dy = p.y - this.y;
+        const dz = p.z - this.z;
         return Math.sqrt(dx * dx + dy * dy + dz * dz);
-    };
-    DPoint.prototype.setX = function (x) {
+    }
+    setX(x) {
         this.x = typeof x === 'number' ? x : x(this);
         return this;
-    };
-    DPoint.prototype.setZ = function (z) {
+    }
+    setZ(z) {
         this.z = typeof z === 'number' ? z : z(this);
         return this;
-    };
-    DPoint.prototype.setY = function (y) {
+    }
+    setY(y) {
         this.y = typeof y === 'number' ? y : y(this);
         return this;
-    };
-    DPoint.prototype.clone = function () {
-        var p = new DPoint(this.x, this.y, this.z);
-        p.properties = __assign({}, this.properties);
+    }
+    clone() {
+        const p = new DPoint(this.x, this.y, this.z);
+        p.properties = Object.assign({}, this.properties);
         return p;
-    };
-    DPoint.prototype.gt = function (p) {
+    }
+    gt(p) {
         return this.x > p.x && this.y > p.y;
-    };
-    DPoint.prototype.lt = function (p) {
+    }
+    lt(p) {
         return this.x < p.x && this.y < p.y;
-    };
-    DPoint.prototype.gtOrEqual = function (p) {
+    }
+    gtOrEqual(p) {
         return this.gt(p) || this.equal(p);
-    };
-    DPoint.prototype.ltOrEqual = function (p) {
+    }
+    ltOrEqual(p) {
         return this.lt(p) || this.equal(p);
-    };
-    DPoint.prototype.rotate = function (a) {
-        var x = this.x * Math.cos(a) - this.y * Math.sin(a);
-        var y = this.x * Math.sin(a) + this.y * Math.cos(a);
+    }
+    rotate(a) {
+        const x = this.x * Math.cos(a) - this.y * Math.sin(a);
+        const y = this.x * Math.sin(a) + this.y * Math.cos(a);
         this.x = x;
         this.y = y;
         return this;
-    };
-    DPoint.prototype.rotate3dX = function (a) {
-        var _a = this, y = _a.y, z = _a.z;
+    }
+    rotate3dX(a) {
+        const { y, z } = this;
         this.y = y * Math.cos(a) + z * Math.sin(a);
         this.z = -y * Math.sin(a) + z * Math.cos(a);
         return this;
-    };
-    DPoint.prototype.rotate3dY = function (a) {
-        var _a = this, x = _a.x, z = _a.z;
+    }
+    rotate3dY(a) {
+        const { x, z } = this;
         this.x = x * Math.cos(a) + z * Math.sin(a);
         this.z = -x * Math.sin(a) + z * Math.cos(a);
         return this;
-    };
-    DPoint.prototype.rotate3dZ = function (a) {
-        var _a = this, x = _a.x, y = _a.y;
+    }
+    rotate3dZ(a) {
+        const { x, y } = this;
         this.x = x * Math.cos(a) - y * Math.sin(a);
         this.y = -x * Math.sin(a) + y * Math.cos(a);
         return this;
-    };
-    DPoint.prototype.move = function (x, y, z) {
-        if (y === void 0) { y = x; }
-        var xV = 0;
-        var yV = 0;
-        var zV = undefined;
+    }
+    move(x, y = x, z) {
+        let xV = 0;
+        let yV = 0;
+        let zV = undefined;
         if (x instanceof DPoint) {
             xV = this.x + x.x;
             yV = this.y + x.y;
@@ -253,84 +221,82 @@ var DPoint = (function () {
             this.z = zV;
         }
         return this;
-    };
-    DPoint.prototype.degreeToMeters = function () {
+    }
+    degreeToMeters() {
         (0, utils_1.checkFunction)('degreeToMeters')
             .checkArgument('this')
             .shouldBeDegree(this);
-        var x = ((this.x + exports.PI_IN_DEGREE) % exports.DOUBLE_PI_IN_DEGREE - exports.PI_IN_DEGREE) * MITERS_IN_ONE_DEGREE;
-        var y = (Math.log(Math.tan(((this.y + exports.HALF_PI_IN_DEGREE) % exports.PI_IN_DEGREE) *
+        const x = ((this.x + exports.PI_IN_DEGREE) % exports.DOUBLE_PI_IN_DEGREE - exports.PI_IN_DEGREE) * MITERS_IN_ONE_DEGREE;
+        const y = (Math.log(Math.tan(((this.y + exports.HALF_PI_IN_DEGREE) % exports.PI_IN_DEGREE) *
             (Math.PI / exports.DOUBLE_PI_IN_DEGREE))) / exports.PI_TO_DEGREE) * MITERS_IN_ONE_DEGREE;
         this.x = x;
         this.y = y;
         return this;
-    };
-    DPoint.prototype.metersToDegree = function () {
+    }
+    metersToDegree() {
         (0, utils_1.checkFunction)('metersToDegree')
             .checkArgument('this')
             .shouldBeMeters(this);
-        var lon = this.x * DEGREES_IN_ONE_MITER;
-        var lat = Math.atan(Math.pow(Math.E, ((this.y / MITERS_IN_ONE_DEGREE) * exports.PI_TO_DEGREE))) *
+        const lon = this.x * DEGREES_IN_ONE_MITER;
+        const lat = Math.atan(Math.pow(Math.E, ((this.y / MITERS_IN_ONE_DEGREE) * exports.PI_TO_DEGREE))) *
             (exports.DOUBLE_PI_IN_DEGREE / Math.PI) - exports.HALF_PI_IN_DEGREE;
         this.x = lon;
         this.y = lat;
         return this;
-    };
-    DPoint.prototype.degreeToRadians = function () {
+    }
+    degreeToRadians() {
         (0, utils_1.checkFunction)('degreeToRadians')
             .checkArgument('this')
             .shouldBeDegree(this);
         return this.scale(exports.PI_TO_DEGREE);
-    };
-    DPoint.prototype.radiansToDegrees = function () {
+    }
+    radiansToDegrees() {
         (0, utils_1.checkFunction)('radiansToDegrees')
             .checkArgument('this')
             .shouldBeRadians(this);
         return this.scale(exports.DEGREE_TO_PI);
-    };
-    DPoint.prototype.radiansToMeters = function () {
+    }
+    radiansToMeters() {
         (0, utils_1.checkFunction)('radiansToMeters')
             .checkArgument('this')
             .shouldBeRadians(this);
         return this.radiansToDegrees().degreeToMeters();
-    };
-    DPoint.prototype.metersToRadians = function () {
+    }
+    metersToRadians() {
         (0, utils_1.checkFunction)('metersToRadians')
             .checkArgument('this')
             .shouldBeMeters(this);
         return this.metersToDegree().degreeToRadians();
-    };
-    DPoint.prototype.round = function () {
+    }
+    round() {
         this.x = Math.round(this.x);
         this.y = Math.round(this.y);
         return this;
-    };
-    DPoint.prototype.ceil = function () {
+    }
+    ceil() {
         this.x = Math.ceil(this.x);
         this.y = Math.ceil(this.y);
         return this;
-    };
-    DPoint.prototype.floor = function () {
+    }
+    floor() {
         this.x = Math.floor(this.x);
         this.y = Math.floor(this.y);
         return this;
-    };
-    DPoint.prototype.toFixed = function (n) {
-        if (n === void 0) { n = 2; }
+    }
+    toFixed(n = 2) {
         this.x = parseFloat(this.x.toFixed(n));
         this.y = parseFloat(this.y.toFixed(n));
         return this;
-    };
-    DPoint.prototype.abs = function () {
+    }
+    abs() {
         this.x = Math.abs(this.x);
         this.y = Math.abs(this.y);
         return this;
-    };
-    DPoint.prototype.scale = function (x, y, z) {
-        if (y === void 0) { y = x; }
-        var xV = 0;
-        var yV = 0;
-        var zV = undefined;
+    }
+    scale(x, y = x, z) {
+        let xV = 0;
+        let yV = 0;
+        let zV = undefined;
         if (x instanceof DPoint) {
             xV = this.x * x.x;
             yV = this.y * x.y;
@@ -351,12 +317,11 @@ var DPoint = (function () {
             this.z = zV;
         }
         return this;
-    };
-    DPoint.prototype.divide = function (x, y, z) {
-        if (y === void 0) { y = x; }
-        var xV = 0;
-        var yV = 0;
-        var zV = undefined;
+    }
+    divide(x, y = x, z) {
+        let xV = 0;
+        let yV = 0;
+        let zV = undefined;
         if (x instanceof DPoint) {
             xV = this.x / x.x;
             yV = this.y / x.y;
@@ -377,198 +342,135 @@ var DPoint = (function () {
             this.z = zV;
         }
         return this;
-    };
-    DPoint.prototype.equal = function (p) {
+    }
+    equal(p) {
         return this.x === p.x && this.y === p.y && this.z === p.z;
-    };
-    DPoint.prototype.like = function (p, d) {
+    }
+    like(p, d = 0.001) {
         var _a, _b, _c, _d;
-        if (d === void 0) { d = 0.001; }
         if (this.equal(p)) {
             return true;
         }
-        var likeX = Math.abs(this.x - p.x) < d;
-        var likeY = Math.abs(this.y - p.y) < d;
-        var likeZ = Math.abs(((_b = (_a = this.z) !== null && _a !== void 0 ? _a : p.z) !== null && _b !== void 0 ? _b : 0) - ((_d = (_c = p.z) !== null && _c !== void 0 ? _c : this.z) !== null && _d !== void 0 ? _d : 0)) < d;
+        const likeX = Math.abs(this.x - p.x) < d;
+        const likeY = Math.abs(this.y - p.y) < d;
+        const likeZ = Math.abs(((_b = (_a = this.z) !== null && _a !== void 0 ? _a : p.z) !== null && _b !== void 0 ? _b : 0) - ((_d = (_c = p.z) !== null && _c !== void 0 ? _c : this.z) !== null && _d !== void 0 ? _d : 0)) < d;
         return likeX && likeY && likeZ;
-    };
-    DPoint.prototype.flipVertically = function (size) {
-        var v = size;
+    }
+    flipVertically(size) {
+        let v = size;
         if (size instanceof DPoint) {
             v = size.y;
         }
         this.y = v - this.y;
         return this;
-    };
-    Object.defineProperty(DPoint.prototype, "likeRadians", {
-        get: function () {
-            if (radiansPolygon.length === 0) {
-                radiansPolygon.push(new DPoint(-Math.PI, -Math.PI / 2), new DPoint(Math.PI, Math.PI / 2));
-            }
-            return radiansPolygon.simpleInclude(this);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(DPoint.prototype, "likeWorldGeodeticSystem", {
-        get: function () {
-            if (worldGeodeticPolygon.length === 0) {
-                worldGeodeticPolygon.push(new DPoint(-180, -90), new DPoint(180, 90));
-            }
-            return !this.likeRadians && worldGeodeticPolygon.simpleInclude(this);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(DPoint.prototype, "likePseudoMercator", {
-        get: function () {
-            if (pseudoMercatorPolygon.length === 0) {
-                pseudoMercatorPolygon.push(new DPoint(-20026376.39, -20048966.10), new DPoint(20026376.39, 20048966.10));
-            }
-            return !this.likeRadians && !this.likeWorldGeodeticSystem && pseudoMercatorPolygon.simpleInclude(this);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(DPoint.prototype, "w", {
-        get: function () {
-            return this.x;
-        },
-        set: function (x) {
-            this.x = x;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(DPoint.prototype, "h", {
-        get: function () {
-            return this.y;
-        },
-        set: function (y) {
-            this.y = y;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(DPoint.prototype, "area", {
-        get: function () {
-            (0, utils_1.checkFunction)('area')
-                .checkArgument('this')
-                .shouldBeMeters(this);
-            return this.w * this.h;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(DPoint.prototype, "hip", {
-        get: function () {
-            (0, utils_1.checkFunction)('hip')
-                .checkArgument('this')
-                .shouldBeMeters(this);
-            return Math.sqrt(this.w * this.w + this.h * this.h);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(DPoint.prototype, "min", {
-        get: function () {
-            return Math.min(this.x, this.y);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(DPoint.prototype, "max", {
-        get: function () {
-            return Math.max(this.x, this.y);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(DPoint.prototype, "hipPoint", {
-        get: function () {
-            var hip = this.hip;
-            return new DPoint(hip, hip);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(DPoint.prototype, "xPoint", {
-        get: function () {
-            var x = this.x;
-            return new DPoint(x, x);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(DPoint.prototype, "yPoint", {
-        get: function () {
-            var y = this.y;
-            return new DPoint(y, y);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(DPoint.prototype, "wPoint", {
-        get: function () {
-            return this.xPoint;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(DPoint.prototype, "hPoint", {
-        get: function () {
-            return this.yPoint;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    DPoint.prototype.simple = function (xKey, yKey) {
-        var _a;
-        if (xKey === void 0) { xKey = 'x'; }
-        if (yKey === void 0) { yKey = 'y'; }
-        return _a = {},
-            _a[xKey] = this.x,
-            _a[yKey] = this.y,
-            _a;
-    };
-    DPoint.prototype.setIfLessThan = function (p) {
+    }
+    get likeRadians() {
+        if (radiansPolygon.length === 0) {
+            radiansPolygon.push(new DPoint(-Math.PI, -Math.PI / 2), new DPoint(Math.PI, Math.PI / 2));
+        }
+        return radiansPolygon.simpleInclude(this);
+    }
+    get likeWorldGeodeticSystem() {
+        if (worldGeodeticPolygon.length === 0) {
+            worldGeodeticPolygon.push(new DPoint(-180, -90), new DPoint(180, 90));
+        }
+        return !this.likeRadians && worldGeodeticPolygon.simpleInclude(this);
+    }
+    get likePseudoMercator() {
+        if (pseudoMercatorPolygon.length === 0) {
+            pseudoMercatorPolygon.push(new DPoint(-20026376.39, -20048966.10), new DPoint(20026376.39, 20048966.10));
+        }
+        return !this.likeRadians && !this.likeWorldGeodeticSystem && pseudoMercatorPolygon.simpleInclude(this);
+    }
+    get w() {
+        return this.x;
+    }
+    set w(x) {
+        this.x = x;
+    }
+    get h() {
+        return this.y;
+    }
+    set h(y) {
+        this.y = y;
+    }
+    get area() {
+        (0, utils_1.checkFunction)('area')
+            .checkArgument('this')
+            .shouldBeMeters(this);
+        return this.w * this.h;
+    }
+    get hip() {
+        (0, utils_1.checkFunction)('hip')
+            .checkArgument('this')
+            .shouldBeMeters(this);
+        return Math.sqrt(this.w * this.w + this.h * this.h);
+    }
+    get min() {
+        return Math.min(this.x, this.y);
+    }
+    get max() {
+        return Math.max(this.x, this.y);
+    }
+    get hipPoint() {
+        const { hip } = this;
+        return new DPoint(hip, hip);
+    }
+    get xPoint() {
+        const { x } = this;
+        return new DPoint(x, x);
+    }
+    get yPoint() {
+        const { y } = this;
+        return new DPoint(y, y);
+    }
+    get wPoint() {
+        return this.xPoint;
+    }
+    get hPoint() {
+        return this.yPoint;
+    }
+    simple(xKey = 'x', yKey = 'y') {
+        return {
+            [xKey]: this.x,
+            [yKey]: this.y
+        };
+    }
+    setIfLessThan(p) {
         this.x = Math.max(this.x, p.x);
         this.y = Math.max(this.y, p.y);
         return this;
-    };
-    DPoint.prototype.minus = function () {
+    }
+    minus() {
         return this.scale(-1);
-    };
-    DPoint.prototype.orthodromicPath = function (point, pointsCount) {
-        if (pointsCount === void 0) { pointsCount = 360; }
+    }
+    orthodromicPath(point, pointsCount = 360) {
         (0, utils_1.checkFunction)('orthodromicPath')
             .checkArgument('this')
             .shouldBeDegree(this)
             .checkArgument('point')
             .shouldBeDegree(point);
-        var t = this.clone().degreeToRadians();
-        var p = point.clone().degreeToRadians();
-        var d = Math.sin(p.x - t.x);
-        var step = (p.x - t.x) / (pointsCount - 1);
+        const t = this.clone().degreeToRadians();
+        const p = point.clone().degreeToRadians();
+        const d = Math.sin(p.x - t.x);
+        const step = (p.x - t.x) / (pointsCount - 1);
         return new DPolygon_1.DPolygon((0, utils_1.createArray)(pointsCount)
-            .map(function (v, i) {
-            var x = t.x + step * i;
-            var y = Math.atan((Math.tan(t.y) * Math.sin(p.x - x)) / d +
+            .map((v, i) => {
+            const x = t.x + step * i;
+            const y = Math.atan((Math.tan(t.y) * Math.sin(p.x - x)) / d +
                 (Math.tan(p.y) * Math.sin(x - t.x)) / d);
             return new DPoint(x, y).radiansToDegrees();
         }));
-    };
-    DPoint.prototype.sortByDistance = function (p) {
-        var _this = this;
+    }
+    sortByDistance(p) {
         return p
             .clone()
-            .map(function (d, index) {
-            d.properties.distance = d.distance(_this);
+            .map((d, index) => {
+            d.properties.distance = d.distance(this);
             d.properties.index = index;
             return d;
         })
-            .sort(function (a, b) { return a.properties.distance - b.properties.distance; });
-    };
-    return DPoint;
-}());
+            .sort((a, b) => a.properties.distance - b.properties.distance);
+    }
+}
 exports.DPoint = DPoint;