dgeoutils 2.2.24 → 2.3.0

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

@@ -1,11 +1,8 @@
-"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()) {
+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()) {
         this.a = a;
         this.b = b;
         this.c = c;
@@ -25,7 +22,7 @@ class DPlane {
             return new DPlane(0, 0, 1, -p1.z, p1, p2, p3);
         }
         const d = 1;
-        const [a, b, c] = (0, utils_1.gaussianElimination)([
+        const [a, b, c] = gaussianElimination([
             [p1.x, p1.y, p1.z, -d],
             [p2.x, p2.y, p2.z, -d],
             [p3.x, p3.y, p3.z, -d]
@@ -33,7 +30,7 @@ class DPlane {
         return new DPlane(a, b, c, d, p1, p2, p3);
     }
     x(p) {
-        if (p instanceof DPoint_1.DPoint) {
+        if (p instanceof DPoint) {
             const { a, b, c, d } = this;
             const { y, z } = p;
             p.x = -(b * y + c * z + d) / a;
@@ -42,7 +39,7 @@ class DPlane {
         return p.map((t) => this.x(t));
     }
     y(p) {
-        if (p instanceof DPoint_1.DPoint) {
+        if (p instanceof DPoint) {
             const { a, b, c, d } = this;
             const { x, z } = p;
             p.y = -(a * x + c * z + d) / b;
@@ -51,7 +48,7 @@ class DPlane {
         return p.map((t) => this.y(t));
     }
     z(p) {
-        if (p instanceof DPoint_1.DPoint) {
+        if (p instanceof DPoint) {
             const { a, b, c, d } = this;
             const { x, y } = p;
             p.z = -(a * x + b * y + d) / c;
@@ -64,7 +61,7 @@ class DPlane {
         return new DPlane(a, b, c, d, p1, p2, p3);
     }
     distance(p) {
-        if (p instanceof DPoint_1.DPoint) {
+        if (p instanceof 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);
@@ -76,10 +73,10 @@ class DPlane {
     equal(p) {
         const { a, b, c, d } = p;
         const { a: q, b: w, c: e, d: r } = this;
-        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);
+        return DNumbers.like(a, q) &&
+            DNumbers.like(b, w) &&
+            DNumbers.like(c, e) &&
+            DNumbers.like(d, r);
     }
     same(p) {
         const { a, b, c, d } = p;
@@ -88,10 +85,10 @@ class DPlane {
         const y = b / w;
         const u = c / e;
         const i = d / r;
-        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);
+        return DNumbers.like(t, y) &&
+            DNumbers.like(t, u) &&
+            DNumbers.like(t, c) &&
+            DNumbers.like(t, i);
     }
     parallel(p) {
         const { a, b, c, d } = p;
@@ -100,10 +97,9 @@ class DPlane {
         const y = b / w;
         const u = c / e;
         const i = d / r;
-        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);
+        return DNumbers.like(t, y) &&
+            DNumbers.like(t, u) &&
+            DNumbers.like(t, c) &&
+            !DNumbers.like(t, i);
     }
 }
-exports.DPlane = DPlane;

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

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

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

@@ -1,15 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DPolygon = exports.MIN_POINTS_IN_VALID_POLYGON = void 0;
-const DPoint_1 = require("./DPoint");
-const DLine_1 = require("./DLine");
-const DCircle_1 = require("./DCircle");
-const DNumbers_1 = require("./DNumbers");
-const jsts_1 = require("jsts");
-const DPolygonLoop_1 = require("./DPolygonLoop");
-const utils_1 = require("./utils");
-const { buffer: { BufferParameters: { CAP_ROUND, CAP_FLAT, CAP_SQUARE } } } = jsts_1.operation;
-exports.MIN_POINTS_IN_VALID_POLYGON = 3;
+import { DPoint } from './DPoint';
+import { DLine } from './DLine';
+import { DCircle } from './DCircle';
+import { DNumbers } from './DNumbers';
+import { io as jstsIo, operation } from 'jsts';
+import { DPolygonLoop } from './DPolygonLoop';
+import { isDefAndNotNull } from './utils';
+const { buffer: { BufferParameters: { CAP_ROUND, CAP_FLAT, CAP_SQUARE } } } = operation;
+export const MIN_POINTS_IN_VALID_POLYGON = 3;
 const APPROXIMATION_VALUE = 0.1;
 const MAX_CONVEX_ITERATIONS = 100;
 const CLOSE_TO_INTERSECTION_DISTANCE = 0.001;
@@ -26,8 +23,8 @@ const containCalculator = (poly, p) => {
     }
     let totalFi = 0;
     for (const [{ x, y }, { x: a, y: b }] of poly.loopPointsGenerator()()) {
-        const line1 = new DLine_1.DLine(x - p.x, y - p.y, 0);
-        const line2 = new DLine_1.DLine(a - p.x, b - p.y, 0);
+        const line1 = new DLine(x - p.x, y - p.y, 0);
+        const line2 = new DLine(a - p.x, b - p.y, 0);
         const fiDif = line1.findFi(line2);
         if (line1.vectorProduct(line2).c > 0) {
             totalFi += fiDif;
@@ -50,7 +47,7 @@ const containCalculator = (poly, p) => {
     }
     return result;
 };
-class DPolygon {
+export class DPolygon {
     constructor(pPoints = []) {
         this.pPoints = pPoints;
         this.properties = {};
@@ -58,7 +55,7 @@ class DPolygon {
         this.searchStore = {};
     }
     static arrayOfTrianglesToVertices(triangles, height) {
-        return triangles.map((v) => ((0, utils_1.isDefAndNotNull)(height) ? v
+        return triangles.map((v) => (isDefAndNotNull(height) ? v
             .loop()
             .height(height)
             .run() : v)
@@ -67,7 +64,7 @@ class DPolygon {
     }
     static minAreaRectangleSize(poly) {
         const { first, second, last } = poly.clone().open();
-        return new DPoint_1.DPoint(first.distance(second), first.distance(last));
+        return new DPoint(first.distance(second), first.distance(last));
     }
     static toDash(poly) {
         let p = new DPolygon();
@@ -107,7 +104,7 @@ class DPolygon {
             const [path, ...holes] = reg.groups.data
                 .split('), (')
                 .map((p) => new DPolygon(p.split(', ')
-                .map((pares) => DPoint_1.DPoint.parse(pares.split(' ').map(Number)))));
+                .map((pares) => DPoint.parse(pares.split(' ').map(Number)))));
             if (holes && holes.length) {
                 path.holes = holes;
             }
@@ -117,18 +114,18 @@ class DPolygon {
             const regexp = /LINESTRING \((?<data>(?:(?!\)$).)*?)\)$/miu;
             const reg = regexp.exec(data);
             res = new DPolygon(reg.groups.data
-                .split(', ').map((t) => DPoint_1.DPoint.parse(t.split(' ').map(Number))));
+                .split(', ').map((t) => DPoint.parse(t.split(' ').map(Number))));
         }
         if (data.indexOf('POINT') === 0) {
-            res = new DPolygon([DPoint_1.DPoint.parseFromWKT(data)]);
+            res = new DPolygon([DPoint.parseFromWKT(data)]);
         }
         return res;
     }
     static createSquareBySize(size) {
-        return new DPolygon([DPoint_1.DPoint.zero(), size.clone().setX(0), size.clone(), size.clone().setY(0)]).close();
+        return new DPolygon([DPoint.zero(), size.clone().setX(0), size.clone(), size.clone().setY(0)]).close();
     }
     loop() {
-        return new DPolygonLoop_1.DPolygonLoop(this);
+        return new DPolygonLoop(this);
     }
     set points(p) {
         this.pPoints = p;
@@ -166,24 +163,24 @@ class DPolygon {
     get extend() {
         const { minX, minY, maxX, maxY } = this;
         return new DPolygon([
-            new DPoint_1.DPoint(minX, minY),
-            new DPoint_1.DPoint(maxX, minY),
-            new DPoint_1.DPoint(maxX, maxY),
-            new DPoint_1.DPoint(minX, maxY),
-            new DPoint_1.DPoint(minX, minY)
+            new DPoint(minX, minY),
+            new DPoint(maxX, minY),
+            new DPoint(maxX, maxY),
+            new DPoint(minX, maxY),
+            new DPoint(minX, minY)
         ]);
     }
     get size() {
         const { w, h } = this;
-        return new DPoint_1.DPoint(w, h);
+        return new DPoint(w, h);
     }
     get leftTop() {
         const { minX, minY } = this;
-        return new DPoint_1.DPoint(minX, minY);
+        return new DPoint(minX, minY);
     }
     get rightBottom() {
         const { maxX, maxY } = this;
-        return new DPoint_1.DPoint(maxX, maxY);
+        return new DPoint(maxX, maxY);
     }
     get length() {
         return this.pPoints.length;
@@ -245,7 +242,7 @@ class DPolygon {
         return p;
     }
     get valid() {
-        return this.length > exports.MIN_POINTS_IN_VALID_POLYGON;
+        return this.length > MIN_POINTS_IN_VALID_POLYGON;
     }
     get first() {
         return this.at(0);
@@ -314,7 +311,7 @@ class DPolygon {
             const p2 = p.first;
             const p3 = p.second;
             const d = p2.findInnerAngle(p1, p3);
-            if (d > Math.PI || DNumbers_1.DNumbers.likeZero(DNumbers_1.DNumbers.rad2Deg(d)) || DNumbers_1.DNumbers.likePI(d) || DNumbers_1.DNumbers.like2PI(d)) {
+            if (d > Math.PI || DNumbers.likeZero(DNumbers.rad2Deg(d)) || DNumbers.likePI(d) || DNumbers.like2PI(d)) {
                 p.removePart(-1, 1);
             }
             else {
@@ -331,7 +328,7 @@ class DPolygon {
                 const p2 = p.at(i);
                 const p3 = p.at(i + 1);
                 const d = p2.findInnerAngle(p1, p3);
-                if (d > Math.PI || DNumbers_1.DNumbers.likeZero(DNumbers_1.DNumbers.rad2Deg(d)) || DNumbers_1.DNumbers.likePI(d) || DNumbers_1.DNumbers.like2PI(d)) {
+                if (d > Math.PI || DNumbers.likeZero(DNumbers.rad2Deg(d)) || DNumbers.likePI(d) || DNumbers.like2PI(d)) {
                     p.removePart(--i, 1);
                 }
             }
@@ -489,7 +486,7 @@ class DPolygon {
         return false;
     }
     findIndex(a) {
-        if (a instanceof DPoint_1.DPoint) {
+        if (a instanceof DPoint) {
             return this.points.findIndex((t) => t.equal(a));
         }
         return this.points.findIndex(a);
@@ -567,8 +564,8 @@ class DPolygon {
         const poly = this.deintersection;
         let totalFi = 0;
         for (const [{ x, y }, { x: a, y: b }] of poly.loopPointsGenerator()()) {
-            const line1 = new DLine_1.DLine(x - p.x, y - p.y, 0);
-            const line2 = new DLine_1.DLine(a - p.x, b - p.y, 0);
+            const line1 = new DLine(x - p.x, y - p.y, 0);
+            const line2 = new DLine(a - p.x, b - p.y, 0);
             const fiDif = line1.findFi(line2);
             if (line1.vectorProduct(line2).c > 0) {
                 totalFi += fiDif;
@@ -622,7 +619,7 @@ class DPolygon {
         return this;
     }
     static parse(a) {
-        return new DPolygon(a.map((r) => DPoint_1.DPoint.parse(r)));
+        return new DPolygon(a.map((r) => DPoint.parse(r)));
     }
     toArrayOfCoords() {
         return this.mapArray((r) => r.toCoords());
@@ -638,7 +635,7 @@ class DPolygon {
                 currentPieceLength = pieceLength;
             }
             else if (d - currentPieceLength > 0) {
-                const circle = new DCircle_1.DCircle(p1, currentPieceLength);
+                const circle = new DCircle(p1, currentPieceLength);
                 const line = p1.findLine(p2);
                 const intersectionPoint = line.intersectionWithCircle(circle)
                     .filter((p) => line.inRange(p, CLOSE_TO_INTERSECTION_DISTANCE))[0];
@@ -850,13 +847,13 @@ class DPolygon {
         return this.first.equal(this.last);
     }
     buffer(v, quadrantSegments = 64, type = DPolygon.CAP_ROUND) {
-        const reader = new jsts_1.io.WKTReader();
+        const reader = new jstsIo.WKTReader();
         const { noHoles, closed } = this;
         const points = reader
             .read(noHoles.toWKT(closed ? DPolygon.WKT_POLYGON : DPolygon.WKT_LINESTRING))
             .buffer(v, quadrantSegments, type)
             .getCoordinates();
-        return new DPolygon(points.map(({ x, y }) => new DPoint_1.DPoint(x, y)));
+        return new DPolygon(points.map(({ x, y }) => new DPoint(x, y)));
     }
     sideBuffers(v, quadrantSegments = 64) {
         const { first, last } = this;
@@ -949,7 +946,7 @@ class DPolygon {
     }
     getJSTSGeometry(p, unionThis, unionThat) {
         const unionOrIntersection = unionThat === unionThis;
-        const reader = new jsts_1.io.WKTReader();
+        const reader = new jstsIo.WKTReader();
         const a = reader.read(this.noHoles.toWKT());
         const b = reader.read(p.noHoles.toWKT());
         if (!unionOrIntersection) {
@@ -970,11 +967,11 @@ class DPolygon {
             if (coordinates.length) {
                 let result = coordinates.reduce((ak, { x, y }, index) => {
                     const lastIndex = ak.length - 1;
-                    const t = new DPoint_1.DPoint(x, y);
+                    const t = new DPoint(x, y);
                     const { first } = ak[lastIndex];
                     if (t.equal(first)) {
                         if (coordinates[index + 1]) {
-                            const nextPoint = new DPoint_1.DPoint(coordinates[index + 1].x, coordinates[index + 1].y);
+                            const nextPoint = new DPoint(coordinates[index + 1].x, coordinates[index + 1].y);
                             if (ak[lastIndex].length > 1) {
                                 ak.push(new DPolygon([nextPoint]));
                             }
@@ -984,7 +981,7 @@ class DPolygon {
                         ak[lastIndex].push(t);
                     }
                     return ak;
-                }, [new DPolygon([new DPoint_1.DPoint(coordinates[0].x, coordinates[0].y)])]);
+                }, [new DPolygon([new DPoint(coordinates[0].x, coordinates[0].y)])]);
                 if (unionThat && unionThis && result.length > 1) {
                     for (const q of result) {
                         for (const r of result) {
@@ -1032,7 +1029,6 @@ class DPolygon {
         return null;
     }
 }
-exports.DPolygon = DPolygon;
 DPolygon.CAP_ROUND = CAP_ROUND;
 DPolygon.CAP_FLAT = CAP_FLAT;
 DPolygon.CAP_SQUARE = CAP_SQUARE;

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

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DPolygonLoop = void 0;
 var LoopFunctions;
 (function (LoopFunctions) {
     LoopFunctions[LoopFunctions["getTileFromCoords"] = 0] = "getTileFromCoords";
@@ -170,7 +167,7 @@ const decodePoolRecord = (a, { functionName, pointArg, numberPointArg, numberArg
     }
     return res;
 };
-class DPolygonLoop {
+export class DPolygonLoop {
     constructor(parent) {
         this.parent = parent;
         this.pool = [];
@@ -393,4 +390,3 @@ class DPolygonLoop {
         return this;
     }
 }
-exports.DPolygonLoop = DPolygonLoop;

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

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FastSearch = void 0;
-class FastSearch {
+export class FastSearch {
     constructor() {
         this.searchStore = {};
     }
@@ -26,4 +23,3 @@ class FastSearch {
         return this.searchStore[x][y][z || 'undefined'];
     }
 }
-exports.FastSearch = FastSearch;