dgeoutils 2.4.1 → 2.4.4

package/dist/cjs/DPolygon.js

@@ -1,44 +1,128 @@
 "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;
-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;
+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;
 exports.MIN_POINTS_IN_VALID_POLYGON = 3;
-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));
+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); });
     if (hasSamePoint) {
         return true;
     }
-    for (const [, , polygonLine] of poly.loopPointsGenerator(true)()) {
-        const onBorder = polygonLine.x(p).equal(p) && polygonLine.inRange(p);
-        if (onBorder) {
-            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;
+            }
         }
     }
-    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_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;
+            }
         }
-        else {
-            totalFi -= fiDif;
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
         }
+        finally { if (e_2) throw e_2.error; }
     }
-    const eps = Math.PI / 10000;
-    let result = false;
-    const absTotalFi = Math.abs(totalFi);
+    var eps = Math.PI / 10000;
+    var result = false;
+    var absTotalFi = Math.abs(totalFi);
     if (absTotalFi < eps) {
         result = false;
     }
@@ -50,46 +134,58 @@ const containCalculator = (poly, p) => {
     }
     return result;
 };
-class DPolygon {
-    constructor(pPoints = []) {
+var DPolygon = (function () {
+    function DPolygon(pPoints) {
+        if (pPoints === void 0) { pPoints = []; }
         this.pPoints = pPoints;
         this.properties = {};
         this.holes = [];
         this.searchStore = {};
     }
-    static arrayOfTrianglesToVertices(triangles, height) {
-        return triangles.map((v) => ((0, utils_1.isDefAndNotNull)(height) ? v
+    DPolygon.arrayOfTrianglesToVertices = function (triangles, height) {
+        return triangles.map(function (v) { return ((0, utils_1.isDefAndNotNull)(height) ? v
             .loop()
             .height(height)
             .run() : v)
-            .toArrayOfCoords())
+            .toArrayOfCoords(); })
             .flat(2);
-    }
-    static minAreaRectangleSize(poly) {
-        const { first, second, last } = poly.clone().open();
+    };
+    DPolygon.minAreaRectangleSize = function (poly) {
+        var _a = poly.clone().open(), first = _a.first, second = _a.second, last = _a.last;
         return new DPoint_1.DPoint(first.distance(second), first.distance(last));
-    }
-    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;
+    };
+    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;
                 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;
-    }
-    static minAreaRectangleDirection(poly) {
-        const { first, second, last } = poly.clone().open();
+    };
+    DPolygon.minAreaRectangleDirection = function (poly) {
+        var _a = poly.clone().open(), first = _a.first, second = _a.second, last = _a.last;
         if (!first || !second || !last) {
             return 0;
         }
@@ -97,374 +193,581 @@ class DPolygon {
             return first.findLine(second).getFi();
         }
         return first.findLine(last).getFi();
-    }
-    static parseFromWKT(wkt) {
-        const data = wkt.trim().toUpperCase();
-        let res = new DPolygon();
+    };
+    DPolygon.parseFromWKT = function (wkt) {
+        var data = wkt.trim().toUpperCase();
+        var res = new DPolygon();
         if (data.indexOf('POLYGON') === 0) {
-            const regexp = /POLYGON \(\((?<data>(?:(?!\)\)$).)*?)\)\)$/miu;
-            const reg = regexp.exec(data);
-            const [path, ...holes] = reg.groups.data
+            var regexp = /POLYGON \(\((?<data>(?:(?!\)\)$).)*?)\)\)$/miu;
+            var reg = regexp.exec(data);
+            var _a = __read(reg.groups.data
                 .split('), (')
-                .map((p) => new DPolygon(p.split(', ')
-                .map((pares) => DPoint_1.DPoint.parse(pares.split(' ').map(Number)))));
+                .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);
             if (holes && holes.length) {
                 path.holes = holes;
             }
             res = path;
         }
         if (data.indexOf('LINESTRING') === 0) {
-            const regexp = /LINESTRING \((?<data>(?:(?!\)$).)*?)\)$/miu;
-            const reg = regexp.exec(data);
+            var regexp = /LINESTRING \((?<data>(?:(?!\)$).)*?)\)$/miu;
+            var reg = regexp.exec(data);
             res = new DPolygon(reg.groups.data
-                .split(', ').map((t) => DPoint_1.DPoint.parse(t.split(' ').map(Number))));
+                .split(', ').map(function (t) { return DPoint_1.DPoint.parse(t.split(' ').map(Number)); }));
         }
         if (data.indexOf('POINT') === 0) {
             res = new DPolygon([DPoint_1.DPoint.parseFromWKT(data)]);
         }
         return res;
