dgeoutils 2.4.41 → 2.4.44

package/dist/cjs/InterpolationMatrix.js

@@ -1,173 +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 __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-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;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InterpolationMatrix = void 0;
-var DPolygon_1 = require("./DPolygon");
-var DPoint_1 = require("./DPoint");
-var utils_1 = require("./utils");
-var InterpolationMatrix = (function () {
-    function InterpolationMatrix(bboxLike, stepSize, keys, p) {
-        if (p === void 0) { p = 2; }
-        this.stepSize = stepSize;
-        this.p = p;
-        this.points = [];
-        this.cells = {};
-        this.allCells = [];
-        this.minPoint = bboxLike.minPoint;
-        this.maxPoint = bboxLike.maxPoint;
-        this.sizePoly = DPolygon_1.DPolygon.createSquareBySize(new DPoint_1.DPoint(this.stepSize));
-        this.size = this.maxPoint.clone().move(this.minPoint.clone().minus())
-            .divide(this.stepSize)
-            .ceil();
-        this.keys = Array.isArray(keys) ? keys : [keys];
-        this.generateCells();
-    }
-    InterpolationMatrix.prototype.setKnownPoints = function (points) {
-        var _this = this;
-        this.points = points instanceof DPolygon_1.DPolygon ? points.points : points;
-        this.minPoint.setProperties(this.points.reduce(function (a, v) { return _this.keys
-            .reduce(function (aa, k) {
-            var _a;
-            aa[k] = Math.min((_a = a[k]) !== null && _a !== void 0 ? _a : Infinity, v.properties[k]);
-            return aa;
-        }, a); }, {}));
-        this.maxPoint.setProperties(this.points.reduce(function (a, v) { return _this.keys
-            .reduce(function (aa, k) {
-            var _a;
-            aa[k] = Math.max((_a = a[k]) !== null && _a !== void 0 ? _a : -Infinity, v.properties[k]);
-            return aa;
-        }, a); }, {}));
-        return this;
-    };
-    InterpolationMatrix.prototype.positionToCellCoords = function (d) {
-        return d.clone()
-            .move(this.minPoint.clone().minus())
-            .divide(this.stepSize)
-            .floor();
-    };
-    InterpolationMatrix.prototype.calculate = function () {
-        this.setKnownValues();
-        this.interpolateValues();
-        return this;
-    };
-    InterpolationMatrix.prototype.getCellValue = function (_a, key) {
-        var x = _a.x, y = _a.y;
-        var cell = this.cells[x][y];
-        if (key) {
-            if (Array.isArray(key)) {
-                return key.reduce(function (a, k) {
-                    a[k] = cell.properties[k];
-                    return a;
-                }, {});
-            }
-            return cell.properties[key];
-        }
-        return __assign({}, cell.properties);
-    };
-    Object.defineProperty(InterpolationMatrix.prototype, "getCellData", {
-        get: function () {
-            return this.allCells.reduce(function (a, c) {
-                var _a = c.properties, x = _a.x, y = _a.y, props = __rest(_a, ["x", "y"]);
-                a[x] = a[x] || {};
-                a[x][y] = __assign({}, props);
-                return a;
-            }, {});
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(InterpolationMatrix.prototype, "allCellsClone", {
-        get: function () {
-            return this.allCells.map(function (p) { return p.clone(); });
-        },
-        enumerable: false,
-        configurable: true
-    });
-    InterpolationMatrix.prototype.interpolateValues = function () {
-        var _this = this;
-        var points = this.points.map(function (p) { return _this.positionToCellCoords(p); });
-        this.allCells.forEach(function (cell) {
-            var t = new DPoint_1.DPoint(cell.properties.x, cell.properties.y);
-            var distances = points.map(function (p) { return Math.pow(t.distance(p), _this.p); });
-            _this.keys.forEach(function (k) {
-                if ((0, utils_1.isDefAndNotNull)(cell.properties[k])) {
-                    return;
-                }
-                var _a = __read(distances.reduce(function (a, d, i) {
-                    if ((0, utils_1.isDefAndNotNull)(_this.points[i].properties[k])) {
-                        a[0] += _this.points[i].properties[k] / d;
-                        a[1] += 1 / d;
-                    }
-                    return a;
-                }, [0, 0]), 2), valueSum = _a[0], oneSum = _a[1];
-                cell.properties[k] = valueSum / oneSum;
-            });
-        });
-    };
-    InterpolationMatrix.prototype.setKnownValues = function () {
-        var _this = this;
-        this.points.forEach(function (p) {
-            var _a = _this.positionToCellCoords(p), x = _a.x, y = _a.y;
-            _this.keys.forEach(function (k) {
-                _this.cells[x][y].properties[k] = p.properties[k];
-            });
-        });
-    };
-    InterpolationMatrix.prototype.generateCells = function () {
-        for (var i = this.minPoint.x, x = 0; i < this.maxPoint.x; i += this.stepSize, x++) {
-            this.cells[x] = this.cells[x] || {};
-            for (var j = this.minPoint.y, y = 0; j < this.maxPoint.y; j += this.stepSize, y++) {
-                var t = this.sizePoly
-                    .clone()
-                    .loop()
-                    .move(i, j)
-                    .run()
-                    .setProperties({
-                    x: x,
-                    y: y
-                });
-                this.cells[x][y] = t;
-                this.allCells.push(t);
-            }
-        }
-    };
-    return InterpolationMatrix;
-}());
-exports.InterpolationMatrix = InterpolationMatrix;

package/dist/cjs/TraceMatrix.d.ts

@@ -1,22 +0,0 @@
-import { DPoint } from './DPoint';
-import { DPolygon } from './DPolygon';
-export declare enum TraceMatrixValues {
-    f = 0,
-    t = 1
-}
-export declare type SimpleMatrix = TraceMatrixValues[][];
-export declare class TraceMatrix {
-    private readonly m;
-    approximation: boolean;
-    private readonly size;
-    constructor(s: DPoint, f: (p: DPoint) => TraceMatrixValues);
-    fullMatrixTrace(): DPolygon[];
-    private reverseMatrix;
-    private findGroupByIndex;
-    private findMarked;
-    private totalCountInMatrix;
-    private findAllGroupsInMatrix;
-    private traceGroup;
-    private createHoleMatrix;
-    static createMatrix(size: DPoint, f?: (pos: DPoint) => TraceMatrixValues): SimpleMatrix;
-}

package/dist/cjs/TraceMatrix.js

@@ -1,285 +0,0 @@
-"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;
-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 = {}));
-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];
-};
-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];
-};
-var TraceMatrix = (function () {
-    function TraceMatrix(s, f) {
-        var _this = this;
-        this.approximation = true;
-        this.findGroupByIndex = function (m, s) {
-            var res = new DPolygon_1.DPolygon();
-            if (s && getByPosition(m, s) === TraceMatrixValues.t) {
-                res.push(s);
-                var startIndex = 0;
-                var marked = TraceMatrix.createMatrix(_this.size, function () { return TraceMatrixValues.f; });
-                setByPosition(marked, s, TraceMatrixValues.t);
-                while (startIndex < res.length) {
-                    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);
-                                setByPosition(marked, t, TraceMatrixValues.t);
-                            }
-                        }
-                    }
-                    startIndex++;
-                }
-            }
-            return res;
-        };
-        this.findAllGroupsInMatrix = function (m) {
-            var firstMark = _this.findMarked(m);
-            if (!firstMark) {
-                return [];
-            }
-            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)) {
-                var mark = _this.findMarked(m);
-                while (mark && fs.find(mark)) {
-                    mark = _this.findMarked(m, mark);
-                }
-                var nextGroup = _this.findGroupByIndex(m, mark);
-                groupSum += nextGroup.length;
-                allGroups = __spreadArray(__spreadArray([], __read(allGroups), false), __read(nextGroup.points), false);
-                fs.add(nextGroup.points);
-                groups.push(nextGroup);
-            }
-            return groups.filter(function (g) { return g.length > 2; });
-        };
-        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),
-                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)
-            ];
-            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) {
-                var t = group.at(0).clone();
-                return new DPolygon_1.DPolygon([t, t, t]);
-            }
-            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) {
-                    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;
-                    }
-                    direction = right(direction);
-                }
-                if (prevDirection !== direction) {
-                    points.push(p);
-                    prevDirection = direction;
-                }
-                p = p.clone().move(traceDirections[direction]);
-                direction = left(left(direction));
-            }
-            if (_this.approximation) {
-                return points.approximation().close();
-            }
-            return points.clone().close();
-        };
-        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();
-            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));
-            }
-            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));
-            }
-            while (startCoords.length) {
-                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; }
-                }
-            }
-            var t = _this.reverseMatrix(tmpMatrix);
-            return _this.totalCountInMatrix(t) ? t : null;
-        };
-        this.size = s.clone().scale(4);
-        var t = TraceMatrix.createMatrix(this.size, function (p) {
-            var _a = p.clone().mod(4), x = _a.x, y = _a.y;
-            if ([1, 2].includes(x) && [1, 2].includes(y)) {
-                return f(p.clone().div(4));
-            }
-            return TraceMatrixValues.f;
-        });
-        this.m = TraceMatrix.createMatrix(this.size);
-        for (var i = 1; i < this.size.y - 1; i++) {
-            for (var j = 1; j < this.size.x - 1; j++) {
-                if (t[i][j] === TraceMatrixValues.t) {
-                    this.m[i - 1][j - 1] = TraceMatrixValues.t;
-                    this.m[i - 1][j] = TraceMatrixValues.t;
-                    this.m[i - 1][j + 1] = TraceMatrixValues.t;
-                    this.m[i][j - 1] = TraceMatrixValues.t;
-                    this.m[i][j] = TraceMatrixValues.t;
-                    this.m[i][j + 1] = TraceMatrixValues.t;
-                    this.m[i + 1][j - 1] = TraceMatrixValues.t;
-                    this.m[i + 1][j] = TraceMatrixValues.t;
-                    this.m[i + 1][j + 1] = TraceMatrixValues.t;
-                }
-            }
-        }
-    }
-    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.loop()
-                .divide(4)
-                .round()
-                .run();
-        });
-    };
-    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;
-                    ini = true;
-                    continue;
-                }
-                if (getByPosition(m, new DPoint_1.DPoint(i, j)) === TraceMatrixValues.t) {
-                    return new DPoint_1.DPoint(i, j);
-                }
-            }
-        }
-        return null;
-    };
-    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;
-    };
-    TraceMatrix.createMatrix = function (size, f) {
-        if (f === void 0) { f = function () { return TraceMatrixValues.f; }; }
-        return (0, utils_1.createArray)(size.h)
-            .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.d.ts

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

package/dist/cjs/index.js

@@ -1,37 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = 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];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DGeo = exports.parseDegreesMinutesSeconds = exports.getCombinations = exports.cartesianProduct = exports.isDefAndNotNull = exports.createMatrix = exports.createArray = exports.createCanvas = exports.gaussianElimination = void 0;
-__exportStar(require("./DCircle"), exports);
-__exportStar(require("./DLine"), exports);
-__exportStar(require("./DNumbers"), exports);
-__exportStar(require("./DPoint"), exports);
-__exportStar(require("./DPolygon"), exports);
-__exportStar(require("./FastSearch"), exports);
-__exportStar(require("./TraceMatrix"), exports);
-__exportStar(require("./InterpolationMatrix"), exports);
-__exportStar(require("./DPolygonLoop"), exports);
-__exportStar(require("./DPlane"), exports);
-var utils_1 = require("./utils");
-Object.defineProperty(exports, "gaussianElimination", { enumerable: true, get: function () { return utils_1.gaussianElimination; } });
-Object.defineProperty(exports, "createCanvas", { enumerable: true, get: function () { return utils_1.createCanvas; } });
-Object.defineProperty(exports, "createArray", { enumerable: true, get: function () { return utils_1.createArray; } });
-Object.defineProperty(exports, "createMatrix", { enumerable: true, get: function () { return utils_1.createMatrix; } });
-Object.defineProperty(exports, "isDefAndNotNull", { enumerable: true, get: function () { return utils_1.isDefAndNotNull; } });
-Object.defineProperty(exports, "cartesianProduct", { enumerable: true, get: function () { return utils_1.cartesianProduct; } });
-Object.defineProperty(exports, "getCombinations", { enumerable: true, get: function () { return utils_1.getCombinations; } });
-Object.defineProperty(exports, "parseDegreesMinutesSeconds", { enumerable: true, get: function () { return utils_1.parseDegreesMinutesSeconds; } });
-Object.defineProperty(exports, "DGeo", { enumerable: true, get: function () { return utils_1.DGeo; } });

