dgeoutils 2.4.41 → 2.4.44

package/dist/cjs/DPolygon.js

@@ -1,1745 +0,0 @@
-"use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __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;
-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 triangleCenter = function (triangle) {
-    var p0 = triangle.at(0);
-    var p1 = triangle.at(1);
-    var p2 = triangle.at(2);
-    return new DPoint_1.DPoint((p0.x + p1.x + p2.x) / 3, (p0.y + p1.y + p2.y) / 3);
-};
-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;
-    }
-    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;
-            }
-        }
-    }
-    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;
-            }
-        }
-    }
-    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; }
-    }
-    var eps = Math.PI / 10000;
-    var result = false;
-    var absTotalFi = Math.abs(totalFi);
-    if (absTotalFi < eps) {
-        result = false;
-    }
-    else if (Math.abs(2 * Math.PI - absTotalFi) < eps) {
-        result = true;
-    }
-    else {
-        throw new Error('contains2 faild');
-    }
-    return result;
-};
-var DPolygon = (function () {
-    function DPolygon(pPoints) {
-        if (pPoints === void 0) { 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
-            .loop()
-            .height(height)
-            .run() : v)
-            .toArrayOfCoords(); })
-            .flat(2);
-    };
-    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));
-    };
-    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.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;
-        if (!first || !second || !last) {
-            return 0;
-        }
-        if (first.distance(second) > first.distance(last)) {
-            return first.findLine(second).getFi();
-        }
-        return first.findLine(last).getFi();
-    };
-    DPolygon.parseFromWKT = function (wkt) {
-        var data = wkt.trim().toUpperCase();
-        var res = new DPolygon();
-        if (data.indexOf('POLYGON') === 0) {
-            var regexp = /POLYGON \(\((?<data>(?:(?!\)\)$).)*?)\)\)$/miu;
-            var reg = regexp.exec(data);
-            var _a = __read(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);
-            if (holes && holes.length) {
-                path.holes = holes;
-            }
-            res = path;
-        }
-        if (data.indexOf('LINESTRING') === 0) {
-            var regexp = /LINESTRING \((?<data>(?:(?!\)$).)*?)\)$/miu;
-            var reg = regexp.exec(data);
-            res = new DPolygon(reg.groups.data
-                .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;
-    };
-    DPolygon.createSquareBySize = function (size) {
-        return new DPolygon([DPoint_1.DPoint.zero(), size.clone().setX(0), size.clone(), size.clone().setY(0)]).close();
-    };
-    DPolygon.prototype.loop = function () {
-        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, "innerCenter", {
-        get: function () {
-            var center = this.center;
-            return this.toTriangles().map(function (t) {
-                var c = triangleCenter(t);
-                c.properties.score = Math.min(c.distance(t.at(0)), c.distance(t.at(1)), c.distance(t.at(2))) + c.distance(center);
-                return c;
-            })
-                .sort(function (a, b) { return a.properties.score - b.properties.score; })[0];
-        },
-        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, "minPoint", {
-        get: function () {
-            return this.leftTop;
-        },
-        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, "maxPoint", {
-        get: function () {
-            return this.rightBottom;
-        },
-        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, "filledDeintersection", {
-        get: function () {
-            var p = this.clone().deintersection.removeDuplicates().clockWise.open();
-            var findSameCorners = function (startIndex) {
-                if (startIndex === void 0) { startIndex = 0; }
-                var store = {};
-                for (var i = startIndex; i < p.length; i++) {
-                    var key = p.at(i).toString();
-                    if (typeof store[key] === 'number') {
-                        return [store[key], i];
-                    }
-                    store[key] = i;
-                }
-                return undefined;
-            };
-            var indexes = findSameCorners();
-            var holes = [];
-            while (indexes) {
-                var a = new DPolygon(p.clone().removePart(indexes[0], indexes[1] - indexes[0]));
-                if (a.isClockwise) {
-                    indexes = findSameCorners(indexes[0] + 1);
-                }
-                else {
-                    holes.push(a.close());
-                    p.removePart(indexes[0], indexes[1] - indexes[0]);
-                    indexes = findSameCorners();
-                }
-            }
-            p.holes = holes;
-            return p.close();
-        },
-        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);
-                        }
-                    }
-                }
-            }
-            catch (e_6_1) { e_6 = { error: e_6_1 }; }
-            finally {
-                try {
-                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-                }
-                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;
-                    }
-                }
-            }
-            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; }
-            }
-            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();
-            }
-            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 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);
-    };
-    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;
-    };
-    DPolygon.prototype.setCenter = function (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; }
-        if (type === DPolygon.WKT_POLYGON) {
-            var h = '';
-            if (this.holes && this.holes.length) {
-                h = ", ".concat(this.holes.map(function (hole) { return hole.toString(); })
-                    .join(', '));
-            }
-            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 (".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;
-    };
-    DPolygon.prototype.map = function (f) {
-        this.pPoints = this.mapArray(f);
-        this.holes = this.holes.map(function (h) { return h.map(f); });
-        return this;
-    };
-    DPolygon.prototype.mapArray = function (f) {
-        return this.pPoints.map(f);
-    };
-    DPolygon.prototype.sort = function (f) {
-        this.points.sort(f);
-        return this;
-    };
-    DPolygon.prototype.at = function (index) {
-        var length = this.length;
-        return this.points[(index % length + length) % length];
-    };
-    DPolygon.prototype.pop = function () {
-        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 () {
-        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 () {
-        this.pPoints = this.pPoints.reverse();
-        this.holes = this.holes.map(function (h) { return 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 "(".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;
-    };
-    DPolygon.prototype.open = function () {
-        var 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(); });
-        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(); });
-        res.properties = __assign({}, this.properties);
-        return res;
-    };
-    DPolygon.prototype.equal = function (p) {
-        if (!(p instanceof DPolygon)) {
-            return false;
-        }
-        if (this.length !== p.length || this.holes.length !== p.holes.length) {
-            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()
-            .close()
-            .toString();
-        for (var i = 0; i < pClone.length; i++) {
-            if (thisAsString === pClone.toString() || thisAsString === pClone.clone().reverse()
-                .toString()) {
-                return true;
-            }
-            pClone.nextStart();
-        }
-        return false;
-    };
-    DPolygon.prototype.findIndex = function (a) {
-        if (a instanceof DPoint_1.DPoint) {
-            return this.points.findIndex(function (t) { return t.equal(a); });
-        }
-        return this.points.findIndex(a);
-    };
-    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));
-    };
-    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);
-    };
-    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;
-    };
-    DPolygon.prototype.simpleInclude = function (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; }
-        if (this.length > 1) {
-            var ctx = canvas.getContext('2d');
-            if (fillColor) {
-                ctx.fillStyle = fillColor;
-            }
-            if (strokeColor) {
-                ctx.strokeStyle = strokeColor;
-            }
-            if (lineWidth) {
-                ctx.lineWidth = lineWidth;
-            }
-            if (fillColor || strokeColor) {
-                ctx.beginPath();
-            }
-            this.goByPath(ctx, steps % this.length);
-            if (shadowColor) {
-                ctx.shadowColor = shadowColor;
-                ctx.shadowBlur = 0;
-                ctx.shadowOffsetX = 1;
-                ctx.shadowOffsetY = 1;
-            }
-            if (fillColor) {
-                ctx.closePath();
-                ctx.fill();
-            }
-            if (strokeColor) {
-                ctx.stroke();
-            }
-        }
-        return this;
-    };
-    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;
-    };
-    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;
-        }
-        var 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;
-                }
-            }
-        }
-        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; }
-        }
-        var eps = Math.PI / 10000;
-        var absTotalFi = Math.abs(totalFi);
-        if (absTotalFi < eps) {
-            return false;
-        }
-        else if (Math.abs(2 * Math.PI - absTotalFi) < eps) {
-            return true;
-        }
-        throw new Error('contains2 faild');
-    };
-    DPolygon.prototype.onBorder = function (p) {
-        var e_12, _a;
-        var simpleInclude = this.simpleInclude(p);
-        if (simpleInclude) {
-            var poly = this.deintersection;
-            var hasSamePoint = this.points.some(function (point) { return 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);
-                }
-                finally { if (e_12) throw e_12.error; }
-            }
-        }
-        return false;
-    };
-    DPolygon.prototype.nextStart = function () {
-        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);
-            if (p1.equal(p2)) {
-                this.removePart(i, 1);
-                i--;
-            }
-        }
-        return this;
-    };
-    DPolygon.toGeoJSONFeatureCollection = function (polygons, format) {
-        if (format === void 0) { format = utils_1.DGeo.parseFormat; }
-        return {
-            type: 'FeatureCollection',
-            features: polygons.map(function (polygon) { return polygon.toGeoJSONFeature(format); })
-        };
-    };
-    DPolygon.parse = function (a, format) {
-        if (format === void 0) { format = utils_1.DGeo.parseFormat; }
-        if (a.type) {
-            switch (a.type) {
-                case 'FeatureCollection':
-                    return a.features.reduce(function (ak, f) {
-                        var t = DPolygon.parse(f, format);
-                        if (Array.isArray(t)) {
-                            ak.push.apply(ak, __spreadArray([], __read(t), false));
-                        }
-                        else {
-                            ak.push(t);
-                        }
-                        return ak;
-                    }, []);
-                case 'Feature': {
-                    var t = DPolygon.parse(a.geometry, format);
-                    var props_1 = __assign(__assign({}, a.properties), (a.id ? ({
-                        id: a.id
-                    }) : ({})));
-                    if (Array.isArray(t)) {
-                        t.forEach(function (record) {
-                            record.properties = __assign({}, props_1);
-                        });
-                    }
-                    else {
-                        t.properties = __assign({}, props_1);
-                    }
-                    return t;
-                }
-                case 'LineString':
-                case 'MultiPoint':
-                    return new DPolygon(a.coordinates.map(function (c) { return DPoint_1.DPoint.parse(c, format); }));
-                case 'Polygon':
-                    return a.coordinates.reduce(function (ak, line, index) {
-                        if (index === 0) {
-                            ak.points = line.map(function (c) { return DPoint_1.DPoint.parse(c, format); });
-                        }
-                        else {
-                            ak.holes.push(new DPolygon(line.map(function (c) { return DPoint_1.DPoint.parse(c, format); })));
-                        }
-                        return ak;
-                    }, new DPolygon());
-                case 'MultiLineString':
-                    return a.coordinates.reduce(function (ak, line) {
-                        ak.push(new DPolygon(line.map(function (c) { return DPoint_1.DPoint.parse(c, format); })));
-                        return ak;
-                    }, []);
-                case 'MultiPolygon':
-                    return a.coordinates.reduce(function (ak, coordinates) {
-                        ak.push(DPolygon.parse({
-                            type: 'Polygon',
-                            coordinates: coordinates
-                        }, format));
-                        return ak;
-                    }, []);
-                case 'GeometryCollection':
-                    return a.geometries.reduce(function (ak, line) {
-                        ak.push(DPolygon.parse(line, format));
-                        return ak;
-                    }, []);
-                default:
-            }
-        }
-        return new DPolygon(a
-            .map(function (r) { return DPoint_1.DPoint.parse(r, format); }));
-    };
-    DPolygon.prototype.toArrayOfCoords = function (format) {
-        if (format === void 0) { format = utils_1.DGeo.parseFormat; }
-        return this.mapArray(function (r) { return r.toCoords(format); });
-    };
-    DPolygon.prototype.toGeoJSONFeature = function (format) {
-        if (format === void 0) { format = utils_1.DGeo.parseFormat; }
-        return {
-            type: 'Feature',
-            properties: __assign({}, this.properties),
-            geometry: this.toGeoJSON(format)
-        };
-    };
-    DPolygon.prototype.toGeoJSON = function (format) {
-        if (format === void 0) { format = utils_1.DGeo.parseFormat; }
-        if (this.closed) {
-            return {
-                type: 'Polygon',
-                coordinates: __spreadArray([
-                    this.toArrayOfCoords(format)
-                ], __read(this.holes.map(function (h) { return h.toArrayOfCoords(format); })), false)
-            };
-        }
-        return {
-            type: 'LineString',
-            coordinates: this.toArrayOfCoords(format)
-        };
-    };
-    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) {
-                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_1.insertAfter(i, intersectionPoint);
-                if (withAltitude) {
-                    var 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;
-        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;
-            }
-        }
-        catch (e_14_1) { e_14 = { error: e_14_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-            }
-            finally { if (e_14) throw e_14.error; }
-        }
-    };
-    DPolygon.prototype.fastHas = function (_a) {
-        var x = _a.x, y = _a.y, z = _a.z;
-        if (!this.searchStore[x]) {
-            return false;
-        }
-        if (!this.searchStore[x][y]) {
-            return false;
-        }
-        if (!this.searchStore[x][y][z || 'undefined']) {
-            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) {
-        try {
-            var res = this.simpleLogicFunction(p, true, true);
-            if (res === null) {
-                return null;
-            }
-            if (res instanceof DPolygon) {
-                return res;
-            }
-            return null;
-        }
-        catch (ex) {
-            return null;
-        }
-    };
-    DPolygon.prototype.simpleIntersection = function (p) {
-        return this.simpleLogicFunction(p, false, false);
-    };
-    DPolygon.prototype.simpleDifference = function (p) {
-        return this.simpleLogicFunction(p, true, false);
-    };
-    DPolygon.prototype.smartUnion = function (p) {
-        var e_16, _a;
-        var 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) {
-                    if (a.equal(b)) {
-                        return "continue";
-                    }
-                    var r = a.simpleUnion(b);
-                    if (r) {
-                        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;
-    };
-    DPolygon.prototype.toTriangles = function () {
-        var q = this.clone().removeDuplicates()
-            .open();
-        if (q.length < 3) {
-            return [];
-        }
-        if (q.length === 3) {
-            return [q];
-        }
-        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));
-            var contain = poly.holes.reduce(function (a, hole) { return 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);
-                if (innerAndNotIntersect(poly, p0, p2)) {
-                    poly.removePart(0, 1);
-                    return new DPolygon([
-                        p0.clone(),
-                        p1.clone(),
-                        p2.clone()
-                    ]);
-                }
-                poly.push(poly.shift());
-            }
-            return undefined;
-        };
-        var p = this.clone().removeDuplicates().clockWise.open();
-        while (p.holes.length) {
-            var h = p.holes.shift()
-                .clone()
-                .clockWise
-                .reverse()
-                .close();
-            for (var 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));
-                    break;
-                }
-                p.push(p.shift());
-            }
-        }
-        var res = [];
-        while (p.length > 3) {
-            var 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()
-                .intersection(l, true).length));
-            var contain = poly.holes.reduce(function (a, hole) { return 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);
-                if (innerAndNotIntersect(poly, p0, p2)) {
-                    poly.removePart(0, 1);
-                    return [
-                        p0.properties.index,
-                        p1.properties.index,
-                        p2.properties.index
-                    ];
-                }
-                poly.push(poly.shift());
-            }
-            return undefined;
-        };
-        var p = this.clone();
-        var index = 0;
-        p.points.forEach(function (f) {
-            f.properties.index = index++;
-        });
-        p.holes.forEach(function (h) {
-            h.pPoints.forEach(function (f) {
-                f.properties.index = index++;
-            });
-        });
-        p = p.clockWise.open();
-        while (p.holes.length) {
-            var h = p.holes.shift()
-                .clone()
-                .clockWise
-                .reverse()
-                .close();
-            for (var 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));
-                    break;
-                }
-                p.push(p.shift());
-            }
-        }
-        var res = [];
-        while (p.length > 3) {
-            var triangle = getTriangle(p);
-            if (triangle) {
-                res.push.apply(res, __spreadArray([], __read(triangle), false));
-            }
-        }
-        res.push.apply(res, __spreadArray([], __read(p.points.map(function (f) { return f.properties.index; })), false));
-        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
-            .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));
-        buffer.unshift(buffer.pop());
-        return [linePart.reverse(), buffer];
-    };
-    DPolygon.prototype.setProperties = function (v) {
-        this.properties = typeof v === 'object' ? v : v(this);
-        return this;
-    };
-    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;
-    };
-    DPolygon.prototype.setGrowingHeight = function (from, to) {
-        var fullLength = this.fullLength;
-        var prevPoint = this.first;
-        var d = to - from;
-        var currentDistance = 0;
-        this.loop()
-            .setZ(function (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];
-                }
-            });
-        };
-    };
-    DPolygon.prototype.getBezierPoint = function (v) {
-        var e_18, _a;
-        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; }
-        }
-        this.pop();
-        return this.getBezierPoint(v);
-    };
-    DPolygon.prototype.simpleIncludeX = function (p) {
-        var x = p.x;
-        return this.minX <= x && this.maxX >= x;
-    };
-    DPolygon.prototype.simpleIncludeY = function (p) {
-        var y = p.y;
-        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]);
-            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);
-            recResult1.pop();
-            return __spreadArray(__spreadArray([], __read(recResult1), false), __read(recResult2), false);
-        }
-        return [points[0], points[end]];
-    };
-    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 (var i = 1; i <= (steps % this.length); i++) {
-            var _a = this.at(i), x = _a.x, y = _a.y;
-            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());
-        if (!unionOrIntersection) {
-            return a.difference(b);
-        }
-        else if (unionThis) {
-            return a.union(b);
-        }
-        else if (!unionThis) {
-            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);
-        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;
-                    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 (ak[lastIndex].length > 1) {
-                                ak.push(new DPolygon([nextPoint]));
-                            }
-                        }
-                    }
-                    else {
-                        ak[lastIndex].push(t);
-                    }
-                    return ak;
-                }, [new DPolygon([new DPoint_1.DPoint(coordinates_1[0].x, coordinates_1[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; }
-                            }
-                            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(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; }
-                        }
-                        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;
-                }
-                if (result.length === 1) {
-                    return result[0].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;