-    }
-    static createSquareBySize(size) {
+    };
+    DPolygon.createSquareBySize = function (size) {
         return new DPolygon([DPoint_1.DPoint.zero(), size.clone().setX(0), size.clone(), size.clone().setY(0)]).close();
-    }
-    loop() {
+    };
+    DPolygon.prototype.loop = function () {
         return new DPolygonLoop_1.DPolygonLoop(this);
-    }
-    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);
+    };
+    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);
                 }
             }
-        }
-        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_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);
+                }
+            }
+            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);
                         }
                     }
                 }
             }
-        }
-        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;
+            catch (e_6_1) { e_6 = { error: e_6_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                 }
-                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;
+                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;
                     }
                 }
             }
-            if (!maxWidthPoint1 || !maxWidthPoint2 || !maxHeightPoint) {
-                continue;
+            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; }
             }
-            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;
+            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();
             }
-        }
-        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);
+            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();
             }
-            else {
-                break;
+            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);
+                }
             }
-        } 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);
+            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; }
             }
-            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();
-        }
-        return this.clone().reverse();
-    }
-    get noHoles() {
-        const res = this.clone();
-        res.holes = [];
-        return res;
-    }
-    reduce(f, v) {
+            return sum < 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DPolygon.prototype, "clockWise", {
+        get: function () {
+            if (this.isClockwise) {
+                return this.clone();
+            }
+            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);
-    }
-    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);
+    };
+    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);
+                }
             }
         }
+        catch (e_10_1) { e_10 = { error: e_10_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_10) throw e_10.error; }
+        }
         return res;
-    }
-    setCenter(newCenter) {
+    };
+    DPolygon.prototype.setCenter = function (newCenter) {
         return this.loop()
             .move(newCenter.clone().move(this.center.minus()))
             .run();
-    }
-    toWKT(type = DPolygon.WKT_POLYGON, withZ = false) {
+    };
+    DPolygon.prototype.toWKT = function (type, withZ) {
+        if (type === void 0) { type = DPolygon.WKT_POLYGON; }
+        if (withZ === void 0) { withZ = false; }
         if (type === DPolygon.WKT_POLYGON) {
-            let h = '';
+            var h = '';
             if (this.holes && this.holes.length) {
-                h = `, ${this.holes.map((hole) => hole.toString())
-                    .join(', ')}`;
+                h = ", ".concat(this.holes.map(function (hole) { return hole.toString(); })
+                    .join(', '));
             }
-            return `POLYGON ((${this.deintersection.mapArray((r) => `${r.x} ${r.y}${withZ ? ` ${r.z}` : ''}`)
-                .join(', ')})${h})`;
+            return "POLYGON ((".concat(this.deintersection.mapArray(function (r) { return "".concat(r.x, " ").concat(r.y).concat(withZ ? " ".concat(r.z) : ''); })
+                .join(', '), ")").concat(h, ")");
         }
-        return `LINESTRING (${this.mapArray((r) => `${r.x} ${r.y}${withZ ? ` ${r.z}` : ''}`)
-            .join(', ')})`;
-    }
-    filter(f) {
+        return "LINESTRING (".concat(this.mapArray(function (r) { return "".concat(r.x, " ").concat(r.y).concat(withZ ? " ".concat(r.z) : ''); })
+            .join(', '), ")");
+    };
+    DPolygon.prototype.filter = function (f) {
         this.pPoints = this.pPoints.filter(f);
         return this;
-    }
-    map(f) {
+    };
+    DPolygon.prototype.map = function (f) {
         this.pPoints = this.mapArray(f);
-        this.holes = this.holes.map((h) => h.map(f));
+        this.holes = this.holes.map(function (h) { return h.map(f); });
         return this;
-    }
-    mapArray(f) {
+    };
+    DPolygon.prototype.mapArray = function (f) {
         return this.pPoints.map(f);
-    }
-    sort(f) {
+    };
+    DPolygon.prototype.sort = function (f) {
         this.points.sort(f);
         return this;
-    }
-    at(index) {
-        const { length } = this;
+    };
+    DPolygon.prototype.at = function (index) {
+        var length = this.length;
         return this.points[(index % length + length) % length];
-    }
-    pop() {
+    };
+    DPolygon.prototype.pop = function () {
         return this.pPoints.pop();
-    }
-    push(...args) {
-        return this.pPoints.push(...args);
-    }
-    shift() {
+    };
+    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 () {
         return this.pPoints.shift();
-    }
-    unshift(...args) {
-        return this.pPoints.unshift(...args);
-    }
-    reverse() {
+    };
+    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 () {
         this.pPoints = this.pPoints.reverse();
-        this.holes = this.holes.map((h) => h.reverse());
+        this.holes = this.holes.map(function (h) { return h.reverse(); });
         return this;
-    }
-    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;
+    };
+    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 "(".concat(this.mapArray(function (r) { return r.toString(); }).join(', '), ")");
+    };
+    DPolygon.prototype.close = function () {
+        var p0 = this.first;
         if (p0 && !this.closed) {
             this.push(p0.clone());
         }
         return this;
-    }
-    open() {
-        const p = this.first;
+    };
+    DPolygon.prototype.open = function () {
+        var p = this.first;
         if (this.length > 2 && p && this.closed) {
             this.pop();
         }
         return this;
-    }
-    add(poly) {
-        const res = new DPolygon([...this.points, ...poly.points]).close();
-        res.holes = [...this.holes, ...poly.holes].map((h) => h.clone());
+    };
+    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(); });
         return res;
