dgeoutils 2.4.1 → 2.4.4

package/dist/cjs/TraceMatrix.js

@@ -1,43 +1,81 @@
 "use strict";
+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));
+};
+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.");
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TraceMatrix = exports.TraceMatrixValues = void 0;
-const DPoint_1 = require("./DPoint");
-const DPolygon_1 = require("./DPolygon");
-const FastSearch_1 = require("./FastSearch");
-const utils_1 = require("./utils");
+var DPoint_1 = require("./DPoint");
+var DPolygon_1 = require("./DPolygon");
+var FastSearch_1 = require("./FastSearch");
+var utils_1 = require("./utils");
 var TraceMatrixValues;
 (function (TraceMatrixValues) {
     TraceMatrixValues[TraceMatrixValues["f"] = 0] = "f";
     TraceMatrixValues[TraceMatrixValues["t"] = 1] = "t";
 })(TraceMatrixValues = exports.TraceMatrixValues || (exports.TraceMatrixValues = {}));
-const getByPosition = (m, p, defaultValue = TraceMatrixValues.f) => {
+var getByPosition = function (m, p, defaultValue) {
+    if (defaultValue === void 0) { defaultValue = TraceMatrixValues.f; }
     if (m[p.y] === undefined || m[p.y][p.x] === undefined) {
         return defaultValue;
     }
     return m[p.y][p.x];
 };
-const setByPosition = (m, p, value) => {
+var setByPosition = function (m, p, value) {
     if (m[p.y] === undefined || m[p.y][p.x] === undefined) {
         return value;
     }
     m[p.y][p.x] = value;
     return m[p.y][p.x];
 };
-class TraceMatrix {
-    constructor(size, f) {
+var TraceMatrix = (function () {
+    function TraceMatrix(size, f) {
+        var _this = this;
         this.size = size;
-        this.findGroupByIndex = (m, s) => {
-            const res = new DPolygon_1.DPolygon();
+        this.findGroupByIndex = function (m, s) {
+            var res = new DPolygon_1.DPolygon();
             if (s && getByPosition(m, s) === TraceMatrixValues.t) {
                 res.push(s);
-                let startIndex = 0;
-                const marked = TraceMatrix.createMatrix(this.size, () => TraceMatrixValues.f);
+                var startIndex = 0;
+                var marked = TraceMatrix.createMatrix(_this.size, function () { return TraceMatrixValues.f; });
                 setByPosition(marked, s, TraceMatrixValues.t);
                 while (startIndex < res.length) {
-                    const r = res.at(startIndex);
-                    for (let i = -1; i < 2; i++) {
-                        for (let j = -1; j < 2; j++) {
-                            const t = new DPoint_1.DPoint(r.x + i, r.y + j);
+                    var r = res.at(startIndex);
+                    for (var i = -1; i < 2; i++) {
+                        for (var j = -1; j < 2; j++) {
+                            var t = new DPoint_1.DPoint(r.x + i, r.y + j);
                             if (getByPosition(marked, t, TraceMatrixValues.t) === TraceMatrixValues.f &&
                                 getByPosition(m, t, TraceMatrixValues.f) === TraceMatrixValues.t) {
                                 res.push(t);
@@ -50,32 +88,32 @@ class TraceMatrix {
             }
             return res;
         };
-        this.findAllGroupsInMatrix = (m) => {
-            const firstMark = this.findMarked(m);
+        this.findAllGroupsInMatrix = function (m) {
+            var firstMark = _this.findMarked(m);
             if (!firstMark) {
                 return [];
             }
-            const group = this.findGroupByIndex(m, firstMark);
-            const groups = [group];
-            let groupSum = group.length;
-            let allGroups = [...group.points];
-            const fs = new FastSearch_1.FastSearch();
+            var group = _this.findGroupByIndex(m, firstMark);
+            var groups = [group];
+            var groupSum = group.length;
+            var allGroups = __spreadArray([], __read(group.points), false);
+            var fs = new FastSearch_1.FastSearch();
             fs.add(allGroups);
-            while (groupSum < this.totalCountInMatrix(m)) {
-                let mark = this.findMarked(m);
+            while (groupSum < _this.totalCountInMatrix(m)) {
+                var mark = _this.findMarked(m);
                 while (mark && fs.find(mark)) {
-                    mark = this.findMarked(m, mark);
+                    mark = _this.findMarked(m, mark);
                 }
-                const nextGroup = this.findGroupByIndex(m, mark);
+                var nextGroup = _this.findGroupByIndex(m, mark);
                 groupSum += nextGroup.length;
-                allGroups = [...allGroups, ...nextGroup.points];
+                allGroups = __spreadArray(__spreadArray([], __read(allGroups), false), __read(nextGroup.points), false);
                 fs.add(nextGroup.points);
                 groups.push(nextGroup);
             }
-            return groups.filter((g) => g.length > 2);
+            return groups.filter(function (g) { return g.length > 2; });
         };
-        this.traceGroup = (m, group) => {
-            const traceDirections = [
+        this.traceGroup = function (m, group) {
+            var traceDirections = [
                 new DPoint_1.DPoint(-1, -1),
                 new DPoint_1.DPoint(-1, 0),
                 new DPoint_1.DPoint(-1, 1),
@@ -85,20 +123,20 @@ class TraceMatrix {
                 new DPoint_1.DPoint(1, -1),
                 new DPoint_1.DPoint(0, -1)
             ];
-            const left = (d) => (d + traceDirections.length + 1) % traceDirections.length;
-            const right = (d) => (d + traceDirections.length - 1) % traceDirections.length;
+            var left = function (d) { return (d + traceDirections.length + 1) % traceDirections.length; };
+            var right = function (d) { return (d + traceDirections.length - 1) % traceDirections.length; };
             if (group.length < 2) {
-                const t = group.at(0).clone();
+                var t = group.at(0).clone();
                 return new DPolygon_1.DPolygon([t, t, t]);
             }
-            const points = new DPolygon_1.DPolygon();
-            let direction = 0;
-            let prevDirection = Infinity;
-            let p = group.at(0);
+            var points = new DPolygon_1.DPolygon();
+            var direction = 0;
+            var prevDirection = Infinity;
+            var p = group.at(0);
             while (!p.equal(group.at(0)) || points.length < 2) {
                 while (true) {
-                    const nextValue = getByPosition(m, p.clone().move(traceDirections[direction]));
-                    const nextNeighbourValue = getByPosition(m, p.clone().move(traceDirections[left(direction)]));
+                    var nextValue = getByPosition(m, p.clone().move(traceDirections[direction]));
+                    var nextNeighbourValue = getByPosition(m, p.clone().move(traceDirections[left(direction)]));
                     if (nextValue === TraceMatrixValues.t && nextNeighbourValue === TraceMatrixValues.f) {
                         break;
                     }
@@ -113,64 +151,76 @@ class TraceMatrix {
             }
             return points.approximation().close();
         };
-        this.createHoleMatrix = (group) => {
-            const fullTraceDirections = [
+        this.createHoleMatrix = function (group) {
+            var e_1, _a;
+            var fullTraceDirections = [
                 new DPoint_1.DPoint(-1, 0),
                 new DPoint_1.DPoint(0, 1),
                 new DPoint_1.DPoint(1, 0),
                 new DPoint_1.DPoint(0, -1)
             ];
             group.prepareToFastSearch();
-            const tmpMatrix = TraceMatrix
-                .createMatrix(this.size, (p) => group.fastHas(p) ? TraceMatrixValues.t : TraceMatrixValues.f);
-            const startCoords = new DPolygon_1.DPolygon();
-            for (let i = 0; i < this.size.w; i++) {
+            var tmpMatrix = TraceMatrix
+                .createMatrix(_this.size, function (p) { return group.fastHas(p) ? TraceMatrixValues.t : TraceMatrixValues.f; });
+            var startCoords = new DPolygon_1.DPolygon();
+            for (var i = 0; i < _this.size.w; i++) {
                 startCoords.push(new DPoint_1.DPoint(i, -1));
-                startCoords.push(new DPoint_1.DPoint(i, this.size.h));
+                startCoords.push(new DPoint_1.DPoint(i, _this.size.h));
             }
-            for (let i = 0; i < this.size.h; i++) {
+            for (var i = 0; i < _this.size.h; i++) {
                 startCoords.push(new DPoint_1.DPoint(-1, i));
-                startCoords.push(new DPoint_1.DPoint(this.size.w, i));
+                startCoords.push(new DPoint_1.DPoint(_this.size.w, i));
             }
             while (startCoords.length) {
-                const point = startCoords.pop();
-                for (const direction of fullTraceDirections) {
-                    const tmpPoint = point.clone().move(direction);
-                    const value = getByPosition(tmpMatrix, tmpPoint, TraceMatrixValues.t);
-                    if (value === TraceMatrixValues.f) {
-                        setByPosition(tmpMatrix, tmpPoint, TraceMatrixValues.t);
-                        startCoords.push(tmpPoint);
+                var point = startCoords.pop();
+                try {
+                    for (var fullTraceDirections_1 = (e_1 = void 0, __values(fullTraceDirections)), fullTraceDirections_1_1 = fullTraceDirections_1.next(); !fullTraceDirections_1_1.done; fullTraceDirections_1_1 = fullTraceDirections_1.next()) {
+                        var direction = fullTraceDirections_1_1.value;
+                        var tmpPoint = point.clone().move(direction);
+                        var value = getByPosition(tmpMatrix, tmpPoint, TraceMatrixValues.t);
+                        if (value === TraceMatrixValues.f) {
+                            setByPosition(tmpMatrix, tmpPoint, TraceMatrixValues.t);
+                            startCoords.push(tmpPoint);
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (fullTraceDirections_1_1 && !fullTraceDirections_1_1.done && (_a = fullTraceDirections_1.return)) _a.call(fullTraceDirections_1);
                     }
+                    finally { if (e_1) throw e_1.error; }
                 }
             }
-            const t = this.reverseMatrix(tmpMatrix);
-            return this.totalCountInMatrix(t) ? t : null;
+            var t = _this.reverseMatrix(tmpMatrix);
+            return _this.totalCountInMatrix(t) ? t : null;
         };
         this.m = TraceMatrix.createMatrix(this.size, f);
     }
-    fullMatrixTrace() {
-        const groups = this.findAllGroupsInMatrix(this.m);
-        const paths = groups.map((g) => this.traceGroup(this.m, g));
-        const holeMatrixs = groups.map(this.createHoleMatrix);
-        const holesGroups = holeMatrixs.map((m) => m && this.findAllGroupsInMatrix(m));
-        const holesPaths = holesGroups.map((hg, index) => hg && hg.map((g) => this
-            .traceGroup(holeMatrixs[index], g)).filter((r) => r.length > DPolygon_1.MIN_POINTS_IN_VALID_POLYGON));
-        return groups.map((g, index) => {
-            const res = paths[index];
+    TraceMatrix.prototype.fullMatrixTrace = function () {
+        var _this = this;
+        var groups = this.findAllGroupsInMatrix(this.m);
+        var paths = groups.map(function (g) { return _this.traceGroup(_this.m, g); });
+        var holeMatrixs = groups.map(this.createHoleMatrix);
+        var holesGroups = holeMatrixs.map(function (m) { return m && _this.findAllGroupsInMatrix(m); });
+        var holesPaths = holesGroups.map(function (hg, index) { return hg && hg.map(function (g) { return _this
+            .traceGroup(holeMatrixs[index], g); }).filter(function (r) { return r.length > DPolygon_1.MIN_POINTS_IN_VALID_POLYGON; }); });
+        return groups.map(function (g, index) {
+            var res = paths[index];
             if (holesGroups[index] && holesGroups[index].length) {
                 res.holes = holesPaths[index];
             }
             return res;
         });
-    }
-    reverseMatrix(m) {
-        return TraceMatrix.createMatrix(this.size, (p) => getByPosition(m, p) === TraceMatrixValues.f ? TraceMatrixValues.t : TraceMatrixValues.f);
-    }
-    findMarked(m, init) {
-        const s = this.size;
-        let ini = false;
-        for (let i = 0; i < s.w; i++) {
-            for (let j = 0; j < s.h; j++) {
+    };
+    TraceMatrix.prototype.reverseMatrix = function (m) {
+        return TraceMatrix.createMatrix(this.size, function (p) { return getByPosition(m, p) === TraceMatrixValues.f ? TraceMatrixValues.t : TraceMatrixValues.f; });
+    };
+    TraceMatrix.prototype.findMarked = function (m, init) {
+        var s = this.size;
+        var ini = false;
+        for (var i = 0; i < s.w; i++) {
+            for (var j = 0; j < s.h; j++) {
                 if (!ini && init) {
                     i = init.x;
                     j = init.y;
@@ -183,22 +233,24 @@ class TraceMatrix {
             }
         }
         return null;
-    }
-    totalCountInMatrix(m) {
-        let res = 0;
-        const s = this.size;
-        for (let i = 0; i < s.w; i++) {
-            for (let j = 0; j < s.h; j++) {
+    };
+    TraceMatrix.prototype.totalCountInMatrix = function (m) {
+        var res = 0;
+        var s = this.size;
+        for (var i = 0; i < s.w; i++) {
+            for (var j = 0; j < s.h; j++) {
                 if (getByPosition(m, new DPoint_1.DPoint(i, j))) {
                     res++;
                 }
             }
         }
         return res;
-    }
-    static createMatrix(size, f = () => TraceMatrixValues.f) {
+    };
+    TraceMatrix.createMatrix = function (size, f) {
+        if (f === void 0) { f = function () { return TraceMatrixValues.f; }; }
         return (0, utils_1.createArray)(size.h)
-            .map((v, i) => (0, utils_1.createArray)(size.w).map((v2, j) => f(new DPoint_1.DPoint(j, i))));
-    }
-}
+            .map(function (v, i) { return (0, utils_1.createArray)(size.w).map(function (v2, j) { return f(new DPoint_1.DPoint(j, i)); }); });
+    };
+    return TraceMatrix;
+}());
 exports.TraceMatrix = TraceMatrix;

package/dist/cjs/index.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];

package/dist/cjs/utils.js

@@ -1,58 +1,87 @@
 "use strict";
+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.getCombinations = exports.cartesianProduct = exports.createCanvas = exports.gaussianElimination = exports.createMatrix = exports.createArray = exports.checkFunction = exports.isDefAndNotNull = exports.warn = exports.DGeo = void 0;
-const DPoint_1 = require("./DPoint");
+var DPoint_1 = require("./DPoint");
 exports.DGeo = {
     DEBUG: false
 };
-const warn = (...args) => {
+var warn = function () {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
     if (exports.DGeo.DEBUG) {
-        console.warn(...args);
+        console.warn.apply(console, __spreadArray([], __read(args), false));
     }
 };
 exports.warn = warn;
-const isDefAndNotNull = (a) => a != undefined;
+var isDefAndNotNull = function (a) { return a != undefined; };
 exports.isDefAndNotNull = isDefAndNotNull;
-const hook = (scope) => () => scope;
-const shouldBeInt = (scope, funcName, argName) => (p) => {
+var hook = function (scope) { return function () { return scope; }; };
+var shouldBeInt = function (scope, funcName, argName) { return function (p) {
     if (!p.clone().round()
         .equal(p)) {
-        (0, exports.warn)(`"${funcName}" -> "${argName}" should be Int!`);
+        (0, exports.warn)("\"".concat(funcName, "\" -> \"").concat(argName, "\" should be Int!"));
     }
     return scope;
-};
-const shouldBeUInt = (scope, funcName, argName) => (p) => {
+}; };
+var shouldBeUInt = function (scope, funcName, argName) { return function (p) {
     if (!p.clone().round()
         .equal(p) || !p.gtOrEqual(DPoint_1.DPoint.zero())) {
-        (0, exports.warn)(`"${funcName}" -> "${argName}" should be UInt!`);
+        (0, exports.warn)("\"".concat(funcName, "\" -> \"").concat(argName, "\" should be UInt!"));
     }
     return scope;
-};
-const shouldBeDegree = (scope, funcName, argName) => (p) => {
+}; };
+var shouldBeDegree = function (scope, funcName, argName) { return function (p) {
     if (!p.likeWorldGeodeticSystem) {
-        (0, exports.warn)(`"${funcName}" -> "${argName}" should be degree!`);
+        (0, exports.warn)("\"".concat(funcName, "\" -> \"").concat(argName, "\" should be degree!"));
     }
     return scope;
-};
-const shouldBeRadians = (scope, funcName, argName) => (p) => {
+}; };
+var shouldBeRadians = function (scope, funcName, argName) { return function (p) {
     if (!p.likeRadians) {
-        (0, exports.warn)(`"${funcName}" -> "${argName}" should be radians!`);
+        (0, exports.warn)("\"".concat(funcName, "\" -> \"").concat(argName, "\" should be radians!"));
     }
     return scope;
-};
-const shouldExist = (scope, funcName, argName) => (p) => {
+}; };
+var shouldExist = function (scope, funcName, argName) { return function (p) {
     if (!(0, exports.isDefAndNotNull)(p)) {
-        (0, exports.warn)(`"${funcName}" -> "${argName}" should exist!`);
+        (0, exports.warn)("\"".concat(funcName, "\" -> \"").concat(argName, "\" should exist!"));
     }
     return scope;
-};
-const shouldBeMeters = (scope, funcName, argName) => (p) => {
+}; };
+var shouldBeMeters = function (scope, funcName, argName) { return function (p) {
     if (!p.likePseudoMercator) {
-        (0, exports.warn)(`"${funcName}" -> "${argName}" should be meters!`);
+        (0, exports.warn)("\"".concat(funcName, "\" -> \"").concat(argName, "\" should be meters!"));
     }
     return scope;
-};
-const checkFunction = (funcName) => ({
+}; };
+var checkFunction = function (funcName) { return ({
     checkArgument: function (argName) {
         if (!exports.DGeo.DEBUG) {
             return {
@@ -73,64 +102,71 @@ const checkFunction = (funcName) => ({
             shouldExist: shouldExist(this, funcName, argName)
         };
     }
-});
+}); };
 exports.checkFunction = checkFunction;
-const createArray = (v, fillSymbol = 0) => new Array(v).fill(fillSymbol);
+var createArray = function (v, fillSymbol) {
+    if (fillSymbol === void 0) { fillSymbol = 0; }
+    return new Array(v).fill(fillSymbol);
+};
 exports.createArray = createArray;
-const createMatrix = ({ h, w }, fillSymbol = 0) => (0, exports.createArray)(h)
-    .map(() => (0, exports.createArray)(w, fillSymbol));
+var createMatrix = function (_a, fillSymbol) {
+    var h = _a.h, w = _a.w;
+    if (fillSymbol === void 0) { fillSymbol = 0; }
+    return (0, exports.createArray)(h)
+        .map(function () { return (0, exports.createArray)(w, fillSymbol); });
+};
 exports.createMatrix = createMatrix;
-const gaussianElimination = (matrix) => {
-    const n = matrix.length;
-    const matrixClone = (0, exports.createMatrix)(new DPoint_1.DPoint(n + 1, n));
-    for (let i = 0; i < n; i++) {
-        for (let j = 0; j < n + 1; j++) {
+var gaussianElimination = function (matrix) {
+    var n = matrix.length;
+    var matrixClone = (0, exports.createMatrix)(new DPoint_1.DPoint(n + 1, n));
+    for (var i = 0; i < n; i++) {
+        for (var j = 0; j < n + 1; j++) {
             matrix[i][j] = matrix[i][j] === 0 ? exports.gaussianElimination.MIN : matrix[i][j];
             matrixClone[i][j] = matrix[i][j];
         }
     }
-    for (let k = 0; k < n; k++) {
-        for (let i = 0; i < n + 1; i++) {
+    for (var k = 0; k < n; k++) {
+        for (var i = 0; i < n + 1; i++) {
             matrixClone[k][i] /= matrix[k][k];
         }
-        for (let i = k + 1; i < n; i++) {
-            const K = matrixClone[i][k] / matrixClone[k][k];
-            for (let j = 0; j < n + 1; j++) {
+        for (var i = k + 1; i < n; i++) {
+            var K = matrixClone[i][k] / matrixClone[k][k];
+            for (var j = 0; j < n + 1; j++) {
                 matrixClone[i][j] -= matrixClone[k][j] * K;
             }
         }
-        for (let i = 0; i < n; i++) {
-            for (let j = 0; j < n + 1; j++) {
+        for (var i = 0; i < n; i++) {
+            for (var j = 0; j < n + 1; j++) {
                 matrix[i][j] = matrixClone[i][j];
             }
         }
     }
-    for (let k = n - 1; k > -1; k--) {
-        for (let i = n; i > -1; i--) {
+    for (var k = n - 1; k > -1; k--) {
+        for (var i = n; i > -1; i--) {
             matrixClone[k][i] /= matrix[k][k];
         }
-        for (let i = k - 1; i > -1; i--) {
-            const K = matrixClone[i][k] / matrixClone[k][k];
-            for (let j = n; j > -1; j--) {
+        for (var i = k - 1; i > -1; i--) {
+            var K = matrixClone[i][k] / matrixClone[k][k];
+            for (var j = n; j > -1; j--) {
                 matrixClone[i][j] -= matrixClone[k][j] * K;
             }
         }
     }
-    const answer = (0, exports.createArray)(n);
-    for (let i = 0; i < n; i++) {
+    var answer = (0, exports.createArray)(n);
+    for (var i = 0; i < n; i++) {
         answer[i] = matrixClone[i][n];
     }
     return answer;
 };
 exports.gaussianElimination = gaussianElimination;
 exports.gaussianElimination.MIN = 1e-10;
-const createCanvas = (a, b, c) => {
+var createCanvas = function (a, b, c) {
     var _a;
-    let w = 0;
-    let h = 0;
-    let offscreen = false;
+    var w = 0;
+    var h = 0;
+    var offscreen = false;
     if (a instanceof DPoint_1.DPoint) {
-        const { x, y } = a;
+        var x = a.x, y = a.y;
         w = x;
         h = y;
     }
@@ -147,7 +183,7 @@ const createCanvas = (a, b, c) => {
     if (typeof c === 'boolean') {
         offscreen = c;
     }
-    const canvas = offscreen ? new OffscreenCanvas(w, h) : ((_a = exports.createCanvas.document) !== null && _a !== void 0 ? _a : document).createElement('canvas');
+    var canvas = offscreen ? new OffscreenCanvas(w, h) : ((_a = exports.createCanvas.document) !== null && _a !== void 0 ? _a : document).createElement('canvas');
     if (!offscreen) {
         canvas.width = w;
         canvas.height = h;
@@ -155,18 +191,24 @@ const createCanvas = (a, b, c) => {
     return [canvas, canvas.getContext('2d')];
 };
 exports.createCanvas = createCanvas;
-const f = (a, b) => [].concat(...a.map((c) => b.map((d) => [].concat(c, d))));
-const cartesianProduct = (a, b, ...c) => b ? (0, exports.cartesianProduct)(f(a, b), ...c) : a;
+var f = function (a, b) { return [].concat.apply([], __spreadArray([], __read(a.map(function (c) { return b.map(function (d) { return [].concat(c, d); }); })), false)); };
+var cartesianProduct = function (a, b) {
+    var c = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        c[_i - 2] = arguments[_i];
+    }
+    return b ? exports.cartesianProduct.apply(void 0, __spreadArray([f(a, b)], __read(c), false)) : a;
+};
 exports.cartesianProduct = cartesianProduct;
-const getCombinations = (arr) => {
+var getCombinations = function (arr) {
     if (arr.length === 1) {
         return arr[0];
     }
-    const ans = [];
-    const otherCases = (0, exports.getCombinations)(arr.slice(1));
-    for (let i = 0; i < otherCases.length; i++) {
-        for (let j = 0; j < arr[0].length; j++) {
-            ans.push([arr[0][j], ...otherCases[i]]);
+    var ans = [];
+    var otherCases = (0, exports.getCombinations)(arr.slice(1));
+    for (var i = 0; i < otherCases.length; i++) {
+        for (var j = 0; j < arr[0].length; j++) {
+            ans.push(__spreadArray([arr[0][j]], __read(otherCases[i]), false));
         }
     }
     return ans;

package/dist/esm/DCircle.js

@@ -9,7 +9,7 @@ var DCircle = (function () {
         this.r = r;
     }
     DCircle.prototype.toString = function () {
-        return "(" + this.center.toString() + ", " + this.r + ")";
+        return "(".concat(this.center.toString(), ", ").concat(this.r, ")");
     };
     DCircle.prototype.getValue = function () {
         return { center: this.center, r: this.r };

package/dist/esm/DLine.js

@@ -156,7 +156,7 @@ var DLine = (function () {
         configurable: true
     });
     DLine.prototype.toString = function () {
-        return "(" + this.a + ", " + this.b + ", " + this.c + ")";
+        return "(".concat(this.a, ", ").concat(this.b, ", ").concat(this.c, ")");
     };
     DLine.prototype.getValue = function () {
         return [this.a, this.b, this.c];
@@ -257,7 +257,7 @@ var DLine = (function () {
     };
     DLine.prototype.toWKT = function () {
         var _a = this, _b = _a.begin, x1 = _b.x, y1 = _b.y, _c = _a.end, x2 = _c.x, y2 = _c.y;
-        return "LINESTRING (" + x1 + " " + y1 + ", " + x2 + " " + y2 + ")";
+        return "LINESTRING (".concat(x1, " ").concat(y1, ", ").concat(x2, " ").concat(y2, ")");
     };
     DLine.prototype.movePoint = function (i, k) {
         var isArray = Array.isArray(i);

package/dist/esm/DPoint.js

@@ -133,7 +133,7 @@ var DPoint = (function () {
         return a2 + Math.PI * 2 - a1;
     };
     DPoint.prototype.toString = function () {
-        return this.x + " " + this.y;
+        return "".concat(this.x, " ").concat(this.y);
     };
     DPoint.prototype.getValue = function () {
         return [this.x, this.y];
@@ -144,7 +144,7 @@ var DPoint = (function () {
     };
     DPoint.prototype.toWKT = function () {
         var _a = this, x = _a.x, y = _a.y;
-        return "POINT (" + x + " " + y + ")";
+        return "POINT (".concat(x, " ").concat(y, ")");
     };
     DPoint.prototype.distance = function (p) {
         checkFunction('distance')