@nativerent/js-utils 1.2.1 → 1.2.3

package/dist/index.js

@@ -1,645 +1,675 @@
-'use strict';
-
-function debounce(fn, delay) {
-  let timeout;
-  return function(...args) {
-    clearTimeout(timeout);
-    timeout = setTimeout(() => fn.apply(null, args), delay);
-  };
-}
-function throttle(fn, delay) {
-  let lastCall = 0;
-  return function(...args) {
-    const now = (/* @__PURE__ */ new Date()).getTime();
-    if (now - lastCall < delay) {
-      return;
+export function debounce(fn, delay) {
+    let timeout;
+    return function (...args) {
+        clearTimeout(timeout);
+        timeout = setTimeout(() => fn.apply(null, args), delay);
+    };
+}
+export function throttle(fn, delay) {
+    let lastCall = 0;
+    return function (...args) {
+        const now = new Date().getTime();
+        if (now - lastCall < delay) {
+            return;
+        }
+        lastCall = now;
+        fn(...args);
+    };
+}
+export function isObject(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+export function isFn(value) {
+    return typeof value === "function";
+}
+export function isStr(value) {
+    return typeof value === "string";
+}
+export function isString(value) {
+    return typeof value === "string";
+}
+/**
+ * Check if the given argument is a string which is not empty
+ */
+export function isNotEmptyString(value) {
+    return isString(value) && value.length > 0;
+}
+export function isHTMLElement(value) {
+    return value instanceof HTMLElement || value instanceof SVGElement;
+}
+export function isNum(value) {
+    return typeof value === "number";
+}
+export function isBool(value) {
+    return typeof value === "boolean";
+}
+export function isUndef(value) {
+    return typeof value === "undefined";
+}
+export function isNullOrUndef(value) {
+    return value === null || typeof value === "undefined";
+}
+export function isDefined(value) {
+    return !isUndef(value);
+}
+/**
+ * Returns an array containing all the elements of array1 that are not in array2 and vice-versa
+ */
+export function arrayDiff(array1, array2) {
+    return array1
+        .filter((value) => !array2.includes(value))
+        .concat(array2.filter((value) => !array1.includes(value)));
+}
+/**
+ * Returns an array of elements present in array1 and array2
+ */
+export function arrayIntersect(array1, array2) {
+    const set = new Set(array2);
+    return array1.filter((value) => set.has(value));
+}
+export function deepCloneObject(object) {
+    return JSON.parse(JSON.stringify(object));
+}
+// todo: non-px values
+export function getNumericStyleProp(prop, el) {
+    const styles = window.getComputedStyle(el);
+    return !isNullOrUndef(styles[prop]) ? parseFloat(styles[prop] || 0) : 0;
+}
+export function objectHasProp(obj, prop) {
+    return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+/**
+ * Custom version of Object.keys()
+ */
+export function getObjectKeys(object) {
+    let key;
+    let keys = [];
+    for (key in object) {
+        if (Object.prototype.hasOwnProperty.call(object, key)) {
+            keys.push(key);
+        }
     }
-    lastCall = now;
-    fn(...args);
-  };
-}
-function isObject(value) {
-  return !!value && typeof value === "object" && !Array.isArray(value);
-}
-function isFn(value) {
-  return typeof value === "function";
-}
-function isStr(value) {
-  return typeof value === "string";
-}
-function isString(value) {
-  return typeof value === "string";
-}
-function isNotEmptyString(value) {
-  return isString(value) && value.length;
-}
-function isHTMLElement(value) {
-  return value instanceof HTMLElement || value instanceof SVGElement;
-}
-function isNum(value) {
-  return typeof value === "number";
-}
-function isBool(value) {
-  return typeof value === "boolean";
-}
-function isUndef(value) {
-  return typeof value === "undefined";
-}
-function isNullOrUndef(value) {
-  return value === null || typeof value === "undefined";
-}
-function isDefined(value) {
-  return !isUndef(value);
-}
-function arrayDiff(array1, array2) {
-  return array1.filter((value) => !array2.includes(value)).concat(array2.filter((value) => !array1.includes(value)));
-}
-function arrayIntersect(array1, array2) {
-  return array1.filter((value) => array2.includes(value));
-}
-function deepCloneObject(object) {
-  return JSON.parse(JSON.stringify(object));
-}
-function getNumericStyleProp(prop, el) {
-  const styles = window.getComputedStyle(el);
-  return !isNullOrUndef(styles[prop]) ? parseInt(styles[prop].slice(0, -2)) : 0;
-}
-function objectHasProp(obj, prop) {
-  return Object.prototype.hasOwnProperty.call(obj, prop);
-}
-function getObjectKeys(object) {
-  let key;
-  let keys = [];
-  for (key in object) {
-    if (Object.prototype.hasOwnProperty.call(object, key)) {
-      keys.push(key);
+    return keys;
+}
+/**
+ * Convert an object to a query string
+ * Works with primitive objects
+ */
+export function objectToQueryString(object) {
+    return Object.entries(object)
+        .map(([k, v]) => {
+        if (Array.isArray(v)) {
+            return v
+                .map((item) => `${k}[]=${encodeURIComponent(item || "")}`)
+                .join("&");
+        }
+        else if (isObject(v)) {
+            return `${k}=${encodeURIComponent(JSON.stringify(v))}`;
+        }
+        return `${k}=${encodeURIComponent(v || "")}`;
+    })
+        .join("&");
+}
+export function countObjectInnerLength(object) {
+    return Object.values(object).reduce((sum, arr) => sum + (arr?.length ?? 0), 0);
+}
+/**
+ * Check if the element is in viewport
+ */
+export function isElementVisible(element, minVisiblePercent = 50) {
+    const { top, bottom, height } = element.getBoundingClientRect();
+    if (!height)
+        return false;
+    const viewportTop = 0;
+    const viewportBottom = window.innerHeight;
+    const visibleTop = Math.max(top, viewportTop);
+    const visibleBottom = Math.min(bottom, viewportBottom);
+    const visibleHeight = Math.max(0, visibleBottom - visibleTop);
+    return (visibleHeight / height) * 100 >= minVisiblePercent;
+}
+export function decodeSafeURL(url) {
+    try {
+        return decodeURI(url);
     }
-  }
-  return keys;
-}
-function objectToQueryString(object) {
-  return Object.entries(object).map(([k, v]) => {
-    if (Array.isArray(v)) {
-      return v.map((item) => `${k}[]=${encodeURIComponent(item || "")}`).join("&");
-    } else if (isObject(v)) {
-      return `${k}=${encodeURIComponent(JSON.stringify(v))}`;
+    catch {
+        return url;
     }
-    return `${k}=${encodeURIComponent(v || "")}`;
-  }).join("&");
-}
-function countObjectInnerLength(object) {
-  const obj = Object.values(object);
-  const len = obj.length;
-  if (len === 0) {
-    return 0;
-  } else if (len === 1) {
-    return obj[0].length;
-  } else {
-    return obj.reduce((acc, cur) => {
-      if (Array.isArray(acc)) {
-        acc = acc.length;
-      }
-      if (cur) {
-        acc += cur.length;
-      }
-      return acc;
-    });
-  }
-}
-function isElementVisible(element, minVisiblePercent = 50) {
-  const elementCoords = element.getBoundingClientRect();
-  const elementHeight = elementCoords.height;
-  if (!elementHeight) {
-    return false;
-  }
-  const elementTop = elementCoords.top;
-  const elementBottom = elementCoords.bottom;
-  const viewPortHeight = window.innerHeight;
-  const elementVisibleHeight = elementTop > 0 ? (
-    // the element is in or below viewport
-    viewPortHeight - elementTop
-  ) : (
-    // the element is still in or above viewport
-    elementBottom
-  );
-  return elementVisibleHeight / elementHeight * 100 >= minVisiblePercent;
-}
-function decodeSafeURL(url) {
-  try {
-    return decodeURI(url);
-  } catch (e) {
-    return url;
-  }
 }
-function getSafeURL(url) {
-  url = url ? url : location.href;
-  return encodeURI(decodeSafeURL(url));
+export function getSafeURL(url) {
+    url = url ? url : location.href;
+    return encodeURI(decodeSafeURL(url));
 }
-function parseURL(url) {
-  return new URL(url);
+export function parseURL(url) {
+    return new URL(url);
 }
-function encodeQueryString(url) {
-  if (url.length > 0) {
-    const index = url.indexOf("?");
-    if (index >= 0) {
-      return url.substring(0, index) + parseURL(url).search;
+export function encodeQueryString(url) {
+    if (url.length > 0) {
+        const index = url.indexOf("?");
+        if (index >= 0) {
+            return url.substring(0, index) + parseURL(url).search;
+        }
     }
-  }
-  return url;
-}
-function injectScript(filename) {
-  const script = document.createElement("script");
-  script.src = filename;
-  script.async = true;
-  document.head.appendChild(script);
-}
-function injectStyleLink(filename) {
-  const link = document.createElement("link");
-  link.rel = "stylesheet";
-  link.href = filename;
-  document.head.appendChild(link);
-}
-function toBinaryStr(str) {
-  const encoder = new TextEncoder();
-  const charCodes = encoder.encode(str);
-  return String.fromCharCode(...charCodes);
-}
-function getHtmlElement(id) {
-  return document.getElementById(id);
-}
-function stringToHtmlElements(html) {
-  const template = createHtmlElement("div");
-  template.innerHTML = html.replace(/[\r\n]/gm, "").trim();
-  return template.childNodes;
-}
-function createHtmlElement(type, attributes = {}) {
-  const attrs = getObjectKeys(attributes);
-  const element = document.createElement(type);
-  if (attrs.length) {
-    attrs.forEach((name) => {
-      element.setAttribute(name, attributes[name]);
-    });
-  }
-  return element;
-}
-function insertHtmlElements(nodes, appendTo) {
-  appendTo = appendTo || document.body;
-  const fragment = new DocumentFragment();
-  for (let i = 0; i < nodes.length; i++) {
-    if (!isHTMLElement(nodes[i]) && nodes[i].nodeType !== 3) {
-      continue;
+    return url;
+}
+export function injectScript(filename) {
+    const script = document.createElement("script");
+    script.src = filename;
+    script.async = true;
+    document.head.appendChild(script);
+}
+export function injectStyleLink(filename) {
+    const link = document.createElement("link");
+    link.rel = "stylesheet";
+    link.href = filename;
+    document.head.appendChild(link);
+}
+export function toBinaryStr(str) {
+    const CHUNK = 0x8000; // String.fromCharCode(...charCodes) can overflow the call stack with large strings
+    const bytes = new TextEncoder().encode(str);
+    let result = "";
+    for (let i = 0; i < bytes.length; i += CHUNK) {
+        result += String.fromCharCode(...bytes.subarray(i, i + CHUNK));
     }
-    const node = nodes[i];
-    let newNode;
-    switch (node.nodeName.toLowerCase()) {
-      case "script":
-        const src = node.getAttribute("src");
-        if (!isNullOrUndef(src) && src.length > 0) {
-          newNode = createScriptElement(
-            src,
-            false,
-            flatHtmlAttributes(node.attributes)
-          );
-        } else {
-          newNode = createScriptElement(
-            node.innerHTML,
-            true,
-            flatHtmlAttributes(node.attributes)
-          );
+    return result;
+}
+/**
+ * Find a DOM element where an ad unit should be rendered to
+ */
+export function getHtmlElement(id) {
+    return document.getElementById(id);
+}
+/**
+ * Convert an HTML string into a list of nodes
+ */
+export function stringToHtmlElements(html) {
+    const template = createHtmlElement("div");
+    template.innerHTML = html.replace(/[\r\n]/gm, "").trim();
+    return template.childNodes;
+}
+/**
+ * Creates an HTML element and sets attributes
+ */
+export function createHtmlElement(type, attributes = {}) {
+    const el = document.createElement(type);
+    for (const [k, v] of Object.entries(attributes))
+        el.setAttribute(k, v);
+    return el;
+}
+/**
+ * Insert HTML elements into DOM
+ */
+export function insertHtmlElements(nodes, appendTo = document.body) {
+    const fragment = document.createDocumentFragment();
+    for (let i = 0; i < nodes.length; i++) {
+        const node = nodes[i];
+        // Allow elements + text nodes only
+        if (!isHTMLElement(node) && node?.nodeType !== Node.TEXT_NODE) {
+            continue;
+        }
+        let newNode;
+        // Text node
+        if (node?.nodeType === Node.TEXT_NODE) {
+            newNode = document.createTextNode(node.textContent ?? "");
+            fragment.appendChild(newNode);
+            continue;
         }
-        break;
-      case "style":
-        newNode = createStyleElement(node.textContent);
-        break;
-      case "svg":
-        newNode = createSvgElement(
-          node.innerHTML,
-          flatHtmlAttributes(node.attributes)
-        );
-        break;
-      case "#text":
-        newNode = document.createTextNode(node.textContent ?? "");
-        break;
-      default:
-        newNode = createHtmlElement(
-          node.tagName,
-          flatHtmlAttributes(node.attributes)
-        );
-        if (node.childNodes.length) {
-          insertHtmlElements(node.childNodes, newNode);
-        } else {
-          newNode.innerHTML = node.innerHTML;
+        // Element node from here on
+        const el = node;
+        const tag = el.tagName.toLowerCase();
+        switch (tag) {
+            case "script": {
+                const src = el.getAttribute("src");
+                newNode =
+                    !isNullOrUndef(src) && src.length > 0
+                        ? createScriptElement(src, false, flatHtmlAttributes(el.attributes))
+                        : createScriptElement(el.textContent ?? "", true, flatHtmlAttributes(el.attributes));
+                break;
+            }
+            case "style":
+                newNode = createStyleElement(el.textContent);
+                break;
+            case "svg":
+                newNode = createSvgElement(el.innerHTML, flatHtmlAttributes(el.attributes));
+                break;
+            default: {
+                const created = createHtmlElement(el.tagName, flatHtmlAttributes(el.attributes));
+                // Recurse for children (handles mixed element/text)
+                if (el.childNodes.length) {
+                    insertHtmlElements(el.childNodes, created);
+                }
+                else {
+                    created.textContent = el.textContent ?? "";
+                }
+                newNode = created;
+            }
         }
+        fragment.appendChild(newNode);
     }
-    fragment.appendChild(newNode);
-  }
-  appendTo.appendChild(fragment);
-}
-function flatHtmlAttributes(attributes) {
-  let flatAttributes = {};
-  if (!isNullOrUndef(attributes)) {
+    appendTo.appendChild(fragment);
+}
+/**
+ * Make a simple object which contains only attribute name and value
+ */
+export function flatHtmlAttributes(attributes) {
+    if (!attributes)
+        return {};
+    const result = {};
     for (let i = 0; i < attributes.length; i++) {
-      let attr = attributes[i];
-      if (!isUndef(attr)) {
-        flatAttributes[attr.name] = attr.value;
-      }
+        const attr = attributes[i];
+        if (attr) {
+            result[attr.name] = attr.value;
+        }
     }
-  }
-  return flatAttributes;
-}
-function createScriptElement(js, inline = false, attributes = {}) {
-  const attrs = isObject(attributes) ? getObjectKeys(attributes) : [];
-  const element = createHtmlElement("script");
-  if (attrs.length) {
-    attrs.forEach((name) => {
-      element.setAttribute(name, attributes[name]);
-    });
-  }
-  if (inline) {
-    element.appendChild(document.createTextNode(js));
-  } else {
-    element.async = true;
-    element.src = js;
-  }
-  return element;
-}
-function createStyleElement(css) {
-  const element = createHtmlElement("style");
-  if (css) {
-    element.appendChild(document.createTextNode(css));
-  }
-  return element;
-}
-function createLinkElement(href) {
-  const element = createHtmlElement("link");
-  element.rel = "stylesheet";
-  element.href = href;
-  return element;
-}
-function createSvgElement(content, attributes) {
-  const attrs = getObjectKeys(attributes);
-  const element = document.createElementNS("http://www.w3.org/2000/svg", "svg");
-  if (attrs.length) {
-    attrs.forEach((name) => {
-      element.setAttribute(name, attributes[name]);
-    });
-  }
-  element.innerHTML = content;
-  return element;
-}
-function createPixelElement(src) {
-  const image = document.createElement("img");
-  image.src = src;
-  image.width = 1;
-  image.height = 1;
-  image.style.position = "absolute";
-  image.style.left = "-99999px";
-  return image;
-}
-function insertJs(js, inline = false) {
-  const element = createScriptElement(js, inline);
-  document.head.appendChild(element);
-}
-function insertCss(css, className, external = false) {
-  const element = external ? createLinkElement(css) : createStyleElement(css);
-  if (className) {
-    element.className = className;
-  }
-  document.head.appendChild(element);
-}
-function getScreenSize() {
-  let width, height;
-  if (window.screen) {
-    width = screen.width;
-    height = screen.height;
-  } else {
-    width = window.innerWidth;
-    height = window.innerHeight;
-  }
-  return {
-    width,
-    height
-  };
-}
-function getRandomInt(min = 0, max = 4294967295) {
-  min = Math.ceil(min);
-  max = Math.floor(max);
-  return Math.floor(Math.random() * (max - min)) + min;
-}
-function hashCode(str) {
-  let hash = 0, chr;
-  for (let i = 0; i < str.length; i++) {
-    chr = str.charCodeAt(i);
-    hash = (hash << 5) - hash + chr;
-    hash |= 0;
-  }
-  return hash >>> 0;
-}
-function onDOMReady(callback, ...args) {
-  if (document.readyState === "interactive" || document.readyState === "complete") {
-    callback(...args);
-  } else {
-    document.addEventListener("DOMContentLoaded", () => callback(...args));
-  }
-}
-function toPercent(a, b) {
-  return b > 0 ? a / b * 100 : 0;
-}
-function toCamelCase(string) {
-  return string.split(new RegExp(/[-_.]/)).reduce(
-    (a, b) => a + b.charAt(0).toUpperCase() + b.slice(1)
-  );
-}
-function toSnakeCase(string) {
-  return toCamelCase(string).replace(/(^[A-Z])?([A-Z])/gm, "$1_$2").toLowerCase();
-}
-function capitalize(string) {
-  return string.charAt(0).toUpperCase() + string.slice(1);
-}
-function sortByAlphabet(first, second) {
-  return first.toLowerCase() > second.toLowerCase() ? 1 : -1;
-}
-function getRandomStr(length) {
-  length = length ? length > 100 ? 100 : length : 10;
-  let str = Math.random().toString(36).substring(2);
-  while (str.length < length) {
-    str += Math.random().toString(36).substring(2);
-  }
-  const result = str.slice(-length);
-  return isNaN(Number(result)) ? result : getRandomStr(length);
-}
-function getRandomItem(items) {
-  return items[Math.floor(Math.random() * items.length)];
-}
-function sumArray(values) {
-  if (values.every((value) => isNaN(value))) {
-    return "";
-  } else {
-    return values.reduce((sum, curr) => {
-      const value = Number(curr);
-      if (!isNaN(value)) {
-        return sum + value;
-      } else {
-        return sum;
-      }
-    }, 0);
-  }
-}
-function filterObjectKeysByValues(obj, values) {
-  values = Array.isArray(values) ? values : Array(values);
-  const keys = [];
-  for (const key in obj) {
-    if (!values.includes(obj[key])) {
-      keys.push(key);
+    return result;
+}
+/**
+ * Create a <script> element
+ */
+export function createScriptElement(js, inline = false, attributes = {}) {
+    const el = document.createElement("script");
+    for (const [k, v] of Object.entries(attributes)) {
+        el.setAttribute(k, v);
+    }
+    if (inline) {
+        el.appendChild(document.createTextNode(js));
+    }
+    else {
+        el.async = true;
+        el.src = js;
+    }
+    return el;
+}
+/**
+ * Create a <style> element
+ */
+export function createStyleElement(css) {
+    const element = createHtmlElement("style");
+    if (css) {
+        element.appendChild(document.createTextNode(css));
+    }
+    return element;
+}
+/**
+ * Create a <link> element
+ */
+export function createLinkElement(href) {
+    const element = createHtmlElement("link");
+    element.rel = "stylesheet";
+    element.href = href;
+    return element;
+}
+/**
+ * Create svg elements
+ */
+export function createSvgElement(content, attributes = {}) {
+    const element = document.createElementNS("http://www.w3.org/2000/svg", "svg");
+    for (const [name, value] of Object.entries(attributes)) {
+        element.setAttribute(name, value);
+    }
+    element.innerHTML = content.trim();
+    return element;
+}
+/**
+ * Create an image element to use as a tracking pixel
+ */
+export function createPixelElement(src) {
+    const image = document.createElement("img");
+    image.alt = "";
+    image.src = src;
+    image.width = 1;
+    image.height = 1;
+    image.loading = "eager";
+    image.setAttribute("aria-hidden", "true");
+    image.style.position = "absolute";
+    image.style.left = "-99999px";
+    return image;
+}
+/**
+ * Append a new script element to the DOM head
+ */
+export function insertJs(js, inline = false) {
+    const element = createScriptElement(js, inline);
+    document.head.appendChild(element);
+}
+/**
+ * Append a new style element to the DOM head
+ */
+export function insertCss(css, className, external = false) {
+    const element = external ? createLinkElement(css) : createStyleElement(css);
+    if (className) {
+        element.className = className;
+    }
+    document.head.appendChild(element);
+}
+/**
+ * Get screen sizes
+ */
+export function getScreenSize() {
+    const width = window.screen?.width ?? window.innerWidth;
+    const height = window.screen?.height ?? window.innerHeight;
+    return { width, height };
+}
+/**
+ * Get a random integer between min and max
+ */
+export function getRandomInt(min = 0, max = 4294967295) {
+    min = Math.ceil(min);
+    max = Math.floor(max);
+    if (max <= min) {
+        return min;
+    }
+    return Math.floor(Math.random() * (max - min)) + min;
+}
+/**
+ * Implementation of Java's String.hashCode() method
+ */
+export function hashCode(str) {
+    let hash = 0, chr;
+    for (let i = 0; i < str.length; i++) {
+        chr = str.charCodeAt(i);
+        hash = (hash << 5) - hash + chr;
+        hash |= 0; // convert to 32bit integer
+    }
+    return hash >>> 0;
+}
+/**
+ * Executes a callback as soon as DOM is interactive
+ */
+export function onDOMReady(callback, ...args) {
+    if (document.readyState === "interactive" ||
+        document.readyState === "complete") {
+        callback(...args);
+    }
+    else {
+        document.addEventListener("DOMContentLoaded", () => callback(...args));
     }
-  }
-  return keys;
-}
-function getFromObject(object, key) {
-  return key.split(".").reduce((a, b) => {
-    return a[b];
-  }, object);
-}
-function fireBlurEvent(element, delay = 0) {
-  fireEvent("blur", element, delay);
 }
-function fireInputEvent(element, delay = 0) {
-  fireEvent("input", element, delay);
+/**
+ * Calculate the percentage of two values
+ *
+ * @param a
+ * @param b
+ * @return number
+ */
+export function toPercent(a, b) {
+    return b > 0 ? (a / b) * 100 : 0;
+}
+/**
+ * Make a camelCase string
+ *
+ * @param string
+ * @return string
+ */
+export function toCamelCase(string) {
+    return string
+        .split(new RegExp(/[-_.]/))
+        .reduce((a, b) => a + b.charAt(0).toUpperCase() + b.slice(1));
+}
+/**
+ * Make a snake_case string
+ *
+ * @param string
+ * @return string
+ */
+export function toSnakeCase(string) {
+    return toCamelCase(string)
+        .replace(/(^[A-Z])?([A-Z])/gm, "$1_$2")
+        .toLowerCase();
+}
+/**
+ * Transform the first letter of the given string to the upper case
+ *
+ * @param string
+ * @return string
+ */
+export function capitalize(string) {
+    return string.charAt(0).toUpperCase() + string.slice(1);
+}
+/**
+ * Registry independent string sorting
+ *
+ * @param first
+ * @param second
+ */
+export function sortByAlphabet(first, second) {
+    return first.toLowerCase() > second.toLowerCase() ? 1 : -1;
+}
+/**
+ * @param length
+ * @return string of max length 100
+ */
+export function getRandomStr(length) {
+    length = length ? (length > 100 ? 100 : length) : 10;
+    let str = Math.random().toString(36).substring(2);
+    while (str.length < length) {
+        str += Math.random().toString(36).substring(2);
+    }
+    const result = str.slice(-length);
+    return isNaN(Number(result)) ? result : getRandomStr(length);
+}
+export function getRandomItem(items) {
+    return items[Math.floor(Math.random() * items.length)];
+}
+/**
+ * Summarize elements of the given array
+ *
+ * @param values
+ * @return number | string - a summary of all the numbers in the array or an empty string if
+ * there was only NaNs
+ */
+export function sumArray(values) {
+    if (values.every((value) => isNaN(value))) {
+        return "";
+    }
+    else {
+        return values.reduce((sum, curr) => {
+            const value = Number(curr);
+            if (!isNaN(value)) {
+                return sum + value;
+            }
+            else {
+                return sum;
+            }
+        }, 0);
+    }
 }
-function fireEvent(eventName, element, delay = 0) {
-  setTimeout(() => {
-    if (isString(element)) {
-      element = document.querySelector(element);
+/**
+ * Returns an array of the object keys which values are not present in filter
+ *
+ * @param obj
+ * @param values
+ */
+export function filterObjectKeysByValues(obj, values) {
+    values = Array.isArray(values) ? values : Array(values);
+    const keys = [];
+    for (const key in obj) {
+        if (!values.includes(obj[key])) {
+            keys.push(key);
+        }
     }
-    if (!isNullOrUndef(element)) {
-      element.dispatchEvent(
-        new Event(eventName, {
-          bubbles: true
-        })
-      );
+    return keys;
+}
+export function getFromObject(object, key) {
+    return key.split(".").reduce((a, b) => {
+        return a[b];
+    }, object);
+}
+export function fireBlurEvent(element, delay = 0) {
+    fireEvent("blur", element, delay);
+}
+export function fireInputEvent(element, delay = 0) {
+    fireEvent("input", element, delay);
+}
+export function fireEvent(eventName, element, delay = 0) {
+    setTimeout(() => {
+        const target = isString(element)
+            ? document.querySelector(element)
+            : element;
+        if (target) {
+            target.dispatchEvent(new Event(eventName, { bubbles: true }));
+        }
+    }, delay);
+}
+export function hasObjectChanged(oldObj, values, checkNewKeys = false) {
+    const newMap = new Map(values);
+    // check keys from old
+    for (const key of Object.keys(oldObj)) {
+        let oldVal = oldObj[key];
+        let newVal = newMap.get(key);
+        if (isObject(oldVal)) {
+            if (!isObject(newVal))
+                return true;
+            if (hasObjectChanged(oldVal, Object.entries(newVal), checkNewKeys))
+                return true;
+            continue;
+        }
+        if (Array.isArray(oldVal) || Array.isArray(newVal)) {
+            const oldArr = Array.isArray(oldVal) ? oldVal : [];
+            const newArr = Array.isArray(newVal) ? newVal : [];
+            if (arrayDiff(newArr, oldArr).length > 0)
+                return true;
+            continue;
+        }
+        if (areDiff(newVal, oldVal))
+            return true;
     }
-  }, delay);
-}
-function hasObjectChanged(object, values) {
-  let hasChanged = false;
-  for (const key in object) {
-    let oldVal = object[key];
-    let [, newVal] = values.find(([newKey]) => key === newKey);
-    if (isObject(oldVal)) {
-      if (!isObject(newVal)) {
-        hasChanged = true;
-      } else {
-        hasChanged = hasObjectChanged(oldVal, Object.entries(newVal));
-      }
-    } else if (Array.isArray(newVal) || Array.isArray(oldVal)) {
-      newVal = Array.isArray(newVal) ? newVal : [];
-      oldVal = Array.isArray(oldVal) ? oldVal : [];
-      hasChanged = getObjectKeys(oldVal).length !== getObjectKeys(newVal).length;
-      if (!hasChanged) {
-        hasChanged = arrayDiff(newVal, oldVal).length > 0;
-      }
-    } else {
-      hasChanged = areDiff(newVal, oldVal);
+    // optional: check keys that exist only in new
+    if (checkNewKeys) {
+        for (const key of newMap.keys()) {
+            if (!(key in oldObj))
+                return true;
+        }
     }
-    if (hasChanged) {
-      break;
+    return false;
+}
+export function roundBigNum(number) {
+    const digitsNum = Math.trunc(number).toString().length;
+    let roundTo = 0;
+    switch (true) {
+        case digitsNum > 2 && digitsNum < 5:
+            roundTo = 100;
+            break;
+        case digitsNum >= 5:
+            roundTo = 10000;
+            break;
     }
-  }
-  return hasChanged;
-}
-function roundBigNum(number) {
-  const digitsNum = Math.trunc(number).toString().length;
-  let roundTo = 0;
-  switch (true) {
-    case (digitsNum > 2 && digitsNum < 5):
-      roundTo = 100;
-      break;
-    case digitsNum >= 5:
-      roundTo = 1e4;
-      break;
-  }
-  return roundTo ? Math.round(number / roundTo) * roundTo : number;
-}
-function extractNumbers(value) {
-  if (!isStr(value) && !isNum(value)) {
-    return "";
-  }
-  return value.toString().replace(/[^0-9]/g, "");
-}
-function removeSpaces(value) {
-  if (!isStr(value) && !isNum(value)) {
-    return "";
-  }
-  return value.toString().replace(/\s/g, "");
-}
-function roundUp(num, precision) {
-  const multiplier = Number("1".padEnd(precision + 1, "0"));
-  return Math.ceil(num * multiplier) / multiplier;
-}
-function roundDown(num, precision) {
-  const multiplier = Number("1".padEnd(precision + 1, "0"));
-  return Math.floor(num * multiplier) / multiplier;
-}
-function areDiff(val1, val2, strict) {
-  if (strict) {
-    return val1 !== val2;
-  }
-  if (Boolean(val1) || Boolean(val2)) {
-    return val1 != val2;
-  }
-  return false;
-}
-function flattenObject(obj, prefix = "") {
-  return Object.keys(obj).reduce((acc, k) => {
-    const pre = prefix.length ? prefix + "." : "";
-    if ((isObject(obj[k]) || Array.isArray(obj[k])) && getObjectKeys(obj[k]).length > 0) {
-      Object.assign(acc, flattenObject(obj[k], pre + k));
-    } else {
-      acc[pre + k] = obj[k];
+    return roundTo ? Math.round(number / roundTo) * roundTo : number;
+}
+export function extractNumbers(value) {
+    if (!isString(value) && !isNum(value)) {
+        return "";
     }
-    return acc;
-  }, {});
-}
-function flattenObjectAsArray(obj) {
-  const result = {};
-  const flat = flattenObject(obj);
-  Object.keys(flat).forEach((key) => {
-    const newKey = key.replaceAll(/\.([^.]+)/g, "[$1]");
-    result[newKey] = flat[key];
-  });
-  return result;
-}
-function parseObjectPathStr(pathStr) {
-  const pathParts = pathStr.replace(/\[/g, ".").replace(/\]/g, "").split(".");
-  if (pathParts.length > 1 && pathParts[1].includes("[")) {
-    return [pathParts[0], ...parseObjectPathStr(pathParts[1])];
-  }
-  return pathParts;
-}
-function formatNumber(num, fractionDigits) {
-  fractionDigits = isNullOrUndef(fractionDigits) ? 2 : fractionDigits;
-  return new Intl.NumberFormat("ru-RU", {
-    style: "decimal",
-    minimumFractionDigits: fractionDigits,
-    maximumFractionDigits: fractionDigits
-  }).format(Number(num)).replace(",", ".").replace(/\u00A0/g, " ");
-}
-function formatNumberWithSign(num, fractionDigits) {
-  return formatWithSign(num, formatNumber(num, fractionDigits));
-}
-function formatPercent(num) {
-  return formatNumber(num) + "%";
-}
-function formatWithSign(num, numString) {
-  numString = numString ? numString : num.toString();
-  return (Number(num) < 0 ? "" : "+") + numString;
-}
-function autoSizeText(el, height, minFontSize, maxFontSize = 50) {
-  let attempts = 30;
-  const resizeText = () => {
-    if (getTextHeight() === 0) {
-      return;
+    return value.toString().replace(/[^0-9]/g, "");
+}
+export function removeSpaces(value) {
+    if (!isString(value) && !isNum(value)) {
+        return "";
     }
-    while (attempts && getTextHeight() > height) {
-      attempts--;
-      reduceText();
+    return value.toString().replace(/\s/g, "");
+}
+export function roundUp(num, precision) {
+    const multiplier = Number("1".padEnd(precision + 1, "0"));
+    return Math.ceil(num * multiplier) / multiplier;
+}
+export function roundDown(num, precision) {
+    const multiplier = Number("1".padEnd(precision + 1, "0"));
+    return Math.floor(num * multiplier) / multiplier;
+}
+export function areDiff(val1, val2, strict) {
+    if (strict) {
+        return val1 !== val2;
     }
-    while (attempts && getTextHeight() < height) {
-      attempts--;
-      enlargeText();
+    // at least one value is not empty
+    if (Boolean(val1) || Boolean(val2)) {
+        return val1 != val2;
     }
-  };
-  const reduceText = () => {
-    const fontSize = getNumericStyleProp("fontSize", el);
-    const newFontSize = fontSize - 1;
-    if (fontSize > 1 && newFontSize >= minFontSize) {
-      el.style.fontSize = `${newFontSize}px`;
+    // both empty, but not equally empty!
+    // each one may be one of: empty string, null or undefined
+    return false;
+}
+export function flattenObject(obj, prefix = "") {
+    const pre = prefix ? `${prefix}.` : "";
+    return Object.keys(obj).reduce((acc, k) => {
+        const val = obj[k];
+        const key = `${pre}${k}`;
+        if (isObject(val) || Array.isArray(val)) {
+            Object.assign(acc, flattenObject(val, key));
+        }
+        else {
+            acc[key] = val;
+        }
+        return acc;
+    }, {});
+}
+export function flattenObjectAsArray(obj) {
+    const flat = flattenObject(obj);
+    const result = {};
+    for (const key of Object.keys(flat)) {
+        const newKey = key.replace(/\.([^.]+)/g, "[$1]");
+        result[newKey] = flat[key];
     }
-  };
-  const enlargeText = () => {
-    const fontSize = getNumericStyleProp("fontSize", el);
-    const newFontSize = fontSize + 1;
-    if (newFontSize <= maxFontSize) {
-      el.style.fontSize = `${newFontSize}px`;
+    return result;
+}
+export function parseObjectPathStr(pathStr) {
+    const pathParts = pathStr.replace(/\[/g, ".").replace(/\]/g, "").split(".");
+    if (pathParts[0] && pathParts[1] && pathParts[1].includes("[")) {
+        return [pathParts[0], ...parseObjectPathStr(pathParts[1])];
     }
-  };
-  const getTextHeight = () => Math.floor(
-    el.scrollHeight - getNumericStyleProp("paddingTop", el) - getNumericStyleProp("paddingBottom", el)
-  );
-  resizeText();
-}
-
-exports.areDiff = areDiff;
-exports.arrayDiff = arrayDiff;
-exports.arrayIntersect = arrayIntersect;
-exports.autoSizeText = autoSizeText;
-exports.capitalize = capitalize;
-exports.countObjectInnerLength = countObjectInnerLength;
-exports.createHtmlElement = createHtmlElement;
-exports.createLinkElement = createLinkElement;
-exports.createPixelElement = createPixelElement;
-exports.createScriptElement = createScriptElement;
-exports.createStyleElement = createStyleElement;
-exports.createSvgElement = createSvgElement;
-exports.debounce = debounce;
-exports.decodeSafeURL = decodeSafeURL;
-exports.deepCloneObject = deepCloneObject;
-exports.encodeQueryString = encodeQueryString;
-exports.extractNumbers = extractNumbers;
-exports.filterObjectKeysByValues = filterObjectKeysByValues;
-exports.fireBlurEvent = fireBlurEvent;
-exports.fireEvent = fireEvent;
-exports.fireInputEvent = fireInputEvent;
-exports.flatHtmlAttributes = flatHtmlAttributes;
-exports.flattenObject = flattenObject;
-exports.flattenObjectAsArray = flattenObjectAsArray;
-exports.formatNumber = formatNumber;
-exports.formatNumberWithSign = formatNumberWithSign;
-exports.formatPercent = formatPercent;
-exports.formatWithSign = formatWithSign;
-exports.getFromObject = getFromObject;
-exports.getHtmlElement = getHtmlElement;
-exports.getNumericStyleProp = getNumericStyleProp;
-exports.getObjectKeys = getObjectKeys;
-exports.getRandomInt = getRandomInt;
-exports.getRandomItem = getRandomItem;
-exports.getRandomStr = getRandomStr;
-exports.getSafeURL = getSafeURL;
-exports.getScreenSize = getScreenSize;
-exports.hasObjectChanged = hasObjectChanged;
-exports.hashCode = hashCode;
-exports.injectScript = injectScript;
-exports.injectStyleLink = injectStyleLink;
-exports.insertCss = insertCss;
-exports.insertHtmlElements = insertHtmlElements;
-exports.insertJs = insertJs;
-exports.isBool = isBool;
-exports.isDefined = isDefined;
-exports.isElementVisible = isElementVisible;
-exports.isFn = isFn;
-exports.isHTMLElement = isHTMLElement;
-exports.isNotEmptyString = isNotEmptyString;
-exports.isNullOrUndef = isNullOrUndef;
-exports.isNum = isNum;
-exports.isObject = isObject;
-exports.isStr = isStr;
-exports.isString = isString;
-exports.isUndef = isUndef;
-exports.objectHasProp = objectHasProp;
-exports.objectToQueryString = objectToQueryString;
-exports.onDOMReady = onDOMReady;
-exports.parseObjectPathStr = parseObjectPathStr;
-exports.parseURL = parseURL;
-exports.removeSpaces = removeSpaces;
-exports.roundBigNum = roundBigNum;
-exports.roundDown = roundDown;
-exports.roundUp = roundUp;
-exports.sortByAlphabet = sortByAlphabet;
-exports.stringToHtmlElements = stringToHtmlElements;
-exports.sumArray = sumArray;
-exports.throttle = throttle;
-exports.toBinaryStr = toBinaryStr;
-exports.toCamelCase = toCamelCase;
-exports.toPercent = toPercent;
-exports.toSnakeCase = toSnakeCase;
-//# sourceMappingURL=index.js.map
+    return pathParts;
+}
+export function formatNumber(num, fractionDigits) {
+    fractionDigits = isNullOrUndef(fractionDigits) ? 2 : fractionDigits;
+    return new Intl.NumberFormat("ru-RU", {
+        style: "decimal",
+        minimumFractionDigits: fractionDigits,
+        maximumFractionDigits: fractionDigits,
+    })
+        .format(Number(num))
+        .replace(",", ".")
+        .replace(/\u00A0/g, " "); // charCode 160, White-space
+}
+export function formatNumberWithSign(num, fractionDigits) {
+    return formatWithSign(num, formatNumber(num, fractionDigits));
+}
+export function formatPercent(num) {
+    return formatNumber(num) + "%";
+}
+export function formatWithSign(num, numString) {
+    numString = numString ? numString : num.toString();
+    return (Number(num) < 0 ? "" : "+") + numString;
+}
+export function autoSizeText(el, height, minFontSize, maxFontSize = 50) {
+    let attempts = 30;
+    const resizeText = () => {
+        if (getTextHeight() === 0) {
+            return;
+        }
+        while (attempts && getTextHeight() > height) {
+            attempts--;
+            reduceText();
+        }
+        while (attempts && getTextHeight() < height) {
+            attempts--;
+            enlargeText();
+        }
+    };
+    const reduceText = () => {
+        const fontSize = getNumericStyleProp("fontSize", el);
+        const newFontSize = fontSize - 1;
+        if (fontSize > 1 && newFontSize >= minFontSize) {
+            el.style.fontSize = `${newFontSize}px`;
+        }
+    };
+    const enlargeText = () => {
+        const fontSize = getNumericStyleProp("fontSize", el);
+        const newFontSize = fontSize + 1;
+        if (newFontSize <= maxFontSize) {
+            el.style.fontSize = `${newFontSize}px`;
+        }
+    };
+    const getTextHeight = () => Math.floor(el.scrollHeight -
+        getNumericStyleProp("paddingTop", el) -
+        getNumericStyleProp("paddingBottom", el));
+    resizeText();
+}
+//# sourceMappingURL=index.js.map