-    }
-    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());
+    };
+    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(); });
         res.properties = this.properties;
         return res;
-    }
-    equal(p) {
+    };
+    DPolygon.prototype.equal = function (p) {
         if (!(p instanceof DPolygon)) {
             return false;
         }
@@ -472,14 +775,14 @@ class DPolygon {
             return false;
         }
         return (this.same(p) &&
-            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()
+            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()
             .close()
             .toString();
-        for (let i = 0; i < pClone.length; i++) {
+        for (var i = 0; i < pClone.length; i++) {
             if (thisAsString === pClone.toString() || thisAsString === pClone.clone().reverse()
                 .toString()) {
                 return true;
@@ -487,37 +790,45 @@ class DPolygon {
             pClone.nextStart();
         }
         return false;
-    }
-    findIndex(a) {
+    };
+    DPolygon.prototype.findIndex = function (a) {
         if (a instanceof DPoint_1.DPoint) {
-            return this.points.findIndex((t) => t.equal(a));
+            return this.points.findIndex(function (t) { return t.equal(a); });
         }
         return this.points.findIndex(a);
-    }
-    approximation(e = Math.sqrt(this.perimeter) * APPROXIMATION_VALUE) {
+    };
+    DPolygon.prototype.approximation = function (e) {
+        if (e === void 0) { e = Math.sqrt(this.perimeter) * APPROXIMATION_VALUE; }
         return new DPolygon(this.clone().douglasPeucker(this.pPoints, e));
-    }
-    insertAfter(index, ...points) {
-        this.pPoints.splice(index + 1, 0, ...points);
-    }
-    removePart(index, count) {
+    };
+    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) {
         return this.pPoints.splice(index + 1, count);
-    }
-    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));
+    };
+    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); });
         return in1 || in2;
