dgeoutils 2.4.2 → 2.4.3

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

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

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

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

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

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

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

@@ -1,15 +1,12 @@
-"use strict";
-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 TraceMatrixValues;
+import { DPoint } from './DPoint';
+import { DPolygon, MIN_POINTS_IN_VALID_POLYGON } from './DPolygon';
+import { FastSearch } from './FastSearch';
+import { createArray } from './utils';
+export var TraceMatrixValues;
 (function (TraceMatrixValues) {
     TraceMatrixValues[TraceMatrixValues["f"] = 0] = "f";
     TraceMatrixValues[TraceMatrixValues["t"] = 1] = "t";
-})(TraceMatrixValues = exports.TraceMatrixValues || (exports.TraceMatrixValues = {}));
+})(TraceMatrixValues || (TraceMatrixValues = {}));
 const getByPosition = (m, p, defaultValue = TraceMatrixValues.f) => {
     if (m[p.y] === undefined || m[p.y][p.x] === undefined) {
         return defaultValue;
@@ -23,11 +20,11 @@ const setByPosition = (m, p, value) => {
     m[p.y][p.x] = value;
     return m[p.y][p.x];
 };
-class TraceMatrix {
+export class TraceMatrix {
     constructor(size, f) {
         this.size = size;
         this.findGroupByIndex = (m, s) => {
-            const res = new DPolygon_1.DPolygon();
+            const res = new DPolygon();
             if (s && getByPosition(m, s) === TraceMatrixValues.t) {
                 res.push(s);
                 let startIndex = 0;
@@ -37,7 +34,7 @@ class TraceMatrix {
                     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);
+                            const t = new 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);
@@ -59,7 +56,7 @@ class TraceMatrix {
             const groups = [group];
             let groupSum = group.length;
             let allGroups = [...group.points];
-            const fs = new FastSearch_1.FastSearch();
+            const fs = new FastSearch();
             fs.add(allGroups);
             while (groupSum < this.totalCountInMatrix(m)) {
                 let mark = this.findMarked(m);
@@ -76,22 +73,22 @@ class TraceMatrix {
         };
         this.traceGroup = (m, group) => {
             const traceDirections = [
-                new DPoint_1.DPoint(-1, -1),
-                new DPoint_1.DPoint(-1, 0),
-                new DPoint_1.DPoint(-1, 1),
-                new DPoint_1.DPoint(0, 1),
-                new DPoint_1.DPoint(1, 1),
-                new DPoint_1.DPoint(1, 0),
-                new DPoint_1.DPoint(1, -1),
-                new DPoint_1.DPoint(0, -1)
+                new DPoint(-1, -1),
+                new DPoint(-1, 0),
+                new DPoint(-1, 1),
+                new DPoint(0, 1),
+                new DPoint(1, 1),
+                new DPoint(1, 0),
+                new DPoint(1, -1),
+                new DPoint(0, -1)
             ];
             const left = (d) => (d + traceDirections.length + 1) % traceDirections.length;
             const right = (d) => (d + traceDirections.length - 1) % traceDirections.length;
             if (group.length < 2) {
                 const t = group.at(0).clone();
-                return new DPolygon_1.DPolygon([t, t, t]);
+                return new DPolygon([t, t, t]);
             }
-            const points = new DPolygon_1.DPolygon();
+            const points = new DPolygon();
             let direction = 0;
             let prevDirection = Infinity;
             let p = group.at(0);
@@ -115,22 +112,22 @@ class TraceMatrix {
         };
         this.createHoleMatrix = (group) => {
             const 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)
+                new DPoint(-1, 0),
+                new DPoint(0, 1),
+                new DPoint(1, 0),
+                new 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();
+            const startCoords = new DPolygon();
             for (let 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(i, -1));
+                startCoords.push(new DPoint(i, this.size.h));
             }
             for (let 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, i));
+                startCoords.push(new DPoint(this.size.w, i));
             }
             while (startCoords.length) {
                 const point = startCoords.pop();
@@ -154,7 +151,7 @@ class TraceMatrix {
         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));
+            .traceGroup(holeMatrixs[index], g)).filter((r) => r.length > MIN_POINTS_IN_VALID_POLYGON));
         return groups.map((g, index) => {
             const res = paths[index];
             if (holesGroups[index] && holesGroups[index].length) {
@@ -177,8 +174,8 @@ class TraceMatrix {
                     ini = true;
                     continue;
                 }
-                if (getByPosition(m, new DPoint_1.DPoint(i, j)) === TraceMatrixValues.t) {
-                    return new DPoint_1.DPoint(i, j);
+                if (getByPosition(m, new DPoint(i, j)) === TraceMatrixValues.t) {
+                    return new DPoint(i, j);
                 }
             }
         }
@@ -189,7 +186,7 @@ class TraceMatrix {
         const s = this.size;
         for (let i = 0; i < s.w; i++) {
             for (let j = 0; j < s.h; j++) {
-                if (getByPosition(m, new DPoint_1.DPoint(i, j))) {
+                if (getByPosition(m, new DPoint(i, j))) {
                     res++;
                 }
             }
@@ -197,8 +194,7 @@ class TraceMatrix {
         return res;
     }
     static createMatrix(size, f = () => 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))));
+        return createArray(size.h)
+            .map((v, i) => createArray(size.w).map((v2, j) => f(new DPoint(j, i))));
     }
 }
-exports.TraceMatrix = TraceMatrix;

package/dist/es2015/index.js

@@ -0,0 +1,10 @@
+export * from './DCircle';
+export * from './DLine';
+export * from './DNumbers';
+export * from './DPoint';
+export * from './DPolygon';
+export * from './FastSearch';
+export * from './TraceMatrix';
+export * from './DPolygonLoop';
+export * from './DPlane';
+export { gaussianElimination, createCanvas, createArray, createMatrix, isDefAndNotNull, cartesianProduct, getCombinations, DGeo } from './utils';

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

@@ -1,60 +1,55 @@
-"use strict";
-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");
-exports.DGeo = {
+import { DPoint } from './DPoint';
+export const DGeo = {
     DEBUG: false
 };
-const warn = (...args) => {
-    if (exports.DGeo.DEBUG) {
+export const warn = (...args) => {
+    if (DGeo.DEBUG) {
         console.warn(...args);
     }
 };
-exports.warn = warn;
-const isDefAndNotNull = (a) => a != undefined;
-exports.isDefAndNotNull = isDefAndNotNull;
+export const isDefAndNotNull = (a) => a != undefined;
 const hook = (scope) => () => scope;
 const shouldBeInt = (scope, funcName, argName) => (p) => {
     if (!p.clone().round()
         .equal(p)) {
-        (0, exports.warn)(`"${funcName}" -> "${argName}" should be Int!`);
+        warn(`"${funcName}" -> "${argName}" should be Int!`);
     }
     return scope;
 };
 const shouldBeUInt = (scope, funcName, argName) => (p) => {
     if (!p.clone().round()
-        .equal(p) || !p.gtOrEqual(DPoint_1.DPoint.zero())) {
-        (0, exports.warn)(`"${funcName}" -> "${argName}" should be UInt!`);
+        .equal(p) || !p.gtOrEqual(DPoint.zero())) {
+        warn(`"${funcName}" -> "${argName}" should be UInt!`);
     }
     return scope;
 };
 const shouldBeDegree = (scope, funcName, argName) => (p) => {
     if (!p.likeWorldGeodeticSystem) {
-        (0, exports.warn)(`"${funcName}" -> "${argName}" should be degree!`);
+        warn(`"${funcName}" -> "${argName}" should be degree!`);
     }
     return scope;
 };
 const shouldBeRadians = (scope, funcName, argName) => (p) => {
     if (!p.likeRadians) {
-        (0, exports.warn)(`"${funcName}" -> "${argName}" should be radians!`);
+        warn(`"${funcName}" -> "${argName}" should be radians!`);
     }
     return scope;
 };
 const shouldExist = (scope, funcName, argName) => (p) => {
-    if (!(0, exports.isDefAndNotNull)(p)) {
-        (0, exports.warn)(`"${funcName}" -> "${argName}" should exist!`);
+    if (!isDefAndNotNull(p)) {
+        warn(`"${funcName}" -> "${argName}" should exist!`);
     }
     return scope;
 };
 const shouldBeMeters = (scope, funcName, argName) => (p) => {
     if (!p.likePseudoMercator) {
-        (0, exports.warn)(`"${funcName}" -> "${argName}" should be meters!`);
+        warn(`"${funcName}" -> "${argName}" should be meters!`);
     }
     return scope;
 };
-const checkFunction = (funcName) => ({
+export const checkFunction = (funcName) => ({
     checkArgument: function (argName) {
-        if (!exports.DGeo.DEBUG) {
+        if (!DGeo.DEBUG) {
             return {
                 shouldBeDegree: hook(this),
                 shouldBeMeters: hook(this),
@@ -74,18 +69,15 @@ const checkFunction = (funcName) => ({
         };
     }
 });
-exports.checkFunction = checkFunction;
-const createArray = (v, fillSymbol = 0) => new Array(v).fill(fillSymbol);
-exports.createArray = createArray;
-const createMatrix = ({ h, w }, fillSymbol = 0) => (0, exports.createArray)(h)
-    .map(() => (0, exports.createArray)(w, fillSymbol));
-exports.createMatrix = createMatrix;
-const gaussianElimination = (matrix) => {
+export const createArray = (v, fillSymbol = 0) => new Array(v).fill(fillSymbol);
+export const createMatrix = ({ h, w }, fillSymbol = 0) => createArray(h)
+    .map(() => createArray(w, fillSymbol));
+export const gaussianElimination = (matrix) => {
     const n = matrix.length;
-    const matrixClone = (0, exports.createMatrix)(new DPoint_1.DPoint(n + 1, n));
+    const matrixClone = createMatrix(new DPoint(n + 1, n));
     for (let i = 0; i < n; i++) {
         for (let j = 0; j < n + 1; j++) {
-            matrix[i][j] = matrix[i][j] === 0 ? exports.gaussianElimination.MIN : matrix[i][j];
+            matrix[i][j] = matrix[i][j] === 0 ? gaussianElimination.MIN : matrix[i][j];
             matrixClone[i][j] = matrix[i][j];
         }
     }
@@ -116,20 +108,19 @@ const gaussianElimination = (matrix) => {
             }
         }
     }
-    const answer = (0, exports.createArray)(n);
+    const answer = createArray(n);
     for (let 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) => {
+gaussianElimination.MIN = 1e-10;
+export const createCanvas = (a, b, c) => {
     var _a;
     let w = 0;
     let h = 0;
     let offscreen = false;
-    if (a instanceof DPoint_1.DPoint) {
+    if (a instanceof DPoint) {
         const { x, y } = a;
         w = x;
         h = y;
@@ -147,23 +138,21 @@ 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');
+    const canvas = offscreen ? new OffscreenCanvas(w, h) : ((_a = createCanvas.document) !== null && _a !== void 0 ? _a : document).createElement('canvas');
     if (!offscreen) {
         canvas.width = w;
         canvas.height = h;
     }
     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;
-exports.cartesianProduct = cartesianProduct;
-const getCombinations = (arr) => {
+export const cartesianProduct = (a, b, ...c) => b ? cartesianProduct(f(a, b), ...c) : a;
+export const getCombinations = (arr) => {
     if (arr.length === 1) {
         return arr[0];
     }
     const ans = [];
-    const otherCases = (0, exports.getCombinations)(arr.slice(1));
+    const otherCases = 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]]);
@@ -171,4 +160,3 @@ const getCombinations = (arr) => {
     }
     return ans;
 };
-exports.getCombinations = getCombinations;

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')