dgeoutils 2.4.4 → 2.4.7

package/dist/cjs/DPoint.d.ts

@@ -1,10 +1,13 @@
 import { DLine } from './DLine';
 import { DPolygon } from './DPolygon';
+import { Point } from 'geojson';
 export declare const EARTH_RADIUS_IN_METERS = 6371008.8;
 export declare type DCoord = [number, number] | [number, number, number];
 export interface LatLng {
     lat: number;
-    lng: number;
+    lng?: number;
+    lon?: number;
+    alt?: number;
 }
 export declare const HALF_PI_IN_DEGREE = 90;
 export declare const PI_IN_DEGREE = 180;
@@ -24,12 +27,15 @@ export declare class DPoint {
     constructor(x: number, y: number);
     constructor(x: number, y: number, z?: number);
     static zero(): DPoint;
-    static parse(c: LatLng | number[] | DCoord): DPoint;
+    static parse(c: LatLng | number[] | DCoord | Point, format?: string): DPoint;
     static parseFromWKT(wkt: string): DPoint;
     static random(): DPoint;
+    static getTileFromQuadKey(quadKey: string): DPoint;
     getTileFromCoords(zoom?: number): DPoint;
+    getQuadKeyFromTile(zoom?: number): string;
     getCoordsFromTile(zoom?: number): DPoint;
-    toCoords(): DCoord;
+    toCoords(format?: string): DCoord;
+    toGeoJSON(format?: string): Point;
     findLine(p: DPoint): DLine;
     findInnerAngle(p1: DPoint, p3: DPoint): number;
     toString(): string;

package/dist/cjs/DPoint.js

@@ -57,13 +57,34 @@ var DPoint = (function () {
     DPoint.zero = function () {
         return new DPoint();
     };
-    DPoint.parse = function (c) {
-        var _a = c, lat = _a.lat, lng = _a.lng;
+    DPoint.parse = function (c, format) {
+        if (format === void 0) { format = 'xyz'; }
+        var _a = c, lat = _a.lat, lon = _a.lon, _b = _a.lng, lng = _b === void 0 ? lon : _b, alt = _a.alt;
         if (lat && lng) {
-            return new DPoint(lat, lng, 0);
+            return new DPoint(lat, lng, alt !== null && alt !== void 0 ? alt : 0);
         }
-        var _b = __read(c, 3), x = _b[0], y = _b[1], z = _b[2];
-        return new DPoint(x, y, z);
+        var t = c;
+        if (c.type === 'Point') {
+            t = c.coordinates;
+        }
+        return format.replace(/[^x-z]/gmiu, '')
+            .split('')
+            .reduce(function (a, k, index) {
+            var _a, _b;
+            switch (k) {
+                case 'x':
+                    a.x = (_a = t[index]) !== null && _a !== void 0 ? _a : 0;
+                    break;
+                case 'y':
+                    a.y = (_b = t[index]) !== null && _b !== void 0 ? _b : 0;
+                    break;
+                case 'z':
+                    a.z = t[index];
+                    break;
+                default:
+            }
+            return a;
+        }, new DPoint());
     };
     DPoint.parseFromWKT = function (wkt) {
         var regexp = /POINT \((?<data>(?:(?!\)).)*?)\)$/miu;
@@ -75,6 +96,29 @@ var DPoint = (function () {
     DPoint.random = function () {
         return new DPoint(Math.random(), Math.random());
     };
+    DPoint.getTileFromQuadKey = function (quadKey) {
+        var p = new DPoint(0, 0, quadKey.length);
+        for (var i = p.z; i > 0; i--) {
+            var mask = 1 << (i - 1);
+            switch (quadKey[p.z - i]) {
+                case '0':
+                    break;
+                case '1':
+                    p.x |= mask;
+                    break;
+                case '2':
+                    p.y |= mask;
+                    break;
+                case '3':
+                    p.x |= mask;
+                    p.y |= mask;
+                    break;
+                default:
+                    throw new Error('Invalid QuadKey digit sequence.');
+            }
+        }
+        return p;
+    };
     DPoint.prototype.getTileFromCoords = function (zoom) {
         if (zoom === void 0) { zoom = this.z; }
         (0, utils_1.checkFunction)('getTileFromCoords')
@@ -84,6 +128,23 @@ var DPoint = (function () {
         var y = Math.floor((1 - Math.log(Math.tan(this.y * exports.PI_TO_DEGREE) + 1 / Math.cos(this.y * exports.PI_TO_DEGREE)) / Math.PI) / 2 * (Math.pow(2, zoom)));
         return new DPoint(x, y, zoom);
     };
+    DPoint.prototype.getQuadKeyFromTile = function (zoom) {
+        if (zoom === void 0) { zoom = this.z; }
+        var quadKey = [];
+        for (var i = zoom; i > 0; i--) {
+            var digit = 0;
+            var mask = 1 << (i - 1);
+            if ((this.x & mask) !== 0) {
+                digit++;
+            }
+            if ((this.y & mask) !== 0) {
+                digit++;
+                digit++;
+            }
+            quadKey.push(digit);
+        }
+        return quadKey.join('');
+    };
     DPoint.prototype.getCoordsFromTile = function (zoom) {
         if (zoom === void 0) { zoom = this.z; }
         (0, utils_1.checkFunction)('getCoordsFromTile')
@@ -94,11 +155,23 @@ var DPoint = (function () {
         var y = exports.PI_IN_DEGREE / Math.PI * Math.atan((Math.exp(n) - Math.exp(-n)) / 2);
         return new DPoint(x, y, zoom);
     };
-    DPoint.prototype.toCoords = function () {
-        if (this.z === undefined) {
-            return [this.x, this.y];
-        }
-        return [this.x, this.y, this.z];
+    DPoint.prototype.toCoords = function (format) {
+        var _this = this;
+        if (format === void 0) { format = 'xyz'; }
+        return format.replace(/[^x-z]/gmiu, '').split('')
+            .map(function (k) { return ({
+            x: _this.x,
+            y: _this.y,
+            z: _this.z
+        })[k]; })
+            .filter(function (r) { return r !== undefined; });
+    };
+    DPoint.prototype.toGeoJSON = function (format) {
+        if (format === void 0) { format = 'xyz'; }
+        return {
+            type: 'Point',
+            coordinates: this.toCoords(format)
+        };
     };
     DPoint.prototype.findLine = function (p) {
         (0, utils_1.checkFunction)('findLine')

package/dist/cjs/DPolygon.d.ts

@@ -3,12 +3,13 @@ import { DCoord, DPoint, LatLng } from './DPoint';
 import { DLine } from './DLine';
 import { DPolygonLoop } from './DPolygonLoop';
 import { True } from './utils';
+import { LineString, Polygon, Geometry as GeoJsonGeometry, Feature, FeatureCollection } from 'geojson';
+interface DeepArray<T> extends Array<T | DeepArray<T>> {
+}
 export declare const MIN_POINTS_IN_VALID_POLYGON = 3;
 export declare class DPolygon {
     private pPoints;
-    properties: {
-        [key: string]: any;
-    };
+    properties: Record<string, any>;
     holes: DPolygon[];
     private searchStore;
     constructor(pPoints?: DPoint[]);
@@ -93,10 +94,14 @@ export declare class DPolygon {
     onBorder(p: DPoint): boolean;
     nextStart(): DPolygon;
     removeDuplicates(): DPolygon;
-    static parse(a: LatLng[]): DPolygon;
-    static parse(a: number[][]): DPolygon;
-    static parse(a: DCoord[]): DPolygon;
-    toArrayOfCoords(): DCoord[];
+    static toGeoJSONFeatureCollection(polygons: DPolygon[], format?: string): FeatureCollection<LineString | Polygon, Record<string, any>>;
+    static parse(a: LatLng[], format?: string): DPolygon;
+    static parse(a: number[][], format?: string): DPolygon;
+    static parse(a: DCoord[], format?: string): DPolygon;
+    static parse(a: GeoJsonGeometry | Feature | FeatureCollection<LineString | Polygon>, format?: string): DPolygon | DeepArray<DPolygon>;
+    toArrayOfCoords(format?: string): DCoord[];
+    toGeoJSONFeature(format?: string): Feature<LineString | Polygon, Record<string, any>>;
+    toGeoJSON(format?: string): LineString | Polygon;
     divideToPieces(piecesCount: number, withAltitude?: boolean): DPolygon;
     prepareToFastSearch(): void;
     fastHas({ x, y, z }: DPoint): boolean;
@@ -122,3 +127,4 @@ export declare class DPolygon {
     private getJSTSGeometry;
     private simpleLogicFunction;
 }
+export {};

package/dist/cjs/DPolygon.js

@@ -1,4 +1,15 @@
 "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;
@@ -955,11 +966,96 @@ var DPolygon = (function () {
         }
         return this;
     };
-    DPolygon.parse = function (a) {
-        return new DPolygon(a.map(function (r) { return DPoint_1.DPoint.parse(r); }));
+    DPolygon.toGeoJSONFeatureCollection = function (polygons, format) {
+        if (format === void 0) { format = 'xyz'; }
+        return {
+            type: 'FeatureCollection',
+            features: polygons.map(function (polygon) { return polygon.toGeoJSONFeature(format); })
+        };
     };
-    DPolygon.prototype.toArrayOfCoords = function () {
-        return this.mapArray(function (r) { return r.toCoords(); });
+    DPolygon.parse = function (a, format) {
+        if (format === void 0) { format = 'xyz'; }
+        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);
+                    t.properties = __assign(__assign({}, a.properties), { id: a.id });
+                    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 = 'xyz'; }
+        return this.mapArray(function (r) { return r.toCoords(format); });
+    };
+    DPolygon.prototype.toGeoJSONFeature = function (format) {
+        if (format === void 0) { format = 'xyz'; }
+        return {
+            type: 'Feature',
+            properties: __assign({}, this.properties),
+            geometry: this.toGeoJSON(format)
+        };
+    };
+    DPolygon.prototype.toGeoJSON = function (format) {
+        if (format === void 0) { format = 'xyz'; }
+        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;

package/dist/es2015/DPoint.js

@@ -25,13 +25,33 @@ export class DPoint {
     static zero() {
         return new DPoint();
     }
-    static parse(c) {
-        const { lat, lng } = c;
+    static parse(c, format = 'xyz') {
+        const { lat, lon, lng = lon, alt } = c;
         if (lat && lng) {
-            return new DPoint(lat, lng, 0);
+            return new DPoint(lat, lng, alt !== null && alt !== void 0 ? alt : 0);
         }
-        const [x, y, z] = c;
-        return new DPoint(x, y, z);
+        let t = c;
+        if (c.type === 'Point') {
+            t = c.coordinates;
+        }
+        return format.replace(/[^x-z]/gmiu, '')
+            .split('')
+            .reduce((a, k, index) => {
+            var _a, _b;
+            switch (k) {
+                case 'x':
+                    a.x = (_a = t[index]) !== null && _a !== void 0 ? _a : 0;
+                    break;
+                case 'y':
+                    a.y = (_b = t[index]) !== null && _b !== void 0 ? _b : 0;
+                    break;
+                case 'z':
+                    a.z = t[index];
+                    break;
+                default:
+            }
+            return a;
+        }, new DPoint());
     }
     static parseFromWKT(wkt) {
         const regexp = /POINT \((?<data>(?:(?!\)).)*?)\)$/miu;
@@ -43,6 +63,29 @@ export class DPoint {
     static random() {
         return new DPoint(Math.random(), Math.random());
     }
+    static getTileFromQuadKey(quadKey) {
+        const p = new DPoint(0, 0, quadKey.length);
+        for (let i = p.z; i > 0; i--) {
+            const mask = 1 << (i - 1);
+            switch (quadKey[p.z - i]) {
+                case '0':
+                    break;
+                case '1':
+                    p.x |= mask;
+                    break;
+                case '2':
+                    p.y |= mask;
+                    break;
+                case '3':
+                    p.x |= mask;
+                    p.y |= mask;
+                    break;
+                default:
+                    throw new Error('Invalid QuadKey digit sequence.');
+            }
+        }
+        return p;
+    }
     getTileFromCoords(zoom = this.z) {
         checkFunction('getTileFromCoords')
             .checkArgument('this')
@@ -51,6 +94,22 @@ export class DPoint {
         const y = Math.floor((1 - Math.log(Math.tan(this.y * PI_TO_DEGREE) + 1 / Math.cos(this.y * PI_TO_DEGREE)) / Math.PI) / 2 * (Math.pow(2, zoom)));
         return new DPoint(x, y, zoom);
     }
+    getQuadKeyFromTile(zoom = this.z) {
+        const quadKey = [];
+        for (let i = zoom; i > 0; i--) {
+            let digit = 0;
+            const mask = 1 << (i - 1);
+            if ((this.x & mask) !== 0) {
+                digit++;
+            }
+            if ((this.y & mask) !== 0) {
+                digit++;
+                digit++;
+            }
+            quadKey.push(digit);
+        }
+        return quadKey.join('');
+    }
     getCoordsFromTile(zoom = this.z) {
         checkFunction('getCoordsFromTile')
             .checkArgument('this')
@@ -60,11 +119,20 @@ export class DPoint {
         const y = PI_IN_DEGREE / Math.PI * Math.atan((Math.exp(n) - Math.exp(-n)) / 2);
         return new DPoint(x, y, zoom);
     }
-    toCoords() {
-        if (this.z === undefined) {
-            return [this.x, this.y];
-        }
-        return [this.x, this.y, this.z];
+    toCoords(format = 'xyz') {
+        return format.replace(/[^x-z]/gmiu, '').split('')
+            .map((k) => ({
+            x: this.x,
+            y: this.y,
+            z: this.z
+        })[k])
+            .filter((r) => r !== undefined);
+    }
+    toGeoJSON(format = 'xyz') {
+        return {
+            type: 'Point',
+            coordinates: this.toCoords(format)
+        };
     }
     findLine(p) {
         checkFunction('findLine')

package/dist/es2015/DPolygon.js

@@ -618,11 +618,92 @@ export class DPolygon {
         }
         return this;
     }
-    static parse(a) {
-        return new DPolygon(a.map((r) => DPoint.parse(r)));
+    static toGeoJSONFeatureCollection(polygons, format = 'xyz') {
+        return {
+            type: 'FeatureCollection',
+            features: polygons.map((polygon) => polygon.toGeoJSONFeature(format))
+        };
+    }
+    static parse(a, format = 'xyz') {
+        if (a.type) {
+            switch (a.type) {
+                case 'FeatureCollection':
+                    return a.features.reduce((ak, f) => {
+                        const t = DPolygon.parse(f, format);
+                        if (Array.isArray(t)) {
+                            ak.push(...t);
+                        }
+                        else {
+                            ak.push(t);
+                        }
+                        return ak;
+                    }, []);
+                case 'Feature': {
+                    const t = DPolygon.parse(a.geometry, format);
+                    t.properties = Object.assign(Object.assign({}, a.properties), { id: a.id });
+                    return t;
+                }
+                case 'LineString':
+                case 'MultiPoint':
+                    return new DPolygon(a.coordinates.map((c) => DPoint.parse(c, format)));
+                case 'Polygon':
+                    return a.coordinates.reduce((ak, line, index) => {
+                        if (index === 0) {
+                            ak.points = line.map((c) => DPoint.parse(c, format));
+                        }
+                        else {
+                            ak.holes.push(new DPolygon(line.map((c) => DPoint.parse(c, format))));
+                        }
+                        return ak;
+                    }, new DPolygon());
+                case 'MultiLineString':
+                    return a.coordinates.reduce((ak, line) => {
+                        ak.push(new DPolygon(line.map((c) => DPoint.parse(c, format))));
+                        return ak;
+                    }, []);
+                case 'MultiPolygon':
+                    return a.coordinates.reduce((ak, coordinates) => {
+                        ak.push(DPolygon.parse({
+                            type: 'Polygon',
+                            coordinates
+                        }, format));
+                        return ak;
+                    }, []);
+                case 'GeometryCollection':
+                    return a.geometries.reduce((ak, line) => {
+                        ak.push(DPolygon.parse(line, format));
+                        return ak;
+                    }, []);
+                default:
+            }
+        }
+        return new DPolygon(a
+            .map((r) => DPoint.parse(r, format)));
     }
-    toArrayOfCoords() {
-        return this.mapArray((r) => r.toCoords());
+    toArrayOfCoords(format = 'xyz') {
+        return this.mapArray((r) => r.toCoords(format));
+    }
+    toGeoJSONFeature(format = 'xyz') {
+        return {
+            type: 'Feature',
+            properties: Object.assign({}, this.properties),
+            geometry: this.toGeoJSON(format)
+        };
+    }
+    toGeoJSON(format = 'xyz') {
+        if (this.closed) {
+            return {
+                type: 'Polygon',
+                coordinates: [
+                    this.toArrayOfCoords(format),
+                    ...this.holes.map((h) => h.toArrayOfCoords(format))
+                ]
+            };
+        }
+        return {
+            type: 'LineString',
+            coordinates: this.toArrayOfCoords(format)
+        };
     }
     divideToPieces(piecesCount, withAltitude = false) {
         const { fullLength } = this;

package/dist/esm/DPoint.js

@@ -54,13 +54,34 @@ var DPoint = (function () {
     DPoint.zero = function () {
         return new DPoint();
     };
-    DPoint.parse = function (c) {
-        var _a = c, lat = _a.lat, lng = _a.lng;
+    DPoint.parse = function (c, format) {
+        if (format === void 0) { format = 'xyz'; }
+        var _a = c, lat = _a.lat, lon = _a.lon, _b = _a.lng, lng = _b === void 0 ? lon : _b, alt = _a.alt;
         if (lat && lng) {
-            return new DPoint(lat, lng, 0);
+            return new DPoint(lat, lng, alt !== null && alt !== void 0 ? alt : 0);
         }
-        var _b = __read(c, 3), x = _b[0], y = _b[1], z = _b[2];
-        return new DPoint(x, y, z);
+        var t = c;
+        if (c.type === 'Point') {
+            t = c.coordinates;
+        }
+        return format.replace(/[^x-z]/gmiu, '')
+            .split('')
+            .reduce(function (a, k, index) {
+            var _a, _b;
+            switch (k) {
+                case 'x':
+                    a.x = (_a = t[index]) !== null && _a !== void 0 ? _a : 0;
+                    break;
+                case 'y':
+                    a.y = (_b = t[index]) !== null && _b !== void 0 ? _b : 0;
+                    break;
+                case 'z':
+                    a.z = t[index];
+                    break;
+                default:
+            }
+            return a;
+        }, new DPoint());
     };
     DPoint.parseFromWKT = function (wkt) {
         var regexp = /POINT \((?<data>(?:(?!\)).)*?)\)$/miu;
@@ -72,6 +93,29 @@ var DPoint = (function () {
     DPoint.random = function () {
         return new DPoint(Math.random(), Math.random());
     };
+    DPoint.getTileFromQuadKey = function (quadKey) {
+        var p = new DPoint(0, 0, quadKey.length);
+        for (var i = p.z; i > 0; i--) {
+            var mask = 1 << (i - 1);
+            switch (quadKey[p.z - i]) {
+                case '0':
+                    break;
+                case '1':
+                    p.x |= mask;
+                    break;
+                case '2':
+                    p.y |= mask;
+                    break;
+                case '3':
+                    p.x |= mask;
+                    p.y |= mask;
+                    break;
+                default:
+                    throw new Error('Invalid QuadKey digit sequence.');
+            }
+        }
+        return p;
+    };
     DPoint.prototype.getTileFromCoords = function (zoom) {
         if (zoom === void 0) { zoom = this.z; }
         checkFunction('getTileFromCoords')
@@ -81,6 +125,23 @@ var DPoint = (function () {
         var y = Math.floor((1 - Math.log(Math.tan(this.y * PI_TO_DEGREE) + 1 / Math.cos(this.y * PI_TO_DEGREE)) / Math.PI) / 2 * (Math.pow(2, zoom)));
         return new DPoint(x, y, zoom);
     };
+    DPoint.prototype.getQuadKeyFromTile = function (zoom) {
+        if (zoom === void 0) { zoom = this.z; }
+        var quadKey = [];
+        for (var i = zoom; i > 0; i--) {
+            var digit = 0;
+            var mask = 1 << (i - 1);
+            if ((this.x & mask) !== 0) {
+                digit++;
+            }
+            if ((this.y & mask) !== 0) {
+                digit++;
+                digit++;
+            }
+            quadKey.push(digit);
+        }
+        return quadKey.join('');
+    };
     DPoint.prototype.getCoordsFromTile = function (zoom) {
         if (zoom === void 0) { zoom = this.z; }
         checkFunction('getCoordsFromTile')
@@ -91,11 +152,23 @@ var DPoint = (function () {
         var y = PI_IN_DEGREE / Math.PI * Math.atan((Math.exp(n) - Math.exp(-n)) / 2);
         return new DPoint(x, y, zoom);
     };
-    DPoint.prototype.toCoords = function () {
-        if (this.z === undefined) {
-            return [this.x, this.y];
-        }
-        return [this.x, this.y, this.z];
+    DPoint.prototype.toCoords = function (format) {
+        var _this = this;
+        if (format === void 0) { format = 'xyz'; }
+        return format.replace(/[^x-z]/gmiu, '').split('')
+            .map(function (k) { return ({
+            x: _this.x,
+            y: _this.y,
+            z: _this.z
+        })[k]; })
+            .filter(function (r) { return r !== undefined; });
+    };
+    DPoint.prototype.toGeoJSON = function (format) {
+        if (format === void 0) { format = 'xyz'; }
+        return {
+            type: 'Point',
+            coordinates: this.toCoords(format)
+        };
     };
     DPoint.prototype.findLine = function (p) {
         checkFunction('findLine')