-    }
-    simpleInclude(p) {
+    };
+    DPolygon.prototype.simpleInclude = function (p) {
         return this.simpleIncludeX(p) && this.simpleIncludeY(p);
-    }
-    drawPolygonOnCanvas(canvas, fillColor, strokeColor, shadowColor, lineWidth = 1, steps = this.length - 1) {
+    };
+    DPolygon.prototype.drawPolygonOnCanvas = function (canvas, fillColor, strokeColor, shadowColor, lineWidth, steps) {
+        if (lineWidth === void 0) { lineWidth = 1; }
+        if (steps === void 0) { steps = this.length - 1; }
         if (this.length > 1) {
-            const ctx = canvas.getContext('2d');
+            var ctx = canvas.getContext('2d');
             if (fillColor) {
                 ctx.fillStyle = fillColor;
             }
@@ -546,39 +857,51 @@ class DPolygon {
             }
         }
         return this;
-    }
-    clearPolygonOnCanvas(canvas) {
-        const ctx = canvas.getContext('2d');
-        const old = ctx.globalCompositeOperation;
+    };
+    DPolygon.prototype.clearPolygonOnCanvas = function (canvas) {
+        var ctx = canvas.getContext('2d');
+        var old = ctx.globalCompositeOperation;
         ctx.globalCompositeOperation = 'destination-out';
         this.goByPath(ctx);
         ctx.fill();
         ctx.globalCompositeOperation = old;
-    }
-    contain(p, isBorderInside = false) {
-        const simpleInclude = this.simpleInclude(p);
+    };
+    DPolygon.prototype.contain = function (p, isBorderInside) {
+        var e_11, _a;
+        if (isBorderInside === void 0) { isBorderInside = false; }
+        var simpleInclude = this.simpleInclude(p);
         if (!simpleInclude) {
             return false;
         }
-        const onBorder = this.onBorder(p);
+        var onBorder = this.onBorder(p);
         if (onBorder) {
             return isBorderInside;
         }
-        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;
+        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;
+                }
             }
-            else {
-                totalFi -= fiDif;
+        }
+        catch (e_11_1) { e_11 = { error: e_11_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
             }
+            finally { if (e_11) throw e_11.error; }
         }
-        const eps = Math.PI / 10000;
-        const absTotalFi = Math.abs(totalFi);
+        var eps = Math.PI / 10000;
+        var absTotalFi = Math.abs(totalFi);
         if (absTotalFi < eps) {
             return false;
         }
@@ -586,66 +909,79 @@ class DPolygon {
             return true;
         }
         throw new Error('contains2 faild');
-    }
-    onBorder(p) {
-        const simpleInclude = this.simpleInclude(p);
+    };
+    DPolygon.prototype.onBorder = function (p) {
+        var e_12, _a;
+        var simpleInclude = this.simpleInclude(p);
         if (simpleInclude) {
-            const poly = this.deintersection;
-            const hasSamePoint = this.points.some((point) => point.equal(p));
+            var poly = this.deintersection;
+            var hasSamePoint = this.points.some(function (point) { return point.equal(p); });
             if (hasSamePoint) {
                 return true;
             }
-            for (const [, , polygonLine] of poly.loopPointsGenerator(true)()) {
-                const onBorder = polygonLine.x(p).equal(p) && polygonLine.inRange(p);
-                if (onBorder) {
-                    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);
                 }
+                finally { if (e_12) throw e_12.error; }
             }
         }
         return false;
