dgeoutils 2.3.7 → 2.4.2

package/dist/{es2015/DCircle.js → DCircle.js}

@@ -1,8 +1,11 @@
-import { DPoint, EARTH_RADIUS_IN_METERS } from './DPoint';
-import { DPolygon } from './DPolygon';
-import { checkFunction } from './utils';
-export class DCircle {
-    constructor(center = DPoint.zero(), r = 0) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DCircle = void 0;
+const DPoint_1 = require("./DPoint");
+const DPolygon_1 = require("./DPolygon");
+const utils_1 = require("./utils");
+class DCircle {
+    constructor(center = DPoint_1.DPoint.zero(), r = 0) {
         this.center = center;
         this.r = r;
     }
@@ -37,10 +40,10 @@ export class DCircle {
         const y32 = y2 + hd * dx;
         const res = [];
         if (!isNaN(x31) && !isNaN(y31)) {
-            res.push(new DPoint(x31, y31));
+            res.push(new DPoint_1.DPoint(x31, y31));
         }
         if (!isNaN(x32) && !isNaN(y32) && !(x31 === x32 && y31 === y32)) {
-            res.push(new DPoint(x32, y32));
+            res.push(new DPoint_1.DPoint(x32, y32));
         }
         return res;
     }
@@ -52,17 +55,17 @@ export class DCircle {
         const points = [];
         let angle = startAngle;
         while (angle < stopAngle - step) {
-            points.push(new DPoint(this.r).scale(Math.cos(angle), Math.sin(angle))
+            points.push(new DPoint_1.DPoint(this.r).scale(Math.cos(angle), Math.sin(angle))
                 .move(this.center));
             angle += step;
         }
         const x = this.r * Math.cos(stopAngle) + this.center.x;
         const y = this.r * Math.sin(stopAngle) + this.center.y;
-        points.push(new DPoint(x, y));
-        return new DPolygon(points);
+        points.push(new DPoint_1.DPoint(x, y));
+        return new DPolygon_1.DPolygon(points);
     }
     findPolygonInsideOnSphere(pointCount = 64, startAngle = 0, stopAngle = 2 * Math.PI) {
-        checkFunction('findPolygonInsideOnSphere')
+        (0, utils_1.checkFunction)('findPolygonInsideOnSphere')
             .checkArgument('center')
             .shouldBeDegree(this.center);
         const step = 2 * Math.PI / pointCount;
@@ -73,15 +76,16 @@ export class DCircle {
             angle += step;
         }
         points.push(this.sphereOffset(stopAngle));
-        return new DPolygon(points);
+        return new DPolygon_1.DPolygon(points);
     }
-    sphereOffset(bearing, earthRadius = EARTH_RADIUS_IN_METERS) {
+    sphereOffset(bearing, earthRadius = DPoint_1.EARTH_RADIUS_IN_METERS) {
         const { x: lon1, y: lat1 } = this.center.clone().degreeToRadians();
         const dByR = this.r / earthRadius;
         const lat = Math.asin(Math.sin(lat1) * Math.cos(dByR) +
             Math.cos(lat1) * Math.sin(dByR) * Math.cos(bearing));
         const lon = lon1 +
             Math.atan2(Math.sin(bearing) * Math.sin(dByR) * Math.cos(lat1), Math.cos(dByR) - Math.sin(lat1) * Math.sin(lat));
-        return new DPoint(lon, lat).radiansToDegrees();
+        return new DPoint_1.DPoint(lon, lat).radiansToDegrees();
     }
 }
+exports.DCircle = DCircle;

package/dist/{es2015/DLine.js → DLine.js}

@@ -1,8 +1,11 @@
-import { DPoint } from './DPoint';
-import { checkFunction } from './utils';
-import { DNumbers } from './DNumbers';
-export class DLine {
-    constructor(a, b, c, begin = DPoint.zero(), end = DPoint.zero()) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DLine = void 0;
+const DPoint_1 = require("./DPoint");
+const utils_1 = require("./utils");
+const DNumbers_1 = require("./DNumbers");
+class DLine {
+    constructor(a, b, c, begin = DPoint_1.DPoint.zero(), end = DPoint_1.DPoint.zero()) {
         this.a = a;
         this.b = b;
         this.c = c;
@@ -13,7 +16,7 @@ export class DLine {
         return new DLine(this.a, this.b, this.c, this.begin.clone(), this.end.clone());
     }
     findPerpendicular(p) {
-        checkFunction('findPerpendicular')
+        (0, utils_1.checkFunction)('findPerpendicular')
             .checkArgument('this.begin')
             .shouldBeMeters(this.begin)
             .checkArgument('this.end')
@@ -23,7 +26,7 @@ export class DLine {
         return new DLine(-this.b, this.a, this.b * p.x - this.a * p.y);
     }
     perpendicularDistance(p) {
-        checkFunction('perpendicularDistance')
+        (0, utils_1.checkFunction)('perpendicularDistance')
             .checkArgument('this.begin')
             .shouldBeMeters(this.begin)
             .checkArgument('this.end')
@@ -137,21 +140,21 @@ export class DLine {
     }
     x(p) {
         if (this.isParallelY) {
-            return new DPoint(-this.c / this.a, p.y);
+            return new DPoint_1.DPoint(-this.c / this.a, p.y);
         }
         if (this.isParallelX) {
-            return new DPoint(p.x, -this.c / this.b);
+            return new DPoint_1.DPoint(p.x, -this.c / this.b);
         }
-        return new DPoint(-this.b / this.a * p.y - this.c / this.a, p.y);
+        return new DPoint_1.DPoint(-this.b / this.a * p.y - this.c / this.a, p.y);
     }
     y(p) {
         if (this.isParallelY) {
-            return new DPoint(-this.c / this.a, p.y);
+            return new DPoint_1.DPoint(-this.c / this.a, p.y);
         }
         if (this.isParallelX) {
-            return new DPoint(p.x, -this.c / this.b);
+            return new DPoint_1.DPoint(p.x, -this.c / this.b);
         }
-        return new DPoint(p.x, -this.a / this.b * p.x - this.c / this.b);
+        return new DPoint_1.DPoint(p.x, -this.a / this.b * p.x - this.c / this.b);
     }
     findPoint(l) {
         if (this.isParallelY && l.isParallelY) {
@@ -161,28 +164,28 @@ export class DLine {
             return null;
         }
         if (this.isParallelX && l.isParallelY) {
-            return new DPoint(-l.c / l.a, -this.c / this.b);
+            return new DPoint_1.DPoint(-l.c / l.a, -this.c / this.b);
         }
         if (this.isParallelY && l.isParallelX) {
-            return new DPoint(-this.c / this.a, -l.c / l.b);
+            return new DPoint_1.DPoint(-this.c / this.a, -l.c / l.b);
         }
         if (this.isParallelY) {
             const x = -this.c / this.a;
-            return l.y(new DPoint(x));
+            return l.y(new DPoint_1.DPoint(x));
         }
         if (this.isParallelX) {
             const y = -this.c / this.b;
-            return l.x(new DPoint(0, y));
+            return l.x(new DPoint_1.DPoint(0, y));
         }
         if (l.isParallelY) {
             const x = -l.c / l.a;
-            return this.y(new DPoint(x));
+            return this.y(new DPoint_1.DPoint(x));
         }
         if (l.isParallelX) {
             const y = -l.c / l.b;
-            return this.x(new DPoint(0, y));
+            return this.x(new DPoint_1.DPoint(0, y));
         }
-        const res = this.y(new DPoint((l.c / l.b - this.c / this.b) / (this.a / this.b - l.a / l.b)));
+        const res = this.y(new DPoint_1.DPoint((l.c / l.b - this.c / this.b) / (this.a / this.b - l.a / l.b)));
         if (!isFinite(res.x) && !isFinite(res.y)) {
             return null;
         }
@@ -201,7 +204,7 @@ export class DLine {
         return [this.begin, this.end];
     }
     getFi() {
-        checkFunction('getFi')
+        (0, utils_1.checkFunction)('getFi')
             .checkArgument('this.begin')
             .shouldBeMeters(this.begin)
             .checkArgument('this.end')
@@ -222,13 +225,13 @@ export class DLine {
         const p = isArray ? i : [i];
         const d = (isArray ? k : [k]);
         const fi = this.findFi(new DLine(1, 0, 0));
-        const td = this.x(new DPoint(1, 1)).distance(this.x(new DPoint(2, 2))) / 2;
-        const sinCos = new DPoint(Math.sin(fi), Math.cos(fi));
+        const td = this.x(new DPoint_1.DPoint(1, 1)).distance(this.x(new DPoint_1.DPoint(2, 2))) / 2;
+        const sinCos = new DPoint_1.DPoint(Math.sin(fi), Math.cos(fi));
         const dt = sinCos.clone().scale(td);
         const p1T = p[0].clone().move(dt.clone().minus());
         const p2T = p[0].clone().move(dt);
         let res = [];
-        if (DNumbers.like(this.y(p1T).y, p1T.y) || DNumbers.like(this.y(p2T).y, p2T.y)) {
+        if (DNumbers_1.DNumbers.like(this.y(p1T).y, p1T.y) || DNumbers_1.DNumbers.like(this.y(p2T).y, p2T.y)) {
             res = p.map((t, index) => t.clone()
                 .move(sinCos.clone().scale(d[index])));
         }
@@ -255,3 +258,4 @@ export class DLine {
         return new DLine(w * c - e * b, e * a - q * c, q * b - w * a);
     }
 }
+exports.DLine = DLine;

package/dist/DNumbers.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DNumbers = void 0;
+const DPoint_1 = require("./DPoint");
+const delta = 0.001;
+class DNumbers {
+    static like(v, s, d = delta) {
+        return Math.abs(v - s) < d;
+    }
+    static likeZero(v) {
+        return DNumbers.like(v, 0);
+    }
+    static like2PI(v) {
+        return DNumbers.like(DNumbers.rad2Deg(v), DPoint_1.DOUBLE_PI_IN_DEGREE);
+    }
+    static likePI(v) {
+        return DNumbers.like(DNumbers.rad2Deg(v), DPoint_1.PI_IN_DEGREE);
+    }
+    static rad2Deg(v) {
+        return v * DPoint_1.DEGREE_TO_PI;
+    }
+    static deg2Rad(v) {
+        return v * DPoint_1.PI_TO_DEGREE;
+    }
+}
+exports.DNumbers = DNumbers;

package/dist/{es2015/DPlane.js → DPlane.js}

@@ -1,8 +1,11 @@
-import { DPoint } from './DPoint';
-import { gaussianElimination } from './utils';
-import { DNumbers } from './DNumbers';
-export class DPlane {
-    constructor(a, b, c, d, p1 = DPoint.zero(), p2 = DPoint.zero(), p3 = DPoint.zero()) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DPlane = void 0;
+const DPoint_1 = require("./DPoint");
+const utils_1 = require("./utils");
+const DNumbers_1 = require("./DNumbers");
+class DPlane {
+    constructor(a, b, c, d, p1 = DPoint_1.DPoint.zero(), p2 = DPoint_1.DPoint.zero(), p3 = DPoint_1.DPoint.zero()) {
         this.a = a;
         this.b = b;
         this.c = c;
@@ -22,7 +25,7 @@ export class DPlane {
             return new DPlane(0, 0, 1, -p1.z, p1, p2, p3);
         }
         const d = 1;
-        const [a, b, c] = gaussianElimination([
+        const [a, b, c] = (0, utils_1.gaussianElimination)([
             [p1.x, p1.y, p1.z, -d],
             [p2.x, p2.y, p2.z, -d],
             [p3.x, p3.y, p3.z, -d]
@@ -30,7 +33,7 @@ export class DPlane {
         return new DPlane(a, b, c, d, p1, p2, p3);
     }
     x(p) {
-        if (p instanceof DPoint) {
+        if (p instanceof DPoint_1.DPoint) {
             const { a, b, c, d } = this;
             const { y, z } = p;
             p.x = -(b * y + c * z + d) / a;
@@ -39,7 +42,7 @@ export class DPlane {
         return p.map((t) => this.x(t));
     }
     y(p) {
-        if (p instanceof DPoint) {
+        if (p instanceof DPoint_1.DPoint) {
             const { a, b, c, d } = this;
             const { x, z } = p;
             p.y = -(a * x + c * z + d) / b;
@@ -48,7 +51,7 @@ export class DPlane {
         return p.map((t) => this.y(t));
     }
     z(p) {
-        if (p instanceof DPoint) {
+        if (p instanceof DPoint_1.DPoint) {
             const { a, b, c, d } = this;
             const { x, y } = p;
             p.z = -(a * x + b * y + d) / c;
@@ -61,7 +64,7 @@ export class DPlane {
         return new DPlane(a, b, c, d, p1, p2, p3);
     }
     distance(p) {
-        if (p instanceof DPoint) {
+        if (p instanceof DPoint_1.DPoint) {
             const { x, y, z } = p;
             const { a, b, c, d } = this;
             return Math.abs(a * x + b * y + c * z + d) / Math.sqrt(a * a + b * b + c * c);
@@ -73,10 +76,10 @@ export class DPlane {
     equal(p) {
         const { a, b, c, d } = p;
         const { a: q, b: w, c: e, d: r } = this;
-        return DNumbers.like(a, q) &&
-            DNumbers.like(b, w) &&
-            DNumbers.like(c, e) &&
-            DNumbers.like(d, r);
+        return DNumbers_1.DNumbers.like(a, q) &&
+            DNumbers_1.DNumbers.like(b, w) &&
+            DNumbers_1.DNumbers.like(c, e) &&
+            DNumbers_1.DNumbers.like(d, r);
     }
     same(p) {
         const { a, b, c, d } = p;
@@ -85,10 +88,10 @@ export class DPlane {
         const y = b / w;
         const u = c / e;
         const i = d / r;
-        return DNumbers.like(t, y) &&
-            DNumbers.like(t, u) &&
-            DNumbers.like(t, c) &&
-            DNumbers.like(t, i);
+        return DNumbers_1.DNumbers.like(t, y) &&
+            DNumbers_1.DNumbers.like(t, u) &&
+            DNumbers_1.DNumbers.like(t, c) &&
+            DNumbers_1.DNumbers.like(t, i);
     }
     parallel(p) {
         const { a, b, c, d } = p;
@@ -97,9 +100,10 @@ export class DPlane {
         const y = b / w;
         const u = c / e;
         const i = d / r;
-        return DNumbers.like(t, y) &&
-            DNumbers.like(t, u) &&
-            DNumbers.like(t, c) &&
-            !DNumbers.like(t, i);
+        return DNumbers_1.DNumbers.like(t, y) &&
+            DNumbers_1.DNumbers.like(t, u) &&
+            DNumbers_1.DNumbers.like(t, c) &&
+            !DNumbers_1.DNumbers.like(t, i);
     }
 }
+exports.DPlane = DPlane;

package/dist/{es2015/DPoint.js → DPoint.js}

@@ -1,21 +1,24 @@
-import { DLine } from './DLine';
-import { DPolygon } from './DPolygon';
-import { checkFunction, createArray, isDefAndNotNull } from './utils';
+"use strict";
+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;
+const DLine_1 = require("./DLine");
+const DPolygon_1 = require("./DPolygon");
+const utils_1 = require("./utils");
 const diff = 0;
-const radiansPolygon = new DPolygon();
-const pseudoMercatorPolygon = new DPolygon();
-const worldGeodeticPolygon = new DPolygon();
-export const EARTH_RADIUS_IN_METERS = 6371008.8;
+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;
 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;
-export const HALF_PI_IN_DEGREE = 90;
-export const PI_IN_DEGREE = 180;
-export const DOUBLE_PI_IN_DEGREE = 360;
-export const PI_TO_DEGREE = Math.PI / PI_IN_DEGREE;
-export const DEGREE_TO_PI = PI_IN_DEGREE / Math.PI;
-export class DPoint {
+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;
+class DPoint {
     constructor(x = 0, y = x, z) {
         this.x = x;
         this.y = y;
@@ -44,20 +47,20 @@ export class DPoint {
         return new DPoint(Math.random(), Math.random());
     }
     getTileFromCoords(zoom = this.z) {
-        checkFunction('getTileFromCoords')
+        (0, utils_1.checkFunction)('getTileFromCoords')
             .checkArgument('this')
             .shouldBeDegree(this);
-        const x = Math.floor((this.x + PI_IN_DEGREE) / DOUBLE_PI_IN_DEGREE * (Math.pow(2, zoom)));
-        const y = Math.floor((1 - Math.log(Math.tan(this.y * PI_TO_DEGREE) + 1 / Math.cos(this.y * 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);
     }
     getCoordsFromTile(zoom = this.z) {
-        checkFunction('getCoordsFromTile')
+        (0, utils_1.checkFunction)('getCoordsFromTile')
             .checkArgument('this')
             .shouldBeUInt(this);
         const n = Math.PI - 2 * Math.PI * this.y / (Math.pow(2, zoom));
-        const x = this.x / (Math.pow(2, zoom)) * DOUBLE_PI_IN_DEGREE - PI_IN_DEGREE;
-        const y = PI_IN_DEGREE / Math.PI * Math.atan((Math.exp(n) - Math.exp(-n)) / 2);
+        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);
     }
     toCoords() {
@@ -67,7 +70,7 @@ export class DPoint {
         return [this.x, this.y, this.z];
     }
     findLine(p) {
-        checkFunction('findLine')
+        (0, utils_1.checkFunction)('findLine')
             .checkArgument('this')
             .shouldBeMeters(this)
             .checkArgument('p')
@@ -79,15 +82,15 @@ export class DPoint {
         const b = p.x - this.x - diff;
         const c = this.x * p.y - p.x * this.y - diff;
         if (a === 0) {
-            return new DLine(0, 1, c / b, this, p);
+            return new DLine_1.DLine(0, 1, c / b, this, p);
         }
         if (b === 0) {
-            return new DLine(1, 0, c / a, this, p);
+            return new DLine_1.DLine(1, 0, c / a, this, p);
         }
-        return new DLine(a, b, c, this, p);
+        return new DLine_1.DLine(a, b, c, this, p);
     }
     findInnerAngle(p1, p3) {
-        checkFunction('findInnerAngle')
+        (0, utils_1.checkFunction)('findInnerAngle')
             .checkArgument('this')
             .shouldBeMeters(this)
             .checkArgument('p1')
@@ -116,7 +119,7 @@ export class DPoint {
         return `POINT (${x} ${y})`;
     }
     distance(p) {
-        checkFunction('distance')
+        (0, utils_1.checkFunction)('distance')
             .checkArgument('this')
             .shouldBeMeters(this)
             .checkArgument('p')
@@ -126,7 +129,7 @@ export class DPoint {
         return Math.sqrt(dx * dx + dy * dy);
     }
     distance3d(p) {
-        checkFunction('distance3d')
+        (0, utils_1.checkFunction)('distance3d')
             .checkArgument('this')
             .shouldBeMeters(this)
             .checkArgument('p')
@@ -201,66 +204,66 @@ export class DPoint {
         if (x instanceof DPoint) {
             xV = this.x + x.x;
             yV = this.y + x.y;
-            if (isDefAndNotNull(this.z) && isDefAndNotNull(x.z)) {
+            if ((0, utils_1.isDefAndNotNull)(this.z) && (0, utils_1.isDefAndNotNull)(x.z)) {
                 zV = this.z + x.z;
             }
         }
         else {
             xV = this.x + x;
             yV = this.y + y;
-            if (isDefAndNotNull(this.z) && isDefAndNotNull(z)) {
+            if ((0, utils_1.isDefAndNotNull)(this.z) && (0, utils_1.isDefAndNotNull)(z)) {
                 zV = this.z + z;
             }
         }
         this.x = xV;
         this.y = yV;
-        if (isDefAndNotNull(zV)) {
+        if ((0, utils_1.isDefAndNotNull)(zV)) {
             this.z = zV;
         }
         return this;
     }
     degreeToMeters() {
-        checkFunction('degreeToMeters')
+        (0, utils_1.checkFunction)('degreeToMeters')
             .checkArgument('this')
             .shouldBeDegree(this);
-        const x = ((this.x + PI_IN_DEGREE) % DOUBLE_PI_IN_DEGREE - PI_IN_DEGREE) * MITERS_IN_ONE_DEGREE;
-        const y = (Math.log(Math.tan(((this.y + HALF_PI_IN_DEGREE) % PI_IN_DEGREE) *
-            (Math.PI / DOUBLE_PI_IN_DEGREE))) / PI_TO_DEGREE) * MITERS_IN_ONE_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;
     }
     metersToDegree() {
-        checkFunction('metersToDegree')
+        (0, utils_1.checkFunction)('metersToDegree')
             .checkArgument('this')
             .shouldBeMeters(this);
         const lon = this.x * DEGREES_IN_ONE_MITER;
-        const lat = Math.atan(Math.pow(Math.E, ((this.y / MITERS_IN_ONE_DEGREE) * PI_TO_DEGREE))) *
-            (DOUBLE_PI_IN_DEGREE / Math.PI) - HALF_PI_IN_DEGREE;
+        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;
     }
     degreeToRadians() {
-        checkFunction('degreeToRadians')
+        (0, utils_1.checkFunction)('degreeToRadians')
             .checkArgument('this')
             .shouldBeDegree(this);
-        return this.scale(PI_TO_DEGREE);
+        return this.scale(exports.PI_TO_DEGREE);
     }
     radiansToDegrees() {
-        checkFunction('radiansToDegrees')
+        (0, utils_1.checkFunction)('radiansToDegrees')
             .checkArgument('this')
             .shouldBeRadians(this);
-        return this.scale(DEGREE_TO_PI);
+        return this.scale(exports.DEGREE_TO_PI);
     }
     radiansToMeters() {
-        checkFunction('radiansToMeters')
+        (0, utils_1.checkFunction)('radiansToMeters')
             .checkArgument('this')
             .shouldBeRadians(this);
         return this.radiansToDegrees().degreeToMeters();
     }
     metersToRadians() {
-        checkFunction('metersToRadians')
+        (0, utils_1.checkFunction)('metersToRadians')
             .checkArgument('this')
             .shouldBeMeters(this);
         return this.metersToDegree().degreeToRadians();
@@ -297,20 +300,20 @@ export class DPoint {
         if (x instanceof DPoint) {
             xV = this.x * x.x;
             yV = this.y * x.y;
-            if (isDefAndNotNull(this.z) && isDefAndNotNull(x.z)) {
+            if ((0, utils_1.isDefAndNotNull)(this.z) && (0, utils_1.isDefAndNotNull)(x.z)) {
                 zV = this.z * x.z;
             }
         }
         else {
             xV = this.x * x;
             yV = this.y * y;
-            if (isDefAndNotNull(this.z) && isDefAndNotNull(z)) {
+            if ((0, utils_1.isDefAndNotNull)(this.z) && (0, utils_1.isDefAndNotNull)(z)) {
                 zV = this.z * z;
             }
         }
         this.x = xV;
         this.y = yV;
-        if (isDefAndNotNull(zV)) {
+        if ((0, utils_1.isDefAndNotNull)(zV)) {
             this.z = zV;
         }
         return this;
@@ -322,20 +325,20 @@ export class DPoint {
         if (x instanceof DPoint) {
             xV = this.x / x.x;
             yV = this.y / x.y;
-            if (isDefAndNotNull(this.z) && isDefAndNotNull(x.z)) {
+            if ((0, utils_1.isDefAndNotNull)(this.z) && (0, utils_1.isDefAndNotNull)(x.z)) {
                 zV = this.z / x.z;
             }
         }
         else {
             xV = this.x / x;
             yV = this.y / y;
-            if (isDefAndNotNull(this.z) && isDefAndNotNull(z)) {
+            if ((0, utils_1.isDefAndNotNull)(this.z) && (0, utils_1.isDefAndNotNull)(z)) {
                 zV = this.z / z;
             }
         }
         this.x = xV;
         this.y = yV;
-        if (isDefAndNotNull(zV)) {
+        if ((0, utils_1.isDefAndNotNull)(zV)) {
             this.z = zV;
         }
         return this;
@@ -392,13 +395,13 @@ export class DPoint {
         this.y = y;
     }
     get area() {
-        checkFunction('area')
+        (0, utils_1.checkFunction)('area')
             .checkArgument('this')
             .shouldBeMeters(this);
         return this.w * this.h;
     }
     get hip() {
-        checkFunction('hip')
+        (0, utils_1.checkFunction)('hip')
             .checkArgument('this')
             .shouldBeMeters(this);
         return Math.sqrt(this.w * this.w + this.h * this.h);
@@ -442,7 +445,7 @@ export class DPoint {
         return this.scale(-1);
     }
     orthodromicPath(point, pointsCount = 360) {
-        checkFunction('orthodromicPath')
+        (0, utils_1.checkFunction)('orthodromicPath')
             .checkArgument('this')
             .shouldBeDegree(this)
             .checkArgument('point')
@@ -451,7 +454,7 @@ export class DPoint {
         const p = point.clone().degreeToRadians();
         const d = Math.sin(p.x - t.x);
         const step = (p.x - t.x) / (pointsCount - 1);
-        return new DPolygon(createArray(pointsCount)
+        return new DPolygon_1.DPolygon((0, utils_1.createArray)(pointsCount)
             .map((v, i) => {
             const x = t.x + step * i;
             const y = Math.atan((Math.tan(t.y) * Math.sin(p.x - x)) / d +
@@ -470,3 +473,4 @@ export class DPoint {
             .sort((a, b) => a.properties.distance - b.properties.distance);
     }
 }
+exports.DPoint = DPoint;

package/dist/{cjs/DPolygon.d.ts → DPolygon.d.ts}

@@ -97,7 +97,7 @@ export declare class DPolygon {
     static parse(a: number[][]): DPolygon;
     static parse(a: DCoord[]): DPolygon;
     toArrayOfCoords(): DCoord[];
-    divideToPieces(piecesCount: number): DPolygon;
+    divideToPieces(piecesCount: number, withAltitude?: boolean): DPolygon;
     prepareToFastSearch(): void;
     fastHas({ x, y, z }: DPoint): boolean;
     get growingPiecesGenerator(): () => Generator<DPolygon, DPolygon>;