@openglobus/og 0.18.0 → 0.18.1

package/{src/utils/shared.ts → lib/js/utils/shared.js}

@@ -1,63 +1,52 @@
 /**
  * @module og/utils/shared
  */
-
-import {Extent} from "../Extent";
-import {LonLat} from "../LonLat";
-import {Vec2} from "../math/Vec2";
-import {NumberArray2} from "../math/Vec2";
-import {NumberArray3, Vec3} from "../math/Vec3";
-import {NumberArray4, Vec4} from "../math/Vec4";
-import {colorTable} from "./colorTable";
-
-export function getDefault(param?: any, def?: any): boolean {
+import { Extent } from "../Extent";
+import { LonLat } from "../LonLat";
+import { Vec2 } from "../math/Vec2";
+import { Vec3 } from "../math/Vec3";
+import { Vec4 } from "../math/Vec4";
+import { colorTable } from "./colorTable";
+export function getDefault(param, def) {
     return param != undefined ? param : def;
 }
-
-export function isEmpty(v: any): boolean {
+export function isEmpty(v) {
     return v == null;
 }
-
 /**
  * Returns true if the object pointer is undefined.
  * @function
  * @param {Object} obj - Object pointer.
  * @returns {boolean} Returns true if object is undefined.
  */
-export function isUndef(obj?: any): boolean {
+export function isUndef(obj) {
     return obj === void 0;
 }
-
-export function isUndefExt(obj: any, defVal: any): any {
+export function isUndefExt(obj, defVal) {
     return isUndef(obj) ? defVal : obj;
 }
-
-let _stampCounter: number = 0;
-
-export function stamp(obj: any): number {
+let _stampCounter = 0;
+export function stamp(obj) {
     let stamp = obj._openglobus_id;
     if (!stamp) {
         stamp = obj._openglobus_id = ++_stampCounter;
     }
     return stamp;
 }
-
-export function isString(s: any): boolean {
+export function isString(s) {
     return typeof s === "string" || s instanceof String;
 }
-
 /**
  * Convert html color string to the RGBA number vector.
  * @param {string} htmlColor - HTML string("#C6C6C6" or "#EF5" or "rgb(8,8,8)" or "rgba(8,8,8)") color.
  * @param {number} [opacity] - Opacity for the output vector.
  * @returns {Vec4} -
  */
-export function htmlColorToRgba(htmlColor: string, opacity?: number): Vec4 {
-    let hColor: any | undefined = colorTable[htmlColor];
+export function htmlColorToRgba(htmlColor, opacity) {
+    let hColor = colorTable[htmlColor];
     if (hColor) {
         htmlColor = hColor;
     }
-
     if (htmlColor[0] === "#") {
         let shorthandRegex = /^#?([a-f\d])([a-f\d])([a-f\d])$/i;
         let hex = htmlColor.replace(shorthandRegex, function (m, r, g, b) {
@@ -65,45 +54,34 @@ export function htmlColorToRgba(htmlColor: string, opacity?: number): Vec4 {
         });
         let result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
         if (result) {
-            return new Vec4(
-                parseInt(result[1], 16) / 255,
-                parseInt(result[2], 16) / 255,
-                parseInt(result[3], 16) / 255,
-                isEmpty(opacity) ? 1.0 : opacity
-            );
-        } else {
+            return new Vec4(parseInt(result[1], 16) / 255, parseInt(result[2], 16) / 255, parseInt(result[3], 16) / 255, isEmpty(opacity) ? 1.0 : opacity);
+        }
+        else {
             return new Vec4();
         }
-    } else {
+    }
+    else {
         if (isEmpty(opacity)) {
             opacity = 1.0;
         }
         let m = htmlColor.split(",");
-        return new Vec4(
-            parseInt(m[0].split("(")[1]) / 255,
-            parseInt(m[1]) / 255,
-            parseInt(m[2]) / 255,
-            !isEmpty(m[3]) ? parseFloat(m[3]) : opacity
-        );
+        return new Vec4(parseInt(m[0].split("(")[1]) / 255, parseInt(m[1]) / 255, parseInt(m[2]) / 255, !isEmpty(m[3]) ? parseFloat(m[3]) : opacity);
     }
 }
-
-export function htmlColorToFloat32Array(htmlColor: string, opacity?: number): Float32Array {
+export function htmlColorToFloat32Array(htmlColor, opacity) {
     let c = htmlColorToRgba(htmlColor, opacity);
     return new Float32Array([c.x, c.y, c.z, c.w]);
 }
-
 /**
  * Convert html color string to the RGB number vector.
  * @param {string} htmlColor - HTML string("#C6C6C6" or "#EF5" or "rgb(8,8,8)" or "rgba(8,8,8)") color.
  * @returns {Vec3} -
  */
-export function htmlColorToRgb(htmlColor: string): Vec3 {
-    let hColor: any | undefined = colorTable[htmlColor];
+export function htmlColorToRgb(htmlColor) {
+    let hColor = colorTable[htmlColor];
     if (hColor) {
         htmlColor = hColor;
     }
-
     if (htmlColor[0] === "#") {
         let shorthandRegex = /^#?([a-f\d])([a-f\d])([a-f\d])$/i;
         let hex = htmlColor.replace(shorthandRegex, function (m, r, g, b) {
@@ -111,24 +89,17 @@ export function htmlColorToRgb(htmlColor: string): Vec3 {
         });
         let result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
         if (result) {
-            return new Vec3(
-                parseInt(result[1], 16) / 255,
-                parseInt(result[2], 16) / 255,
-                parseInt(result[3], 16) / 255
-            );
-        } else {
+            return new Vec3(parseInt(result[1], 16) / 255, parseInt(result[2], 16) / 255, parseInt(result[3], 16) / 255);
+        }
+        else {
             return new Vec3();
         }
-    } else {
+    }
+    else {
         let m = htmlColor.split(",");
-        return new Vec3(
-            parseInt(m[0].split("(")[1]) / 255,
-            parseInt(m[1]) / 255,
-            parseInt(m[2]) / 255
-        );
+        return new Vec3(parseInt(m[0].split("(")[1]) / 255, parseInt(m[1]) / 255, parseInt(m[2]) / 255);
     }
 }
-
 /**
  * Replace template substrings between '{' and '}' tokens.
  * @param {string} template - String with templates in "{" and "}"
@@ -144,28 +115,25 @@ export function htmlColorToRgb(htmlColor: string): Vec3 {
  * og.utils.stringTemplate("http://earth3.openglobus.org/{z}/{y}/{x}.ddm", substrings);
  * //returns http://earth3.openglobus.org/8/15/12.ddm
  */
-export function stringTemplate(template: string, params?: any): string {
+export function stringTemplate(template, params) {
     return template.replace(/{[^{}]+}/g, function (key) {
         return params[key.replace(/[{}]+/g, "")] || "";
     });
 }
-
-export function getHTML(template: string, params?: any): string {
+export function getHTML(template, params) {
     return stringTemplate(template, params);
 }
-
-export function parseHTML(htmlStr: string): HTMLElement[] {
+export function parseHTML(htmlStr) {
     let p = document.createElement("div");
     p.innerHTML = htmlStr;
-    let domArr: HTMLElement[] = [];
+    let domArr = [];
     for (let i = 0; i < p.childNodes.length; i++) {
-        domArr.push(p.childNodes[i] as HTMLElement);
+        domArr.push(p.childNodes[i]);
         p.removeChild(p.childNodes[i]);
     }
     return domArr;
 }
-
-export function print2d(id: string, text: string, x: number, y: number) {
+export function print2d(id, text, x, y) {
     let el = document.getElementById(id);
     if (!el) {
         el = document.createElement("div");
@@ -177,111 +145,118 @@ export function print2d(id: string, text: string, x: number, y: number) {
     el.style.left = `${x}px`;
     el.style.top = `${y}px`;
 }
-
-export function defaultString(str?: string, def: string = ""): string {
+export function defaultString(str, def = "") {
     return str ? str.trim().toLowerCase() : def;
 }
-
-export function createVector3(v?: Vec3 | Vec2 | NumberArray3 | NumberArray2 | null, def?: Vec3): Vec3 {
+export function createVector3(v, def) {
     if (v) {
         if (v instanceof Vec3) {
             return v.clone();
-        } else if (v instanceof Array) {
+        }
+        else if (v instanceof Array) {
             return Vec3.fromVec(v);
-        } else if (v instanceof Vec2) {
+        }
+        else if (v instanceof Vec2) {
             return new Vec3(v.x, v.y, 0.0);
         }
-    } else if (def) {
+    }
+    else if (def) {
         return def;
     }
     return new Vec3();
 }
-
-export function createVector4(v?: Vec4 | NumberArray4 | null, def?: Vec4): Vec4 {
+export function createVector4(v, def) {
     if (v) {
         if (v instanceof Vec4) {
             return v.clone();
-        } else if (v instanceof Array) {
+        }
+        else if (v instanceof Array) {
             return Vec4.fromVec(v);
         }
-    } else if (def) {
+    }
+    else if (def) {
         return def;
     }
     return new Vec4();
 }
-
-export function createColorRGBA(c?: string | NumberArray4 | Vec4 | null, def?: Vec4): Vec4 {
+export function createColorRGBA(c, def) {
     if (c) {
         if (isString(c)) {
-            return htmlColorToRgba(c as string);
-        } else if (c instanceof Array) {
+            return htmlColorToRgba(c);
+        }
+        else if (c instanceof Array) {
             return Vec4.fromVec(c);
-        } else if (c instanceof Vec4) {
+        }
+        else if (c instanceof Vec4) {
             return c.clone();
         }
-    } else if (def) {
+    }
+    else if (def) {
         return def;
     }
     return new Vec4(1.0, 1.0, 1.0, 1.0);
 }
-
-export function createColorRGB(c?: string | NumberArray3 | Vec3 | null, def?: Vec3): Vec3 {
+export function createColorRGB(c, def) {
     if (c) {
         if (isString(c)) {
-            return htmlColorToRgb(c as string);
-        } else if (c instanceof Array) {
+            return htmlColorToRgb(c);
+        }
+        else if (c instanceof Array) {
             return Vec3.fromVec(c);
-        } else if (c instanceof Vec3) {
-            return (c as Vec3).clone();
         }
-    } else if (def) {
+        else if (c instanceof Vec3) {
+            return c.clone();
+        }
+    }
+    else if (def) {
         return def;
     }
     return new Vec3(1.0, 1.0, 1.0);
 }
-
-export function createExtent(e?: Extent | [[number, number], [number, number]] | null, def?: Extent): Extent {
+export function createExtent(e, def) {
     if (e) {
         if (e instanceof Array) {
             return new Extent(createLonLat(e[0]), createLonLat(e[1]));
-        } else if (e instanceof Extent) {
+        }
+        else if (e instanceof Extent) {
             return e.clone();
         }
-    } else if (def) {
+    }
+    else if (def) {
         return def;
     }
     return new Extent();
 }
-
-export function createLonLat(l?: LonLat | NumberArray2 | NumberArray3, def?: LonLat): LonLat {
+export function createLonLat(l, def) {
     if (l) {
         if (l instanceof Array) {
             return new LonLat(l[0], l[1], l[2]);
-        } else if (l instanceof LonLat) {
+        }
+        else if (l instanceof LonLat) {
             return l.clone();
         }
-    } else if (def) {
+    }
+    else if (def) {
         return def;
     }
     return new LonLat();
 }
-
-export function binarySearchFast(arr: number[] | TypedArray, x: number) {
-    let start = 0,
-        end = arr.length - 1;
+export function binarySearchFast(arr, x) {
+    let start = 0, end = arr.length - 1;
     while (start <= end) {
         let k = Math.floor((start + end) * 0.5);
         if (arr[k] === x) {
             return k;
-        } else if (arr[k] < x) {
+        }
+        else if (arr[k] < x) {
             start = k + 1;
-        } else {
+        }
+        else {
             end = k - 1;
         }
     }
     return -1;
 }
-
 /**
  * Finds an item in a sorted array.
  * @param {any[]} ar The sorted array to search.
@@ -298,7 +273,7 @@ export function binarySearchFast(arr: number[] | TypedArray, x: number) {
  * var numbers = [0, 2, 4, 6, 8];
  * var index = og.utils.binarySearch(numbers, 6, comparator); // 3
  */
-export function binarySearch(ar: any[], el: any, compare_fn: Function): number {
+export function binarySearch(ar, el, compare_fn) {
     let m = 0;
     let n = ar.length - 1;
     while (m <= n) {
@@ -306,15 +281,16 @@ export function binarySearch(ar: any[], el: any, compare_fn: Function): number {
         let cmp = compare_fn(el, ar[k], k);
         if (cmp > 0) {
             m = k + 1;
-        } else if (cmp < 0) {
+        }
+        else if (cmp < 0) {
             n = k - 1;
-        } else {
+        }
+        else {
             return k;
         }
     }
     return -m - 1;
 }
-
 /**
  * Binary insertion that uses binarySearch algorithm.
  * @param {any[]} ar - The sorted array to insert.
@@ -323,7 +299,7 @@ export function binarySearch(ar: any[], el: any, compare_fn: Function): number {
  *        elements in the array.
  * @returns {number} Array index position in which item inserted in.
  */
-export function binaryInsert(ar: any[], el: any, compare_fn: Function): number {
+export function binaryInsert(ar, el, compare_fn) {
     let i = binarySearch(ar, el, compare_fn);
     if (i < 0) {
         i = ~i;
@@ -331,7 +307,6 @@ export function binaryInsert(ar: any[], el: any, compare_fn: Function): number {
     ar.splice(i, 0, el);
     return i;
 }
-
 /**
  * Returns two segment lines intersection coordinate.
  * @static
@@ -342,36 +317,26 @@ export function binaryInsert(ar: any[], el: any, compare_fn: Function): number {
  * @param {boolean} [isSegment] - Lines are segments.
  * @return {Vec2} - Intersection coordinate.
  */
-export function getLinesIntersection2v(start1: Vec2, end1: Vec2, start2: Vec2, end2: Vec2, isSegment: boolean): Vec2 | undefined {
+export function getLinesIntersection2v(start1, end1, start2, end2, isSegment) {
     let dir1 = end1.sub(start1);
     let dir2 = end2.sub(start2);
-
     let a1 = -dir1.y;
     let b1 = +dir1.x;
     let d1 = -(a1 * start1.x + b1 * start1.y);
-
     let a2 = -dir2.y;
     let b2 = +dir2.x;
     let d2 = -(a2 * start2.x + b2 * start2.y);
-
     let seg1_line2_start = a2 * start1.x + b2 * start1.y + d2;
     let seg1_line2_end = a2 * end1.x + b2 * end1.y + d2;
-
     let seg2_line1_start = a1 * start2.x + b1 * start2.y + d1;
     let seg2_line1_end = a1 * end2.x + b1 * end2.y + d1;
-
-    if (
-        isSegment &&
-        (seg1_line2_start * seg1_line2_end > 0 || seg2_line1_start * seg2_line1_end > 0)
-    ) {
+    if (isSegment &&
+        (seg1_line2_start * seg1_line2_end > 0 || seg2_line1_start * seg2_line1_end > 0)) {
         return undefined;
     }
-
     let u = seg1_line2_start / (seg1_line2_start - seg1_line2_end);
-
     return new Vec2(start1.x + u * dir1.x, start1.y + u * dir1.y);
 }
-
 /**
  * Returns two segment lines intersection coordinate.
  * @static
@@ -382,46 +347,35 @@ export function getLinesIntersection2v(start1: Vec2, end1: Vec2, start2: Vec2, e
  * @param {boolean} [isSegment=false] - Lines are segments.
  * @return {Vec2} - Intersection coordinate.
  */
-export function getLinesIntersectionLonLat(start1: LonLat, end1: LonLat, start2: LonLat, end2: LonLat, isSegment: boolean = false): LonLat | undefined {
+export function getLinesIntersectionLonLat(start1, end1, start2, end2, isSegment = false) {
     let dir1 = new LonLat(end1.lon - start1.lon, end1.lat - start1.lat);
     let dir2 = new LonLat(end2.lon - start2.lon, end2.lat - start2.lat);
-
     let a1 = -dir1.lat;
     let b1 = +dir1.lon;
     let d1 = -(a1 * start1.lon + b1 * start1.lat);
-
     let a2 = -dir2.lat;
     let b2 = +dir2.lon;
     let d2 = -(a2 * start2.lon + b2 * start2.lat);
-
     let seg1_line2_start = a2 * start1.lon + b2 * start1.lat + d2;
     let seg1_line2_end = a2 * end1.lon + b2 * end1.lat + d2;
-
     let seg2_line1_start = a1 * start2.lon + b1 * start2.lat + d1;
     let seg2_line1_end = a1 * end2.lon + b1 * end2.lat + d1;
-
-    if (
-        isSegment &&
-        (seg1_line2_start * seg1_line2_end > 0 || seg2_line1_start * seg2_line1_end > 0)
-    ) {
+    if (isSegment &&
+        (seg1_line2_start * seg1_line2_end > 0 || seg2_line1_start * seg2_line1_end > 0)) {
         return undefined;
     }
-
     let u = seg1_line2_start / (seg1_line2_start - seg1_line2_end);
-
     return new LonLat(start1.lon + u * dir1.lon, start1.lat + u * dir1.lat);
 }
-
 /**
  * Converts XML to JSON
  * @static
  * @param {Object} xml - Xml object
  * @return {Object} - Json converted object.
  */
-export function xmlToJson(xml: any): any {
+export function xmlToJson(xml) {
     // Create the return object
-    let obj: any = {};
-
+    let obj = {};
     if (xml.nodeType === 1) {
         // element
         // do attributes
@@ -432,11 +386,11 @@ export function xmlToJson(xml: any): any {
                 obj["@attributes"][attribute.nodeName] = attribute.nodeValue;
             }
         }
-    } else if (xml.nodeType === 3) {
+    }
+    else if (xml.nodeType === 3) {
         // text
         obj = xml.nodeValue;
     }
-
     // do children
     if (xml.hasChildNodes()) {
         for (let i = 0; i < xml.childNodes.length; i++) {
@@ -444,7 +398,8 @@ export function xmlToJson(xml: any): any {
             let nodeName = item.nodeName;
             if (typeof obj[nodeName] === "undefined") {
                 obj[nodeName] = xmlToJson(item);
-            } else {
+            }
+            else {
                 if (typeof obj[nodeName].push === "undefined") {
                     let old = obj[nodeName];
                     obj[nodeName] = [];
@@ -456,37 +411,29 @@ export function xmlToJson(xml: any): any {
     }
     return obj;
 }
-
 export const castType = {
-    string: function (v: any) {
+    string: function (v) {
         return isEmpty(v) ? v : v.toString();
     },
-
-    date: function (v: any) {
+    date: function (v) {
         return isEmpty(v) ? v : new Date(v * 1000);
     },
-
-    datetime: function (v: any) {
+    datetime: function (v) {
         return isEmpty(v) ? v : new Date(v * 1000);
     },
-
-    time: function (v: any) {
+    time: function (v) {
         return isEmpty(v) ? v : parseInt(v);
     },
-
-    integer: function (v: any) {
+    integer: function (v) {
         return isEmpty(v) ? v : parseInt(v);
     },
-
-    float: function (v: any) {
+    float: function (v) {
         return isEmpty(v) ? v : parseFloat(v);
     },
-
-    boolean: function (str: any) {
+    boolean: function (str) {
         if (str === null) {
             return str;
         }
-
         if (typeof str === "boolean") {
             if (str === true) {
                 return true;
@@ -510,39 +457,29 @@ export const castType = {
         return false;
     }
 };
-
-export function base64toBlob(base64Data: string, contentType: string = ""): Blob {
-
+export function base64toBlob(base64Data, contentType = "") {
     let sliceSize = 1024;
     let byteCharacters = atob(base64Data);
     let bytesLength = byteCharacters.length;
     let slicesCount = Math.ceil(bytesLength / sliceSize);
     let byteArrays = new Array(slicesCount);
-
     for (let sliceIndex = 0; sliceIndex < slicesCount; ++sliceIndex) {
-
         let begin = sliceIndex * sliceSize;
         let end = Math.min(begin + sliceSize, bytesLength);
         let bytes = new Array(end - begin);
-
         for (let offset = begin, i = 0; offset < end; ++i, ++offset) {
             bytes[i] = byteCharacters[offset].charCodeAt(0);
         }
-
         byteArrays[sliceIndex] = new Uint8Array(bytes);
     }
-    return new Blob(byteArrays, {type: contentType});
+    return new Blob(byteArrays, { type: contentType });
 }
-
-export function base64StringToBlog(string: string): Blob {
-
+export function base64StringToBlog(string) {
     let block = string.split(";");
     let contentType = block[0].split(":")[1];
     let data = block[1].split(",")[1];
-
     return base64toBlob(data, contentType);
 }
-
 ///**
 // *
 // * @param {LonLat} p
@@ -552,7 +489,6 @@ export function base64StringToBlog(string: string): Blob {
 // * @param {Array<Number>} res
 // */
 //export function cartesianToBarycentricLonLat(p, v1, v2, v3, res) {
-
 //    const y2y3 = v2.lat - v3.lat,
 //        x3x2 = v3.lon - v2.lon,
 //        x1x3 = v1.lon - v3.lon,
@@ -560,33 +496,30 @@ export function base64StringToBlog(string: string): Blob {
 //        y3y1 = v3.lat - v1.lat,
 //        xx3 = p.lon - v3.lon,
 //        yy3 = p.lat - v3.lat;
-
 //    const d = y2y3 * x1x3 + x3x2 * y1y3,
 //        lambda1 = (y2y3 * xx3 + x3x2 * yy3) / d,
 //        lambda2 = (y3y1 * xx3 + x1x3 * yy3) / d;
-
 //    res[0] = lambda1;
 //    res[1] = lambda2;
 //    res[2] = 1 - lambda1 - lambda2;
-
 //    return 0 <= res[0] && res[0] <= 1 && 0 <= lambda1 && lambda1 <= 1 && 0 <= lambda2 && lambda2 <= 1;
 //};
-
 /**
  * Callback throttling
  * @param {any} func
  * @param {Number} limit
  * @param {boolean} [skip]
  */
-export function throttle(func: Function, limit: number, skip: boolean) {
-    let lastFunc: any;
-    let lastRan: number = 0;
+export function throttle(func, limit, skip) {
+    let lastFunc;
+    let lastRan = 0;
     return function () {
         const args = arguments;
         if (!lastRan) {
             func.apply(null, args);
             lastRan = Date.now();
-        } else {
+        }
+        else {
             if (skip) {
                 clearTimeout(lastFunc);
             }
@@ -599,7 +532,6 @@ export function throttle(func: Function, limit: number, skip: boolean) {
         }
     };
 }
-
 /**
  *
  * y2-----Q12--------------Q22---
@@ -628,189 +560,138 @@ export function throttle(func: Function, limit: number, skip: boolean) {
  * @param {Number} [y1=0.0] -
  * @param {Number} [y2=1.0] -
  */
-export function blerp(
-    x: number, y: number, fQ11: number, fQ21: number, fQ12: number, fQ22: number,
-    x1: number = 0.0, x2: number = 1.0, y1: number = 0.0, y2: number = 1.0): number {
-    return (
-        (fQ11 * (x2 - x) * (y2 - y) +
-            fQ21 * (x - x1) * (y2 - y) +
-            fQ12 * (x2 - x) * (y - y1) +
-            fQ22 * (x - x1) * (y - y1)) /
-        ((x2 - x1) * (y2 - y1))
-    );
+export function blerp(x, y, fQ11, fQ21, fQ12, fQ22, x1 = 0.0, x2 = 1.0, y1 = 0.0, y2 = 1.0) {
+    return ((fQ11 * (x2 - x) * (y2 - y) +
+        fQ21 * (x - x1) * (y2 - y) +
+        fQ12 * (x2 - x) * (y - y1) +
+        fQ22 * (x - x1) * (y - y1)) /
+        ((x2 - x1) * (y2 - y1)));
 }
-
-export function blerp2(x: number, y: number, fQ11: number, fQ21: number, fQ12: number, fQ22: number): number {
-    return (
-        fQ11 * (1.0 - x) * (1.0 - y) + fQ21 * x * (1.0 - y) + fQ12 * (1.0 - x) * y + fQ22 * x * y
-    );
+export function blerp2(x, y, fQ11, fQ21, fQ12, fQ22) {
+    return (fQ11 * (1.0 - x) * (1.0 - y) + fQ21 * x * (1.0 - y) + fQ12 * (1.0 - x) * y + fQ22 * x * y);
 }
-
-export function extractElevationTiles(rgbaData: number[] | TypedArray, outCurrenElevations: number[] | TypedArray, outChildrenElevations: number[][][] | TypedArray[][]) {
+export function extractElevationTiles(rgbaData, outCurrenElevations, outChildrenElevations) {
     let destSize = Math.sqrt(outCurrenElevations.length) - 1;
     let destSizeOne = destSize + 1;
     let sourceSize = Math.sqrt(rgbaData.length / 4);
     let dt = sourceSize / destSize;
-
-    let rightHeigh = 0,
-        bottomHeigh = 0;
-
-    for (
-        let k = 0, currIndex = 0, sourceDataLength = rgbaData.length / 4;
-        k < sourceDataLength;
-        k++
-    ) {
+    let rightHeigh = 0, bottomHeigh = 0;
+    for (let k = 0, currIndex = 0, sourceDataLength = rgbaData.length / 4; k < sourceDataLength; k++) {
         let height = rgbaData[k * 4];
-
-        let i = Math.floor(k / sourceSize),
-            j = k % sourceSize;
-
-        let tileX = Math.floor(j / destSize),
-            tileY = Math.floor(i / destSize);
-
+        let i = Math.floor(k / sourceSize), j = k % sourceSize;
+        let tileX = Math.floor(j / destSize), tileY = Math.floor(i / destSize);
         let destArr = outChildrenElevations[tileY][tileX];
-
-        let ii = i % destSize,
-            jj = j % destSize;
-
+        let ii = i % destSize, jj = j % destSize;
         let destIndex = (ii + tileY) * destSizeOne + jj + tileX;
-
         destArr[destIndex] = height;
-
         if ((i + tileY) % dt === 0 && (j + tileX) % dt === 0) {
             outCurrenElevations[currIndex++] = height;
         }
-
         if ((j + 1) % destSize === 0 && j !== sourceSize - 1) {
             //current tile
             rightHeigh = rgbaData[(k + 1) * 4];
             let middleHeight = (height + rightHeigh) * 0.5;
             destIndex = (ii + tileY) * destSizeOne + jj + 1;
             destArr[destIndex] = middleHeight;
-
             if ((i + tileY) % dt === 0) {
                 outCurrenElevations[currIndex++] = middleHeight;
             }
-
             //next right tile
             let rightindex = (ii + tileY) * destSizeOne + ((jj + 1) % destSize);
             outChildrenElevations[tileY][tileX + 1][rightindex] = middleHeight;
         }
-
         if ((i + 1) % destSize === 0 && i !== sourceSize - 1) {
             //current tile
             bottomHeigh = rgbaData[(k + sourceSize) * 4];
             let middleHeight = (height + bottomHeigh) * 0.5;
             destIndex = (ii + 1) * destSizeOne + jj + tileX;
             destArr[destIndex] = middleHeight;
-
             if ((j + tileX) % dt === 0) {
                 outCurrenElevations[currIndex++] = middleHeight;
             }
-
             //next bottom tile
             let bottomindex = ((ii + 1) % destSize) * destSizeOne + jj + tileX;
             outChildrenElevations[tileY + 1][tileX][bottomindex] = middleHeight;
         }
-
-        if (
-            (j + 1) % destSize === 0 &&
+        if ((j + 1) % destSize === 0 &&
             j !== sourceSize - 1 &&
             (i + 1) % destSize === 0 &&
-            i !== sourceSize - 1
-        ) {
+            i !== sourceSize - 1) {
             //current tile
             let rightBottomHeight = rgbaData[(k + sourceSize + 1) * 4];
             let middleHeight = (height + rightHeigh + bottomHeigh + rightBottomHeight) * 0.25;
             destIndex = (ii + 1) * destSizeOne + (jj + 1);
             destArr[destIndex] = middleHeight;
-
             outCurrenElevations[currIndex++] = middleHeight;
-
             //next right tile
             let rightindex = (ii + 1) * destSizeOne;
             outChildrenElevations[tileY][tileX + 1][rightindex] = middleHeight;
-
             //next bottom tile
             let bottomindex = destSize;
             outChildrenElevations[tileY + 1][tileX][bottomindex] = middleHeight;
-
             //next right bottom tile
             let rightBottomindex = 0;
             outChildrenElevations[tileY + 1][tileX + 1][rightBottomindex] = middleHeight;
         }
     }
 }
-
-export type TypedArray =
-    | Int8Array
-    | Uint8Array
-    | Uint8ClampedArray
-    | Int16Array
-    | Uint16Array
-    | Int32Array
-    | Uint32Array
-    | Float32Array
-    | Float64Array;
-
 /**
  * Concatenates two the same type arrays
  * @param {TypedArray} a
  * @param {TypedArray | number[]} b
  */
-export function concatTypedArrays(a: TypedArray, b: TypedArray | number[]): TypedArray {
-    let c = new (a as any).constructor(a.length + b.length); //hacky
+export function concatTypedArrays(a, b) {
+    let c = new a.constructor(a.length + b.length); //hacky
     c.set(a, 0);
     c.set(b, a.length);
     return c;
 }
-
 /**
  * Concatenates two the same  arrays
  * @param {TypedArray | number[]} [a=[]] - First array
  * @param {TypedArray | number[]} [b=[]] - Second array
  * @return {TypedArray | number[]} -
  */
-export function concatArrays(a: TypedArray | number[] = [], b: TypedArray | number[] = []): TypedArray | number[] {
+export function concatArrays(a = [], b = []) {
     if (ArrayBuffer.isView(a)) {
-        return concatTypedArrays(a as TypedArray, b as TypedArray);
-    } else {
+        return concatTypedArrays(a, b);
+    }
+    else {
         for (let i = 0; i < b.length; i++) {
             a.push(b[i]);
         }
         return a;
     }
 }
-
 /**
  * Convert simple array to typed
  * @param arr {number[]}
  * @param ctor {Float32Array}
  * @returns {TypedArray}
  */
-export function makeArrayTyped(arr: TypedArray | number[], ctor: Function = Float32Array) {
+export function makeArrayTyped(arr, ctor = Float32Array) {
     if (!ArrayBuffer.isView(arr)) {
-        const typedArr = new (ctor as any)(arr.length); //hacky
+        const typedArr = new ctor(arr.length); //hacky
         typedArr.set(arr, 0);
         return typedArr;
-    } else {
+    }
+    else {
         return arr;
     }
 }
-
 /**
  * Convert typed array to array
  * @param arr {TypedArray | number[]}
  * @returns {number[]}
  */
-export function makeArray(arr: TypedArray | number[]): number[] {
+export function makeArray(arr) {
     if (ArrayBuffer.isView(arr)) {
         return Array.from(arr);
-    } else {
+    }
+    else {
         return arr;
     }
 }
-
 /**
  *
  * @param {TypedArray | Array} arr
@@ -818,19 +699,20 @@ export function makeArray(arr: TypedArray | number[]): number[] {
  * @param {Number} deleteCount
  * @param {{ result: number[] }} [out]
  */
-
-export function spliceArray(arr: TypedArray | number[], starting: number, deleteCount: number, out?: { result: number[] } | { result: TypedArray }): TypedArray | number[] {
+export function spliceArray(arr, starting, deleteCount, out) {
     if (ArrayBuffer.isView(arr)) {
         if (starting < 0) {
             deleteCount = Math.abs(starting);
             starting += arr.length;
         }
-        return spliceTypedArray(arr, starting, deleteCount, out as { result: TypedArray });
-    } else {
+        return spliceTypedArray(arr, starting, deleteCount, out);
+    }
+    else {
         let res;
         if (starting < 0) {
             res = arr.splice(starting);
-        } else {
+        }
+        else {
             res = arr.splice(starting, deleteCount);
         }
         if (out) {
@@ -839,7 +721,6 @@ export function spliceArray(arr: TypedArray | number[], starting: number, delete
         return arr;
     }
 }
-
 /**
  *
  * @param {TypedArray} arr
@@ -847,20 +728,19 @@ export function spliceArray(arr: TypedArray | number[], starting: number, delete
  * @param {Number} deleteCount
  * @param {{ result: TypedArray }} [out]
  */
-export function spliceTypedArray<T extends TypedArray>(arr: T, starting: number, deleteCount: number, out?: { result: T }): T {
+export function spliceTypedArray(arr, starting, deleteCount, out) {
     if (arr.length === 0) {
         return arr;
     }
     const newSize = arr.length - deleteCount;
-    const splicedArray = new (arr as any).constructor(newSize); //hacky
+    const splicedArray = new arr.constructor(newSize); //hacky
     splicedArray.set(arr.subarray(0, starting));
     splicedArray.set(arr.subarray(starting + deleteCount), starting);
     if (out) {
-        out.result = arr.subarray(starting, starting + deleteCount) as T;
+        out.result = arr.subarray(starting, starting + deleteCount);
     }
     return splicedArray;
 }
-
 /**
  * Returns 64-bit triangle coordinate array from inside of the source triangle array.
  * @static
@@ -872,29 +752,22 @@ export function spliceTypedArray<T extends TypedArray>(arr: T, starting: number,
  * @return {Float64Array} Triangle coordinates array from the source array.
  * @TODO: optimization
  */
-export function getMatrixSubArray64(sourceArr: TypedArray | number[], gridSize: number, i0: number, j0: number, size: number): Float64Array {
-
+export function getMatrixSubArray64(sourceArr, gridSize, i0, j0, size) {
     const size_1 = size + 1;
     const i0size = i0 + size_1;
     const j0size = j0 + size_1;
-
     let res = new Float64Array(size_1 * size_1 * 3);
     let vInd = 0;
-
     for (let i = i0; i < i0size; i++) {
         for (let j = j0; j < j0size; j++) {
-
             let ind = 3 * (i * (gridSize + 1) + j);
-
             res[vInd++] = sourceArr[ind];
             res[vInd++] = sourceArr[ind + 1];
             res[vInd++] = sourceArr[ind + 2];
         }
     }
-
     return res;
 }
-
 /**
  * Returns 32-bit triangle coordinate array from inside of the source triangle array.
  * @static
@@ -905,29 +778,22 @@ export function getMatrixSubArray64(sourceArr: TypedArray | number[], gridSize:
  * @param {number} size - Square matrix result size.
  * @return {Float32Array} Triangle coordinates array from the source array.
  */
-export function getMatrixSubArray32(sourceArr: TypedArray | number[], gridSize: number, i0: number, j0: number, size: number): Float32Array {
-
+export function getMatrixSubArray32(sourceArr, gridSize, i0, j0, size) {
     const size_1 = size + 1;
     const i0size = i0 + size_1;
     const j0size = j0 + size_1;
-
     let res = new Float32Array(size_1 * size_1 * 3);
     let vInd = 0;
-
     for (let i = i0; i < i0size; i++) {
         for (let j = j0; j < j0size; j++) {
-
             let ind = 3 * (i * (gridSize + 1) + j);
-
             res[vInd++] = sourceArr[ind];
             res[vInd++] = sourceArr[ind + 1];
             res[vInd++] = sourceArr[ind + 2];
         }
     }
-
     return res;
 }
-
 /**
  * Returns two float32 triangle coordinate arrays from inside of the source triangle array.
  * @static
@@ -940,108 +806,85 @@ export function getMatrixSubArray32(sourceArr: TypedArray | number[], gridSize:
  * @return{Array.<number>} Triangle coordinates array from the source array.
  * @TODO: optimization
  */
-export function getMatrixSubArrayBoundsExt(
-    sourceArr: TypedArray | number[],
-    sourceArrHigh: TypedArray | number[],
-    sourceArrLow: TypedArray | number[],
-    noDataVertices: TypedArray | number[] | undefined,
-    gridSize: number,
-    i0: number,
-    j0: number,
-    size: number,
-    outArr: TypedArray | number[],
-    outArrHigh: TypedArray | number[],
-    outArrLow: TypedArray | number[],
-    outBounds: any,
-    outNoDataVertices: TypedArray | number[]
-) {
+export function getMatrixSubArrayBoundsExt(sourceArr, sourceArrHigh, sourceArrLow, noDataVertices, gridSize, i0, j0, size, outArr, outArrHigh, outArrLow, outBounds, outNoDataVertices) {
     const i0size = i0 + size + 1;
     const j0size = j0 + size + 1;
-
     gridSize += 1;
-
-    let vInd = 0,
-        nInd = 0;
-
+    let vInd = 0, nInd = 0;
     for (let i = i0; i < i0size; i++) {
         for (let j = j0; j < j0size; j++) {
-            let indBy3 = i * gridSize + j,
-                ind = 3 * indBy3;
-
-            let x = sourceArr[ind],
-                y = sourceArr[ind + 1],
-                z = sourceArr[ind + 2];
-
+            let indBy3 = i * gridSize + j, ind = 3 * indBy3;
+            let x = sourceArr[ind], y = sourceArr[ind + 1], z = sourceArr[ind + 2];
             if (!noDataVertices || noDataVertices[indBy3] === 0) {
-                if (x < outBounds.xmin) outBounds.xmin = x;
-                if (x > outBounds.xmax) outBounds.xmax = x;
-                if (y < outBounds.ymin) outBounds.ymin = y;
-                if (y > outBounds.ymax) outBounds.ymax = y;
-                if (z < outBounds.zmin) outBounds.zmin = z;
-                if (z > outBounds.zmax) outBounds.zmax = z;
-            } else {
+                if (x < outBounds.xmin)
+                    outBounds.xmin = x;
+                if (x > outBounds.xmax)
+                    outBounds.xmax = x;
+                if (y < outBounds.ymin)
+                    outBounds.ymin = y;
+                if (y > outBounds.ymax)
+                    outBounds.ymax = y;
+                if (z < outBounds.zmin)
+                    outBounds.zmin = z;
+                if (z > outBounds.zmax)
+                    outBounds.zmax = z;
+            }
+            else {
                 outNoDataVertices[nInd] = 1;
             }
-
             nInd++;
-
             outArr[vInd] = x;
             outArrLow[vInd] = sourceArrLow[ind];
             outArrHigh[vInd++] = sourceArrHigh[ind];
-
             outArr[vInd] = y;
             outArrLow[vInd] = sourceArrLow[ind + 1];
             outArrHigh[vInd++] = sourceArrHigh[ind + 1];
-
             outArr[vInd] = z;
             outArrLow[vInd] = sourceArrLow[ind + 2];
             outArrHigh[vInd++] = sourceArrHigh[ind + 2];
         }
     }
 }
-
-export function cloneArray(items: any[]): any[] {
+export function cloneArray(items) {
     return items.map((item) => (Array.isArray(item) ? cloneArray(item) : item));
 }
-
 /**
  * Promise for load images
  * @function
  * @param {string} url - link to image.
  * @returns {Promise<Image>} Returns promise.
  */
-export async function loadImage(url: string): Promise<HTMLImageElement> {
-    return new Promise<HTMLImageElement>(resolve => {
+export async function loadImage(url) {
+    return new Promise(resolve => {
         const image = new Image();
         image.addEventListener('load', () => {
             resolve(image);
         });
         image.src = url;
-        image.crossOrigin = ""
+        image.crossOrigin = "";
         return image;
     });
 }
-
 /**
  * Gets image is loaded
  * @param {HTMLImageElement} image
  * @returns {boolean} Returns true is the image is loaded
  */
-export function isImageLoaded(image: HTMLImageElement): boolean {
+export function isImageLoaded(image) {
     return image.complete && image.naturalHeight !== 0;
 }
-
-export function distanceFormat(v: number): string {
+export function distanceFormat(v) {
     if (v > 1000) {
         return `${(v / 1000).toFixed(1)} km`;
-    } else if (v > 9) {
+    }
+    else if (v > 9) {
         return `${Math.round(v)} m`;
-    } else {
+    }
+    else {
         return `${v.toFixed(1)} m`;
     }
 }
-
-export function getUrlParam(paramName: string): number | undefined {
+export function getUrlParam(paramName) {
     let urlParams = new URLSearchParams(location.search);
     let param = urlParams.get(paramName);
     if (param) {