-    }
-    nextStart() {
+    };
+    DPolygon.prototype.nextStart = function () {
         this.open();
         this.push(this.shift());
         this.close();
         return this;
-    }
-    removeDuplicates() {
-        for (let i = 0; i < this.length - 1; i++) {
-            const p1 = this.at(i);
-            const p2 = this.at(i + 1);
+    };
+    DPolygon.prototype.removeDuplicates = function () {
+        for (var i = 0; i < this.length - 1; i++) {
+            var p1 = this.at(i);
+            var p2 = this.at(i + 1);
             if (p1.equal(p2)) {
                 this.removePart(i, 1);
                 i--;
             }
         }
         return this;
-    }
-    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);
+    };
+    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, withAltitude) {
+        var e_13, _a;
+        if (withAltitude === void 0) { withAltitude = false; }
+        var fullLength = this.fullLength;
+        var pieceLength = fullLength / piecesCount;
+        var currentPieceLength = pieceLength;
+        var _loop_3 = function (p1, p2, i) {
+            var d = p1.distance(p2);
             if (d === currentPieceLength) {
                 p2.properties.pieceBorder = true;
                 currentPieceLength = pieceLength;
             }
             else if (d - currentPieceLength > 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];
+                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];
                 intersectionPoint.properties.pieceBorder = true;
-                this.insertAfter(i, intersectionPoint);
+                this_1.insertAfter(i, intersectionPoint);
                 if (withAltitude) {
-                    const p1z = p1.z;
+                    var p1z = p1.z;
                     intersectionPoint.z = p1z - (p1z - p2.z) * (p1.distance(intersectionPoint) / d);
                 }
                 currentPieceLength = pieceLength;
@@ -653,22 +989,48 @@ class DPolygon {
             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;
-    }
-    prepareToFastSearch() {
+    };
+    DPolygon.prototype.prepareToFastSearch = function () {
+        var e_14, _a;
         this.searchStore = {};
-        for (const { x, y, z } of this.points) {
-            if (!this.searchStore[x]) {
-                this.searchStore[x] = {};
+        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;
             }
-            if (!this.searchStore[x][y]) {
-                this.searchStore[x][y] = {};
+        }
+        catch (e_14_1) { e_14 = { error: e_14_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
             }
-            this.searchStore[x][y][z || 'undefined'] = true;
+            finally { if (e_14) throw e_14.error; }
         }
-    }
-    fastHas({ x, y, z }) {
+    };
+    DPolygon.prototype.fastHas = function (_a) {
+        var x = _a.x, y = _a.y, z = _a.z;
         if (!this.searchStore[x]) {
             return false;
         }
@@ -679,23 +1041,56 @@ class DPolygon {
             return false;
         }
         return this.searchStore[x][y][z || 'undefined'];
-    }
-    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) {
+    };
+    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) {
         try {
-            const res = this.simpleLogicFunction(p, true, true);
+            var res = this.simpleLogicFunction(p, true, true);
             if (res === null) {
                 return null;
             }
@@ -707,49 +1102,77 @@ class DPolygon {
         catch (ex) {
             return null;
         }
-    }
-    simpleIntersection(p) {
+    };
+    DPolygon.prototype.simpleIntersection = function (p) {
         return this.simpleLogicFunction(p, false, false);
-    }
-    simpleDifference(p) {
+    };
+    DPolygon.prototype.simpleDifference = function (p) {
         return this.simpleLogicFunction(p, true, false);
-    }
-    smartUnion(p) {
-        const res = this.clone().simpleUnion(p);
+    };
+    DPolygon.prototype.smartUnion = function (p) {
+        var e_16, _a;
+        var res = this.clone().simpleUnion(p);
         if (res) {
-            let allHoles = [...this.holes, ...p.holes, ...res.holes].map((h) => h.clone());
-            for (const a of allHoles) {
-                for (const b of allHoles) {
+            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) {
                     if (a.equal(b)) {
-                        continue;
+                        return "continue";
                     }
-                    const r = a.simpleUnion(b);
+                    var r = a.simpleUnion(b);
                     if (r) {
-                        allHoles = allHoles.filter((v) => !v.equal(a) && !v.equal(b));
+                        allHoles = allHoles.filter(function (v) { return !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;
-    }
-    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()
+    };
+    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()
                 .intersection(l, true).length));
-            const contain = poly.holes.reduce((a, hole) => a && !hole
-                .contain(center), poly.contain(center));
+            var contain = poly.holes.reduce(function (a, hole) { return a && !hole
+                .contain(center); }, poly.contain(center));
             return !intersections && contain;
         };
-        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);
+        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);
                 if (innerAndNotIntersect(poly, p0, p2)) {
                     poly.removePart(0, 1);
                     return new DPolygon([
@@ -762,47 +1185,47 @@ class DPolygon {
             }
             return undefined;
         };
-        const p = this.clone().clockWise.open();
+        var p = this.clone().clockWise.open();
         while (p.holes.length) {
-            const h = p.holes.shift()
+            var h = p.holes.shift()
                 .clone()
                 .clockWise
                 .reverse()
                 .close();
-            for (let i = 0; i < p.length; i++) {
+            for (var i = 0; i < p.length; i++) {
                 if (innerAndNotIntersect(p, p.first, h.first)) {
-                    p.insertAfter(0, ...h.points, p.first);
+                    p.insertAfter.apply(p, __spreadArray(__spreadArray([0], __read(h.points), false), [p.first], false));
                     break;
                 }
                 p.push(p.shift());
             }
         }
-        const res = [];
+        var res = [];
         while (p.length > 3) {
-            const triangle = getTriangle(p);
+            var triangle = getTriangle(p);
             if (triangle) {
                 res.push(triangle);
             }
         }
         res.push(p);
         return res;
-    }
-    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()
+    };
+    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()
                 .intersection(l, true).length));
-            const contain = poly.holes.reduce((a, hole) => a && !hole
-                .contain(center), poly.contain(center));
+            var contain = poly.holes.reduce(function (a, hole) { return a && !hole
+                .contain(center); }, poly.contain(center));
             return !intersections && contain;
         };
