dgeoutils 2.3.6 → 2.4.1

package/dist/cjs/DPolygon.js

@@ -1,128 +1,44 @@
 "use strict";
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
-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;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DPolygon = exports.MIN_POINTS_IN_VALID_POLYGON = void 0;
-var DPoint_1 = require("./DPoint");
-var DLine_1 = require("./DLine");
-var DCircle_1 = require("./DCircle");
-var DNumbers_1 = require("./DNumbers");
-var jsts_1 = require("jsts");
-var DPolygonLoop_1 = require("./DPolygonLoop");
-var utils_1 = require("./utils");
-var _a = jsts_1.operation.buffer.BufferParameters, CAP_ROUND = _a.CAP_ROUND, CAP_FLAT = _a.CAP_FLAT, CAP_SQUARE = _a.CAP_SQUARE;
+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;
-var APPROXIMATION_VALUE = 0.1;
-var MAX_CONVEX_ITERATIONS = 100;
-var CLOSE_TO_INTERSECTION_DISTANCE = 0.001;
-var containCalculator = function (poly, p) {
-    var e_1, _a, e_2, _b;
-    var hasSamePoint = poly.points.some(function (point) { return point.equal(p); });
+const APPROXIMATION_VALUE = 0.1;
+const MAX_CONVEX_ITERATIONS = 100;
+const CLOSE_TO_INTERSECTION_DISTANCE = 0.001;
+const containCalculator = (poly, p) => {
+    const hasSamePoint = poly.points.some((point) => point.equal(p));
     if (hasSamePoint) {
         return true;
     }
-    try {
-        for (var _c = __values(poly.loopPointsGenerator(true)()), _d = _c.next(); !_d.done; _d = _c.next()) {
-            var _e = __read(_d.value, 3), polygonLine = _e[2];
-            var onBorder = polygonLine.x(p).equal(p) && polygonLine.inRange(p);
-            if (onBorder) {
-                return true;
-            }
+    for (const [, , polygonLine] of poly.loopPointsGenerator(true)()) {
+        const onBorder = polygonLine.x(p).equal(p) && polygonLine.inRange(p);
+        if (onBorder) {
+            return true;
         }
     }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-    finally {
-        try {
-            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
-        }
-        finally { if (e_1) throw e_1.error; }
-    }
-    var totalFi = 0;
-    try {
-        for (var _f = __values(poly.loopPointsGenerator()()), _g = _f.next(); !_g.done; _g = _f.next()) {
-            var _h = __read(_g.value, 2), _j = _h[0], x = _j.x, y = _j.y, _k = _h[1], a = _k.x, b = _k.y;
-            var line1 = new DLine_1.DLine(x - p.x, y - p.y, 0);
-            var line2 = new DLine_1.DLine(a - p.x, b - p.y, 0);
-            var fiDif = line1.findFi(line2);
-            if (line1.vectorProduct(line2).c > 0) {
-                totalFi += fiDif;
-            }
-            else {
-                totalFi -= fiDif;
-            }
+    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 fiDif = line1.findFi(line2);
+        if (line1.vectorProduct(line2).c > 0) {
+            totalFi += fiDif;
         }
-    }
-    catch (e_2_1) { e_2 = { error: e_2_1 }; }
-    finally {
-        try {
-            if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
+        else {
+            totalFi -= fiDif;
         }
-        finally { if (e_2) throw e_2.error; }
     }
-    var eps = Math.PI / 10000;
-    var result = false;
-    var absTotalFi = Math.abs(totalFi);
+    const eps = Math.PI / 10000;
+    let result = false;
+    const absTotalFi = Math.abs(totalFi);
     if (absTotalFi < eps) {
         result = false;
     }
@@ -134,58 +50,46 @@ var containCalculator = function (poly, p) {
     }
     return result;
 };
-var DPolygon = (function () {
-    function DPolygon(pPoints) {
-        if (pPoints === void 0) { pPoints = []; }
+class DPolygon {
+    constructor(pPoints = []) {
         this.pPoints = pPoints;
         this.properties = {};
         this.holes = [];
         this.searchStore = {};
     }
-    DPolygon.arrayOfTrianglesToVertices = function (triangles, height) {
-        return triangles.map(function (v) { return ((0, utils_1.isDefAndNotNull)(height) ? v
+    static arrayOfTrianglesToVertices(triangles, height) {
+        return triangles.map((v) => ((0, utils_1.isDefAndNotNull)(height) ? v
             .loop()
             .height(height)
             .run() : v)
-            .toArrayOfCoords(); })
+            .toArrayOfCoords())
             .flat(2);
-    };
-    DPolygon.minAreaRectangleSize = function (poly) {
-        var _a = poly.clone().open(), first = _a.first, second = _a.second, last = _a.last;
+    }
+    static minAreaRectangleSize(poly) {
+        const { first, second, last } = poly.clone().open();
         return new DPoint_1.DPoint(first.distance(second), first.distance(last));
-    };
-    DPolygon.toDash = function (poly) {
-        var e_3, _a;
-        var p = new DPolygon();
-        var result = [p];
-        var trigger = true;
-        try {
-            for (var _b = __values(poly.points), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var point = _c.value;
+    }
+    static toDash(poly) {
+        let p = new DPolygon();
+        const result = [p];
+        let trigger = true;
+        for (const point of poly.points) {
+            if (trigger) {
+                p.push(point.clone());
+            }
+            if (point.properties.pieceBorder) {
+                trigger = !trigger;
                 if (trigger) {
+                    p = new DPolygon();
+                    result.push(p);
                     p.push(point.clone());
                 }
-                if (point.properties.pieceBorder) {
-                    trigger = !trigger;
-                    if (trigger) {
-                        p = new DPolygon();
-                        result.push(p);
-                        p.push(point.clone());
-                    }
-                }
-            }
-        }
-        catch (e_3_1) { e_3 = { error: e_3_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
             }
-            finally { if (e_3) throw e_3.error; }
         }
         return result;
-    };
-    DPolygon.minAreaRectangleDirection = function (poly) {
-        var _a = poly.clone().open(), first = _a.first, second = _a.second, last = _a.last;
+    }
+    static minAreaRectangleDirection(poly) {
+        const { first, second, last } = poly.clone().open();
         if (!first || !second || !last) {
             return 0;
         }
@@ -193,581 +97,374 @@ var DPolygon = (function () {
             return first.findLine(second).getFi();
         }
         return first.findLine(last).getFi();
-    };
-    DPolygon.parseFromWKT = function (wkt) {
-        var data = wkt.trim().toUpperCase();
-        var res = new DPolygon();
+    }
+    static parseFromWKT(wkt) {
+        const data = wkt.trim().toUpperCase();
+        let res = new DPolygon();
         if (data.indexOf('POLYGON') === 0) {
-            var regexp = /POLYGON \(\((?<data>(?:(?!\)\)$).)*?)\)\)$/miu;
-            var reg = regexp.exec(data);
-            var _a = __read(reg.groups.data
+            const regexp = /POLYGON \(\((?<data>(?:(?!\)\)$).)*?)\)\)$/miu;
+            const reg = regexp.exec(data);
+            const [path, ...holes] = reg.groups.data
                 .split('), (')
-                .map(function (p) { return new DPolygon(p.split(', ')
-                .map(function (pares) { return DPoint_1.DPoint.parse(pares.split(' ').map(Number)); })); })), path = _a[0], holes = _a.slice(1);
+                .map((p) => new DPolygon(p.split(', ')
+                .map((pares) => DPoint_1.DPoint.parse(pares.split(' ').map(Number)))));
             if (holes && holes.length) {
                 path.holes = holes;
             }
             res = path;
         }
         if (data.indexOf('LINESTRING') === 0) {
-            var regexp = /LINESTRING \((?<data>(?:(?!\)$).)*?)\)$/miu;
-            var reg = regexp.exec(data);
+            const regexp = /LINESTRING \((?<data>(?:(?!\)$).)*?)\)$/miu;
+            const reg = regexp.exec(data);
             res = new DPolygon(reg.groups.data
-                .split(', ').map(function (t) { return DPoint_1.DPoint.parse(t.split(' ').map(Number)); }));
+                .split(', ').map((t) => DPoint_1.DPoint.parse(t.split(' ').map(Number))));
         }
         if (data.indexOf('POINT') === 0) {
             res = new DPolygon([DPoint_1.DPoint.parseFromWKT(data)]);
         }
         return res;
-    };
-    DPolygon.createSquareBySize = function (size) {
+    }
+    static createSquareBySize(size) {
         return new DPolygon([DPoint_1.DPoint.zero(), size.clone().setX(0), size.clone(), size.clone().setY(0)]).close();
-    };
-    DPolygon.prototype.loop = function () {
+    }
+    loop() {
         return new DPolygonLoop_1.DPolygonLoop(this);
-    };
-    Object.defineProperty(DPolygon.prototype, "points", {
-        get: function () {
-            return this.pPoints;
-        },
-        set: function (p) {
-            this.pPoints = p;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(DPolygon.prototype, "maxX", {
-        get: function () {
-            return this.reduce(function (a, r) { return Math.max(a, r.x); }, -Infinity);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(DPolygon.prototype, "minX", {
-        get: function () {
-            return this.reduce(function (a, r) { return Math.min(a, r.x); }, Infinity);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(DPolygon.prototype, "maxY", {
-        get: function () {
-            return this.reduce(function (a, r) { return Math.max(a, r.y); }, -Infinity);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(DPolygon.prototype, "minY", {
-        get: function () {
-            return this.reduce(function (a, r) { return Math.min(a, r.y); }, Infinity);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(DPolygon.prototype, "center", {
-        get: function () {
-            return this.leftTop.move(this.size.divide(2));
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(DPolygon.prototype, "h", {
-        get: function () {
-            return this.maxY - this.minY;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(DPolygon.prototype, "w", {
-        get: function () {
-            return this.maxX - this.minX;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(DPolygon.prototype, "dY", {
-        get: function () {
-            return this.h;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(DPolygon.prototype, "dX", {
-        get: function () {
-            return this.w;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(DPolygon.prototype, "extend", {
-        get: function () {
-            var _a = this, minX = _a.minX, minY = _a.minY, maxX = _a.maxX, maxY = _a.maxY;
-            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)
-            ]);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(DPolygon.prototype, "size", {
-        get: function () {
-            var _a = this, w = _a.w, h = _a.h;
-            return new DPoint_1.DPoint(w, h);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(DPolygon.prototype, "leftTop", {
-        get: function () {
-            var _a = this, minX = _a.minX, minY = _a.minY;
-            return new DPoint_1.DPoint(minX, minY);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(DPolygon.prototype, "rightBottom", {
-        get: function () {
-            var _a = this, maxX = _a.maxX, maxY = _a.maxY;
-            return new DPoint_1.DPoint(maxX, maxY);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(DPolygon.prototype, "length", {
-        get: function () {
-            return this.pPoints.length;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(DPolygon.prototype, "fullLength", {
-        get: function () {
-            return this.clone().open().perimeter;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(DPolygon.prototype, "perimeter", {
-        get: function () {
-            var e_4, _a;
-            var p = 0;
-            try {
-                for (var _b = __values(this.loopPointsGenerator()()), _c = _b.next(); !_c.done; _c = _b.next()) {
-                    var _d = __read(_c.value, 2), p1 = _d[0], p2 = _d[1];
-                    p += p1.distance(p2);
-                }
-            }
-            catch (e_4_1) { e_4 = { error: e_4_1 }; }
-            finally {
-                try {
-                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-                }
-                finally { if (e_4) throw e_4.error; }
-            }
-            return p;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(DPolygon.prototype, "area", {
-        get: function () {
-            var e_5, _a;
-            var sum = 0;
-            try {
-                for (var _b = __values(this.deintersection.loopPointsGenerator()()), _c = _b.next(); !_c.done; _c = _b.next()) {
-                    var _d = __read(_c.value, 2), _e = _d[0], x = _e.x, y = _e.y, _f = _d[1], a = _f.x, b = _f.y;
-                    sum += x * b - y * a;
-                }
-            }
-            catch (e_5_1) { e_5 = { error: e_5_1 }; }
-            finally {
-                try {
-                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-                }
-                finally { if (e_5) throw e_5.error; }
-            }
-            return Math.abs(sum / 2) - this.holes.reduce(function (a, hole) { return a + hole.area; }, 0);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(DPolygon.prototype, "deintersection", {
-        get: function () {
-            var e_6, _a;
-            var p = this.clone().close();
-            var store = {};
-            for (var i = 0; i < p.length - 1; i++) {
-                var k = p.at(i).toString();
-                store[k] = store[k] || [];
-                store[k].push(i);
-                var _loop_1 = function (j) {
-                    var firstLine = p.at(i).findLine(p.at(i + 1));
-                    var secondLine = p.at(j).findLine(p.at(j + 1));
-                    var intersectionPoint = firstLine.intersection(secondLine);
-                    if (intersectionPoint &&
-                        !__spreadArray(__spreadArray([], __read(firstLine.points), false), __read(secondLine.points), false).some(function (t) { return t.like(intersectionPoint); })) {
-                        var part = p.removePart(i, j - i).reverse();
-                        p.insertAfter.apply(p, __spreadArray([i], __read(part), false));
-                        p.insertAfter(j, intersectionPoint);
-                        p.insertAfter(i, intersectionPoint);
-                    }
-                };
-                for (var j = i + 2; j < p.length - 1; j++) {
-                    _loop_1(j);
+    }
+    set points(p) {
+        this.pPoints = p;
+    }
+    get points() {
+        return this.pPoints;
+    }
+    get maxX() {
+        return this.reduce((a, r) => Math.max(a, r.x), -Infinity);
+    }
+    get minX() {
+        return this.reduce((a, r) => Math.min(a, r.x), Infinity);
+    }
+    get maxY() {
+        return this.reduce((a, r) => Math.max(a, r.y), -Infinity);
+    }
+    get minY() {
+        return this.reduce((a, r) => Math.min(a, r.y), Infinity);
+    }
+    get center() {
+        return this.leftTop.move(this.size.divide(2));
+    }
+    get h() {
+        return this.maxY - this.minY;
+    }
+    get w() {
+        return this.maxX - this.minX;
+    }
+    get dY() {
+        return this.h;
+    }
+    get dX() {
+        return this.w;
+    }
+    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)
+        ]);
+    }
+    get size() {
+        const { w, h } = this;
+        return new DPoint_1.DPoint(w, h);
+    }
+    get leftTop() {
+        const { minX, minY } = this;
+        return new DPoint_1.DPoint(minX, minY);
+    }
+    get rightBottom() {
+        const { maxX, maxY } = this;
+        return new DPoint_1.DPoint(maxX, maxY);
+    }
+    get length() {
+        return this.pPoints.length;
+    }
+    get fullLength() {
+        return this.clone().open().perimeter;
+    }
+    get perimeter() {
+        let p = 0;
+        for (const [p1, p2] of this.loopPointsGenerator()()) {
+            p += p1.distance(p2);
+        }
+        return p;
+    }
+    get area() {
+        let sum = 0;
+        for (const [{ x, y }, { x: a, y: b }] of this.deintersection.loopPointsGenerator()()) {
+            sum += x * b - y * a;
+        }
+        return Math.abs(sum / 2) - this.holes.reduce((a, hole) => a + hole.area, 0);
+    }
+    get deintersection() {
+        let p = this.clone().close();
+        const store = {};
+        for (let i = 0; i < p.length - 1; i++) {
+            const k = p.at(i).toString();
+            store[k] = store[k] || [];
+            store[k].push(i);
+            for (let j = i + 2; j < p.length - 1; j++) {
+                const firstLine = p.at(i).findLine(p.at(i + 1));
+                const secondLine = p.at(j).findLine(p.at(j + 1));
+                const intersectionPoint = firstLine.intersection(secondLine);
+                if (intersectionPoint &&
+                    ![...firstLine.points, ...secondLine.points].some((t) => t.like(intersectionPoint))) {
+                    const part = p.removePart(i, j - i).reverse();
+                    p.insertAfter(i, ...part);
+                    p.insertAfter(j, intersectionPoint);
+                    p.insertAfter(i, intersectionPoint);
                 }
             }
-            try {
-                for (var _b = __values(Object.keys(store)), _c = _b.next(); !_c.done; _c = _b.next()) {
-                    var key = _c.value;
-                    var record = store[key];
-                    if (record.length > 1) {
-                        var _loop_2 = function (j) {
-                            var origin_1 = p.clone();
-                            var d = record[j] - record[j - 1];
-                            if (d > 1) {
-                                var part = new DPolygon(origin_1.removePart(record[j - 1], d));
-                                var allInside = part.reduce(function (a, e) { return a && containCalculator(origin_1, e); }, true);
-                                if (allInside && origin_1.isClockwise === part.isClockwise) {
-                                    origin_1.insertAfter.apply(origin_1, __spreadArray([record[j - 1] - 1], __read(part.reverse().points), false));
-                                    p = origin_1;
-                                }
-                            }
-                        };
-                        for (var j = record.length - 1; j > 0; j--) {
-                            _loop_2(j);
+        }
+        for (const key of Object.keys(store)) {
+            const record = store[key];
+            if (record.length > 1) {
+                for (let j = record.length - 1; j > 0; j--) {
+                    const origin = p.clone();
+                    const d = record[j] - record[j - 1];
+                    if (d > 1) {
+                        const part = new DPolygon(origin.removePart(record[j - 1], d));
+                        const allInside = part.reduce((a, e) => a && containCalculator(origin, e), true);
+                        if (allInside && origin.isClockwise === part.isClockwise) {
+                            origin.insertAfter(record[j - 1] - 1, ...part.reverse().points);
+                            p = origin;
                         }
                     }
                 }
             }
-            catch (e_6_1) { e_6 = { error: e_6_1 }; }
-            finally {
-                try {
-                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        return p;
+    }
+    get valid() {
+        return this.length > exports.MIN_POINTS_IN_VALID_POLYGON;
+    }
+    get first() {
+        return this.at(0);
+    }
+    get second() {
+        return this.at(1);
+    }
+    get last() {
+        return this.at(this.length - 1);
+    }
+    get minAreaRectangle() {
+        const p = this.convex;
+        let resultPolygon = new DPolygon();
+        let resultArea = Infinity;
+        for (const [, , l] of p.loopPointsGenerator(true)()) {
+            let maxWidth = 0;
+            let maxWidthPoint1 = null;
+            let maxWidthPoint2 = null;
+            let maxHeight = 0;
+            let maxHeightPoint = null;
+            for (const [z, , , i] of p.loopPointsGenerator()()) {
+                const p1 = l.findPoint(l.findPerpendicular(z));
+                const h = p1.distance(z);
+                if (h >= maxHeight) {
+                    maxHeight = h;
+                    maxHeightPoint = z;
                 }
-                finally { if (e_6) throw e_6.error; }
-            }
-            return p;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(DPolygon.prototype, "valid", {
-        get: function () {
-            return this.length > exports.MIN_POINTS_IN_VALID_POLYGON;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(DPolygon.prototype, "first", {
-        get: function () {
-            return this.at(0);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(DPolygon.prototype, "second", {
-        get: function () {
-            return this.at(1);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(DPolygon.prototype, "last", {
-        get: function () {
-            return this.at(this.length - 1);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(DPolygon.prototype, "minAreaRectangle", {
-        get: function () {
-            var e_7, _a, e_8, _b;
-            var p = this.convex;
-            var resultPolygon = new DPolygon();
-            var resultArea = Infinity;
-            try {
-                for (var _c = __values(p.loopPointsGenerator(true)()), _d = _c.next(); !_d.done; _d = _c.next()) {
-                    var _e = __read(_d.value, 3), l = _e[2];
-                    var maxWidth = 0;
-                    var maxWidthPoint1 = null;
-                    var maxWidthPoint2 = null;
-                    var maxHeight = 0;
-                    var maxHeightPoint = null;
-                    try {
-                        for (var _f = (e_8 = void 0, __values(p.loopPointsGenerator()())), _g = _f.next(); !_g.done; _g = _f.next()) {
-                            var _h = __read(_g.value, 4), z = _h[0], i = _h[3];
-                            var p1 = l.findPoint(l.findPerpendicular(z));
-                            var h = p1.distance(z);
-                            if (h >= maxHeight) {
-                                maxHeight = h;
-                                maxHeightPoint = z;
-                            }
-                            for (var j = i; j < p.length - 1; j++) {
-                                var p2 = l.findPoint(l.findPerpendicular(p.at(j)));
-                                var w = p1.distance(p2);
-                                if (w >= maxWidth) {
-                                    maxWidth = w;
-                                    maxWidthPoint1 = p1;
-                                    maxWidthPoint2 = p2;
-                                }
-                            }
-                        }
-                    }
-                    catch (e_8_1) { e_8 = { error: e_8_1 }; }
-                    finally {
-                        try {
-                            if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
-                        }
-                        finally { if (e_8) throw e_8.error; }
-                    }
-                    if (!maxWidthPoint1 || !maxWidthPoint2 || !maxHeightPoint) {
-                        continue;
-                    }
-                    var widthLine = maxWidthPoint1.findLine(maxWidthPoint2);
-                    var perpendicular1 = widthLine.findPerpendicular(maxWidthPoint1);
-                    var perpendicular2 = widthLine.findPerpendicular(maxWidthPoint2);
-                    var tempPolygon = new DPolygon([
-                        maxWidthPoint1,
-                        maxWidthPoint2,
-                        perpendicular2.findPoint(perpendicular2.findPerpendicular(maxHeightPoint)),
-                        perpendicular1.findPoint(perpendicular1.findPerpendicular(maxHeightPoint))
-                    ]).close();
-                    if (tempPolygon.area < resultArea) {
-                        resultPolygon = tempPolygon;
-                        resultArea = tempPolygon.area;
+                for (let j = i; j < p.length - 1; j++) {
+                    const p2 = l.findPoint(l.findPerpendicular(p.at(j)));
+                    const w = p1.distance(p2);
+                    if (w >= maxWidth) {
+                        maxWidth = w;
+                        maxWidthPoint1 = p1;
+                        maxWidthPoint2 = p2;
                     }
                 }
             }
-            catch (e_7_1) { e_7 = { error: e_7_1 }; }
-            finally {
-                try {
-                    if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
-                }
-                finally { if (e_7) throw e_7.error; }
+            if (!maxWidthPoint1 || !maxWidthPoint2 || !maxHeightPoint) {
+                continue;
             }
-            return resultPolygon;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(DPolygon.prototype, "convex", {
-        get: function () {
-            var p = this.clone().open();
-            var isClockwise = p.isClockwise;
-            if (!isClockwise) {
-                p.reverse();
+            const widthLine = maxWidthPoint1.findLine(maxWidthPoint2);
+            const perpendicular1 = widthLine.findPerpendicular(maxWidthPoint1);
+            const perpendicular2 = widthLine.findPerpendicular(maxWidthPoint2);
+            const tempPolygon = new DPolygon([
+                maxWidthPoint1,
+                maxWidthPoint2,
+                perpendicular2.findPoint(perpendicular2.findPerpendicular(maxHeightPoint)),
+                perpendicular1.findPoint(perpendicular1.findPerpendicular(maxHeightPoint))
+            ]).close();
+            if (tempPolygon.area < resultArea) {
+                resultPolygon = tempPolygon;
+                resultArea = tempPolygon.area;
             }
-            var l = 0;
-            do {
-                var p1 = p.last;
-                var p2 = p.first;
-                var p3 = p.second;
-                var 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)) {
-                    p.removePart(-1, 1);
-                }
-                else {
-                    break;
-                }
-            } while (p.length);
-            p.close();
-            var iteration = 0;
-            do {
-                p = p.deintersection;
-                l = p.length;
-                for (var i = 1; i < p.length - 1; i++) {
-                    var p1 = p.at(i - 1);
-                    var p2 = p.at(i);
-                    var p3 = p.at(i + 1);
-                    var 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)) {
-                        p.removePart(--i, 1);
-                    }
-                }
-                iteration++;
-            } while (p.length !== l && iteration < MAX_CONVEX_ITERATIONS);
-            if (!isClockwise) {
-                p.reverse();
-            }
-            return p;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(DPolygon.prototype, "isClockwise", {
-        get: function () {
-            var e_9, _a;
-            var sum = 0;
-            try {
-                for (var _b = __values(this.clone().close()
-                    .loopPointsGenerator()()), _c = _b.next(); !_c.done; _c = _b.next()) {
-                    var _d = __read(_c.value, 2), _e = _d[0], x = _e.x, y = _e.y, _f = _d[1], a = _f.x, b = _f.y;
-                    sum += (a - x) * (b + y);
-                }
-            }
-            catch (e_9_1) { e_9 = { error: e_9_1 }; }
-            finally {
-                try {
-                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-                }
-                finally { if (e_9) throw e_9.error; }
+        }
+        return resultPolygon;
+    }
+    get convex() {
+        let p = this.clone().open();
+        const { isClockwise } = p;
+        if (!isClockwise) {
+            p.reverse();
+        }
+        let l = 0;
+        do {
+            const p1 = p.last;
+            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)) {
+                p.removePart(-1, 1);
             }
-            return sum < 0;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(DPolygon.prototype, "clockWise", {
-        get: function () {
-            if (this.isClockwise) {
-                return this.clone();
+            else {
+                break;
             }
-            return this.clone().reverse();
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(DPolygon.prototype, "noHoles", {
-        get: function () {
-            var res = this.clone();
-            res.holes = [];
-            return res;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    DPolygon.prototype.reduce = function (f, v) {
-        return this.pPoints.reduce(f, v);
-    };
-    DPolygon.prototype.intersection = function (l, includeOnly) {
-        var e_10, _a;
-        if (includeOnly === void 0) { includeOnly = false; }
-        var res = [];
-        try {
-            for (var _b = __values(this.loopPointsGenerator(true)()), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var _d = __read(_c.value, 3), line = _d[2];
-                var intersect = line.intersection(l, 0, includeOnly);
-                if (intersect) {
-                    res.push(intersect);
+        } while (p.length);
+        p.close();
+        let iteration = 0;
+        do {
+            p = p.deintersection;
+            l = p.length;
+            for (let i = 1; i < p.length - 1; i++) {
+                const p1 = p.at(i - 1);
+                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)) {
+                    p.removePart(--i, 1);
                 }
             }
+            iteration++;
+        } while (p.length !== l && iteration < MAX_CONVEX_ITERATIONS);
+        if (!isClockwise) {
+            p.reverse();
+        }
+        return p;
+    }
+    get isClockwise() {
+        let sum = 0;
+        for (const [{ x, y }, { x: a, y: b }] of this.clone().close()
+            .loopPointsGenerator()()) {
+            sum += (a - x) * (b + y);
+        }
+        return sum < 0;
+    }
+    get clockWise() {
+        if (this.isClockwise) {
+            return this.clone();
         }
-        catch (e_10_1) { e_10 = { error: e_10_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        return this.clone().reverse();
+    }
+    get noHoles() {
+        const res = this.clone();
+        res.holes = [];
+        return res;
+    }
+    reduce(f, v) {
+        return this.pPoints.reduce(f, v);
+    }
+    intersection(l, includeOnly = false) {
+        const res = [];
+        for (const [, , line] of this.loopPointsGenerator(true)()) {
+            const intersect = line.intersection(l, 0, includeOnly);
+            if (intersect) {
+                res.push(intersect);
             }
-            finally { if (e_10) throw e_10.error; }
         }
         return res;
-    };
-    DPolygon.prototype.setCenter = function (newCenter) {
+    }
+    setCenter(newCenter) {
         return this.loop()
             .move(newCenter.clone().move(this.center.minus()))
             .run();
-    };
-    DPolygon.prototype.toWKT = function (type, withZ) {
-        if (type === void 0) { type = DPolygon.WKT_POLYGON; }
-        if (withZ === void 0) { withZ = false; }
+    }
+    toWKT(type = DPolygon.WKT_POLYGON, withZ = false) {
         if (type === DPolygon.WKT_POLYGON) {
-            var h = '';
+            let h = '';
             if (this.holes && this.holes.length) {
-                h = ", " + this.holes.map(function (hole) { return hole.toString(); })
-                    .join(', ');
+                h = `, ${this.holes.map((hole) => hole.toString())
+                    .join(', ')}`;
             }
-            return "POLYGON ((" + this.deintersection.mapArray(function (r) { return r.x + " " + r.y + (withZ ? " " + r.z : ''); })
-                .join(', ') + ")" + h + ")";
+            return `POLYGON ((${this.deintersection.mapArray((r) => `${r.x} ${r.y}${withZ ? ` ${r.z}` : ''}`)
+                .join(', ')})${h})`;
         }
-        return "LINESTRING (" + this.mapArray(function (r) { return r.x + " " + r.y + (withZ ? " " + r.z : ''); })
-            .join(', ') + ")";
-    };
-    DPolygon.prototype.filter = function (f) {
+        return `LINESTRING (${this.mapArray((r) => `${r.x} ${r.y}${withZ ? ` ${r.z}` : ''}`)
+            .join(', ')})`;
+    }
+    filter(f) {
         this.pPoints = this.pPoints.filter(f);
         return this;
-    };
-    DPolygon.prototype.map = function (f) {
+    }
+    map(f) {
         this.pPoints = this.mapArray(f);
-        this.holes = this.holes.map(function (h) { return h.map(f); });
+        this.holes = this.holes.map((h) => h.map(f));
         return this;
-    };
-    DPolygon.prototype.mapArray = function (f) {
+    }
+    mapArray(f) {
         return this.pPoints.map(f);
-    };
-    DPolygon.prototype.sort = function (f) {
+    }
+    sort(f) {
         this.points.sort(f);
         return this;
-    };
-    DPolygon.prototype.at = function (index) {
-        var length = this.length;
+    }
+    at(index) {
+        const { length } = this;
         return this.points[(index % length + length) % length];
-    };
-    DPolygon.prototype.pop = function () {
+    }
+    pop() {
         return this.pPoints.pop();
-    };
-    DPolygon.prototype.push = function () {
-        var _a;
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        return (_a = this.pPoints).push.apply(_a, __spreadArray([], __read(args), false));
-    };
-    DPolygon.prototype.shift = function () {
+    }
+    push(...args) {
+        return this.pPoints.push(...args);
+    }
+    shift() {
         return this.pPoints.shift();
-    };
-    DPolygon.prototype.unshift = function () {
-        var _a;
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        return (_a = this.pPoints).unshift.apply(_a, __spreadArray([], __read(args), false));
-    };
-    DPolygon.prototype.reverse = function () {
+    }
+    unshift(...args) {
+        return this.pPoints.unshift(...args);
+    }
+    reverse() {
         this.pPoints = this.pPoints.reverse();
-        this.holes = this.holes.map(function (h) { return h.reverse(); });
+        this.holes = this.holes.map((h) => h.reverse());
         return this;
-    };
-    DPolygon.prototype.getValue = function () {
-        return (this.pPoints.map(function (r) { return r.getValue(); }) + this.holes
-            .reduce(function (a, h) { return a + h.getValue(); }, ''));
-    };
-    DPolygon.prototype.toString = function () {
-        return "(" + this.mapArray(function (r) { return r.toString(); }).join(', ') + ")";
-    };
-    DPolygon.prototype.close = function () {
-        var p0 = this.first;
+    }
+    getValue() {
+        return (this.pPoints.map((r) => r.getValue()) + this.holes
+            .reduce((a, h) => a + h.getValue(), ''));
+    }
+    toString() {
+        return `(${this.mapArray((r) => r.toString()).join(', ')})`;
+    }
+    close() {
+        const p0 = this.first;
         if (p0 && !this.closed) {
             this.push(p0.clone());
         }
         return this;
-    };
-    DPolygon.prototype.open = function () {
-        var p = this.first;
+    }
+    open() {
+        const p = this.first;
         if (this.length > 2 && p && this.closed) {
             this.pop();
         }
         return this;
-    };
-    DPolygon.prototype.add = function (poly) {
-        var res = new DPolygon(__spreadArray(__spreadArray([], __read(this.points), false), __read(poly.points), false)).close();
-        res.holes = __spreadArray(__spreadArray([], __read(this.holes), false), __read(poly.holes), false).map(function (h) { return h.clone(); });
+    }
+    add(poly) {
+        const res = new DPolygon([...this.points, ...poly.points]).close();
+        res.holes = [...this.holes, ...poly.holes].map((h) => h.clone());
         return res;
-    };
-    DPolygon.prototype.has = function (p) {
-        return this.pPoints.some(function (q) { return q.equal(p); });
-    };
-    DPolygon.prototype.clone = function () {
-        var res = new DPolygon(this.points.map(function (r) { return r.clone(); }));
-        res.holes = this.holes.map(function (h) { return h.clone(); });
+    }
+    has(p) {
+        return this.pPoints.some((q) => q.equal(p));
+    }
+    clone() {
+        const res = new DPolygon(this.points.map((r) => r.clone()));
+        res.holes = this.holes.map((h) => h.clone());
         res.properties = this.properties;
         return res;
-    };
-    DPolygon.prototype.equal = function (p) {
+    }
+    equal(p) {
         if (!(p instanceof DPolygon)) {
             return false;
         }
@@ -775,14 +472,14 @@ var DPolygon = (function () {
             return false;
         }
         return (this.same(p) &&
-            this.holes.reduce(function (a, hole) { return a && p.holes.some(function (pHoles) { return pHoles.same(hole); }); }, true));
-    };
-    DPolygon.prototype.same = function (p) {
-        var pClone = p.clone().close();
-        var thisAsString = this.clone()
+            this.holes.reduce((a, hole) => a && p.holes.some((pHoles) => pHoles.same(hole)), true));
+    }
+    same(p) {
+        const pClone = p.clone().close();
+        const thisAsString = this.clone()
             .close()
             .toString();
-        for (var i = 0; i < pClone.length; i++) {
+        for (let i = 0; i < pClone.length; i++) {
             if (thisAsString === pClone.toString() || thisAsString === pClone.clone().reverse()
                 .toString()) {
                 return true;
@@ -790,45 +487,37 @@ var DPolygon = (function () {
             pClone.nextStart();
         }
         return false;
-    };
-    DPolygon.prototype.findIndex = function (a) {
+    }
+    findIndex(a) {
         if (a instanceof DPoint_1.DPoint) {
-            return this.points.findIndex(function (t) { return t.equal(a); });
+            return this.points.findIndex((t) => t.equal(a));
         }
         return this.points.findIndex(a);
-    };
-    DPolygon.prototype.approximation = function (e) {
-        if (e === void 0) { e = Math.sqrt(this.perimeter) * APPROXIMATION_VALUE; }
+    }
+    approximation(e = Math.sqrt(this.perimeter) * APPROXIMATION_VALUE) {
         return new DPolygon(this.clone().douglasPeucker(this.pPoints, e));
-    };
-    DPolygon.prototype.insertAfter = function (index) {
-        var _a;
-        var points = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            points[_i - 1] = arguments[_i];
-        }
-        (_a = this.pPoints).splice.apply(_a, __spreadArray([index + 1, 0], __read(points), false));
-    };
-    DPolygon.prototype.removePart = function (index, count) {
+    }
+    insertAfter(index, ...points) {
+        this.pPoints.splice(index + 1, 0, ...points);
+    }
+    removePart(index, count) {
         return this.pPoints.splice(index + 1, count);
-    };
-    DPolygon.prototype.hasSimpleIntersection = function (p) {
-        var extend1 = this.extend;
-        var extend2 = p.extend;
-        var extend1points = extend1.points;
-        var extend2points = extend2.points;
-        var in1 = extend1points.some(function (t) { return extend2.simpleInclude(t); });
-        var in2 = extend2points.some(function (t) { return extend1.simpleInclude(t); });
+    }
+    hasSimpleIntersection(p) {
+        const extend1 = this.extend;
+        const extend2 = p.extend;
+        const extend1points = extend1.points;
+        const extend2points = extend2.points;
+        const in1 = extend1points.some((t) => extend2.simpleInclude(t));
+        const in2 = extend2points.some((t) => extend1.simpleInclude(t));
         return in1 || in2;
-    };
-    DPolygon.prototype.simpleInclude = function (p) {
+    }
+    simpleInclude(p) {
         return this.simpleIncludeX(p) && this.simpleIncludeY(p);
-    };
-    DPolygon.prototype.drawPolygonOnCanvas = function (canvas, fillColor, strokeColor, shadowColor, lineWidth, steps) {
-        if (lineWidth === void 0) { lineWidth = 1; }
-        if (steps === void 0) { steps = this.length - 1; }
+    }
+    drawPolygonOnCanvas(canvas, fillColor, strokeColor, shadowColor, lineWidth = 1, steps = this.length - 1) {
         if (this.length > 1) {
-            var ctx = canvas.getContext('2d');
+            const ctx = canvas.getContext('2d');
             if (fillColor) {
                 ctx.fillStyle = fillColor;
             }
@@ -857,51 +546,39 @@ var DPolygon = (function () {
             }
         }
         return this;
-    };
-    DPolygon.prototype.clearPolygonOnCanvas = function (canvas) {
-        var ctx = canvas.getContext('2d');
-        var old = ctx.globalCompositeOperation;
+    }
+    clearPolygonOnCanvas(canvas) {
+        const ctx = canvas.getContext('2d');
+        const old = ctx.globalCompositeOperation;
         ctx.globalCompositeOperation = 'destination-out';
         this.goByPath(ctx);
         ctx.fill();
         ctx.globalCompositeOperation = old;
-    };
-    DPolygon.prototype.contain = function (p, isBorderInside) {
-        var e_11, _a;
-        if (isBorderInside === void 0) { isBorderInside = false; }
-        var simpleInclude = this.simpleInclude(p);
+    }
+    contain(p, isBorderInside = false) {
+        const simpleInclude = this.simpleInclude(p);
         if (!simpleInclude) {
             return false;
         }
-        var onBorder = this.onBorder(p);
+        const onBorder = this.onBorder(p);
         if (onBorder) {
             return isBorderInside;
         }
-        var poly = this.deintersection;
-        var totalFi = 0;
-        try {
-            for (var _b = __values(poly.loopPointsGenerator()()), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var _d = __read(_c.value, 2), _e = _d[0], x = _e.x, y = _e.y, _f = _d[1], a = _f.x, b = _f.y;
-                var line1 = new DLine_1.DLine(x - p.x, y - p.y, 0);
-                var line2 = new DLine_1.DLine(a - p.x, b - p.y, 0);
-                var fiDif = line1.findFi(line2);
-                if (line1.vectorProduct(line2).c > 0) {
-                    totalFi += fiDif;
-                }
-                else {
-                    totalFi -= fiDif;
-                }
+        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 fiDif = line1.findFi(line2);
+            if (line1.vectorProduct(line2).c > 0) {
+                totalFi += fiDif;
             }
-        }
-        catch (e_11_1) { e_11 = { error: e_11_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            else {
+                totalFi -= fiDif;
             }
-            finally { if (e_11) throw e_11.error; }
         }
-        var eps = Math.PI / 10000;
-        var absTotalFi = Math.abs(totalFi);
+        const eps = Math.PI / 10000;
+        const absTotalFi = Math.abs(totalFi);
         if (absTotalFi < eps) {
             return false;
         }
@@ -909,123 +586,89 @@ var DPolygon = (function () {
             return true;
         }
         throw new Error('contains2 faild');
-    };
-    DPolygon.prototype.onBorder = function (p) {
-        var e_12, _a;
-        var simpleInclude = this.simpleInclude(p);
+    }
+    onBorder(p) {
+        const simpleInclude = this.simpleInclude(p);
         if (simpleInclude) {
-            var poly = this.deintersection;
-            var hasSamePoint = this.points.some(function (point) { return point.equal(p); });
+            const poly = this.deintersection;
+            const hasSamePoint = this.points.some((point) => point.equal(p));
             if (hasSamePoint) {
                 return true;
             }
-            try {
-                for (var _b = __values(poly.loopPointsGenerator(true)()), _c = _b.next(); !_c.done; _c = _b.next()) {
-                    var _d = __read(_c.value, 3), polygonLine = _d[2];
-                    var onBorder = polygonLine.x(p).equal(p) && polygonLine.inRange(p);
-                    if (onBorder) {
-                        return true;
-                    }
-                }
-            }
-            catch (e_12_1) { e_12 = { error: e_12_1 }; }
-            finally {
-                try {
-                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            for (const [, , polygonLine] of poly.loopPointsGenerator(true)()) {
+                const onBorder = polygonLine.x(p).equal(p) && polygonLine.inRange(p);
+                if (onBorder) {
+                    return true;
                 }
-                finally { if (e_12) throw e_12.error; }
             }
         }
         return false;
-    };
-    DPolygon.prototype.nextStart = function () {
+    }
+    nextStart() {
         this.open();
         this.push(this.shift());
         this.close();
         return this;
-    };
-    DPolygon.prototype.removeDuplicates = function () {
-        for (var i = 0; i < this.length - 1; i++) {
-            var p1 = this.at(i);
-            var p2 = this.at(i + 1);
+    }
+    removeDuplicates() {
+        for (let i = 0; i < this.length - 1; i++) {
+            const p1 = this.at(i);
+            const p2 = this.at(i + 1);
             if (p1.equal(p2)) {
                 this.removePart(i, 1);
                 i--;
             }
         }
         return this;
-    };
-    DPolygon.parse = function (a) {
-        return new DPolygon(a.map(function (r) { return DPoint_1.DPoint.parse(r); }));
-    };
-    DPolygon.prototype.toArrayOfCoords = function () {
-        return this.mapArray(function (r) { return r.toCoords(); });
-    };
-    DPolygon.prototype.divideToPieces = function (piecesCount) {
-        var e_13, _a;
-        var fullLength = this.fullLength;
-        var pieceLength = fullLength / piecesCount;
-        var currentPieceLength = pieceLength;
-        var _loop_3 = function (p1, p2, i) {
-            var d = p1.distance(p2);
+    }
+    static parse(a) {
+        return new DPolygon(a.map((r) => DPoint_1.DPoint.parse(r)));
+    }
+    toArrayOfCoords() {
+        return this.mapArray((r) => r.toCoords());
+    }
+    divideToPieces(piecesCount, withAltitude = false) {
+        const { fullLength } = this;
+        const pieceLength = fullLength / piecesCount;
+        let currentPieceLength = pieceLength;
+        for (const [p1, p2, , i] of this.loopPointsGenerator()()) {
+            const d = p1.distance(p2);
             if (d === currentPieceLength) {
                 p2.properties.pieceBorder = true;
                 currentPieceLength = pieceLength;
             }
             else if (d - currentPieceLength > 0) {
-                var circle = new DCircle_1.DCircle(p1, currentPieceLength);
-                var line_1 = p1.findLine(p2);
-                var intersectionPoint = line_1.intersectionWithCircle(circle)
-                    .filter(function (p) { return line_1.inRange(p, CLOSE_TO_INTERSECTION_DISTANCE); })[0];
+                const circle = new DCircle_1.DCircle(p1, currentPieceLength);
+                const line = p1.findLine(p2);
+                const intersectionPoint = line.intersectionWithCircle(circle)
+                    .filter((p) => line.inRange(p, CLOSE_TO_INTERSECTION_DISTANCE))[0];
                 intersectionPoint.properties.pieceBorder = true;
-                this_1.insertAfter(i, intersectionPoint);
+                this.insertAfter(i, intersectionPoint);
+                if (withAltitude) {
+                    const p1z = p1.z;
+                    intersectionPoint.z = p1z - (p1z - p2.z) * (p1.distance(intersectionPoint) / d);
+                }
                 currentPieceLength = pieceLength;
             }
             else {
                 currentPieceLength -= d;
             }
-        };
-        var this_1 = this;
-        try {
-            for (var _b = __values(this.loopPointsGenerator()()), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var _d = __read(_c.value, 4), p1 = _d[0], p2 = _d[1], i = _d[3];
-                _loop_3(p1, p2, i);
-            }
-        }
-        catch (e_13_1) { e_13 = { error: e_13_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-            }
-            finally { if (e_13) throw e_13.error; }
         }
         return this;
-    };
-    DPolygon.prototype.prepareToFastSearch = function () {
-        var e_14, _a;
+    }
+    prepareToFastSearch() {
         this.searchStore = {};
-        try {
-            for (var _b = __values(this.points), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var _d = _c.value, x = _d.x, y = _d.y, z = _d.z;
-                if (!this.searchStore[x]) {
-                    this.searchStore[x] = {};
-                }
-                if (!this.searchStore[x][y]) {
-                    this.searchStore[x][y] = {};
-                }
-                this.searchStore[x][y][z || 'undefined'] = true;
+        for (const { x, y, z } of this.points) {
+            if (!this.searchStore[x]) {
+                this.searchStore[x] = {};
             }
-        }
-        catch (e_14_1) { e_14 = { error: e_14_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            if (!this.searchStore[x][y]) {
+                this.searchStore[x][y] = {};
             }
-            finally { if (e_14) throw e_14.error; }
+            this.searchStore[x][y][z || 'undefined'] = true;
         }
-    };
-    DPolygon.prototype.fastHas = function (_a) {
-        var x = _a.x, y = _a.y, z = _a.z;
+    }
+    fastHas({ x, y, z }) {
         if (!this.searchStore[x]) {
             return false;
         }
@@ -1036,56 +679,23 @@ var DPolygon = (function () {
             return false;
         }
         return this.searchStore[x][y][z || 'undefined'];
-    };
-    Object.defineProperty(DPolygon.prototype, "growingPiecesGenerator", {
-        get: function () {
-            var polygon = this;
-            return function () {
-                var r, _a, _b, p, e_15_1;
-                var e_15, _c;
-                return __generator(this, function (_d) {
-                    switch (_d.label) {
-                        case 0:
-                            r = new DPolygon();
-                            _d.label = 1;
-                        case 1:
-                            _d.trys.push([1, 6, 7, 8]);
-                            _a = __values(polygon.pPoints), _b = _a.next();
-                            _d.label = 2;
-                        case 2:
-                            if (!!_b.done) return [3, 5];
-                            p = _b.value;
-                            r.push(p);
-                            if (!p.properties.pieceBorder) return [3, 4];
-                            return [4, r.clone()];
-                        case 3:
-                            _d.sent();
-                            _d.label = 4;
-                        case 4:
-                            _b = _a.next();
-                            return [3, 2];
-                        case 5: return [3, 8];
-                        case 6:
-                            e_15_1 = _d.sent();
-                            e_15 = { error: e_15_1 };
-                            return [3, 8];
-                        case 7:
-                            try {
-                                if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
-                            }
-                            finally { if (e_15) throw e_15.error; }
-                            return [7];
-                        case 8: return [2, r.clone()];
-                    }
-                });
-            };
-        },
-        enumerable: false,
-        configurable: true
-    });
-    DPolygon.prototype.simpleUnion = function (p) {
+    }
+    get growingPiecesGenerator() {
+        const polygon = this;
+        return function* () {
+            const r = new DPolygon();
+            for (const p of polygon.pPoints) {
+                r.push(p);
+                if (p.properties.pieceBorder) {
+                    yield r.clone();
+                }
+            }
+            return r.clone();
+        };
+    }
+    simpleUnion(p) {
         try {
-            var res = this.simpleLogicFunction(p, true, true);
+            const res = this.simpleLogicFunction(p, true, true);
             if (res === null) {
                 return null;
             }
@@ -1097,77 +707,49 @@ var DPolygon = (function () {
         catch (ex) {
             return null;
         }
-    };
-    DPolygon.prototype.simpleIntersection = function (p) {
+    }
+    simpleIntersection(p) {
         return this.simpleLogicFunction(p, false, false);
-    };
-    DPolygon.prototype.simpleDifference = function (p) {
+    }
+    simpleDifference(p) {
         return this.simpleLogicFunction(p, true, false);
-    };
-    DPolygon.prototype.smartUnion = function (p) {
-        var e_16, _a;
-        var res = this.clone().simpleUnion(p);
+    }
+    smartUnion(p) {
+        const res = this.clone().simpleUnion(p);
         if (res) {
-            var allHoles = __spreadArray(__spreadArray(__spreadArray([], __read(this.holes), false), __read(p.holes), false), __read(res.holes), false).map(function (h) { return h.clone(); });
-            var _loop_4 = function (a) {
-                var e_17, _b;
-                var _loop_5 = function (b) {
+            let allHoles = [...this.holes, ...p.holes, ...res.holes].map((h) => h.clone());
+            for (const a of allHoles) {
+                for (const b of allHoles) {
                     if (a.equal(b)) {
-                        return "continue";
+                        continue;
                     }
-                    var r = a.simpleUnion(b);
+                    const r = a.simpleUnion(b);
                     if (r) {
-                        allHoles = allHoles.filter(function (v) { return !v.equal(a) && !v.equal(b); });
+                        allHoles = allHoles.filter((v) => !v.equal(a) && !v.equal(b));
                         allHoles.push(r);
                     }
-                };
-                try {
-                    for (var allHoles_2 = (e_17 = void 0, __values(allHoles)), allHoles_2_1 = allHoles_2.next(); !allHoles_2_1.done; allHoles_2_1 = allHoles_2.next()) {
-                        var b = allHoles_2_1.value;
-                        _loop_5(b);
-                    }
-                }
-                catch (e_17_1) { e_17 = { error: e_17_1 }; }
-                finally {
-                    try {
-                        if (allHoles_2_1 && !allHoles_2_1.done && (_b = allHoles_2.return)) _b.call(allHoles_2);
-                    }
-                    finally { if (e_17) throw e_17.error; }
-                }
-            };
-            try {
-                for (var allHoles_1 = __values(allHoles), allHoles_1_1 = allHoles_1.next(); !allHoles_1_1.done; allHoles_1_1 = allHoles_1.next()) {
-                    var a = allHoles_1_1.value;
-                    _loop_4(a);
                 }
             }
-            catch (e_16_1) { e_16 = { error: e_16_1 }; }
-            finally {
-                try {
-                    if (allHoles_1_1 && !allHoles_1_1.done && (_a = allHoles_1.return)) _a.call(allHoles_1);
-                }
-                finally { if (e_16) throw e_16.error; }
-            }
             res.holes = allHoles;
         }
         return res;
-    };
-    DPolygon.prototype.toTriangles = function () {
-        var innerAndNotIntersect = function (poly, p1, p2) {
-            var l = p1.findLine(p2);
-            var center = l.center;
-            var intersections = poly.holes.reduce(function (a, hole) { return a && Boolean(hole.clone().close()
-                .intersection(l, true).length); }, Boolean(poly.clone().close()
+    }
+    toTriangles() {
+        const innerAndNotIntersect = (poly, p1, p2) => {
+            const l = p1.findLine(p2);
+            const { center } = l;
+            const intersections = poly.holes.reduce((a, hole) => a && Boolean(hole.clone().close()
+                .intersection(l, true).length), Boolean(poly.clone().close()
                 .intersection(l, true).length));
-            var contain = poly.holes.reduce(function (a, hole) { return a && !hole
-                .contain(center); }, poly.contain(center));
+            const contain = poly.holes.reduce((a, hole) => a && !hole
+                .contain(center), poly.contain(center));
             return !intersections && contain;
         };
-        var getTriangle = function (poly) {
-            for (var i = 0; i < poly.length; i++) {
-                var p0 = poly.at(0);
-                var p1 = poly.at(1);
-                var p2 = poly.at(2);
+        const getTriangle = (poly) => {
+            for (let i = 0; i < poly.length; i++) {
+                const p0 = poly.at(0);
+                const p1 = poly.at(1);
+                const p2 = poly.at(2);
                 if (innerAndNotIntersect(poly, p0, p2)) {
                     poly.removePart(0, 1);
                     return new DPolygon([
@@ -1180,47 +762,47 @@ var DPolygon = (function () {
             }
             return undefined;
         };
-        var p = this.clone().clockWise.open();
+        const p = this.clone().clockWise.open();
         while (p.holes.length) {
-            var h = p.holes.shift()
+            const h = p.holes.shift()
                 .clone()
                 .clockWise
                 .reverse()
                 .close();
-            for (var i = 0; i < p.length; i++) {
+            for (let i = 0; i < p.length; i++) {
                 if (innerAndNotIntersect(p, p.first, h.first)) {
-                    p.insertAfter.apply(p, __spreadArray(__spreadArray([0], __read(h.points), false), [p.first], false));
+                    p.insertAfter(0, ...h.points, p.first);
                     break;
                 }
                 p.push(p.shift());
             }
         }
-        var res = [];
+        const res = [];
         while (p.length > 3) {
-            var triangle = getTriangle(p);
+            const triangle = getTriangle(p);
             if (triangle) {
                 res.push(triangle);
             }
         }
         res.push(p);
         return res;
-    };
-    DPolygon.prototype.getTrianglesPointIndexes = function () {
-        var innerAndNotIntersect = function (poly, p1, p2) {
-            var l = p1.findLine(p2);
-            var center = l.center;
-            var intersections = poly.holes.reduce(function (a, hole) { return a && Boolean(hole.clone().close()
-                .intersection(l, true).length); }, Boolean(poly.clone().close()
+    }
+    getTrianglesPointIndexes() {
+        const innerAndNotIntersect = (poly, p1, p2) => {
+            const l = p1.findLine(p2);
+            const { center } = l;
+            const intersections = poly.holes.reduce((a, hole) => a && Boolean(hole.clone().close()
+                .intersection(l, true).length), Boolean(poly.clone().close()
                 .intersection(l, true).length));
-            var contain = poly.holes.reduce(function (a, hole) { return a && !hole
-                .contain(center); }, poly.contain(center));
+            const contain = poly.holes.reduce((a, hole) => a && !hole
+                .contain(center), poly.contain(center));
             return !intersections && contain;
         };
-        var getTriangle = function (poly) {
-            for (var i = 0; i < poly.length; i++) {
-                var p0 = poly.at(0);
-                var p1 = poly.at(1);
-                var p2 = poly.at(2);
+        const getTriangle = (poly) => {
+            for (let i = 0; i < poly.length; i++) {
+                const p0 = poly.at(0);
+                const p1 = poly.at(1);
+                const p2 = poly.at(2);
                 if (innerAndNotIntersect(poly, p0, p2)) {
                     poly.removePart(0, 1);
                     return [
@@ -1233,186 +815,147 @@ var DPolygon = (function () {
             }
             return undefined;
         };
-        var p = this.clone();
-        var index = 0;
-        p.points.forEach(function (f) {
+        let p = this.clone();
+        let index = 0;
+        p.points.forEach((f) => {
             f.properties.index = index++;
         });
-        p.holes.forEach(function (h) {
-            h.pPoints.forEach(function (f) {
+        p.holes.forEach((h) => {
+            h.pPoints.forEach((f) => {
                 f.properties.index = index++;
             });
         });
         p = p.clockWise.open();
         while (p.holes.length) {
-            var h = p.holes.shift()
+            const h = p.holes.shift()
                 .clone()
                 .clockWise
                 .reverse()
                 .close();
-            for (var i = 0; i < p.length; i++) {
+            for (let i = 0; i < p.length; i++) {
                 if (innerAndNotIntersect(p, p.first, h.first)) {
-                    p.insertAfter.apply(p, __spreadArray(__spreadArray([0], __read(h.points), false), [p.first], false));
+                    p.insertAfter(0, ...h.points, p.first);
                     break;
                 }
                 p.push(p.shift());
             }
         }
-        var res = [];
+        const res = [];
         while (p.length > 3) {
-            var triangle = getTriangle(p);
+            const triangle = getTriangle(p);
             if (triangle) {
-                res.push.apply(res, __spreadArray([], __read(triangle), false));
+                res.push(...triangle);
             }
         }
-        res.push.apply(res, __spreadArray([], __read(p.points.map(function (f) { return f.properties.index; })), false));
+        res.push(...p.points.map((f) => f.properties.index));
         return res;
-    };
-    Object.defineProperty(DPolygon.prototype, "closed", {
-        get: function () {
-            return this.first.equal(this.last);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    DPolygon.prototype.buffer = function (v, quadrantSegments, type) {
-        if (quadrantSegments === void 0) { quadrantSegments = 64; }
-        if (type === void 0) { type = DPolygon.CAP_ROUND; }
-        var reader = new jsts_1.io.WKTReader();
-        var _a = this, noHoles = _a.noHoles, closed = _a.closed;
-        var points = reader
+    }
+    get closed() {
+        return this.first.equal(this.last);
+    }
+    buffer(v, quadrantSegments = 64, type = DPolygon.CAP_ROUND) {
+        const reader = new jsts_1.io.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(function (_a) {
-            var x = _a.x, y = _a.y;
-            return new DPoint_1.DPoint(x, y);
-        }));
-    };
-    DPolygon.prototype.sideBuffers = function (v, quadrantSegments) {
-        if (quadrantSegments === void 0) { quadrantSegments = 64; }
-        var _a = this, first = _a.first, last = _a.last;
-        var buffer = this.buffer(v, quadrantSegments, DPolygon.CAP_FLAT).open();
-        var _b = __read(first.sortByDistance(buffer).points.map(function (r) { return r.properties.index; }), 2), start0 = _b[0], start1 = _b[1];
-        var _c = __read(last.sortByDistance(buffer).points.map(function (r) { return r.properties.index; }), 2), end0 = _c[0], end1 = _c[1];
-        var fromPoint = Math.min(Math.max(start0, start1), Math.max(end0, end1));
-        var toPoint = Math.max(Math.min(start0, start1), Math.min(end0, end1));
-        var linePart = new DPolygon(buffer.removePart(fromPoint - 1, toPoint - fromPoint + 1));
+        return new DPolygon(points.map(({ x, y }) => new DPoint_1.DPoint(x, y)));
+    }
+    sideBuffers(v, quadrantSegments = 64) {
+        const { first, last } = this;
+        const buffer = this.buffer(v, quadrantSegments, DPolygon.CAP_FLAT).open();
+        const [start0, start1] = first.sortByDistance(buffer).points.map((r) => r.properties.index);
+        const [end0, end1] = last.sortByDistance(buffer).points.map((r) => r.properties.index);
+        const fromPoint = Math.min(Math.max(start0, start1), Math.max(end0, end1));
+        const toPoint = Math.max(Math.min(start0, start1), Math.min(end0, end1));
+        const linePart = new DPolygon(buffer.removePart(fromPoint - 1, toPoint - fromPoint + 1));
         buffer.unshift(buffer.pop());
         return [linePart.reverse(), buffer];
-    };
-    DPolygon.prototype.bezier = function (step) {
-        if (step === void 0) { step = 0.1; }
-        var res = new DPolygon();
-        for (var i = 0; i < 1; i += step) {
+    }
+    bezier(step = 0.1) {
+        const res = new DPolygon();
+        for (let i = 0; i < 1; i += step) {
             res.push(this.clone().getBezierPoint(i));
         }
         return res;
-    };
-    DPolygon.prototype.setGrowingHeight = function (from, to) {
-        var fullLength = this.fullLength;
-        var prevPoint = this.first;
-        var d = to - from;
-        var currentDistance = 0;
+    }
+    setGrowingHeight(from, to) {
+        const { fullLength } = this;
+        let { first: prevPoint } = this;
+        const d = to - from;
+        let currentDistance = 0;
         this.loop()
-            .setZ(function (p) {
+            .setZ((p) => {
             currentDistance += prevPoint.distance(p);
             prevPoint = p;
             return from + currentDistance / fullLength * d;
         })
             .run();
         return this;
-    };
-    DPolygon.prototype.loopPointsGenerator = function (withLine) {
-        if (withLine === void 0) { withLine = false; }
-        var that = this;
-        return function () {
-            var i, p1, p2;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        i = 0;
-                        _a.label = 1;
-                    case 1:
-                        if (!(i < that.length - 1)) return [3, 4];
-                        p1 = that.at(i);
-                        p2 = that.at(i + 1);
-                        return [4, [p1, p2, withLine ? p1.findLine(p2) : undefined, i]];
-                    case 2:
-                        _a.sent();
-                        _a.label = 3;
-                    case 3:
-                        i++;
-                        return [3, 1];
-                    case 4: return [2];
-                }
-            });
+    }
+    loopPointsGenerator(withLine = false) {
+        const that = this;
+        return function* () {
+            for (let i = 0; i < that.length - 1; i++) {
+                const p1 = that.at(i);
+                const p2 = that.at(i + 1);
+                yield [p1, p2, withLine ? p1.findLine(p2) : undefined, i];
+            }
         };
-    };
-    DPolygon.prototype.getBezierPoint = function (v) {
-        var e_18, _a;
+    }
+    getBezierPoint(v) {
         if (this.length === 1) {
             return this.first;
         }
-        try {
-            for (var _b = __values(this.loopPointsGenerator()()), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var _d = __read(_c.value, 2), p1 = _d[0], p2 = _d[1];
-                p1.move(p2.clone().move(p1.clone().minus())
-                    .scale(v));
-            }
-        }
-        catch (e_18_1) { e_18 = { error: e_18_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-            }
-            finally { if (e_18) throw e_18.error; }
+        for (const [p1, p2] of this.loopPointsGenerator()()) {
+            p1.move(p2.clone().move(p1.clone().minus())
+                .scale(v));
         }
         this.pop();
         return this.getBezierPoint(v);
-    };
-    DPolygon.prototype.simpleIncludeX = function (p) {
-        var x = p.x;
+    }
+    simpleIncludeX(p) {
+        const { x } = p;
         return this.minX <= x && this.maxX >= x;
-    };
-    DPolygon.prototype.simpleIncludeY = function (p) {
-        var y = p.y;
+    }
+    simpleIncludeY(p) {
+        const { y } = p;
         return this.minY <= y && this.maxY >= y;
-    };
-    DPolygon.prototype.douglasPeucker = function (points, e) {
-        var dMax = 0;
-        var index = 0;
-        var end = points.length - 1;
-        var line = points[0].findLine(points[end]);
-        for (var i = 1; i < end; i++) {
-            var d = line.perpendicularDistance(points[i]);
+    }
+    douglasPeucker(points, e) {
+        let dMax = 0;
+        let index = 0;
+        const end = points.length - 1;
+        const line = points[0].findLine(points[end]);
+        for (let i = 1; i < end; i++) {
+            const d = line.perpendicularDistance(points[i]);
             if (d > dMax) {
                 index = i;
                 dMax = d;
             }
         }
         if (dMax >= e) {
-            var recResult1 = this.douglasPeucker(points.slice(0, index + 1), e);
-            var recResult2 = this.douglasPeucker(points.slice(index), e);
+            const recResult1 = this.douglasPeucker(points.slice(0, index + 1), e);
+            const recResult2 = this.douglasPeucker(points.slice(index), e);
             recResult1.pop();
-            return __spreadArray(__spreadArray([], __read(recResult1), false), __read(recResult2), false);
+            return [...recResult1, ...recResult2];
         }
         return [points[0], points[end]];
-    };
-    DPolygon.prototype.goByPath = function (ctx, steps) {
-        if (steps === void 0) { steps = this.length - 1; }
-        var start = this.first;
+    }
+    goByPath(ctx, steps = this.length - 1) {
+        const start = this.first;
         ctx.moveTo(start.x, start.y);
-        for (var i = 1; i <= (steps % this.length); i++) {
-            var _a = this.at(i), x = _a.x, y = _a.y;
+        for (let i = 1; i <= (steps % this.length); i++) {
+            const { x, y } = this.at(i);
             ctx.lineTo(x, y);
         }
-    };
-    DPolygon.prototype.getJSTSGeometry = function (p, unionThis, unionThat) {
-        var unionOrIntersection = unionThat === unionThis;
-        var reader = new jsts_1.io.WKTReader();
-        var a = reader.read(this.noHoles.toWKT());
-        var b = reader.read(p.noHoles.toWKT());
+    }
+    getJSTSGeometry(p, unionThis, unionThat) {
+        const unionOrIntersection = unionThat === unionThis;
+        const reader = new jsts_1.io.WKTReader();
+        const a = reader.read(this.noHoles.toWKT());
+        const b = reader.read(p.noHoles.toWKT());
         if (!unionOrIntersection) {
             return a.difference(b);
         }
@@ -1423,21 +966,19 @@ var DPolygon = (function () {
             return a.intersection(b);
         }
         return undefined;
-    };
-    DPolygon.prototype.simpleLogicFunction = function (p, unionThis, unionThat) {
-        var e_19, _a, e_20, _b, e_21, _c, e_22, _d;
-        var c = this.getJSTSGeometry(p, unionThis, unionThat);
+    }
+    simpleLogicFunction(p, unionThis, unionThat) {
+        const c = this.getJSTSGeometry(p, unionThis, unionThat);
         if (c) {
-            var coordinates_1 = c.getCoordinates();
-            if (coordinates_1.length) {
-                var result = coordinates_1.reduce(function (ak, _a, index) {
-                    var x = _a.x, y = _a.y;
-                    var lastIndex = ak.length - 1;
-                    var t = new DPoint_1.DPoint(x, y);
-                    var first = ak[lastIndex].first;
+            const coordinates = c.getCoordinates();
+            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 { first } = ak[lastIndex];
                     if (t.equal(first)) {
-                        if (coordinates_1[index + 1]) {
-                            var nextPoint = new DPoint_1.DPoint(coordinates_1[index + 1].x, coordinates_1[index + 1].y);
+                        if (coordinates[index + 1]) {
+                            const nextPoint = new DPoint_1.DPoint(coordinates[index + 1].x, coordinates[index + 1].y);
                             if (ak[lastIndex].length > 1) {
                                 ak.push(new DPolygon([nextPoint]));
                             }
@@ -1447,92 +988,41 @@ var DPolygon = (function () {
                         ak[lastIndex].push(t);
                     }
                     return ak;
-                }, [new DPolygon([new DPoint_1.DPoint(coordinates_1[0].x, coordinates_1[0].y)])]);
+                }, [new DPolygon([new DPoint_1.DPoint(coordinates[0].x, coordinates[0].y)])]);
                 if (unionThat && unionThis && result.length > 1) {
-                    try {
-                        for (var result_1 = __values(result), result_1_1 = result_1.next(); !result_1_1.done; result_1_1 = result_1.next()) {
-                            var q = result_1_1.value;
-                            var _loop_6 = function (r) {
-                                var _e;
-                                if (q.has(r.first) && !q.equal(r)) {
-                                    var index = q.findIndex(r.first);
-                                    (_e = q.points).splice.apply(_e, __spreadArray([index, 0], __read(r.points), false));
-                                    result = result.filter(function (h) { return !h.equal(r); });
-                                    return "continue";
-                                }
-                                if (result.length < 2) {
-                                    return "break";
-                                }
-                            };
-                            try {
-                                for (var result_2 = (e_20 = void 0, __values(result)), result_2_1 = result_2.next(); !result_2_1.done; result_2_1 = result_2.next()) {
-                                    var r = result_2_1.value;
-                                    var state_1 = _loop_6(r);
-                                    if (state_1 === "break")
-                                        break;
-                                }
-                            }
-                            catch (e_20_1) { e_20 = { error: e_20_1 }; }
-                            finally {
-                                try {
-                                    if (result_2_1 && !result_2_1.done && (_b = result_2.return)) _b.call(result_2);
-                                }
-                                finally { if (e_20) throw e_20.error; }
+                    for (const q of result) {
+                        for (const r of result) {
+                            if (q.has(r.first) && !q.equal(r)) {
+                                const index = q.findIndex(r.first);
+                                q.points.splice(index, 0, ...r.points);
+                                result = result.filter((h) => !h.equal(r));
+                                continue;
                             }
                             if (result.length < 2) {
                                 break;
                             }
                         }
-                    }
-                    catch (e_19_1) { e_19 = { error: e_19_1 }; }
-                    finally {
-                        try {
-                            if (result_1_1 && !result_1_1.done && (_a = result_1.return)) _a.call(result_1);
+                        if (result.length < 2) {
+                            break;
                         }
-                        finally { if (e_19) throw e_19.error; }
                     }
                 }
-                result = result.filter(function (h) { return h.length > 2; }).map(function (h) { return h.close(); });
-                try {
-                    for (var result_3 = __values(result), result_3_1 = result_3.next(); !result_3_1.done; result_3_1 = result_3.next()) {
-                        var q = result_3_1.value;
-                        var _loop_7 = function (r) {
-                            if (result.length < 2) {
-                                return "break";
-                            }
-                            if (!q.equal(r)) {
-                                if (q.contain(r.first, true)) {
-                                    q.holes.push(r);
-                                    result = result.filter(function (h) { return !h.equal(r); });
-                                }
-                            }
-                        };
-                        try {
-                            for (var result_4 = (e_22 = void 0, __values(result)), result_4_1 = result_4.next(); !result_4_1.done; result_4_1 = result_4.next()) {
-                                var r = result_4_1.value;
-                                var state_2 = _loop_7(r);
-                                if (state_2 === "break")
-                                    break;
-                            }
-                        }
-                        catch (e_22_1) { e_22 = { error: e_22_1 }; }
-                        finally {
-                            try {
-                                if (result_4_1 && !result_4_1.done && (_d = result_4.return)) _d.call(result_4);
-                            }
-                            finally { if (e_22) throw e_22.error; }
-                        }
+                result = result.filter((h) => h.length > 2).map((h) => h.close());
+                for (const q of result) {
+                    for (const r of result) {
                         if (result.length < 2) {
                             break;
                         }
+                        if (!q.equal(r)) {
+                            if (q.contain(r.first, true)) {
+                                q.holes.push(r);
+                                result = result.filter((h) => !h.equal(r));
+                            }
+                        }
                     }
-                }
-                catch (e_21_1) { e_21 = { error: e_21_1 }; }
-                finally {
-                    try {
-                        if (result_3_1 && !result_3_1.done && (_c = result_3.return)) _c.call(result_3);
+                    if (result.length < 2) {
+                        break;
                     }
-                    finally { if (e_21) throw e_21.error; }
                 }
                 if (result.length === 0) {
                     return null;
@@ -1540,16 +1030,15 @@ var DPolygon = (function () {
                 if (result.length === 1) {
                     return result[0].close();
                 }
-                return result.map(function (g) { return g.close(); });
+                return result.map((g) => g.close());
             }
         }
         return null;
-    };
-    DPolygon.CAP_ROUND = CAP_ROUND;
-    DPolygon.CAP_FLAT = CAP_FLAT;
-    DPolygon.CAP_SQUARE = CAP_SQUARE;
-    DPolygon.WKT_LINESTRING = 'LINESTRING';
-    DPolygon.WKT_POLYGON = 'POLYGON';
-    return DPolygon;
-}());
+    }
+}
 exports.DPolygon = DPolygon;
+DPolygon.CAP_ROUND = CAP_ROUND;
+DPolygon.CAP_FLAT = CAP_FLAT;
+DPolygon.CAP_SQUARE = CAP_SQUARE;
+DPolygon.WKT_LINESTRING = 'LINESTRING';
+DPolygon.WKT_POLYGON = 'POLYGON';