package/dist/cjs/utils.d.ts

@@ -1,49 +0,0 @@
-/// <reference types="offscreencanvas" />
-import { DPoint } from './DPoint';
-interface DGeoInterface {
-    DEBUG: boolean;
-    parseFormat: string;
-}
-export declare const DGeo: DGeoInterface;
-export declare const warn: (...args: any[]) => void;
-export declare const isDefAndNotNull: (a: any) => boolean;
-declare type CheckFunc = (p: DPoint) => CheckFunction;
-declare type CheckFunc2 = (p: any) => CheckFunction;
-interface CheckArgument {
-    shouldBeDegree: CheckFunc;
-    shouldBeMeters: CheckFunc;
-    shouldBeInt: CheckFunc;
-    shouldBeUInt: CheckFunc;
-    shouldBeRadians: CheckFunc;
-    shouldExist: CheckFunc2;
-}
-interface CheckFunction {
-    checkArgument: (argName: string) => CheckArgument;
-}
-export declare const checkFunction: (funcName: string) => CheckFunction;
-declare type ArrayFillFunction<T> = (index: number) => T;
-export declare const createArray: <T = number>(v: number, fillSymbol?: T | ArrayFillFunction<T> | undefined) => T[];
-declare type MatrixFillFunction<T> = (x: number, y: number) => T;
-export declare const createMatrix: <T>({ h, w }: DPoint, fillSymbol?: T | MatrixFillFunction<T> | undefined) => T[][];
-export declare const gaussianElimination: {
-    (matrix: number[][]): number[];
-    MIN: number;
-};
-export declare type True = true;
-export declare const createCanvas: {
-    (size: number): [HTMLCanvasElement, CanvasRenderingContext2D];
-    (size: number, offscreen: True): [OffscreenCanvas, OffscreenCanvasRenderingContext2D];
-    (w: number, h: number): [HTMLCanvasElement, CanvasRenderingContext2D];
-    (w: number, h: number, offscreen: True): [OffscreenCanvas, OffscreenCanvasRenderingContext2D];
-    (size: DPoint): [HTMLCanvasElement, CanvasRenderingContext2D];
-    (size: DPoint, offscreen: True): [OffscreenCanvas, OffscreenCanvasRenderingContext2D];
-    document?: Document;
-};
-export declare const cartesianProduct: {
-    <T>(a: T[], ...b: T[][]): T[][];
-};
-export declare const getCombinations: <T>(arr: T[][]) => T[][];
-export declare const div: (a: number, b: number) => number;
-export declare const toDegreesMinutesSeconds: (v: number) => string;
-export declare const parseDegreesMinutesSeconds: (i: string) => number;
-export {};