-        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);
+        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);
                 if (innerAndNotIntersect(poly, p0, p2)) {
                     poly.removePart(0, 1);
                     return [
@@ -815,147 +1238,186 @@ class DPolygon {
             }
             return undefined;
         };
-        let p = this.clone();
-        let index = 0;
-        p.points.forEach((f) => {
+        var p = this.clone();
+        var index = 0;
+        p.points.forEach(function (f) {
             f.properties.index = index++;
         });
-        p.holes.forEach((h) => {
-            h.pPoints.forEach((f) => {
+        p.holes.forEach(function (h) {
+            h.pPoints.forEach(function (f) {
                 f.properties.index = index++;
             });
         });
         p = p.clockWise.open();
         while (p.holes.length) {
-            const h = p.holes.shift()
+            var h = p.holes.shift()
                 .clone()
                 .clockWise
                 .reverse()
                 .close();
-            for (let i = 0; i < p.length; i++) {
+            for (var i = 0; i < p.length; i++) {
                 if (innerAndNotIntersect(p, p.first, h.first)) {
-                    p.insertAfter(0, ...h.points, p.first);
+                    p.insertAfter.apply(p, __spreadArray(__spreadArray([0], __read(h.points), false), [p.first], false));
                     break;
                 }
                 p.push(p.shift());
             }
         }
-        const res = [];
+        var res = [];
         while (p.length > 3) {
-            const triangle = getTriangle(p);
+            var triangle = getTriangle(p);
             if (triangle) {
-                res.push(...triangle);
+                res.push.apply(res, __spreadArray([], __read(triangle), false));
             }
         }
-        res.push(...p.points.map((f) => f.properties.index));
+        res.push.apply(res, __spreadArray([], __read(p.points.map(function (f) { return f.properties.index; })), false));
         return res;
-    }
-    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
+    };
+    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
             .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)));
-    }
-    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));
+        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));
         buffer.unshift(buffer.pop());
         return [linePart.reverse(), buffer];
-    }
-    bezier(step = 0.1) {
-        const res = new DPolygon();
-        for (let i = 0; i < 1; i += step) {
+    };
+    DPolygon.prototype.bezier = function (step) {
+        if (step === void 0) { step = 0.1; }
+        var res = new DPolygon();
+        for (var i = 0; i < 1; i += step) {
             res.push(this.clone().getBezierPoint(i));
         }
         return res;
-    }
-    setGrowingHeight(from, to) {
-        const { fullLength } = this;
-        let { first: prevPoint } = this;
-        const d = to - from;
-        let currentDistance = 0;
+    };
+    DPolygon.prototype.setGrowingHeight = function (from, to) {
+        var fullLength = this.fullLength;
+        var prevPoint = this.first;
+        var d = to - from;
+        var currentDistance = 0;
         this.loop()
-            .setZ((p) => {
+            .setZ(function (p) {
             currentDistance += prevPoint.distance(p);
             prevPoint = p;
             return from + currentDistance / fullLength * d;
         })
             .run();
         return this;
-    }
-    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.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];
+                }
+            });
         };
-    }
-    getBezierPoint(v) {
+    };
+    DPolygon.prototype.getBezierPoint = function (v) {
+        var e_18, _a;
         if (this.length === 1) {
             return this.first;
         }
-        for (const [p1, p2] of this.loopPointsGenerator()()) {
-            p1.move(p2.clone().move(p1.clone().minus())
-                .scale(v));
+        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; }
         }
         this.pop();
         return this.getBezierPoint(v);
