@kwiz/common 1.0.1

package/dist/helpers/browser.js

@@ -0,0 +1,1200 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interval = exports.debounce = exports.addEventListeners = exports.ScriptEncode = exports.HTMLDecode = exports.HTMLEncode = exports.isIFrameAccessible = exports.isInsideIFrame = exports.createHtmlElement = exports.createStylesheet = exports.addStyleSheet = exports.delayAsync = exports.waitForAsync = exports.waitFor = exports.waitForWindowObject = exports.composePath = exports.setSelectOptionByIndex = exports.setSelectOptionByValue = exports.getSelectedOption = exports.getSelectOptionByIndex = exports.getSelectOptionByValue = exports.removeAttributeFromHTMLElements = exports.removeHTMLElement = exports.emptyHTMLElement = exports.isNode = exports.isElement = exports.getAnimationEndEventName = exports.getAnimationFlags = exports.getPageHidden = exports.computedStyleToInlineStyle = exports.cumulativeOffset = exports.getScrollbarWidth = exports.getScrollParent = exports.querySelectorAllMaintainOrder = exports.querySelectorAllFirstOrNull = exports.isElementVisible = exports.removeDOMChangedObserver = exports.registerDOMChangedObserver = exports.registerModernThemeChanged = exports.registerModernInplaceNavigationOnInit = exports.registerDocumentLoadComplete = exports.registerDOMContentLoadedListener = exports.HtmlTextContents = exports.elementFromHtml = exports.copyToClipboard = exports.copyTextToClipboard = exports.downloadFile = exports.saveFile = exports.addEventHandler = exports.triggerNativeEvent = void 0;
+exports.getUniqueElementId = exports.getLoadingOverlayHtml = exports.hideLoadingOverlay = exports.showLoadingOverlay = exports.loadModernFormsCSS = exports.findAcestor = exports.isChildOf = exports.DisableAnchorInterceptInHtml = exports.DisableAnchorIntercept = exports.DisableAnchorInterceptValue = exports.DisableAnchorInterceptAttribute = exports.registerUrlChanged = exports.getReactInstanceFromElement = exports.addStyleElement = exports.dispatchCustomEvent = exports.OnWindowResize = exports.throttle = void 0;
+const collections_base_1 = require("./collections.base");
+const images_1 = require("./images");
+const random_1 = require("./random");
+const strings_1 = require("./strings");
+const typecheckers_1 = require("./typecheckers");
+function triggerNativeEvent(ele, eventName) {
+    if ((0, typecheckers_1.isNullOrUndefined)(ele)) {
+        return;
+    }
+    if (!(0, typecheckers_1.isNullOrUndefined)(ele.fireEvent)) { // < IE9
+        ele.fireEvent('on' + eventName);
+    }
+    else {
+        // Different events have different event classes.
+        // If this switch statement can't map an eventName to an eventClass,
+        // the event firing is going to fail.
+        let eventClass = "Events";
+        switch (eventName) {
+            case "click": // Dispatching of 'click' appears to not work correctly in Safari. Use 'mousedown' or 'mouseup' instead.
+            case "mousedown":
+            case "mouseup":
+                eventClass = "MouseEvents";
+                break;
+            case "focus":
+            case "change":
+            case "blur":
+            case "select":
+                eventClass = "HTMLEvents";
+                break;
+            default:
+                eventClass = "CustomEvent";
+                break;
+        }
+        var evt = document.createEvent(eventClass);
+        evt.initEvent(eventName, true, true);
+        ele.dispatchEvent(evt);
+    }
+}
+exports.triggerNativeEvent = triggerNativeEvent;
+function addEventHandler(elm, event, handler) {
+    if ((0, typecheckers_1.isUndefined)(elm.addEventListener)) //IE8
+        elm.attachEvent("on" + event, handler);
+    else
+        elm.addEventListener(event, handler, false);
+}
+exports.addEventHandler = addEventHandler;
+/** prompts user to save/download a text file */
+function saveFile(fileName, fileData, type) {
+    //Issue 6003
+    let blobObject = new Blob([fileData], { type: `${type};charset=utf-8;` });
+    if (window.Blob && window.navigator["msSaveOrOpenBlob"]) {
+        //edge/IE        
+        window.navigator["msSaveOrOpenBlob"](blobObject, fileName);
+    }
+    else {
+        //Issue 6025
+        //var encodedUri = `data:${type};charset=utf-8,` + encodeURIComponent(fileData);
+        let link = document.getElementById('kwizcom_download_link_tmp');
+        if (link) {
+            link.remove();
+            link = null;
+        }
+        var url = URL.createObjectURL(blobObject);
+        if (!link) {
+            link = document.createElement("a");
+            link.style.position = "fixed";
+            link.style.top = "-200px";
+            link.download = fileName;
+            link.innerHTML = "Click Here to download";
+            DisableAnchorIntercept(link);
+            link.id = "kwizcom_download_link_tmp";
+            document.body.appendChild(link); // Required for FF
+            link.href = url;
+        }
+        window.setTimeout(() => {
+            link.click();
+        }, 200);
+    }
+}
+exports.saveFile = saveFile;
+/** force browser to download instead of opening a file */
+function downloadFile(url) {
+    var link = document.createElement('a');
+    link.href = url;
+    var parts = link.href.replace(/\\/g, "/").split('/');
+    var fileName = parts[parts.length - 1];
+    link.download = fileName;
+    DisableAnchorIntercept(link);
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+}
+exports.downloadFile = downloadFile;
+function copyTextToClipboard(text) {
+    var input = document.createElement("input");
+    input.value = text;
+    input.style.position = "absolute";
+    input.style.top = "-100px";
+    input.style.left = "-100px";
+    document.body.appendChild(input);
+    let copied = copyToClipboard(input);
+    input.remove();
+    return copied;
+}
+exports.copyTextToClipboard = copyTextToClipboard;
+/** copies the text of an element to the clipboard. if not supported by browser - will return false so caller must check and show
+ * a message to the user asking him to hit ctrl+c
+ */
+function copyToClipboard(el) {
+    // Copy textarea, pre, div, etc.
+    if (document.body.createTextRange) {
+        // IE 
+        var textRange = document.body.createTextRange();
+        textRange.moveToElementText(el);
+        textRange.select();
+        textRange.execCommand("Copy");
+        return true;
+    }
+    else if (window.getSelection && document.createRange) {
+        // non-IE
+        var editable = el.contentEditable; // Record contentEditable status of element
+        var readOnly = el.readOnly; // Record readOnly status of element
+        el.contentEditable = true; // iOS will only select text on non-form elements if contentEditable = true;
+        el.readOnly = false; // iOS will not select in a read only form element
+        var range = document.createRange();
+        range.selectNodeContents(el);
+        var sel = window.getSelection();
+        sel.removeAllRanges();
+        sel.addRange(range); // Does not work for Firefox if a textarea or input
+        if (el.nodeName === "TEXTAREA" || el.nodeName === "INPUT")
+            el.select(); // Firefox will only select a form element with select()
+        if (el.setSelectionRange && navigator.userAgent.match(/ipad|ipod|iphone/i))
+            el.setSelectionRange(0, 999999); // iOS only selects "form" elements with SelectionRange
+        el.contentEditable = editable; // Restore previous contentEditable status
+        el.readOnly = readOnly; // Restore previous readOnly status 
+        if (document.queryCommandSupported("copy")) {
+            var successful = document.execCommand('copy');
+            if (successful)
+                return true;
+            else
+                return false;
+        }
+        else {
+            if (!navigator.userAgent.match(/ipad|ipod|iphone|android|silk/i))
+                return false;
+        }
+    }
+    return false;
+}
+exports.copyToClipboard = copyToClipboard;
+/** wraps the html in a div element and returns it */
+function elementFromHtml(html) {
+    var d = document.createElement("div");
+    d.innerHTML = html;
+    return d;
+}
+exports.elementFromHtml = elementFromHtml;
+function HtmlTextContents(htmlElement) {
+    let innerText = ((0, typecheckers_1.isString)(htmlElement) ? elementFromHtml(htmlElement) : htmlElement).innerText;
+    return (0, strings_1.stripRichTextWhitespace)(innerText.replace(/\n/g, " ").replace(/ {2}/g, " "));
+}
+exports.HtmlTextContents = HtmlTextContents;
+function registerDOMContentLoadedListener(doc) {
+    return new Promise((resolve, reject) => {
+        doc = doc || document;
+        if ((0, typecheckers_1.isNullOrUndefined)(doc)) {
+            reject();
+            return;
+        }
+        if (!(0, typecheckers_1.isNullOrUndefined)(doc) && doc.readyState === "loading") {
+            doc.addEventListener("DOMContentLoaded", () => {
+                resolve();
+            });
+        }
+        else {
+            resolve();
+        }
+    });
+}
+exports.registerDOMContentLoadedListener = registerDOMContentLoadedListener;
+function registerDocumentLoadComplete(doc) {
+    return new Promise((resolve, reject) => {
+        doc = doc || document;
+        if ((0, typecheckers_1.isNullOrUndefined)(doc) || !(0, typecheckers_1.isFunction)(doc.addEventListener)) {
+            reject();
+            return;
+        }
+        if (doc.readyState === "complete") {
+            resolve();
+        }
+        else {
+            doc.addEventListener("readystatechange", () => {
+                if (doc.readyState === "complete") {
+                    resolve();
+                }
+            });
+        }
+    });
+}
+exports.registerDocumentLoadComplete = registerDocumentLoadComplete;
+/** on modern experience, using navagation does inplace-page update.
+ * document ready, and all windows events will not trigger and global objects will remain.
+ * our app loader will fire this event when the page does that navigation so we can hook up to be notified.
+ */
+function registerModernInplaceNavigationOnInit(handler) {
+    addEventHandler(document, "kwOnInit", handler);
+}
+exports.registerModernInplaceNavigationOnInit = registerModernInplaceNavigationOnInit;
+/** Triggers handler when theme changes on a modern page
+ * When the user changes the site's theme, or when navigating to a sub-site, or clicking back
+ * in the browser navigating back to parent site with different theme
+ */
+function registerModernThemeChanged(handler) {
+    addEventHandler(document, "kwOnThemeChanged", handler);
+}
+exports.registerModernThemeChanged = registerModernThemeChanged;
+let _DOMChangedObserverDefs = [];
+function _getDOMChangedObserverDef(ele) {
+    if (!isElement(ele)) {
+        return null;
+    }
+    let existingDef = _DOMChangedObserverDefs.filter((observer) => {
+        let observerEle = observer.ele;
+        return isElement(observerEle) && observerEle.isSameNode(ele);
+    })[0];
+    return existingDef;
+}
+function _getDomObserverCallbackInfo(callbackOrHandler) {
+    return {
+        handler: (0, typecheckers_1.isNullOrUndefined)(callbackOrHandler) ? null : (0, typecheckers_1.isFunction)(callbackOrHandler) ? callbackOrHandler : callbackOrHandler.handler,
+        key: (0, typecheckers_1.isNullOrUndefined)(callbackOrHandler) || (0, typecheckers_1.isFunction)(callbackOrHandler) ? null : callbackOrHandler.key
+    };
+}
+function registerDOMChangedObserver(callbackOrHandler, ele) {
+    let callbackInfo = _getDomObserverCallbackInfo(callbackOrHandler);
+    if (!(0, typecheckers_1.isFunction)(callbackInfo.handler)) {
+        return;
+    }
+    var win;
+    var doc;
+    if (ele) {
+        try {
+            doc = ele.ownerDocument;
+            win = doc.defaultView || doc.parentWindow;
+        }
+        catch (ex) {
+        }
+    }
+    else {
+        win = window;
+        doc = window && window.document;
+        ele = doc.body;
+    }
+    if ((0, typecheckers_1.isNullOrUndefined)(win) || (0, typecheckers_1.isNullOrUndefined)(doc)) {
+        return;
+    }
+    registerDOMContentLoadedListener(win.document).then(() => {
+        let existingDef = _getDOMChangedObserverDef(ele);
+        if (!(0, typecheckers_1.isNullOrUndefined)(existingDef)) {
+            let existingCallbackIndex = (0, typecheckers_1.isNullOrEmptyString)(callbackInfo.key) ? -1 : (0, collections_base_1.firstIndexOf)(existingDef.callbacks, cb => cb.key === callbackInfo.key);
+            if (existingCallbackIndex >= 0) {
+                //replace
+                existingDef.callbacks[existingCallbackIndex].handler = callbackInfo.handler;
+            }
+            else {
+                existingDef.callbacks.push(callbackInfo);
+            }
+            return;
+        }
+        let newDef = {
+            ele: ele,
+            callbacks: [callbackInfo]
+        };
+        let onDomChanged = debounce(() => {
+            if (!(0, typecheckers_1.isNullOrUndefined)(newDef) && !(0, typecheckers_1.isNullOrEmptyArray)(newDef.callbacks)) {
+                newDef.callbacks.forEach((c) => {
+                    try {
+                        c.handler();
+                    }
+                    catch (e) { }
+                });
+            }
+        }, 100);
+        if ("MutationObserver" in win) {
+            let observer = new win.MutationObserver((mutations) => {
+                let hasUpdates = mutations.some((mutation) => {
+                    return !!mutation.addedNodes && !!mutation.addedNodes.length
+                        || !!mutation.removedNodes && !!mutation.removedNodes.length;
+                });
+                if (hasUpdates) {
+                    onDomChanged();
+                }
+            });
+            observer.observe(ele, {
+                childList: true,
+                subtree: true,
+                attributes: false,
+                characterData: false
+            });
+            newDef.disconnect = () => {
+                observer.disconnect();
+                observer = null;
+            };
+        }
+        else {
+            let domEvents = ["DOMNodeInsertedIntoDocument", "DOMNodeRemovedFromDocument"];
+            domEvents.forEach((eventName) => {
+                newDef.ele.addEventListener(eventName, onDomChanged, false);
+            });
+            newDef.disconnect = () => {
+                domEvents.forEach((eventName) => {
+                    newDef.ele.removeEventListener(eventName, onDomChanged, false);
+                });
+            };
+        }
+        _DOMChangedObserverDefs.push(newDef);
+    });
+}
+exports.registerDOMChangedObserver = registerDOMChangedObserver;
+function removeDOMChangedObserver(callbackOrHandler, ele) {
+    let callbackInfo = _getDomObserverCallbackInfo(callbackOrHandler);
+    if (!(0, typecheckers_1.isFunction)(callbackInfo.handler) && (0, typecheckers_1.isNullOrEmptyString)(callbackInfo.key)) {
+        return; //need function or key to remove
+    }
+    var win;
+    var doc;
+    if (ele) {
+        try {
+            doc = ele.ownerDocument;
+            win = doc.defaultView || doc.parentWindow;
+        }
+        catch (ex) {
+        }
+    }
+    else {
+        win = window;
+        doc = window && window.document;
+        ele = doc.body;
+    }
+    if ((0, typecheckers_1.isNullOrUndefined)(win) || (0, typecheckers_1.isNullOrUndefined)(doc)) {
+        return;
+    }
+    registerDOMContentLoadedListener(win.document).then(() => {
+        let existingDef = _getDOMChangedObserverDef(ele);
+        if ((0, typecheckers_1.isNullOrUndefined)(existingDef) || !isElement(existingDef.ele)) {
+            return;
+        }
+        if (!(0, typecheckers_1.isNullOrEmptyString)(callbackInfo.key)) //find by key
+         {
+            existingDef.callbacks = existingDef.callbacks.filter((cb) => {
+                return cb.key !== callbackInfo.key;
+            });
+        }
+        else //find by handler - probably won't work for functions that are declared inline
+         {
+            existingDef.callbacks = existingDef.callbacks.filter((cb) => {
+                return (0, typecheckers_1.isNullOrEmptyString)(cb.key) && cb.handler !== callbackInfo.handler;
+            });
+        }
+        if (existingDef.callbacks.length === 0) {
+            existingDef.disconnect();
+            _DOMChangedObserverDefs = _DOMChangedObserverDefs.filter((def) => {
+                return def !== existingDef;
+            });
+        }
+    });
+}
+exports.removeDOMChangedObserver = removeDOMChangedObserver;
+function isElementVisible(ele) {
+    //must be a valid element
+    if (!isElement(ele) || !ele.getAttribute) {
+        return false;
+    }
+    try {
+        var doc = ele.ownerDocument;
+        var win = doc.defaultView || doc.parentWindow;
+        var computed = win.getComputedStyle(ele);
+        return !!(computed.display.toLowerCase() !== "none"
+            && computed.visibility.toLowerCase() !== "hidden"
+            && (ele.offsetWidth !== 0
+                || ele.offsetHeight !== 0
+                || ele.offsetParent !== null
+                || ele.getClientRects().length));
+    }
+    catch (ex) {
+    }
+    return false;
+}
+exports.isElementVisible = isElementVisible;
+function querySelectorAllFirstOrNull(selectors, maintainOrder = false) {
+    if ((0, typecheckers_1.isNullOrUndefined)(selectors)) {
+        return null;
+    }
+    if (maintainOrder) {
+        return (querySelectorAllMaintainOrder(selectors)[0] || null);
+    }
+    else {
+        var result = (0, typecheckers_1.isString)(selectors) && !(0, typecheckers_1.isNullOrEmptyString)(selectors) ? document.querySelectorAll(selectors)[0] :
+            Array.isArray(selectors) ? document.querySelectorAll(selectors.join(","))[0] : null;
+        return (result || null);
+    }
+}
+exports.querySelectorAllFirstOrNull = querySelectorAllFirstOrNull;
+function querySelectorAllMaintainOrder(selectors, parent) {
+    if ((0, typecheckers_1.isNullOrUndefined)(selectors)) {
+        return null;
+    }
+    var query;
+    if ((0, typecheckers_1.isString)(selectors) && !(0, typecheckers_1.isNullOrEmptyString)(selectors)) {
+        query = selectors.split(",");
+    }
+    if (Array.isArray(selectors)) {
+        query = selectors;
+    }
+    var eles = [];
+    parent = parent || document;
+    query.forEach((selector) => {
+        if ((0, typecheckers_1.isString)(selector) && !(0, typecheckers_1.isNullOrEmptyString)(selector)) {
+            var result = Array.prototype.slice.call(parent.querySelectorAll(selector));
+            eles = eles.concat(result);
+        }
+    });
+    return eles;
+}
+exports.querySelectorAllMaintainOrder = querySelectorAllMaintainOrder;
+function getScrollParent(node) {
+    if (node === null) {
+        return null;
+    }
+    if (node.scrollHeight > node.clientHeight) {
+        return node;
+    }
+    else {
+        return getScrollParent(node.parentNode);
+    }
+}
+exports.getScrollParent = getScrollParent;
+var _scrollbarWidth = -1;
+function getScrollbarWidth() {
+    if (_scrollbarWidth < 0) {
+        var outer = document.createElement("div");
+        outer.style.visibility = "hidden";
+        outer.style.width = "100px";
+        outer.style["msOverflowStyle"] = "scrollbar"; // needed for WinJS apps
+        document.body.appendChild(outer);
+        var widthNoScroll = outer.offsetWidth;
+        // force scrollbars
+        outer.style.overflow = "scroll";
+        // add innerdiv
+        var inner = document.createElement("div");
+        inner.style.width = "100%";
+        outer.appendChild(inner);
+        var widthWithScroll = inner.offsetWidth;
+        // remove divs
+        outer.parentNode.removeChild(outer);
+        _scrollbarWidth = widthNoScroll - widthWithScroll;
+    }
+    return _scrollbarWidth;
+}
+exports.getScrollbarWidth = getScrollbarWidth;
+function cumulativeOffset(element) {
+    var top = 0, left = 0;
+    do {
+        top += element.offsetTop || 0;
+        left += element.offsetLeft || 0;
+        element = element.offsetParent;
+    } while (element);
+    return {
+        top: top,
+        left: left
+    };
+}
+exports.cumulativeOffset = cumulativeOffset;
+function computedStyleToInlineStyle(elm, options = { recursive: true, removeClassNames: true }) {
+    if (!elm) {
+        return;
+    }
+    if (options.recursive && elm.children && elm.children.length) {
+        var children = Array.prototype.slice.call(elm.children);
+        children.forEach(child => {
+            computedStyleToInlineStyle(child, options);
+        });
+    }
+    var computedStyle = window.getComputedStyle(elm);
+    if (options.removeClassNames) {
+        elm.removeAttribute("class");
+    }
+    elm.setAttribute("style", computedStyle.cssText);
+}
+exports.computedStyleToInlineStyle = computedStyleToInlineStyle;
+function getPageHidden(document = window.document) {
+    var hiddenPropName;
+    if (typeof document.hidden !== "undefined") {
+        // Opera 12.10 and Firefox 18 and later support
+        hiddenPropName = "hidden";
+    }
+    else if (typeof document.msHidden !== "undefined") {
+        hiddenPropName = "msHidden";
+    }
+    else if (typeof document.webkitHidden !== "undefined") {
+        hiddenPropName = "webkitHidden";
+    }
+    return (0, typecheckers_1.isString)(hiddenPropName) ? document[hiddenPropName] : false;
+}
+exports.getPageHidden = getPageHidden;
+function getAnimationFlags() {
+    var isSupported = false, animationstring = 'animation', keyframeprefix = '', domPrefixes = 'Webkit Moz O ms Khtml'.split(' '), pfx = '', elem = document.createElement('div');
+    if (elem.style.animationName !== undefined) {
+        isSupported = true;
+    }
+    if (isSupported === false) {
+        for (var i = 0; i < domPrefixes.length; i++) {
+            if (elem.style[domPrefixes[i] + 'AnimationName'] !== undefined) {
+                pfx = domPrefixes[i];
+                animationstring = pfx + 'Animation';
+                keyframeprefix = '-' + pfx.toLowerCase() + '-';
+                isSupported = true;
+                break;
+            }
+        }
+    }
+    return {
+        supported: isSupported,
+        animationName: animationstring,
+        keyFramePrefix: keyframeprefix,
+        prefix: pfx
+    };
+}
+exports.getAnimationFlags = getAnimationFlags;
+function getAnimationEndEventName() {
+    var animations = {
+        "animation": "animationend",
+        "OAnimation": "oAnimationEnd",
+        "MozAnimation": "animationend",
+        "WebkitAnimation": "webkitAnimationEnd"
+    };
+    var flags = getAnimationFlags();
+    if (flags.supported) {
+        return animations[flags.animationName];
+    }
+}
+exports.getAnimationEndEventName = getAnimationEndEventName;
+function isElement(ele) {
+    return !(0, typecheckers_1.isNullOrUndefined)(ele) && (ele.nodeType === 1 || ele instanceof Element);
+}
+exports.isElement = isElement;
+function isNode(ele) {
+    return !(0, typecheckers_1.isNullOrUndefined)(ele) && ((ele.nodeName && ele.nodeType >= 1 && ele.nodeType <= 12) || ele instanceof Node);
+}
+exports.isNode = isNode;
+function _eleOrSelectorToElementArray(eleOrSelector) {
+    if ((0, typecheckers_1.isNullOrUndefined)(eleOrSelector)) {
+        return [];
+    }
+    var elements;
+    if ((0, typecheckers_1.isString)(eleOrSelector)) {
+        elements = Array.from(document.querySelectorAll(eleOrSelector));
+    }
+    else if (isElement(eleOrSelector)) {
+        elements = [eleOrSelector];
+    }
+    else if (Array.isArray(eleOrSelector)) {
+        elements = eleOrSelector;
+    }
+    else if (eleOrSelector.length
+        || (0, typecheckers_1.isFunction)(eleOrSelector.forEach)
+        || eleOrSelector instanceof NodeList) {
+        elements = Array.from(eleOrSelector);
+    }
+    return elements || [];
+}
+function emptyHTMLElement(eleOrSelector) {
+    var elements = _eleOrSelectorToElementArray(eleOrSelector);
+    elements.forEach((ele) => {
+        if (ele && isElement(ele) && ele.firstChild) {
+            while (ele.firstChild) {
+                try {
+                    ele.removeChild(ele.firstChild);
+                }
+                catch (ex) {
+                    break;
+                }
+            }
+        }
+    });
+}
+exports.emptyHTMLElement = emptyHTMLElement;
+function removeHTMLElement(eleOrSelector) {
+    var elements = _eleOrSelectorToElementArray(eleOrSelector);
+    elements.forEach((ele) => {
+        try {
+            var parent = ele.parentNode || ele.parentElement;
+            if (ele && isElement(ele) && parent && parent.removeChild) {
+                parent.removeChild(ele);
+            }
+        }
+        catch (ex) {
+        }
+    });
+}
+exports.removeHTMLElement = removeHTMLElement;
+function removeAttributeFromHTMLElements(eleOrSelector, attributeName) {
+    var elements = _eleOrSelectorToElementArray(eleOrSelector);
+    elements.forEach((elm) => {
+        try {
+            elm.removeAttribute(attributeName);
+        }
+        catch (ex) {
+        }
+    });
+}
+exports.removeAttributeFromHTMLElements = removeAttributeFromHTMLElements;
+function getSelectOptionByValue(selectElement, value) {
+    if ((0, typecheckers_1.isNullOrUndefined)(selectElement) || (0, typecheckers_1.isNullOrUndefined)(value)) {
+        return null;
+    }
+    var option = Array.from(selectElement.options).filter(o => {
+        return o.value === value.toString();
+    })[0];
+    return option;
+}
+exports.getSelectOptionByValue = getSelectOptionByValue;
+function getSelectOptionByIndex(selectElement, index) {
+    if ((0, typecheckers_1.isNullOrUndefined)(selectElement) || !(0, typecheckers_1.isNumeric)(index)) {
+        return null;
+    }
+    return selectElement.options[Number(index)];
+}
+exports.getSelectOptionByIndex = getSelectOptionByIndex;
+function getSelectedOption(selectElement) {
+    if ((0, typecheckers_1.isNullOrUndefined)(selectElement)) {
+        return null;
+    }
+    return selectElement.options[selectElement.selectedIndex] || Array.from(selectElement.options).filter((option) => {
+        return option.selected;
+    })[0];
+}
+exports.getSelectedOption = getSelectedOption;
+function setSelectOptionByValue(selectElement, value) {
+    var option = getSelectOptionByValue(selectElement, value);
+    if (option) {
+        option.selected = true;
+        return option;
+    }
+    return null;
+}
+exports.setSelectOptionByValue = setSelectOptionByValue;
+function setSelectOptionByIndex(selectElement, index) {
+    if ((0, typecheckers_1.isNullOrUndefined)(selectElement) || (0, typecheckers_1.isNumeric)(index)) {
+        return null;
+    }
+    var option = selectElement.options[Number(index)];
+    if (option) {
+        option.selected = true;
+        return option;
+    }
+    return null;
+}
+exports.setSelectOptionByIndex = setSelectOptionByIndex;
+function composePath(evt) {
+    var path = ((0, typecheckers_1.isFunction)(evt["composedPath"]) && evt["composedPath"]()) || evt.path, target = evt.target;
+    if (path !== null) {
+        // Safari doesn't include Window, and it should.
+        path = (path.indexOf(window) < 0) ? path.concat([window]) : path;
+        return path;
+    }
+    if (target === window) {
+        return [window];
+    }
+    function getParents(node, memo) {
+        memo = memo || [];
+        var parentNode = node.parentNode;
+        if (!parentNode) {
+            return memo;
+        }
+        else {
+            return getParents(parentNode, memo.concat([parentNode]));
+        }
+    }
+    return [target].concat(getParents(target)).concat([window]);
+}
+exports.composePath = composePath;
+/** timeouts after 10 seconds by default */
+function waitForWindowObject(typeFullName, windowOrParent, timeout = 10000) {
+    return waitFor(() => !(0, typecheckers_1.isTypeofFullNameNullOrUndefined)(typeFullName, windowOrParent), timeout);
+}
+exports.waitForWindowObject = waitForWindowObject;
+/** timeouts after 10 seconds by default */
+function waitFor(checker, timeout = 10000, intervalLength = 50) {
+    return new Promise((resolve, reject) => {
+        var timeoutId = null;
+        var max = Math.round(timeout / intervalLength);
+        var count = 0;
+        var exists = false;
+        var _retry = () => {
+            if (timeoutId) {
+                window.clearTimeout(timeoutId);
+            }
+            try {
+                exists = checker();
+            }
+            catch (ex) {
+                resolve(false);
+                return;
+            }
+            if (exists || count > max) {
+                resolve(exists);
+            }
+            else {
+                timeoutId = window.setTimeout(_retry, intervalLength);
+            }
+            count++;
+        };
+        _retry();
+    });
+}
+exports.waitFor = waitFor;
+/**
+ * Waits for an async check to return true or times out.
+ * @param checker           Async function that returns boolean result.
+ * @param timeout           The timeout in milliseconds. Defaults to 10000ms.
+ * @param intervalLength    The interval length in milliseconds to retry the checker function. Defaults to 50ms.
+ */
+function waitForAsync(checker, timeout = 10000, intervalLength = 50) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var max = Math.round(timeout / intervalLength);
+        var count = 0;
+        var exists = false;
+        for (var count = 0; count < max; count++) {
+            exists = yield checker();
+            if (exists) {
+                break;
+            }
+            yield delayAsync(intervalLength);
+        }
+        return exists;
+    });
+}
+exports.waitForAsync = waitForAsync;
+/**
+ * An async function that returns after a set delay.
+ * @param delay The delay in milliseconds. Defaults to 500ms.
+ */
+function delayAsync(delay = 500) {
+    return new Promise((resolve) => {
+        window.setTimeout(() => {
+            resolve(null);
+        }, delay);
+    });
+}
+exports.delayAsync = delayAsync;
+function addStyleSheet(options, doc) {
+    doc = doc || document;
+    var head = doc.head || doc.getElementsByTagName("head")[0];
+    if (head) {
+        var link = createStylesheet(options, doc);
+        head.appendChild(link);
+    }
+}
+exports.addStyleSheet = addStyleSheet;
+function createStylesheet(options, doc) {
+    doc = doc || document;
+    options = options || {};
+    options.properties = Object.assign({
+        type: "text/css",
+        rel: "stylesheet",
+    }, options.properties);
+    return createHtmlElement("link", options, doc);
+}
+exports.createStylesheet = createStylesheet;
+function createHtmlElement(tagName, options, doc) {
+    doc = doc || document;
+    var element = doc.createElement(tagName);
+    if (options) {
+        if (options.attributes) {
+            Object.keys(options.attributes).forEach((attribName) => {
+                var attribValue = options.attributes[attribName];
+                if (!(0, typecheckers_1.isNullOrUndefined)(attribValue)) {
+                    element.setAttribute(attribName, attribValue);
+                }
+            });
+        }
+        if (options.properties) {
+            var mergedProps = Object.assign(Object.assign({}, options.properties), {
+                style: options.style
+            });
+            Object.keys(mergedProps).forEach((propName) => {
+                var obj = mergedProps[propName];
+                if (!(0, typecheckers_1.isNullOrUndefined)(obj)) {
+                    if ((0, typecheckers_1.isString)(obj) || (0, typecheckers_1.isBoolean)(obj) || (0, typecheckers_1.isNumber)(obj)) {
+                        element[propName] = obj;
+                    }
+                    else {
+                        if (!element[propName]) {
+                            element[propName] = obj;
+                        }
+                        else {
+                            Object.keys(obj).forEach((objName) => {
+                                element[propName][objName] = obj[objName];
+                            });
+                        }
+                    }
+                }
+            });
+        }
+    }
+    return element;
+}
+exports.createHtmlElement = createHtmlElement;
+function isInsideIFrame(win) {
+    win = win || window;
+    try {
+        return win.parent.location !== win.location;
+    }
+    catch (ex) {
+        return true;
+    }
+}
+exports.isInsideIFrame = isInsideIFrame;
+function isIFrameAccessible(iframeEle) {
+    try {
+        var location = (iframeEle.contentWindow || iframeEle.contentDocument).location;
+        return location && location.origin ? true : false;
+    }
+    catch (ex) {
+        return false;
+    }
+}
+exports.isIFrameAccessible = isIFrameAccessible;
+function HTMLEncode(d) {
+    if ((0, typecheckers_1.isNullOrEmptyString)(d)) {
+        return "";
+    }
+    var tempString = String(d);
+    var result = [];
+    for (var index = 0; index < tempString.length; index++) {
+        var char = tempString.charAt(index);
+        switch (char) {
+            case "<":
+                result.push("&lt;");
+                break;
+            case ">":
+                result.push("&gt;");
+                break;
+            case "&":
+                result.push("&amp;");
+                break;
+            case '"':
+                result.push("&quot;");
+                break;
+            case "'":
+                result.push("&#39;");
+                break;
+            default:
+                result.push(char);
+        }
+    }
+    return result.join("");
+}
+exports.HTMLEncode = HTMLEncode;
+function HTMLDecode(a) {
+    if ((0, typecheckers_1.isNullOrEmptyString)(a)) {
+        return "";
+    }
+    var e = [/&lt;/g, /&gt;/g, /&quot;/g, /&#39;/g, /&#58;/g, /&#123;/g, /&#125;/g, /&amp;/g];
+    var f = ["<", ">", '"', "'", ":", "{", "}", "&"];
+    var d = [];
+    for (var c = 0; c < a.length; c++) {
+        var b = a.indexOf("&");
+        if (b !== -1) {
+            if (b > 0) {
+                d.push(a.substr(0, b));
+                a = a.substr(b);
+            }
+            a = a.replace(e[c], f[c]);
+        }
+        else {
+            break;
+        }
+    }
+    d.push(a);
+    return d.join("");
+}
+exports.HTMLDecode = HTMLDecode;
+function ScriptEncode(e) {
+    if (null === e || typeof e === "undefined")
+        return "";
+    for (var d = String(e), a = [], c = 0, g = d.length; c < g; c++) {
+        var b = d.charCodeAt(c);
+        if (b > 4095)
+            a.push("\\u" + b.toString(16).toUpperCase());
+        else if (b > 255)
+            a.push("\\u0" + b.toString(16).toUpperCase());
+        else if (b > 127)
+            a.push("\\u00" + b.toString(16).toUpperCase());
+        else {
+            var f = d.charAt(c);
+            switch (f) {
+                case "\n":
+                    a.push("\\n");
+                    break;
+                case "\r":
+                    a.push("\\r");
+                    break;
+                case '"':
+                    a.push("\\u0022");
+                    break;
+                case "%":
+                    a.push("\\u0025");
+                    break;
+                case "&":
+                    a.push("\\u0026");
+                    break;
+                case "'":
+                    a.push("\\u0027");
+                    break;
+                case "(":
+                    a.push("\\u0028");
+                    break;
+                case ")":
+                    a.push("\\u0029");
+                    break;
+                case "+":
+                    a.push("\\u002b");
+                    break;
+                case "/":
+                    a.push("\\u002f");
+                    break;
+                case "<":
+                    a.push("\\u003c");
+                    break;
+                case ">":
+                    a.push("\\u003e");
+                    break;
+                case "\\":
+                    a.push("\\\\");
+                    break;
+                default:
+                    a.push(f);
+            }
+        }
+    }
+    return a.join("");
+}
+exports.ScriptEncode = ScriptEncode;
+function addEventListeners(eles, events, listener, useCapture = false) {
+    if (!(0, typecheckers_1.isFunction)(listener)) {
+        return;
+    }
+    var eventNames;
+    if ((0, typecheckers_1.isString)(events)) {
+        eventNames = events.split(" ");
+    }
+    else if (Array.isArray(events)) {
+        eventNames = events;
+    }
+    if ((0, typecheckers_1.isNullOrEmptyArray)(eventNames)) {
+        return;
+    }
+    var elements = _eleOrSelectorToElementArray(eles);
+    if ((0, typecheckers_1.isNullOrEmptyArray)(elements)) {
+        return;
+    }
+    elements.forEach((ele) => {
+        if (isElement(ele) && (0, typecheckers_1.isFunction)(ele.addEventListener)) {
+            eventNames.forEach((eventName) => {
+                ele.addEventListener(eventName, listener, useCapture);
+            });
+        }
+    });
+}
+exports.addEventListeners = addEventListeners;
+/** defer calling this function multiple times within X time frame to execute only once after the last call */
+function debounce(callback, ms, thisArg = null) {
+    let timeoutId = null;
+    let func = (...args) => {
+        window.clearTimeout(timeoutId);
+        timeoutId = window.setTimeout(() => {
+            callback.apply(thisArg, args);
+        }, ms);
+    };
+    return func;
+}
+exports.debounce = debounce;
+/** call a funciton X number of times, on a specific interval. */
+function interval(callback, msBetweenCalls, numberOfTimesToCall, thisArg = null) {
+    for (let index = 1; index <= numberOfTimesToCall; index++)
+        window.setTimeout(() => { callback.apply(thisArg); }, msBetweenCalls * index);
+}
+exports.interval = interval;
+/** throttle repeated calls to callback, makes sure it is only called once per *wait* at most, but won't defer it for longer than that.
+ * Unlike debounce, which can end up waiting for 5 minutes if it is being called repeatedly.
+ */
+function throttle(callback, wait = 250, thisArg = null) {
+    let previous = 0;
+    let timeout = null;
+    let result;
+    let storedContext = thisArg;
+    let storedArgs;
+    const later = () => {
+        previous = Date.now();
+        timeout = null;
+        result = callback.apply(storedContext, storedArgs);
+        if (!timeout) {
+            storedArgs = [];
+        }
+    };
+    let wrapper = (...args) => {
+        const now = Date.now();
+        const remaining = wait - (now - previous);
+        storedArgs = args;
+        if (remaining <= 0 || remaining > wait) {
+            if (timeout) {
+                clearTimeout(timeout);
+                timeout = null;
+            }
+            previous = now;
+            result = callback.apply(storedContext, storedArgs);
+            if (!timeout) {
+                storedArgs = [];
+            }
+        }
+        else if (!timeout) {
+            timeout = window.setTimeout(later, remaining);
+        }
+        return result;
+    };
+    return wrapper;
+}
+exports.throttle = throttle;
+var _resizeHandlers = {};
+var _resizeRegistered = false;
+function _handleResize() {
+    Object.keys(_resizeHandlers).forEach(key => {
+        try {
+            _resizeHandlers[key]();
+        }
+        catch (e) { }
+    });
+}
+/** allows you to register, re-register or remove a resize handler without ending up with multiple registrations. */
+function OnWindowResize(handlerID, handler) {
+    if (!(0, typecheckers_1.isNullOrUndefined)(handler))
+        _resizeHandlers[handlerID] = handler;
+    else
+        delete _resizeHandlers[handlerID];
+    if (!_resizeRegistered) {
+        _resizeRegistered = true;
+        addEventHandler(window, "resize", debounce(_handleResize, 250));
+    }
+}
+exports.OnWindowResize = OnWindowResize;
+function dispatchCustomEvent(obj, eventName, params = { bubbles: false, cancelable: false, detail: null }) {
+    if ((0, typecheckers_1.isNullOrUndefined)(obj) || !(0, typecheckers_1.isFunction)(obj.dispatchEvent)) {
+        return;
+    }
+    params.bubbles = params.bubbles || false;
+    params.cancelable = params.cancelable || false;
+    params.detail = params.detail || null;
+    let event = null;
+    if ((0, typecheckers_1.isFunction)(window.CustomEvent)) {
+        event = new CustomEvent(eventName, params);
+    }
+    else {
+        event = document.createEvent('CustomEvent');
+        event.initCustomEvent(eventName, params.bubbles, params.cancelable, params.detail);
+    }
+    obj.dispatchEvent(event);
+}
+exports.dispatchCustomEvent = dispatchCustomEvent;
+function addStyleElement(cssText, id) {
+    var parent = document.head || document.getElementsByTagName("head")[0] || document;
+    let cssElm = !(0, typecheckers_1.isNullOrEmptyString)(id) ? document.getElementById(id) : null;
+    if (!cssElm) {
+        cssElm = document.createElement("style");
+        if (!(0, typecheckers_1.isNullOrEmptyString)(id))
+            cssElm.id = id;
+        parent.appendChild(cssElm);
+    }
+    cssElm.innerHTML = cssText;
+    return cssElm;
+}
+exports.addStyleElement = addStyleElement;
+function getReactInstanceFromElement(node) {
+    if (!(0, typecheckers_1.isNullOrUndefined)(node)) {
+        for (const key in node) {
+            if ((key).startsWith("__reactInternalInstance$") || key.startsWith("__reactFiber$")) {
+                return node[key];
+            }
+        }
+    }
+    return null;
+}
+exports.getReactInstanceFromElement = getReactInstanceFromElement;
+/** registers a listener to when the browser url changed */
+function registerUrlChanged(callback) {
+    let url = window.location.href;
+    window.setInterval(() => {
+        if (url !== window.location.href) {
+            url = window.location.href;
+            if ((0, typecheckers_1.isFunction)(callback)) {
+                callback();
+            }
+        }
+    }, 333);
+}
+exports.registerUrlChanged = registerUrlChanged;
+exports.DisableAnchorInterceptAttribute = "data-interception";
+exports.DisableAnchorInterceptValue = "off";
+function DisableAnchorIntercept(link) {
+    link.setAttribute(exports.DisableAnchorInterceptAttribute, exports.DisableAnchorInterceptValue);
+}
+exports.DisableAnchorIntercept = DisableAnchorIntercept;
+/** go over HTML and add  data-interception="off" to all <a> tags. */
+function DisableAnchorInterceptInHtml(html) {
+    return html.replace(/<a /g, `<a ${exports.DisableAnchorInterceptAttribute}="${exports.DisableAnchorInterceptValue}" `);
+}
+exports.DisableAnchorInterceptInHtml = DisableAnchorInterceptInHtml;
+function isChildOf(node, parent) {
+    let _parent = node && node.parentElement;
+    while (_parent) {
+        if (((0, typecheckers_1.isNullOrEmptyString)(parent.id) || _parent.id === parent.id)
+            && ((0, typecheckers_1.isNullOrEmptyString)(parent.class) || _parent.classList.contains(parent.class))
+            && ((0, typecheckers_1.isNullOrEmptyString)(parent.tagName) || _parent.tagName.toUpperCase() === parent.tagName.toUpperCase()))
+            return true;
+        _parent = _parent.parentElement;
+    }
+    return false;
+}
+exports.isChildOf = isChildOf;
+function findAcestor(ele, predicate) {
+    if (!isElement(ele) || !(0, typecheckers_1.isFunction)(predicate)) {
+        return null;
+    }
+    while (ele) {
+        if (predicate(ele)) {
+            return ele;
+        }
+        ele = ele.parentElement;
+    }
+    return null;
+}
+exports.findAcestor = findAcestor;
+function loadModernFormsCSS() {
+    let styleElm = document.getElementById('kw_modernui_css');
+    if (!styleElm) {
+        styleElm = document.createElement("link");
+        styleElm.id = "kw_modernui_css";
+        styleElm.rel = "stylesheet";
+        styleElm.href = "https://apps.kwizcom.com/products/modern/css/app.min.css";
+        document.head.appendChild(styleElm);
+    }
+}
+exports.loadModernFormsCSS = loadModernFormsCSS;
+function showLoadingOverlay(elm, options) {
+    loadModernFormsCSS();
+    let overlay = elm.querySelector('.kw-loading-overlay');
+    if (!overlay) {
+        overlay = document.createElement("div");
+        overlay.className = "kw-loading-overlay kw-fixedCenter kw-absoluteFull";
+        elm.appendChild(overlay);
+    }
+    overlay.innerHTML = options && options.innerHtml || `<img src="${images_1.LOGO_ANIM}" style="max-width: 30%;max-height: 30%;">`;
+    overlay.style.backgroundColor = options && options.bgColor || "white";
+}
+exports.showLoadingOverlay = showLoadingOverlay;
+function hideLoadingOverlay(elm) {
+    if (isElement(elm)) {
+        let overlays = Array.from(elm.querySelectorAll('.kw-loading-overlay'));
+        removeHTMLElement(overlays);
+    }
+}
+exports.hideLoadingOverlay = hideLoadingOverlay;
+function getLoadingOverlayHtml(options) {
+    loadModernFormsCSS();
+    let overlay = document.createElement("div");
+    overlay.className = "kw-loading-overlay kw-fixedCenter kw-absoluteFull";
+    overlay.innerHTML = options && options.innerHtml || `<img src="${images_1.LOGO_ANIM}" style="max-width: 30%;max-height: 30%;">`;
+    overlay.style.backgroundColor = options && options.bgColor || "white";
+    return overlay.outerHTML;
+}
+exports.getLoadingOverlayHtml = getLoadingOverlayHtml;
+function getUniqueElementId(id = "") {
+    return `${id}${(0, random_1.getUniqueId)()}`;
+}
+exports.getUniqueElementId = getUniqueElementId;
+//# sourceMappingURL=browser.js.map