@openglobus/og 0.17.1 → 0.18.0

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

@@ -2,20 +2,19 @@
  * @module og/utils/shared
  */
 
-"use strict";
-
-import { Extent } from "../Extent.js";
-import { LonLat } from "../LonLat.js";
-import { Vec2 } from "../math/Vec2.js";
-import { Vec3 } from "../math/Vec3.js";
-import { Vec4 } from "../math/Vec4.js";
-import { colorTable } from "./colorTable.js";
-
-export function getDefault(param, def) {
+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 {
     return param != undefined ? param : def;
 }
 
-export function isEmpty(v) {
+export function isEmpty(v: any): boolean {
     return v == null;
 }
 
@@ -25,25 +24,25 @@ export function isEmpty(v) {
  * @param {Object} obj - Object pointer.
  * @returns {boolean} Returns true if object is undefined.
  */
-export function isUndef(obj) {
+export function isUndef(obj?: any): boolean {
     return obj === void 0;
 }
 
-export function isUndefExt(obj, defVal) {
+export function isUndefExt(obj: any, defVal: any): any {
     return isUndef(obj) ? defVal : obj;
 }
 
-let _stampCounter = 0;
+let _stampCounter: number = 0;
 
-export function stamp(obj) {
-    var stamp = obj._openglobus_id;
+export function stamp(obj: any): number {
+    let stamp = obj._openglobus_id;
     if (!stamp) {
         stamp = obj._openglobus_id = ++_stampCounter;
     }
     return stamp;
 }
 
-export function isString(s) {
+export function isString(s: any): boolean {
     return typeof s === "string" || s instanceof String;
 }
 
@@ -51,31 +50,35 @@ export function isString(s) {
  * 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 {math.Vec4} -
+ * @returns {Vec4} -
  */
-export function htmlColorToRgba(htmlColor, opacity) {
-    var hColor = colorTable[htmlColor];
+export function htmlColorToRgba(htmlColor: string, opacity?: number): Vec4 {
+    let hColor: any | undefined = colorTable[htmlColor];
     if (hColor) {
         htmlColor = hColor;
     }
 
     if (htmlColor[0] === "#") {
-        var shorthandRegex = /^#?([a-f\d])([a-f\d])([a-f\d])$/i;
-        var hex = htmlColor.replace(shorthandRegex, function (m, r, g, b) {
+        let shorthandRegex = /^#?([a-f\d])([a-f\d])([a-f\d])$/i;
+        let hex = htmlColor.replace(shorthandRegex, function (m, r, g, b) {
             return r + r + g + g + b + b;
         });
-        var result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
-        return new Vec4(
-            parseInt(result[1], 16) / 255,
-            parseInt(result[2], 16) / 255,
-            parseInt(result[3], 16) / 255,
-            isEmpty(opacity) ? 1.0 : opacity
-        );
+        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();
+        }
     } else {
         if (isEmpty(opacity)) {
             opacity = 1.0;
         }
-        var m = htmlColor.split(",");
+        let m = htmlColor.split(",");
         return new Vec4(
             parseInt(m[0].split("(")[1]) / 255,
             parseInt(m[1]) / 255,
@@ -85,7 +88,7 @@ export function htmlColorToRgba(htmlColor, opacity) {
     }
 }
 
-export function htmlColorToFloat32Array(htmlColor, opacity) {
+export function htmlColorToFloat32Array(htmlColor: string, opacity?: number): Float32Array {
     let c = htmlColorToRgba(htmlColor, opacity);
     return new Float32Array([c.x, c.y, c.z, c.w]);
 }
@@ -93,28 +96,31 @@ export function htmlColorToFloat32Array(htmlColor, opacity) {
 /**
  * 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.
- * @param {number} [opacity] - Opacity for the output vector.
  * @returns {Vec3} -
  */
-export function htmlColorToRgb(htmlColor) {
-    var hColor = colorTable[htmlColor];
+export function htmlColorToRgb(htmlColor: string): Vec3 {
+    let hColor: any | undefined = colorTable[htmlColor];
     if (hColor) {
         htmlColor = hColor;
     }
 
     if (htmlColor[0] === "#") {
-        var shorthandRegex = /^#?([a-f\d])([a-f\d])([a-f\d])$/i;
-        var hex = htmlColor.replace(shorthandRegex, function (m, r, g, b) {
+        let shorthandRegex = /^#?([a-f\d])([a-f\d])([a-f\d])$/i;
+        let hex = htmlColor.replace(shorthandRegex, function (m, r, g, b) {
             return r + r + g + g + b + b;
         });
-        var result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
-        return new Vec3(
-            parseInt(result[1], 16) / 255,
-            parseInt(result[2], 16) / 255,
-            parseInt(result[3], 16) / 255
-        );
+        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();
+        }
     } else {
-        var m = htmlColor.split(",");
+        let m = htmlColor.split(",");
         return new Vec3(
             parseInt(m[0].split("(")[1]) / 255,
             parseInt(m[1]) / 255,
@@ -135,32 +141,32 @@ export function htmlColorToRgb(htmlColor) {
  *       "y": 15,
  *       "z": 8
  * }
- * og.utils.stringTemplate("http://earth3.openglobus.org/{z}/{y}/{x}.ddm", substrins);
+ * 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, params) {
+export function stringTemplate(template: string, params?: any): string {
     return template.replace(/{[^{}]+}/g, function (key) {
         return params[key.replace(/[{}]+/g, "")] || "";
     });
 }
 
-export function getHTML(template, params) {
+export function getHTML(template: string, params?: any): string {
     return stringTemplate(template, params);
 }
 
-export function parseHTML(htmlStr) {
-    var p = document.createElement("div");
+export function parseHTML(htmlStr: string): HTMLElement[] {
+    let p = document.createElement("div");
     p.innerHTML = htmlStr;
-    var domArr = [];
+    let domArr: HTMLElement[] = [];
     for (let i = 0; i < p.childNodes.length; i++) {
-        domArr.push(p.childNodes[i]);
+        domArr.push(p.childNodes[i] as HTMLElement);
         p.removeChild(p.childNodes[i]);
     }
     return domArr;
 }
 
-export function print2d(id, text, x, y) {
-    var el = document.getElementById(id);
+export function print2d(id: string, text: string, x: number, y: number) {
+    let el = document.getElementById(id);
     if (!el) {
         el = document.createElement("div");
         el.id = id;
@@ -168,20 +174,22 @@ export function print2d(id, text, x, y) {
         document.body.appendChild(el);
     }
     el.innerHTML = text;
-    el.style.left = x;
-    el.style.top = y;
+    el.style.left = `${x}px`;
+    el.style.top = `${y}px`;
 }
 
-export function defaultString(str, def) {
+export function defaultString(str?: string, def: string = ""): string {
     return str ? str.trim().toLowerCase() : def;
 }
 
-export function createVector3(v, def) {
+export function createVector3(v?: Vec3 | Vec2 | NumberArray3 | NumberArray2 | null, def?: Vec3): Vec3 {
     if (v) {
         if (v instanceof Vec3) {
             return v.clone();
         } else if (v instanceof Array) {
             return Vec3.fromVec(v);
+        } else if (v instanceof Vec2) {
+            return new Vec3(v.x, v.y, 0.0);
         }
     } else if (def) {
         return def;
@@ -189,7 +197,7 @@ export function createVector3(v, def) {
     return new Vec3();
 }
 
-export function createVector4(v, def) {
+export function createVector4(v?: Vec4 | NumberArray4 | null, def?: Vec4): Vec4 {
     if (v) {
         if (v instanceof Vec4) {
             return v.clone();
@@ -202,10 +210,10 @@ export function createVector4(v, def) {
     return new Vec4();
 }
 
-export function createColorRGBA(c, def) {
+export function createColorRGBA(c?: string | NumberArray4 | Vec4 | null, def?: Vec4): Vec4 {
     if (c) {
         if (isString(c)) {
-            return htmlColorToRgba(c);
+            return htmlColorToRgba(c as string);
         } else if (c instanceof Array) {
             return Vec4.fromVec(c);
         } else if (c instanceof Vec4) {
@@ -217,14 +225,14 @@ export function createColorRGBA(c, def) {
     return new Vec4(1.0, 1.0, 1.0, 1.0);
 }
 
-export function createColorRGB(c, def) {
+export function createColorRGB(c?: string | NumberArray3 | Vec3 | null, def?: Vec3): Vec3 {
     if (c) {
         if (isString(c)) {
-            return htmlColorToRgb(c);
+            return htmlColorToRgb(c as string);
         } else if (c instanceof Array) {
             return Vec3.fromVec(c);
         } else if (c instanceof Vec3) {
-            return c.clone();
+            return (c as Vec3).clone();
         }
     } else if (def) {
         return def;
@@ -232,7 +240,7 @@ export function createColorRGB(c, def) {
     return new Vec3(1.0, 1.0, 1.0);
 }
 
-export function createExtent(e, def) {
+export function createExtent(e?: Extent | [[number, number], [number, number]] | null, def?: Extent): Extent {
     if (e) {
         if (e instanceof Array) {
             return new Extent(createLonLat(e[0]), createLonLat(e[1]));
@@ -245,7 +253,7 @@ export function createExtent(e, def) {
     return new Extent();
 }
 
-export function createLonLat(l, def = null) {
+export function createLonLat(l?: LonLat | NumberArray2 | NumberArray3, def?: LonLat): LonLat {
     if (l) {
         if (l instanceof Array) {
             return new LonLat(l[0], l[1], l[2]);
@@ -258,7 +266,7 @@ export function createLonLat(l, def = null) {
     return new LonLat();
 }
 
-export function binarySearchFast(arr, x) {
+export function binarySearchFast(arr: number[] | TypedArray, x: number) {
     let start = 0,
         end = arr.length - 1;
     while (start <= end) {
@@ -276,11 +284,11 @@ export function binarySearchFast(arr, x) {
 
 /**
  * Finds an item in a sorted array.
- * @param {Array} ar The sorted array to search.
- * @param {Object} el The item to find in the array.
- * @param {utils.binarySearch~compare_fn} compare_fn comparator The function to use to compare the item to
+ * @param {any[]} ar The sorted array to search.
+ * @param {any} el The item to find in the array.
+ * @param {Function} compare_fn comparator The function to use to compare the item to
  *        elements in the array.
- * @returns {Number} a negative number  if a is less than b; 0 if a is equal to b;a positive number of a is greater than b.
+ * @returns {number} a negative number  if 'a' is less than 'b'; 0 if 'a' is equal to 'b'; 'a' positive number of 'a' is greater than 'b'.
  *
  * @example
  * // Create a comparator function to search through an array of numbers.
@@ -290,12 +298,12 @@ export function binarySearchFast(arr, x) {
  * var numbers = [0, 2, 4, 6, 8];
  * var index = og.utils.binarySearch(numbers, 6, comparator); // 3
  */
-export function binarySearch(ar, el, compare_fn) {
-    var m = 0;
-    var n = ar.length - 1;
+export function binarySearch(ar: any[], el: any, compare_fn: Function): number {
+    let m = 0;
+    let n = ar.length - 1;
     while (m <= n) {
-        var k = (n + m) >> 1;
-        var cmp = compare_fn(el, ar[k], k);
+        let k = (n + m) >> 1;
+        let cmp = compare_fn(el, ar[k], k);
         if (cmp > 0) {
             m = k + 1;
         } else if (cmp < 0) {
@@ -309,14 +317,14 @@ export function binarySearch(ar, el, compare_fn) {
 
 /**
  * Binary insertion that uses binarySearch algorithm.
- * @param {Array} ar - The sorted array to insert.
- * @param {Object} el - The item to insert.
- * @param {utils.binarySearch~compare_fn} compare_fn - comparator The function to use to compare the item to
+ * @param {any[]} ar - The sorted array to insert.
+ * @param {any} el - The item to insert.
+ * @param {Function} compare_fn - comparator The function to use to compare the item to
  *        elements in the array.
- * @returns {Number} Array index position in which item inserted in.
+ * @returns {number} Array index position in which item inserted in.
  */
-export function binaryInsert(ar, el, compare_fn) {
-    var i = binarySearch(ar, el, compare_fn);
+export function binaryInsert(ar: any[], el: any, compare_fn: Function): number {
+    let i = binarySearch(ar, el, compare_fn);
     if (i < 0) {
         i = ~i;
     }
@@ -327,39 +335,39 @@ export function binaryInsert(ar, el, compare_fn) {
 /**
  * Returns two segment lines intersection coordinate.
  * @static
- * @param {math.Vec2} start1 - First line first coordinate.
- * @param {math.Vec2} end1 - First line second coordinate.
- * @param {math.Vec2} start2 - Second line first coordinate.
- * @param {math.Vec2} end2 - Second line second coordinate.
+ * @param {Vec2} start1 - First line first coordinate.
+ * @param {Vec2} end1 - First line second coordinate.
+ * @param {Vec2} start2 - Second line first coordinate.
+ * @param {Vec2} end2 - Second line second coordinate.
  * @param {boolean} [isSegment] - Lines are segments.
- * @return {math.Vec2} - Intersection coordinate.
+ * @return {Vec2} - Intersection coordinate.
  */
-export function getLinesIntersection2v(start1, end1, start2, end2, isSegment) {
-    var dir1 = end1.sub(start1);
-    var dir2 = end2.sub(start2);
+export function getLinesIntersection2v(start1: Vec2, end1: Vec2, start2: Vec2, end2: Vec2, isSegment: boolean): Vec2 | undefined {
+    let dir1 = end1.sub(start1);
+    let dir2 = end2.sub(start2);
 
-    var a1 = -dir1.y;
-    var b1 = +dir1.x;
-    var d1 = -(a1 * start1.x + b1 * start1.y);
+    let a1 = -dir1.y;
+    let b1 = +dir1.x;
+    let d1 = -(a1 * start1.x + b1 * start1.y);
 
-    var a2 = -dir2.y;
-    var b2 = +dir2.x;
-    var d2 = -(a2 * start2.x + b2 * start2.y);
+    let a2 = -dir2.y;
+    let b2 = +dir2.x;
+    let d2 = -(a2 * start2.x + b2 * start2.y);
 
-    var seg1_line2_start = a2 * start1.x + b2 * start1.y + d2;
-    var seg1_line2_end = a2 * end1.x + b2 * end1.y + d2;
+    let seg1_line2_start = a2 * start1.x + b2 * start1.y + d2;
+    let seg1_line2_end = a2 * end1.x + b2 * end1.y + d2;
 
-    var seg2_line1_start = a1 * start2.x + b1 * start2.y + d1;
-    var seg2_line1_end = a1 * end2.x + b1 * end2.y + d1;
+    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)
     ) {
-        return null;
+        return undefined;
     }
 
-    var u = seg1_line2_start / (seg1_line2_start - seg1_line2_end);
+    let u = seg1_line2_start / (seg1_line2_start - seg1_line2_end);
 
     return new Vec2(start1.x + u * dir1.x, start1.y + u * dir1.y);
 }
@@ -367,39 +375,39 @@ export function getLinesIntersection2v(start1, end1, start2, end2, isSegment) {
 /**
  * Returns two segment lines intersection coordinate.
  * @static
- * @param {math.Vec2} start1 - First line first coordinate.
- * @param {math.Vec2} end1 - First line second coordinate.
- * @param {math.Vec2} start2 - Second line first coordinate.
- * @param {math.Vec2} end2 - Second line second coordinate.
- * @param {boolean} [isSegment] - Lines are segments.
- * @return {math.Vec2} - Intersection coordinate.
+ * @param {Vec2} start1 - First line first coordinate.
+ * @param {Vec2} end1 - First line second coordinate.
+ * @param {Vec2} start2 - Second line first coordinate.
+ * @param {Vec2} end2 - Second line second coordinate.
+ * @param {boolean} [isSegment=false] - Lines are segments.
+ * @return {Vec2} - Intersection coordinate.
  */
-export function getLinesIntersectionLonLat(start1, end1, start2, end2, isSegment) {
-    var dir1 = new LonLat(end1.lon - start1.lon, end1.lat - start1.lat);
-    var dir2 = new LonLat(end2.lon - start2.lon, end2.lat - start2.lat);
+export function getLinesIntersectionLonLat(start1: LonLat, end1: LonLat, start2: LonLat, end2: LonLat, isSegment: boolean = false): LonLat | undefined {
+    let dir1 = new LonLat(end1.lon - start1.lon, end1.lat - start1.lat);
+    let dir2 = new LonLat(end2.lon - start2.lon, end2.lat - start2.lat);
 
-    var a1 = -dir1.lat;
-    var b1 = +dir1.lon;
-    var d1 = -(a1 * start1.lon + b1 * start1.lat);
+    let a1 = -dir1.lat;
+    let b1 = +dir1.lon;
+    let d1 = -(a1 * start1.lon + b1 * start1.lat);
 
-    var a2 = -dir2.lat;
-    var b2 = +dir2.lon;
-    var d2 = -(a2 * start2.lon + b2 * start2.lat);
+    let a2 = -dir2.lat;
+    let b2 = +dir2.lon;
+    let d2 = -(a2 * start2.lon + b2 * start2.lat);
 
-    var seg1_line2_start = a2 * start1.lon + b2 * start1.lat + d2;
-    var seg1_line2_end = a2 * end1.lon + b2 * end1.lat + d2;
+    let seg1_line2_start = a2 * start1.lon + b2 * start1.lat + d2;
+    let seg1_line2_end = a2 * end1.lon + b2 * end1.lat + d2;
 
-    var seg2_line1_start = a1 * start2.lon + b1 * start2.lat + d1;
-    var seg2_line1_end = a1 * end2.lon + b1 * end2.lat + d1;
+    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)
     ) {
-        return null;
+        return undefined;
     }
 
-    var u = seg1_line2_start / (seg1_line2_start - seg1_line2_end);
+    let u = seg1_line2_start / (seg1_line2_start - seg1_line2_end);
 
     return new LonLat(start1.lon + u * dir1.lon, start1.lat + u * dir1.lat);
 }
@@ -410,9 +418,9 @@ export function getLinesIntersectionLonLat(start1, end1, start2, end2, isSegment
  * @param {Object} xml - Xml object
  * @return {Object} - Json converted object.
  */
-export function xmlToJson(xml) {
+export function xmlToJson(xml: any): any {
     // Create the return object
-    var obj = {};
+    let obj: any = {};
 
     if (xml.nodeType === 1) {
         // element
@@ -420,7 +428,7 @@ export function xmlToJson(xml) {
         if (xml.attributes.length > 0) {
             obj["@attributes"] = {};
             for (let j = 0; j < xml.attributes.length; j++) {
-                var attribute = xml.attributes.item(j);
+                let attribute = xml.attributes.item(j);
                 obj["@attributes"][attribute.nodeName] = attribute.nodeValue;
             }
         }
@@ -432,13 +440,13 @@ export function xmlToJson(xml) {
     // do children
     if (xml.hasChildNodes()) {
         for (let i = 0; i < xml.childNodes.length; i++) {
-            var item = xml.childNodes.item(i);
-            var nodeName = item.nodeName;
+            let item = xml.childNodes.item(i);
+            let nodeName = item.nodeName;
             if (typeof obj[nodeName] === "undefined") {
                 obj[nodeName] = xmlToJson(item);
             } else {
                 if (typeof obj[nodeName].push === "undefined") {
-                    var old = obj[nodeName];
+                    let old = obj[nodeName];
                     obj[nodeName] = [];
                     obj[nodeName].push(old);
                 }
@@ -450,31 +458,31 @@ export function xmlToJson(xml) {
 }
 
 export const castType = {
-    string: function (v) {
+    string: function (v: any) {
         return isEmpty(v) ? v : v.toString();
     },
 
-    date: function (v) {
+    date: function (v: any) {
         return isEmpty(v) ? v : new Date(v * 1000);
     },
 
-    datetime: function (v) {
+    datetime: function (v: any) {
         return isEmpty(v) ? v : new Date(v * 1000);
     },
 
-    time: function (v) {
+    time: function (v: any) {
         return isEmpty(v) ? v : parseInt(v);
     },
 
-    integer: function (v) {
+    integer: function (v: any) {
         return isEmpty(v) ? v : parseInt(v);
     },
 
-    float: function (v) {
+    float: function (v: any) {
         return isEmpty(v) ? v : parseFloat(v);
     },
 
-    boolean: function (str) {
+    boolean: function (str: any) {
         if (str === null) {
             return str;
         }
@@ -503,28 +511,31 @@ export const castType = {
     }
 };
 
-export function base64toBlob(base64Data, contentType) {
-    contentType = contentType || "";
-    var sliceSize = 1024;
-    var byteCharacters = atob(base64Data);
-    var bytesLength = byteCharacters.length;
-    var slicesCount = Math.ceil(bytesLength / sliceSize);
-    var byteArrays = new Array(slicesCount);
+export function base64toBlob(base64Data: string, contentType: string = ""): Blob {
+
+    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) {
-        var begin = sliceIndex * sliceSize;
-        var end = Math.min(begin + sliceSize, bytesLength);
 
-        var bytes = new Array(end - begin);
+        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) {
+export function base64StringToBlog(string: string): Blob {
+
     let block = string.split(";");
     let contentType = block[0].split(":")[1];
     let data = block[1].split(",")[1];
@@ -567,22 +578,21 @@ export function base64StringToBlog(string) {
  * @param {Number} limit
  * @param {boolean} [skip]
  */
-export function throttle(func, limit, skip) {
-    let lastFunc;
-    let lastRan;
+export function throttle(func: Function, limit: number, skip: boolean) {
+    let lastFunc: any;
+    let lastRan: number = 0;
     return function () {
-        const context = this;
         const args = arguments;
         if (!lastRan) {
-            func.apply(context, args);
+            func.apply(null, args);
             lastRan = Date.now();
         } else {
             if (skip) {
                 clearTimeout(lastFunc);
             }
-            lastFunc = setTimeout(function () {
+            lastFunc = setTimeout(() => {
                 if (Date.now() - lastRan >= limit) {
-                    func.apply(context, args);
+                    func.apply(null, args);
                     lastRan = Date.now();
                 }
             }, limit - (Date.now() - lastRan));
@@ -618,7 +628,9 @@ export function throttle(func, limit, skip) {
  * @param {Number} [y1=0.0] -
  * @param {Number} [y2=1.0] -
  */
-export function blerp(x, y, fQ11, fQ21, fQ12, fQ22, x1 = 0.0, x2 = 1.0, y1 = 0.0, 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) +
@@ -628,13 +640,13 @@ export function blerp(x, y, fQ11, fQ21, fQ12, fQ22, x1 = 0.0, x2 = 1.0, y1 = 0.0
     );
 }
 
-export function blerp2(x, y, fQ11, fQ21, fQ12, fQ22) {
+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 extractElevationTiles(rgbaData, outCurrenElevations, outChildrenElevations) {
+export function extractElevationTiles(rgbaData: number[] | TypedArray, outCurrenElevations: number[] | TypedArray, outChildrenElevations: number[][][] | TypedArray[][]) {
     let destSize = Math.sqrt(outCurrenElevations.length) - 1;
     let destSizeOne = destSize + 1;
     let sourceSize = Math.sqrt(rgbaData.length / 4);
@@ -730,13 +742,24 @@ export function extractElevationTiles(rgbaData, outCurrenElevations, outChildren
     }
 }
 
+export type TypedArray =
+    | Int8Array
+    | Uint8Array
+    | Uint8ClampedArray
+    | Int16Array
+    | Uint16Array
+    | Int32Array
+    | Uint32Array
+    | Float32Array
+    | Float64Array;
+
 /**
  * Concatenates two the same type arrays
  * @param {TypedArray} a
- * @param {TypedArray} b
+ * @param {TypedArray | number[]} b
  */
-export function concatTypedArrays(a, b) {
-    var c = new a.constructor(a.length + b.length);
+export function concatTypedArrays(a: TypedArray, b: TypedArray | number[]): TypedArray {
+    let c = new (a as any).constructor(a.length + b.length); //hacky
     c.set(a, 0);
     c.set(b, a.length);
     return c;
@@ -744,12 +767,13 @@ export function concatTypedArrays(a, b) {
 
 /**
  * Concatenates two the same  arrays
- * @param {TypedArray | Array} a
- * @param {TypedArray | Array} b
+ * @param {TypedArray | number[]} [a=[]] - First array
+ * @param {TypedArray | number[]} [b=[]] - Second array
+ * @return {TypedArray | number[]} -
  */
-export function concatArrays(a = [], b) {
+export function concatArrays(a: TypedArray | number[] = [], b: TypedArray | number[] = []): TypedArray | number[] {
     if (ArrayBuffer.isView(a)) {
-        return concatTypedArrays(a, b);
+        return concatTypedArrays(a as TypedArray, b as TypedArray);
     } else {
         for (let i = 0; i < b.length; i++) {
             a.push(b[i]);
@@ -760,13 +784,13 @@ export function concatArrays(a = [], b) {
 
 /**
  * Convert simple array to typed
- * @param arr {Array}
- * @param ctor {Float32ArrayConstructor}
+ * @param arr {number[]}
+ * @param ctor {Float32Array}
  * @returns {TypedArray}
  */
-export function makeArrayTyped(arr, ctor = Float32Array) {
+export function makeArrayTyped(arr: TypedArray | number[], ctor: Function = Float32Array) {
     if (!ArrayBuffer.isView(arr)) {
-        const typedArr = new ctor(arr.length);
+        const typedArr = new (ctor as any)(arr.length); //hacky
         typedArr.set(arr, 0);
         return typedArr;
     } else {
@@ -776,10 +800,10 @@ export function makeArrayTyped(arr, ctor = Float32Array) {
 
 /**
  * Convert typed array to array
- * @param arr {TypedArray}
- * @returns {Array}
+ * @param arr {TypedArray | number[]}
+ * @returns {number[]}
  */
-export function makeArray(arr) {
+export function makeArray(arr: TypedArray | number[]): number[] {
     if (ArrayBuffer.isView(arr)) {
         return Array.from(arr);
     } else {
@@ -792,16 +816,16 @@ export function makeArray(arr) {
  * @param {TypedArray | Array} arr
  * @param {Number} starting
  * @param {Number} deleteCount
- * @param {Object} outArr
+ * @param {{ result: number[] }} [out]
  */
 
-export function spliceArray(arr, starting, deleteCount, out) {
+export function spliceArray(arr: TypedArray | number[], starting: number, deleteCount: number, out?: { result: number[] } | { result: TypedArray }): TypedArray | number[] {
     if (ArrayBuffer.isView(arr)) {
         if (starting < 0) {
             deleteCount = Math.abs(starting);
             starting += arr.length;
         }
-        return spliceTypedArray(arr, starting, deleteCount, out);
+        return spliceTypedArray(arr, starting, deleteCount, out as { result: TypedArray });
     } else {
         let res;
         if (starting < 0) {
@@ -816,57 +840,91 @@ export function spliceArray(arr, starting, deleteCount, out) {
     }
 }
 
-window.spliceArray = spliceArray;
-
 /**
  *
  * @param {TypedArray} arr
  * @param {Number} starting
  * @param {Number} deleteCount
- * @param {Array} outArr
+ * @param {{ result: TypedArray }} [out]
  */
-export function spliceTypedArray(arr, starting, deleteCount, out) {
+export function spliceTypedArray<T extends TypedArray>(arr: T, starting: number, deleteCount: number, out?: { result: T }): T {
     if (arr.length === 0) {
         return arr;
     }
     const newSize = arr.length - deleteCount;
-    const splicedArray = new arr.constructor(newSize);
+    const splicedArray = new (arr as any).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);
+        out.result = arr.subarray(starting, starting + deleteCount) as T;
     }
     return splicedArray;
 }
 
 /**
- * Returns triangle coordinate array from inside of the source triangle array.
+ * Returns 64-bit triangle coordinate array from inside of the source triangle array.
  * @static
- * @param {Array.<number>} sourceArr - Source array
+ * @param {TypedArray | number[]} sourceArr - Source array
  * @param {number} gridSize - Source array square matrix size
  * @param {number} i0 - First row index source array matrix
  * @param {number} j0 - First column index
  * @param {number} size - Square matrix result size.
- * @return{Array.<number>} Triangle coordinates array from the source array.
+ * @return {Float64Array} Triangle coordinates array from the source array.
  * @TODO: optimization
  */
-export function getMatrixSubArray(sourceArr, gridSize, i0, j0, size) {
+export function getMatrixSubArray64(sourceArr: TypedArray | number[], gridSize: number, i0: number, j0: number, size: number): Float64Array {
+
     const size_1 = size + 1;
     const i0size = i0 + size_1;
     const j0size = j0 + size_1;
 
-    var res = new Float64Array(size_1 * size_1 * 3);
+    let res = new Float64Array(size_1 * size_1 * 3);
+    let vInd = 0;
 
-    var vInd = 0;
     for (let i = i0; i < i0size; i++) {
         for (let j = j0; j < j0size; j++) {
-            var ind = 3 * (i * (gridSize + 1) + 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
+ * @param {TypedArray | number[]} sourceArr - Source array
+ * @param {number} gridSize - Source array square matrix size
+ * @param {number} i0 - First row index source array matrix
+ * @param {number} j0 - First column index
+ * @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 {
+
+    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;
 }
 
@@ -883,25 +941,28 @@ export function getMatrixSubArray(sourceArr, gridSize, i0, j0, size) {
  * @TODO: optimization
  */
 export function getMatrixSubArrayBoundsExt(
-    sourceArr,
-    sourceArrHigh,
-    sourceArrLow,
-    noDataVertices,
-    gridSize,
-    i0,
-    j0,
-    size,
-    outArr,
-    outArrHigh,
-    outArrLow,
-    outBounds,
-    outNoDataVertices
+    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[]
 ) {
     const i0size = i0 + size + 1;
     const j0size = j0 + size + 1;
+
     gridSize += 1;
-    var vInd = 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,
@@ -939,7 +1000,7 @@ export function getMatrixSubArrayBoundsExt(
     }
 }
 
-export function cloneArray(items) {
+export function cloneArray(items: any[]): any[] {
     return items.map((item) => (Array.isArray(item) ? cloneArray(item) : item));
 }
 
@@ -949,8 +1010,8 @@ export function cloneArray(items) {
  * @param {string} url - link to image.
  * @returns {Promise<Image>} Returns promise.
  */
-export async function loadImage(url) {
-    return new Promise(resolve => {
+export async function loadImage(url: string): Promise<HTMLImageElement> {
+    return new Promise<HTMLImageElement>(resolve => {
         const image = new Image();
         image.addEventListener('load', () => {
             resolve(image);
@@ -966,11 +1027,11 @@ export async function loadImage(url) {
  * @param {HTMLImageElement} image
  * @returns {boolean} Returns true is the image is loaded
  */
-export function isImageLoaded(image) {
+export function isImageLoaded(image: HTMLImageElement): boolean {
     return image.complete && image.naturalHeight !== 0;
 }
 
-export function distanceFormat(v) {
+export function distanceFormat(v: number): string {
     if (v > 1000) {
         return `${(v / 1000).toFixed(1)} km`;
     } else if (v > 9) {
@@ -980,7 +1041,7 @@ export function distanceFormat(v) {
     }
 }
 
-export function getUrlParam(paramName) {
+export function getUrlParam(paramName: string): number | undefined {
     let urlParams = new URLSearchParams(location.search);
     let param = urlParams.get(paramName);
     if (param) {