-    }
-    simpleIncludeX(p) {
-        const { x } = p;
+    };
+    DPolygon.prototype.simpleIncludeX = function (p) {
+        var x = p.x;
         return this.minX <= x && this.maxX >= x;
-    }
-    simpleIncludeY(p) {
-        const { y } = p;
+    };
+    DPolygon.prototype.simpleIncludeY = function (p) {
+        var y = p.y;
         return this.minY <= y && this.maxY >= y;
-    }
-    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]);
+    };
+    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]);
             if (d > dMax) {
                 index = i;
                 dMax = d;
             }
         }
         if (dMax >= e) {
-            const recResult1 = this.douglasPeucker(points.slice(0, index + 1), e);
-            const recResult2 = this.douglasPeucker(points.slice(index), e);
+            var recResult1 = this.douglasPeucker(points.slice(0, index + 1), e);
+            var recResult2 = this.douglasPeucker(points.slice(index), e);
             recResult1.pop();
-            return [...recResult1, ...recResult2];
+            return __spreadArray(__spreadArray([], __read(recResult1), false), __read(recResult2), false);
         }
         return [points[0], points[end]];
-    }
-    goByPath(ctx, steps = this.length - 1) {
-        const start = this.first;
+    };
+    DPolygon.prototype.goByPath = function (ctx, steps) {
+        if (steps === void 0) { steps = this.length - 1; }
+        var start = this.first;
         ctx.moveTo(start.x, start.y);
-        for (let i = 1; i <= (steps % this.length); i++) {
-            const { x, y } = this.at(i);
+        for (var i = 1; i <= (steps % this.length); i++) {
+            var _a = this.at(i), x = _a.x, y = _a.y;
             ctx.lineTo(x, y);
         }
-    }
-    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());
+    };
+    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());
         if (!unionOrIntersection) {
             return a.difference(b);
         }
@@ -966,19 +1428,21 @@ class DPolygon {
             return a.intersection(b);
         }
         return undefined;
-    }
-    simpleLogicFunction(p, unionThis, unionThat) {
-        const c = this.getJSTSGeometry(p, unionThis, unionThat);
+    };
+    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);
         if (c) {
-            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];
+            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;
                     if (t.equal(first)) {
-                        if (coordinates[index + 1]) {
-                            const nextPoint = new DPoint_1.DPoint(coordinates[index + 1].x, coordinates[index + 1].y);
+                        if (coordinates_1[index + 1]) {
+                            var nextPoint = new DPoint_1.DPoint(coordinates_1[index + 1].x, coordinates_1[index + 1].y);
                             if (ak[lastIndex].length > 1) {
                                 ak.push(new DPolygon([nextPoint]));
                             }
@@ -988,41 +1452,92 @@ class DPolygon {
                         ak[lastIndex].push(t);
                     }
                     return ak;
-                }, [new DPolygon([new DPoint_1.DPoint(coordinates[0].x, coordinates[0].y)])]);
+                }, [new DPolygon([new DPoint_1.DPoint(coordinates_1[0].x, coordinates_1[0].y)])]);
                 if (unionThat && unionThis && result.length > 1) {
-                    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;
+                    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; }
                             }
                             if (result.length < 2) {
                                 break;
                             }
                         }
-                        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);
                         }
+                        finally { if (e_19) throw e_19.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;
+                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;
+                            }
                         }
-                        if (!q.equal(r)) {
-                            if (q.contain(r.first, true)) {
-                                q.holes.push(r);
-                                result = result.filter((h) => !h.equal(r));
+                        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; }
+                        }
+                        if (result.length < 2) {
+                            break;
                         }
                     }
-                    if (result.length < 2) {
-                        break;
+                }
+                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);
                     }
+                    finally { if (e_21) throw e_21.error; }
                 }
                 if (result.length === 0) {
                     return null;
@@ -1030,15 +1545,16 @@ class DPolygon {
                 if (result.length === 1) {
                     return result[0].close();
                 }
-                return result.map((g) => g.close());
+                return result.map(function (g) { return 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';