Faris Handy Webdev JavaScript functions

A bunch of useful JavaScript functions
当前为 2018-10-14 提交的版本，查看最新版本。
换行
// ==UserScript==
// @name         Faris Handy Webdev JavaScript functions
// @namespace    http://tampermonkey.net/
// @version      0.3
// @description  A bunch of useful JavaScript functions
// @description  This is not a regular script for you to run! Only use this via the @require keyword.
// @author       Faris Hijazi
// @grant        GM_xmlhttpRequest
// @grant        GM_download
// @grant        GM_setValue
// @grant        GM_getValue
// @grant        GM_setClipboard
// @grant        unsafeWindow
// @grant        window.close
// @grant        window.focus
// @run-at		 document-start
// @include      *
// @require      https://greasemonkey.github.io/gm4-polyfill/gm4-polyfill.js
// ==/UserScript==
 
/**/
if (typeof unsafeWindow === "undefined") unsafeWindow = window;
 
unsafeWindow.URL_REGEX_STR = `(//|http(s?:))[\\d\\w?%\\-_/\\\\=.]+?`;
unsafeWindow.IMAGE_URL_REGEX = new RegExp(`(//|http(s?:))[\\d\\w?%\\-_/\\\\=.]+?\\.(jpg|png|jpeg|gif|tiff|&f=1)`, 'gim');
// /(\/\/|http(s?:))[\d\w?%\-_\/\\=.]+?\.(jpg|png|jpeg|gif|tiff|&f=1)/gim;
unsafeWindow.VID_URL_REGEX = /(\/\/|http(s?:))[\d\w?%\-_\/\\=.]+?\.(mov|webm|mp4|wmv|&f=1)/gim;
 
var useEncryptedGoogle = /encrypted.google.com/.test(location.hostname);
var googleBaseURL = `https://${/google\./.test(location.hostname) ? location.hostname :
    ((useEncryptedGoogle ? "encrypted" : "www") + ".google.com")}`;
 
unsafeWindow.gImgSearchURL = `${googleBaseURL}/search?&hl=en&tbm=isch&q=`;
unsafeWindow.GIMG_REVERSE_SEARCH_URL = `${googleBaseURL}/searchbyimage?&image_url=`;
 
if (typeof GM_setClipboard !== 'undefined') {
    unsafeWindow.setClipboard = GM_setClipboard;
    unsafeWindow.GM_setClipboard = GM_setClipboard;
}
if (typeof GM_xmlhttpRequest !== 'undefined') {
    unsafeWindow.GM_xmlhttpRequest =
        /**
         * Description
         GM_xmlhttpRequest is a cross-origin version of XMLHttpRequest. The beauty of this function is that a user script can make requests that do not use the same-origin policy, creating opportunities for powerful mashups.
 
         Restrictions
         GM_xmlhttpRequest restricts access to the http, https, ftp, data, blob, and moz-blob protocols.
 
         If a script uses one or more @domains then the GM_xmlhttpRequest api will be restricted to those domains.
 
         If the url provided does not pass the above criteria then a error will be thrown when calling GM_xmlhttpRequest
 
         Arguments
         Object details
         A single object with properties defining the request behavior.
 
         String method: Optional. The HTTP method to utilize. Currently only "GET" and "POST" are supported. Defaults to "GET".
         String url: The URL to which the request will be sent. This value may be relative to the page the user script is running on.
         Function onload: Optional. A function called if the request finishes successfully. Passed a Scriptish response object (see below).
         Function onerror: Optional. A function called if the request fails. Passed a Scriptish response object (see below).
         Function onreadystatechange: Optional. A function called whenever the request's readyState changes. Passed a Scriptish response object (see below).
         String data: Optional. Content to send as the body of the request.
         Object headers: Optional. An object containing headers to be sent as part of the request.
         Boolean binary: Optional. Forces the request to send data as binary. Defaults to false.
         Boolean makePrivate: Optional. Forces the request to be a private request (same as initiated from a private window). (0.1.9+)
         Boolean mozBackgroundRequest: Optional. If true security dialogs will not be shown, and the request will fail. Defaults to true.
         String user: Optional. The user name to use for authentication purposes. Defaults to the empty string "".
         String password: Optional. The password to use for authentication purposes. Defaults to the empty string "".
         String overrideMimeType: Optional. Overrides the MIME type returned by the server.
         Boolean ignoreCache: Optional. Forces a request to the server, bypassing the cache. Defaults to false.
         Boolean ignoreRedirect: Optional. Forces the request to ignore both temporary and permanent redirects.
         Boolean ignoreTempRedirect: Optional. Forces the request to ignore only temporary redirects.
         Boolean ignorePermanentRedirect: Optional. Forces the request to ignore only permanent redirects.
         Boolean failOnRedirect: Optional. Forces the request to fail if a redirect occurs.
         Integer redirectionLimit: Optional. Range allowed: 0-10. Forces the request to fail if a certain number of redirects occur.
         Note: A redirectionLimit of 0 is equivalent to setting failOnRedirect to true.
         Note: If both are set, redirectionLimit will take priority over failOnRedirect.
 
         Note: When ignore*Redirect is set and a redirect is encountered the request will still succeed, and subsequently call onload. failOnRedirect or redirectionLimit exhaustion, however, will produce an error when encountering a redirect, and subsequently call onerror.
 
         Response Object
         This is the response object passed to the onload, onerror, and onreadystatechange callbacks described for the details object above.
 
         String responseText: The response to the request in text form.
         String responseJSON: If the content type is JSON (example: application/json, text/x-json, and more..) then responseJSON will be available.
         Integer readyState: The state of the request. Refer to https://developer.mozilla.org/en/XMLHttpRequest#Properties
         String responseHeaders: The string value of all response headers. null if no response has been received.
         Integer status: The HTTP status code from the server. null if the request hasn't yet completed, or resulted in an error.
         String statusText: The entire HTTP status response string from the server. null if the request hasn't yet completed, or resulted in an error.
         String finalUrl: The final URL used for the request. Takes redirects into account. null if the request hasn't yet completed, or resulted in an error.
         For "onprogress" only:
 
         Boolean lengthComputable: Whether it is currently possible to know the total size of the response.
         Integer loaded: The number of bytes loaded thus far.
         Integer total: The total size of the response.
         Returns
         */
        GM_xmlhttpRequest;
}
 
unsafeWindow.log = console.debug;
unsafeWindow.setLog = newDebugState => debug = (typeof newDebugState === "boolean") ? newDebugState : debug;
unsafeWindow.matchSite = matchSite;
unsafeWindow.createElement = createElement;
unsafeWindow.loadScript = loadScript;
unsafeWindow.Proxy = {
    fileStack: url => (`https://process.filestackapi.com/AhTgLagciQByzXpFGRI0Az/${encodeURIComponent(url.trim())}`),
    steemitimages: url => /\.(jpg|jpeg|tiff|png|gif)($|\?)/i.test(url) ? (`https://steemitimages.com/0x0/${url.trim()}`) : url,
    ddg: ddgProxy
};
unsafeWindow.ddgProxy = ddgProxy;
unsafeWindow.getOGZscalarUrl = getOGZscalarUrl;
unsafeWindow.reverseDdgProxy = reverseDdgProxy;
unsafeWindow.isDdgUrl = isDdgUrl;
unsafeWindow.targetIsInput = targetIsInput;
unsafeWindow.createAndAddAttribute = createAndAddAttribute;
unsafeWindow.getGImgReverseSearchURL = getGImgReverseSearchURL;
 
unsafeWindow.toDdgProxy = () => location.href = ddgProxy(location.href);
unsafeWindow.isIterable = obj => obj != null && typeof obj[Symbol.iterator] == 'function';
unsafeWindow.GM_setValue = GM_setValue;
unsafeWindow.GM_getValue = GM_getValue;
 
unsafeWindow.q = q;
unsafeWindow.qa = qa;
unsafeWindow.siteSearchUrl = siteSearchUrl;
unsafeWindow.getAbsoluteURI = getAbsoluteURI;
 
/**Returns the HOSTNAME of a website url*/
unsafeWindow.getHostname = getHostname;
/***/
unsafeWindow.openAllLinks = function () {
    Array.from(document.links).forEach(function (link) {
        if (link.hasAttribute("href")) {
            window.open(link.href);
        }
    });
};
 
/**Returns a DuckDuckGo proxy url (attempts to unblock the url)*/
function ddgProxy(href) {
    return isDdgUrl(href) || /^(javascript)/i.test(href) ? href : (`https://proxy.duckduckgo.com/iu/?u=${encodeURIComponent(href)}&f=1`);
}
 
/**Opens the url via fetch(), then performs a callback giving it the document element*/
unsafeWindow.fetchElement = fetchElement;
/**Opens the url via xmlhttpRequest, then performs a callback giving it the document element*/
unsafeWindow.xmlRequestElement = xmlRequestElement;
unsafeWindow.onLoadDim = onLoadDim;
unsafeWindow.addCss = addCss;
 
/**
 *	@author	https://codepen.io/frosas/
 *	Also works with scripts from other sites if they have CORS enabled (look for the header Access-Control-Allow-Origin: *).
 *
 *	// Usage
 *	var url = 'https://raw.githubusercontent.com/buzamahmooza/Helpful-Web-Userscripts/master/GM_dummy_functions.js?token=AZoN2Rl0UPDtcrOIgaESbGp_tuHy51Hmks5bpijqwA%3D%3D';
 *	loadGitHubScript(url).then((event) => {	});
 */
function loadGitHubScript(url) {
	return fetch(url).
		then(res => res.blob()).
		then(body => loadScript(URL.createObjectURL(body)));
	
	function loadScript(url) {
		new Promise(function(resolve, reject) {
		  var script = document.createElement('script');
		  script.src = url;
		  script.onload = resolve;
		  script.onerror = function(){
			  console.warn("couldn't load script: ", url);
			  if(typeof reject === 'function')
				  reject();
		  }; // TODO Not sure it really works
		  document.head.appendChild(script);
		});
	}
}
 
 
 
/**@deprecated doesn't actually succeed*/
unsafeWindow.addJs = function addJs(js, id) {
    const jsScript = document.createElement('script');
    jsScript.appendChild(document.createTextNode(js));
    if (!!id) jsScript.id = id;
    jsScript.classList.add('addJs');
    return document.getElementsByTagName('head')[0].appendChild(jsScript);
};
unsafeWindow.observe = observe;
unsafeWindow.gfycatPage2GifUrl = function (gfycatPageUrl) {
    if (!/https:\/\/gfycat\.com\/gifs\/detail\/.+/.test(gfycatPageUrl)) {
        throw error("Not a gfycat home url:" + gfycatPageUrl);
    }
    return `https://thumbs.gfycat.com/${gfycatPageUrl.split('/').pop()}-size_restricted.gif`;
};
unsafeWindow.preloader = preloader;
unsafeWindow.waitForElement = waitForElement;
unsafeWindow.includeJs = includeJs;
/**
 * Appends a style element to the head of the document containing the given cssStr text
 * @param cssStr
 * @param id
 * @return {HTMLStyleElement}
 */
function addCss(cssStr, id) {
    const style = document.createElement('style');
    if (style.styleSheet) {
        style.styleSheet.cssText = cssStr;
    } else {
        style.appendChild(document.createTextNode(cssStr));
    }
    if (!!id) style.id = id;
    style.classList.add('addCss');
    return document.getElementsByTagName('head')[0].appendChild(style);
}
unsafeWindow.disableStyles = disableStyles;
function disableStyles(enable) {
    console.log('Disabling styles');
    for (const styleEl of document.querySelectorAll('style, link')) {
        styleEl.disabled = !enable
    }
}
 
unsafeWindow.createAndGetNavbar = createAndGetNavbar;
/**
 * Creates a static navbar at the top of the page.
 * Useful for adding buttons and controls to it
 * @param callback  this callback should be used when instantly adding content to the navbar,
 *  do NOT just take the returned value and start adding elements.
 *  @return {HTMLDivElement} returns the parent navbar element
 */
function createAndGetNavbar(callback) {
    // Settings up the navbar
    // language=CSS
    addCss(`
        div#topnav {
            position: fixed;
            z-index: 1000;
            min-height: 50px;
            top: 0;
            right: 0;
            left: 0;
            background: #525252;
            font-size: 14px;
        }
 
        div#topnav-content {
            margin-left: 115px;
            padding: 10px;
            font-family: inherit;
            font-stretch: extra-condensed;
            font-size: 20px;
        }`, "navbar-css");
 
    function adjustTopMargin() {
        document.body.style.top = `${q('#topnav').offsetHeight}px`;
    }
 
    const navbar = document.createElement(`div`);
    navbar.id = "topnav";
    const navbarContentDiv = document.createElement('div');
    navbarContentDiv.id = "topnav-content";
 
    navbar.appendChild(navbarContentDiv);
 
    document.body.firstElementChild.before(navbar);
 
    window.addEventListener('resize', adjustTopMargin);
 
    document.body.style.position = "relative";
 
    // keep trying to use the callback, works when the navbarContentDiv is finally added
    var interval = setInterval(function () {
        const topnavContentDiv = q('#topnav-content');
        if (topnavContentDiv) {
            clearInterval(interval);
            if (callback)
                callback(topnavContentDiv);
            adjustTopMargin();
        }
    }, 100);
    return navbar;
}
 
 
unsafeWindow.setStyleInHTML = setStyleInHTML;
/**
 * This will set the style of an element by force, by manipulating the style HTML attribute.
 * This gives you more control, you can set the exact text you want in the HTML element (like giving a style priority via "!important").
 * Example calls:
 *  setStyleByHTML(el, "background-image", "url(http://www.example.com/cool.png)")
 *  setStyleByHTML(el, "{ background-image : url(http://www.example.com/cool.png) }")
 * @param {HTMLElement} el
 * @param {String} styleProperty
 * @param {String} styleValue
 * @return el
 */
function setStyleInHTML(el, styleProperty, styleValue) {
    styleProperty = styleProperty.trim().replace(/^.*{|}.*$/g, '');
 
    const split = styleProperty.split(':');
    if (!styleValue && split.length > 1) {
        styleValue = split.pop();
        styleProperty = split.pop();
    }
 
    if (el.hasAttribute('style')) {
        const styleText = el.getAttribute('style');
        const styleArgument = `${styleProperty}: ${styleValue};`;
 
        let newStyle = new RegExp(styleProperty, 'i').test(styleText) ?
            styleText.replace(new RegExp(`${styleProperty}:.+?;`, 'im'), styleArgument) :
            `${styleText} ${styleArgument}`;
 
        el.setAttribute('style', newStyle);
 
        console.debug(
            'adding to style ', `"${styleArgument}"`,
            '\nnewStyle:', `"${newStyle}"`,
            '\nelement:', el
        );
    }
    return el;
}
Math.clamp = function (a, min, max) {
    return a < min ? min :
        a > max ? max : a;
};
 
/**
 * @param targetElement
 * @param callback
 * @param options   mutationObserver options{ childList: boolean, subtree: boolean, attributes: boolean, characterData: boolean }
 * @returns the mutationObserver object
 */
function observe(targetElement, callback, options) {
    if (!targetElement) targetElement = document.body;
    if (!options) {
        options = {
            childList: true, subtree: true,
            attributes: false, characterData: false
        };
    }
    const mutationsHandler = function (mutations) {
        for (const mutation of mutations) {
            if (mutation.addedNodes.length) {
                callback(mutation.target);
            }
            callback();
        }
    };
    callback(targetElement);
    const mutationObserver = new MutationObserver(mutationsHandler);
    mutationObserver.observe(targetElement, options);
    return mutationObserver;
}
 
function getGImgReverseSearchURL(url) {
    // console.debug('gImgReverseSearchURL=', gImgReverseSearchURL);
    return url ? GIMG_REVERSE_SEARCH_URL + encodeURIComponent(url.trim()) : "";
}
 
unsafeWindow.nodeDepth = nodeDepth;
/**
 * returns the number of nodes between the child and parent
 * @param child
 * @param parent    the parent (direct or indirect) of the child element
 * @param currentDepth used for recursion only, do NOT modify it's value
 * @return {number}
 */
function nodeDepth(child, parent = document, currentDepth = 0) {
    if (!child || !parent) throw "Both the child and parent must non-null.";
    if (!parent.contains(child)) throw "The given parent does not contain the child.";
 
    currentDepth++;
    return child.parentNode == parent ?
        currentDepth :
        nodeDepth(child.parentNode, parent, currentDepth);
}
 
/**Returns the href wrapped with proxy.DuckDuckGo.com */
function reverseDdgProxy(href) {
    var s = href;
    if (isZscalarUrl(href)) s = getOGZscalarUrl(href); // extra functionality:
    if (isDdgUrl(href)) {
        s = new URL(location.href).searchParams.get('u');
    }
    // https://proxy.duckduckgo.com/iu/?u=
    if (s && s[0]) {
        return decodeURIComponent(s[0]);
    } else {
        console.log('Was unable to reverseDDGProxy for URL:', href);
        return s;
    }
}
 
unsafeWindow.regexBetween = function (precedingRegEx, betweenRegEx, proceedingRegEx, regexOptions) {
    return new RegExp(`(?<=(${precedingRegEx}))(${!betweenRegEx ? ".+?" : betweenRegEx})(?=(${proceedingRegEx}))`, regexOptions);
};
unsafeWindow.extend = typeof($) == 'undefined' ? null : $.extend;
 
function preloader(imgUrls) {
    console.log('imgs passed:', imgUrls);
    let imgObjs = [];
    // start preloading
    for (const url of imgUrls) {
        // create object
        let imageObj = new Image();
        imageObj.src = url;
        imageObj.onload = (function () {
            console.log('ImageLoaded:', this.src, this);
        });
        imgObjs.push(imageObj);
    }
}
 
// http://code.jquery.com/jquery.js
function includeJs(src) {
    const script = document.createElement('script');
    script.setAttribute('src', src);
    document.getElementsByTagName('head')[0].appendChild(script);
    return script;
}
 
//TODO: fix and test it
/**@WIP
 * @param {function} elementGetter a function to get the wanted element (or event a condition function)
 * that will be called to test if the element has appeared yet. (should return true only when the element appears)
 * @param callback  the elementGetter will be passed as the first argument
 * @return {MutationObserver}
 */
function waitForElement(elementGetter, callback) {
    const observer = new MutationObserver(function (mutations, me) {
        // mutations.forEach(function (mutation) {
        // if (!mutation.addedNodes) return false;
 
        function handleSuccess(node) {
            // console.debug('Wanted node found:', node);
            callback(node);
            me.disconnect();
        }
 
        // for (let i = 0; i < mutation.addedNodes.length; i++) {
        //     var node = mutation.addedNodes[i];
        var node = (typeof(elementGetter) === 'function') ? elementGetter() : q(elementGetter);
        try {
            if (node) {
                if (node.length !== undefined && node.length !== 0) {
                    for (const n of node)
                        handleSuccess(n);
                } else if (node.length === undefined) {
                    handleSuccess(node);
                }
            }
        } catch (e) {
            console.warn(e);
        }
        // }
        // });
    });
 
    observer.observe(document.body, {
        childList: true
        , subtree: true
        , attributes: false
        , characterData: false
    });
    return observer;
    // stop watching using: observer.disconnect();
}
 
/**
 * cross-browser wheel delta
 * Returns the mousewheel scroll delta as -1 (wheelUp) or 1 (wheelDown) (cross-browser support)
 * @param {MouseWheelEvent} wheelEvent
 * @return {number} -1 or 1
 */
unsafeWindow.getWheelDelta = function getWheelDelta(wheelEvent) {
    // cross-browser wheel delta
    wheelEvent = window.event || wheelEvent; // old IE support
    return Math.max(-1, Math.min(1, (wheelEvent.wheelDelta || -wheelEvent.detail)));
};
unsafeWindow.elementUnderMouse = function elementUnderMouse(wheelEvent) {
    return document.elementFromPoint(wheelEvent.clientX, wheelEvent.clientY);
};
 
/** Create an element by typing it's inner HTML.
 For example:   var myAnchor = createElement('<a href="https://example.com">Go to example.com</a>');
 * @param html
 * @param callback optional callback, invoked once the element is created, the element is passed.
 * @return {HTMLElement}
 */
function createElement(html, callback) {
    const div = document.createElement('div');
    div.innerHTML = (html).trim();
    const element = div.firstElementChild;
    if (!!callback && callback.call)
        callback.call(null, element);
 
    return element;
}
/* todo: remove, this thing is terrible and has no point */
function matchSite(siteRegex) {
    let result = location.href.match(siteRegex);
    if (!!result) console.debug("Site matched regex: " + siteRegex);
    return result;
}
function siteSearchUrl(query) {
    if (query) {
        return gImgSearchURL + "site:" + encodeURIComponent(query.trim());
    }
}
 
/**
 * removes all coded functionality to the element by removing it and reappending it's outerHTML
 */
function clearElementFunctions(element) {
    const outerHTML = element.outerHTML;
    element.after(createElement(outerHTML));
    element.remove();
}
unsafeWindow.clearElementFunctions = clearElementFunctions;
 
/**abbreviation for querySelectorAll()
 * @param selector
 * @param node
 * @return {set<HTMLElement>} */
function qa(selector, node = document) {
    return node.querySelectorAll(selector);
}
/**abbreviation for querySelector()
 * @param selector
 * @param node
 * @return {HTMLElement} */
function q(selector, node = document) {
    return node.querySelector(selector);
}
 
unsafeWindow.getIncrementedUrl = getIncrementedUrl;
/** Returns a modified url as a string, either incremented(++) or decremented(--)
 * @param {string} href  the input url you want to modify
 * @param {number} incrAmount (optional) the amount to increment.
 *  Default:  increment by 1 (++).
 *  If the result in the url becomes negative, it will be overridden to 0.
 * @return {string} incremented/decremented url string */
function getIncrementedUrl(href, incrAmount) {
    var e, s;
    let IB = incrAmount ? incrAmount : 1;
 
    function isDigit(c) {
        return ("0" <= c && c <= "9")
    }
    var match = href.match(/&f=1$/);
    var tip = !!match ? match[0] : "";
    let L = href.replace(tip, "");
    let LL = L.length;
    for (e = LL - 1; e >= 0; --e) if (isDigit(L.charAt(e))) {
        for (s = e - 1; s >= 0; --s) if (!isDigit(L.charAt(s))) break;
        break;
    }
    ++s;
    if (e < 0) return;
    let oldNum = L.substring(s, e + 1);
    let newNum = (parseInt(oldNum, 10) + IB);
    if (newNum < 0) newNum = 0;
    let newNumStr = "" + newNum;
    while (newNumStr.length < oldNum.length)
        newNumStr = "0" + newNumStr;
 
    return (L.substring(0, s) + "" + newNumStr + "" + L.slice(e + 1) + "" + tip);
}
 
unsafeWindow.printElementTextAttributes = printElementTextAttributes;
function printElementTextAttributes(el) {
    console.log(
        'innerText:', el.innerText,
        '\nOuterText:', el.outerHTML,
        '\nInnerHTML:', el.innerHTML,
        '\nouterHTML:', el.outerHTML
    );
}
function isZscalarUrl(zscalarUrl) {
    return /https:\/\/zscaler\.kfupm\.edu\.sa\/Default\.aspx\?url=/.test(zscalarUrl);
}
/**
 * @param zscalarUrl {string}
 * @returns {string} the original link that ZScalar is blocking
 */
function getOGZscalarUrl(zscalarUrl) {
    if (!isZscalarUrl(zscalarUrl)) {
        return zscalarUrl;
    } // not a zscalar url
    zscalarUrl = zscalarUrl.trim();
    let x = decodeURIComponent(('' + zscalarUrl).substring(46, zscalarUrl.indexOf('&referer')));
    // let x = decodeURIComponent(('' + zscalarUrl).substring(46, zscalarUrl.indexOf('&referer')));
    console.debug('Extracted ZScalar original link:', x);
    return x;
}
 
/*function loadScript(url, callback) {
    let script = document.createElement("script");
    script.type = "text/javascript";
    if (script.readyState) { //IE
        script.onreadystatechange = function () {
            if (script.readyState === "loaded" ||
                script.readyState === "complete") {
                script.onreadystatechange = null;
                callback();
            }
        };
    } else { //Others
        script.onload = function () {
            callback();
        };
    }
    script.src = url;
    document.getElementsByTagName("head")[0].appendChild(script);
}*/
function loadScript(url, callback, type) {
    if (!callback) callback = () => console.log('Script laoded:', url);
    // Adding the script tag to the head as suggested before
    var head = document.getElementsByTagName('head')[0];
    var script = document.createElement('script');
    if (!type) type = 'text/javascript';
    script.type = type;
    script.src = url;
 
    // Then bind the event to the callback function.
    // There are several events for cross browser compatibility.
    script.onreadystatechange = callback;
    script.onload = callback;
 
    // Fire the loading
    head.appendChild(script);
    return script;
}
 
unsafeWindow.loadModule = loadModule;
unsafeWindow.getElementsWithText = getElementsWithText;
window.document.getElementsWithText = getElementsWithText;
/**
 * Iterates through all HTMLElements and returns the ones that contains innerText matching the given regex/substr
 * @param textRegex
 * @param preliminarySelector   a node selector to narrow down the search from the start
 * @return {[]}
 */
function getElementsWithText(textRegex, preliminarySelector) {
    if (!textRegex) {
        console.error('must have an input value');
        return;
    }
    const matchingEls = [];
    const useSubstring = (typeof textRegex === 'string');
    function elementContainsText(element, regex) {
        return !(regex && element && element.innerText) ? false :
            (useSubstring ? element.innerText.indexOf(regex) > -1 : element.innerText.match(textRegex));
    }
 
    for (const el of document.querySelectorAll(preliminarySelector || '*')) {
        if (elementContainsText(el, textRegex)) {
            var nothingContainsEl = true;
            for (var i = 0; i < matchingEls.length; i++)
                if (matchingEls[i] && matchingEls[i].contains(el) && !Object.is(matchingEls[i], el)) {
                    matchingEls[i] = null; // that old parentEl is now gone, we only want the deepest node
                    nothingContainsEl = false;
                }
            matchingEls.push(el);
        }
    }
    return matchingEls.filter(el => el != null);
}
 
function loadModule(url, callback) {
    return loadScript(url, callback, 'module');
}
/**
 * Creates and adds an attributeNode to the element (if the element doesn't have that attribute)
 * sets the attribute value
 * @param node
 * @param attributeName
 * @param attributeValue
 */
function createAndAddAttribute(node, attributeName, attributeValue) {
    if (!node) {
        console.error('Node is null, cannot add attribute.');
        return;
    }
 
    if (!node.hasAttribute(attributeName)) {
        var attr = document.createAttribute(attributeName);
        attr.value = attributeValue;
        node.setAttributeNode(attr);
    }
    if (!!attributeValue) {
        node.setAttribute(attributeName, attributeValue);
    }
}
 
/** Deal with relative URIs (URIs starting with "/" or "//") */
function getAbsoluteURI(inputUrl) {
    let reconstructedUri = inputUrl
        .replace(new RegExp(`^//`), `${location.protocol}//`)        // If string starts with "//", replace with protocol
        .replace(new RegExp(`^/`), `${getHostname(location.href)}/`);// convert relative uri (precede with hostname if URI starts with "/")
 
    // add protocol if one is not found
    if (!/^https?/.test(reconstructedUri))
        reconstructedUri = `https://${reconstructedUri}`;
 
    return reconstructedUri;
}
 
/**
 * Returns true if the event target is an input element (such as a textfield).
 * This is useful when you want to remap letter keys only when you are not typing in a text field :)
 * @param event
 * @return {boolean}
 */
function targetIsInput(event) {
    const ignores = document.getElementsByTagName('input');
    const target = event.target;
    for (let ignore of ignores)
        if (target === ignore || ignore.contains(target)) {
            // console.log('The target recieving the keycode is of type "input", so it will not recieve your keystroke', target);
            return true;
        }
    return false;
}
 
/** Calls the callback function, passing to it the width and height: "callback(w, h)"
 * @param url
 * @param callback  callback(width, height, url, imgNode, args)
 * @param imgNode
 * @param args  gets passed to the callback
 */
function onLoadDim(url, callback, imgNode, args) {
    var img = new Image();
    if (!url) {
        console.warn('Url is invalid');
        return;
    }
    if (typeof url !== "string") {
        url = !!url.src ? url.src : url.href;
    }
 
    if (typeof callback === 'function') {
        img.addEventListener('load', function () {
            callback(this.naturalWidth, this.naturalHeight, url, imgNode, args);
        });
    } else {
        console.error('onLoad() callback passed should be of type "function".');
    }
    img.src = url;
}
 
/**@deprecated Opens the url via xmlhttpRequest, then performs a callback giving it the document element*/
function xmlRequestElement(url, callback) {
    if (typeof callback !== 'function') console.error("The callback is not a function", callback);
    const req = new XMLHttpRequest();
    req.open('GET', url);
    req.send();
    req.onreadystatechange = function () {
        if (req.readyState === req.DONE) {
            const pageHTML = req.responseText;
            const doc = document.createElement('html');
            doc.innerHTML = pageHTML;
 
            console.log('Recieved document for page ', url + ":", doc);
 
            callback(doc, url);
        }
    };
}
unsafeWindow.fetchDoc = fetchDoc;
function fetchDoc(url, callback) {
    fetch(url, {
            mode: 'no-cors',
            method: 'get'
        }
    ).then((res) => res.text())
        .then((text) => {
            var doc = document.createElement('html');
            doc.innerHTML = text;
            if (callback && typeof callback === 'function')
                callback(doc);
        });
}
/**Opens the url, then performs a callback giving it the document element
 * @param {string} url
 * @param {function} callback   passes: (doc, url, args) to the callback function when the response is complete
 * @param {o} args  Options object.
 *                  "args":   Arguments to pass to the callback (Array or Object type)
 * @returns returns the callback result
 */
function fetchElement(url, callback, args) {
    if (typeof callback !== 'function') console.error('Callback is not a function.!');
    fetch(url).then(
        response => response.text() // .json(), etc.
        // same as function(response) {return response.text();}
    ).then(function (html) {
            var doc = document.implementation.createHTMLDocument('');
            doc.open();
            doc.write(html);
            doc.close();
            try {
                return callback(doc, url, args);
            } catch (e) {
                console.error(e);
                return (html);
            }
        }
    );
}
 
function isDdgUrl(url) {
    return /^https:\/\/proxy\.duckduckgo\.com/.test(url);
}
 
function unicodeToChar(text) {
    return text.replace(/\\u[\dA-F]{4}/gim,
        match => String.fromCharCode(parseInt(match.replace(/\\u/g, ''), 16)));
}
 
 
// don't make public because it conflicts with DDGP Unblocker script
 
/** A class containing static functions to manipulate the srcset attribute */
unsafeWindow.SrcSet = class SrcSet {
    /**
     * @author https://github.com/sindresorhus/srcset/
     * @param arr
     * @return {*}
     */
    static deepUnique(arr) {
        return arr.sort().filter(function (el, i) {
            return JSON.stringify(el) !== JSON.stringify(arr[i - 1]);
        });
    }
    /**
     * @author https://github.com/sindresorhus/srcset/
     * @param str
     * @return {*}
     */
    static parse(str) {
        return this.deepUnique(str.split(',').map(function (el) {
            var ret = {};
 
            el.trim().split(/\s+/).forEach(function (el, i) {
                if (i === 0) {
                    return ret.url = el;
                }
 
                var value = el.substring(0, el.length - 1);
                var postfix = el[el.length - 1];
                var intVal = parseInt(value, 10);
                var floatVal = parseFloat(value);
 
                if (postfix === 'w' && /^[\d]+$/.test(value)) {
                    ret.width = intVal;
                } else if (postfix === 'h' && /^[\d]+$/.test(value)) {
                    ret.height = intVal;
                } else if (postfix === 'x' && !isNaN(floatVal)) {
                    ret.density = floatVal;
                } else {
                    throw new Error('Invalid srcset descriptor: ' + el + '.');
                }
            });
 
            return ret;
        }));
    }
    static stringify(arr) {
        return (arr.map(function (el) {
            if (!el.url) {
                throw new Error('URL is required.');
            }
 
            var ret = [el.url];
 
            if (el.width) {
                ret.push(el.width + 'w');
            }
 
            if (el.height) {
                ret.push(el.height + 'h');
            }
 
            if (el.density) {
                ret.push(el.density + 'x');
            }
 
            return ret.join(' ');
        })).join(', ');
    }
};
 
unsafeWindow.cookieUtils = {
	setCookie: function setCookie(name,value,days) {
		var expires = "";
		if (days) {
			var date = new Date();
			date.setTime(date.getTime() + (days*24*60*60*1000));
			expires = "; expires=" + date.toUTCString();
		}
		document.cookie = name + "=" + (value || "")  + expires + "; path=/";
		return document.cookie;
	},
	getCookie: function getCookie(name) {
		var nameEQ = name + "=";
		var ca = document.cookie.split(';');
		for(var i=0;i < ca.length;i++) {
			var c = ca[i];
			while (c.charAt(0)==' ') c = c.substring(1,c.length);
			if (c.indexOf(nameEQ) == 0) return c.substring(nameEQ.length,c.length);
		}
		return null;
	},
	eraseCookie: function eraseCookie(name) {   
		document.cookie = name+'=; Max-Age=-99999999;';
		return document.cookie;
	}
};
 
unsafeWindow.url2location = url2location;
/**
 * Retrieves an object with parsed URL data
 * @param url
 * @return  {
 * {port: string,
 * protocol: string,
 * href: string,
 * origin: string,
 * pathname: string,
 * hash: string,
 * search: string}
 * }
 */
function url2location(url) {
    const a = document.createElement("a");
    a.href = url;
    return {
        port: a.port,
        protocol: a.protocol,
        href: a.href,
        origin: a.origin,
        pathname: a.pathname,
        hash: a.hash,
        search: a.search
    }
}
/** @param href
 * @param keepPrefix    defaults to false
 *        www.example.com
 *        if true:      example.com
 *        if false:     www.example.com
 * @returns {string} Returns the hostname of the site URL */
function getHostname(href, keepPrefix) {
    const a = document.createElement("a");
    a.href = href;
    // if (keepPrefix) console.debug("getHostname href =", href);
    return a.hostname;
}
/** Inclomplete
 * @type {boolean} */
unsafeWindow.freezeGif = freezeGif;
function freezeGif(img, unfreeze) {
    function createElementAndCallback(type, callback) {
        const element = document.createElement(type);
        callback(element);
        return element;
    }
    var width = img.width,
        height = img.height,
        canvas = createElementAndCallback('canvas', function (clone) {
            clone.width = width;
            clone.height = height;
        }),
        attr,
        i = 0;
 
    var freeze = function () {
        canvas.getContext('2d').drawImage(img, 0, 0, width, height);
 
        for (i = 0; i < img.attributes.length; i++) {
            attr = img.attributes[i];
 
            if (attr.name !== '"') { // test for invalid attributes
                canvas.setAttribute(attr.name, attr.value);
            }
        }
        canvas.classList.add('freeze-gif');
        canvas.style.position = 'absolute';
 
        img.parentNode.insertBefore(canvas, img);
        img.style.visibility = 'hidden';
        // img.style.opacity = 0;
    };
 
    var unfreezeGif = function () {
        console.log('unfreezing', img);
        const freezeCanvas = img.closest('.freeze-gif');
 
        if (!freezeCanvas) {
            console.error('Couldn\'t find freezeCanvas while unfreezing this gif:', img);
        } else {
            freezeCanvas.style.visibility = 'hidden';
        }
        // img.style.opacity = 100;
        img.style.visibility = 'visible';
    };
 
    if (unfreeze) {
        unfreezeGif();
    } else {
        if (img.complete) {
            freeze();
        } else {
            img.addEventListener('load', freeze, true);
        }
    }
}
function getIframeDoc(iframe) {
    return iframe.contentDocument || iframe.contentWindow ? iframe.contentWindow.document : null;
}
 
unsafeWindow.removeClickListeners = removeClickListeners;
function removeClickListeners(selector) {
    if (!!unsafeWindow.$) {
        unsafeWindow.$(!selector ? "*" : selector)
            .unbind("click")
            .off("click")
            .removeAttr("onclick");
    } else {
        console.warn('unsafeWindow.$ is not defined');
    }
}
/**
 * @WIP TODO: Complete this function
 */
function removeEventListeners(eventTarget) {
    var eventType = "click";
    eventTarget = window;
 
    for (const eventType in window.getEventListeners(eventTarget)) {
        const eventListeners = getEventListeners(eventTarget);
        if (eventListeners.hasOwnProperty(eventType))
            for (const o of eventListeners[eventType]) {
                console.log('before:', o);
                o.listener = null;
                console.log('after:', o);
            }
    }
 
 
    // noinspection JSUnresolvedFunction
    let listeners = eventTarget.getEventListeners(eventTarget);
    listeners.forEach(function (listener) {
        console.log('removing listener:', listener);
        eventTarget.removeEventListener("click", listener, false);
    });
}
 
unsafeWindow.removeDoubleSpaces = removeDoubleSpaces;
unsafeWindow.cleanGibberish = cleanGibberish;
unsafeWindow.isBase64ImageData = isBase64ImageData;
unsafeWindow.cleanDates = cleanDates;
 
unsafeWindow.downloadScripts = function downloadScripts() {
    var scriptUrls = Array.from(document.querySelectorAll('script'))
        .map(script => script.src ? script.src : window.URL.createObjectURL(new Blob([script.innerHTML], {type: 'text/plain'}))
        );
    zipFiles(scriptUrls);
};
 
unsafeWindow.escapeEncodedChars = escapeEncodedChars;
/** Escapes Unicode chars, and anything starting with \x, \u,
 * @param text
 * @return {*} */
function escapeEncodedChars(text) {
    return text
        .replace(/\\[u][\dA-F]{4}/gim, match => String.fromCharCode(parseInt(match.replace(/\\u/g, ''), 16)))
        .replace(/\\[x][\dA-F]{2}/gim, match => String.fromCharCode(parseInt(match.replace(/\\x/g, ''), 16)));
}
/**
 * Returns true if the string is an image data string
 * @param str
 * @returns {boolean}
 */
function isBase64ImageData(str) {
    return /^data:image\/.{1,5};base64/.test(str);
}
function removeDoubleSpaces(str) {
    return !!str ? str.replace(/(\s{2,})/g, " ") : str;
}
 
function cleanDates(str) {
    return !!str ? removeDoubleSpaces(str.replace(/\d*\.([^.]+)\.\d*/g, ' ')) : str;
}
function cleanGibberish(str, minWgr, debug=false) {
    if (str) {
        const gibberishRegex = /(\W{2,})|(\d{3,})|(\d+\w{1,5}\d+){2,}/g;
        let noGibberish = removeDoubleSpaces(str.replace(gibberishRegex, " ")),
            /**
             * The minimum word2gibberish ratio to exit the loop
             * @type {number|*}
             */
            minWgr = 0.4 || minWgr;
        if (noGibberish.length < 3) return str;
        /**
         * WGR: Word to Gibberish Ratio (between 0 and 1)
         * 0:   No gibberish    (Good)
         * 1:   100% Gibberish  (Bad)
         * @type {number}
         */
        let wgr = (str.length - noGibberish.length) / str.length;
        if(debug) console.debug(
            'cleanGibberish(' + str + ')' +
            '\nOriginal:', str,
            '\nNoGibberish:', noGibberish,
            '\nRatio:', wgr
        );
 
        return wgr > minWgr ?
            cleanGibberish(noGibberish, minWgr) :
            (str.length > 3 ? str : "");
    }
    return "";
}
var getCssImage = (element) => !element ? null : element.style["background-image"].replace(/(['"]?\)$)|(^url\(["']?)/g, '');
unsafeWindow.getCssImages = () => Array.from(document.querySelectorAll('[style*="background-image"]')).map(getCssImage);
 
unsafeWindow.observeDocument = function observeDocument(callback, options) {
    callback(document.body);
    options = typeof(extend)!=='function'? {}: extend(options, {
        singleCallbackPerMutation: false
    });
    new MutationObserver(
        /** @param mutations */
        function mutationCallback(mutations) {
            for (const mutation of mutations) {
                if (!mutation.addedNodes.length)
                    continue;
                callback(mutation.target);
                if (options.singleCallbackPerMutation === true) {
                    break;
                }
            }
        }
    ).observe(document.body, {
            childList: true,
            subtree: true,
            attributes: true,
            characterData: false
        }
    );
};
unsafeWindow.observeIframe = function observeIframe(iframe, observerInit, observerOptions, args) {
    // older browsers don't get responsive iframe height, for now
    if (!window.MutationObserver) return;
    console.debug('Attaching an iframe observer...', iframe, '\n\n');
    var iframeObserver = new MutationObserver(function (mutations, observer) {
        console.debug(
            'Observed mutation in iframe:', iframe,
            '\nmutations:', mutations
        );
        observerInit(mutations, observer, args);
    });
 
    var interval = setInterval(function () {
        if (iframe.contentWindow && iframe.contentWindow.document) {
            iframeObserver.observe(iframe.contentWindow.document, observerOptions || {
                attributes: true,
                subtree: true,
                childList: true,
                characterData: true
            });
            console.log('Successfully added observer to iframe!', iframe);
 
            clearInterval(interval);
        }
    }, 100);
};
 
unsafeWindow.observeAllFrames = function observeAllFrames(callback) {
    callback(document.body);
    callback(document);
    let mutationObserver = new MutationObserver(function (mutations) {
        for (const mutation of mutations) {
            if (mutation.addedNodes.length) {
                callback(mutation.target);
            }
        }
    });
    const mutationOptions = {
        childList: true, subtree: true,
        attributes: true, characterData: true
    };
    mutationObserver.observe(document, mutationOptions);
    for (const iframe of document.querySelectorAll('iframe')) {
        callback(iframe.body);
        mutationObserver.observe(iframe, mutationOptions);
    }
};
 
/**
 * @param {function} condition
 * @param {function} action
 * @param {number} interval
 */
function waitFor(condition, action, interval) {
    if (typeof condition === 'undefined') {
        console.error('"condition" should be a function type:', condition);
        return false;
    }
    if (typeof action === 'undefined') {
        console.error('"condition" should be a function type:', action);
        return false;
    }
    if (!interval) interval = 50;
 
    var checkExist = setInterval(function () {
        if (condition) {
            console.log("Exists!");
            clearInterval(checkExist);
            action();
        }
    }, interval);
}
 
function downloadUsingXmlhttpRequest(url, opts) {
    var imgUrl = url || "http://static.jsbin.com/images/dave.min.svg?4.1.4";
    GM_xmlhttpRequest({
        method: 'GET',
        url: imgUrl,
        onload: function (respDetails) {
            var binResp = customBase64Encode(respDetails.responseText);
 
            /*-- Here, we just demo that we have a valid base64 encoding
                by inserting the image into the page.
                We could just as easily AJAX-off the data instead.
            */
            var zImgPara = document.createElement('p');
            var zTargetNode = document.querySelector("body *"); //1st child
 
            zImgPara.innerHTML = 'Image: <img src="data:image/png;base64,'
                + binResp + '">';
            zTargetNode.parentNode.insertBefore(zImgPara, zTargetNode);
        },
        overrideMimeType: 'text/plain; charset=x-user-defined'
    });
 
 
    function customBase64Encode(inputStr) {
        var
            bbLen = 3,
            enCharLen = 4,
            inpLen = inputStr.length,
            inx = 0,
            jnx,
            keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
                + "0123456789+/=",
            output = "",
            paddingBytes = 0;
        var
            bytebuffer = new Array(bbLen),
            encodedCharIndexes = new Array(enCharLen);
 
        while (inx < inpLen) {
            for (jnx = 0; jnx < bbLen; ++jnx) {
                /*--- Throw away high-order byte, as documented at:
                  https://developer.mozilla.org/En/Using_XMLHttpRequest#Handling_binary_data
                */
                if (inx < inpLen) {
                    bytebuffer[jnx] = inputStr.charCodeAt(inx++) & 0xff;
                } else {
                    bytebuffer[jnx] = 0;
                }
            }
 
            /*--- Get each encoded character, 6 bits at a time.
                index 0: first  6 bits
                index 1: second 6 bits
                            (2 least significant bits from inputStr byte 1
                             + 4 most significant bits from byte 2)
                index 2: third  6 bits
                            (4 least significant bits from inputStr byte 2
                             + 2 most significant bits from byte 3)
                index 3: forth  6 bits (6 least significant bits from inputStr byte 3)
            */
            encodedCharIndexes[0] = bytebuffer[0] >> 2;
            encodedCharIndexes[1] = ((bytebuffer[0] & 0x3) << 4) | (bytebuffer[1] >> 4);
            encodedCharIndexes[2] = ((bytebuffer[1] & 0x0f) << 2) | (bytebuffer[2] >> 6);
            encodedCharIndexes[3] = bytebuffer[2] & 0x3f;
 
            //--- Determine whether padding happened, and adjust accordingly.
            paddingBytes = inx - (inpLen - 1);
            switch (paddingBytes) {
                case 1:
                    // Set last character to padding char
                    encodedCharIndexes[3] = 64;
                    break;
                case 2:
                    // Set last 2 characters to padding char
                    encodedCharIndexes[3] = 64;
                    encodedCharIndexes[2] = 64;
                    break;
                default:
                    break; // No padding - proceed
            }
 
            /*--- Now grab each appropriate character out of our keystring,
                based on our index array and append it to the output string.
            */
            for (jnx = 0; jnx < enCharLen; ++jnx)
                output += keyStr.charAt(encodedCharIndexes[jnx]);
        }
        return output;
    }
}
 
unsafeWindow.iterateOverURLPattern = function iterateOverURLPattern(inputURL) {
    inputURL = inputURL || '';
 
    var bracketsContent = inputURL.match(/\[.+]/);
    if (bracketsContent.length)
        var [start, end] = bracketsContent[0].replace(/[\[\]]/g, '').split('-');
 
    console.debug(
        'text in brackets:', bracketsContent,
        '\nstart, end:', `["${start}", "${end}"]`
    );
 
    let urls = [];
    for (var i = start; i <= end; i++) {
        var newNum = "" + i;
        while (newNum.length < start.length) newNum = "0" + newNum;
        urls.push(inputURL.replace(/\[.+]/, newNum));
    }
    return urls;
};
 
/*
    CSS for top navbars:
 
.fixed-position {
    position: fixed;
    top: 0px;
    z-index: 16777271;
}
 
*/
 
 
/*global self */
 
/*jslint bitwise: true, indent: 4, laxbreak: true, laxcomma: true, smarttabs: true, plusplus: true */
/*! @source http://purl.eligrey.com/github/FileSaver.js/blob/master/src/FileSaver.js */
/* FileSaver.js
 * A saveAs() FileSaver implementation.
 * 1.3.8
 * 2018-03-22 14:03:47
 *
 * By Eli Grey, https://eligrey.com
 * License: MIT
 *   See https://github.com/eligrey/FileSaver.js/blob/master/LICENSE.md
 *
 */
// noinspection ThisExpressionReferencesGlobalObjectJS
var saveAs = saveAs || (function (view) {
    "use strict";
    // IE <10 is explicitly unsupported
    if (typeof view === "undefined" || typeof navigator !== "undefined" && /MSIE [1-9]\./.test(navigator.userAgent)) {
        return;
    }
    var
        doc = view.document
        // only get URL when necessary in case Blob.js hasn't overridden it yet
        ,
        get_URL = function () {
            return view.URL || view.webkitURL || view;
        },
        save_link = doc.createElementNS("http://www.w3.org/1999/xhtml", "a"),
        can_use_save_link = "download" in save_link,
        click = function (node) {
            var event = new MouseEvent("click");
            node.dispatchEvent(event);
        },
        is_safari = /constructor/i.test(view.HTMLElement) || view.safari,
        is_chrome_ios = /CriOS\/[\d]+/.test(navigator.userAgent),
        setImmediate = view.setImmediate || view.setTimeout,
        throw_outside = function (ex) {
            setImmediate(function () {
                throw ex;
            }, 0);
        },
        force_saveable_type = "application/octet-stream"
        // the Blob API is fundamentally broken as there is no "downloadfinished" event to subscribe to
        ,
        arbitrary_revoke_timeout = 1000 * 40 // in ms
        ,
        revoke = function (file) {
            var revoker = function () {
                if (typeof file === "string") { // file is an object URL
                    get_URL().revokeObjectURL(file);
                } else { // file is a File
                    file.remove();
                }
            };
            setTimeout(revoker, arbitrary_revoke_timeout);
        },
        dispatch = function (filesaver, event_types, event) {
            event_types = [].concat(event_types);
            var i = event_types.length;
            while (i--) {
                var listener = filesaver["on" + event_types[i]];
                if (typeof listener === "function") {
                    try {
                        listener.call(filesaver, event || filesaver);
                    } catch (ex) {
                        throw_outside(ex);
                    }
                }
            }
        },
        auto_bom = function (blob) {
            // prepend BOM for UTF-8 XML and text/* types (including HTML)
            // note: your browser will automatically convert UTF-16 U+FEFF to EF BB BF
            if (/^\s*(?:text\/\S*|application\/xml|\S*\/\S*\+xml)\s*;.*charset\s*=\s*utf-8/i.test(blob.type)) {
                return new Blob([String.fromCharCode(0xFEFF), blob], {
                    type: blob.type
                });
            }
            return blob;
        },
        FileSaver = function (blob, name, no_auto_bom) {
            if (!no_auto_bom) {
                blob = auto_bom(blob);
            }
            // First try a.download, then web filesystem, then object URLs
            var
                filesaver = this,
                type = blob.type,
                force = type === force_saveable_type,
                object_url, dispatch_all = function () {
                    dispatch(filesaver, "writestart progress write writeend".split(" "));
                }
                // on any filesys errors revert to saving with object URLs
                ,
                fs_error = function () {
                    if ((is_chrome_ios || (force && is_safari)) && view.FileReader) {
                        // Safari doesn't allow downloading of blob urls
                        var reader = new FileReader();
                        reader.onloadend = function () {
                            var url = is_chrome_ios ? reader.result : reader.result.replace(/^data:[^;]*;/, 'data:attachment/file;');
                            var popup = view.open(url, '_blank');
                            if (!popup) view.location.href = url;
                            url = undefined; // release reference before dispatching
                            filesaver.readyState = filesaver.DONE;
                            dispatch_all();
                        };
                        reader.readAsDataURL(blob);
                        filesaver.readyState = filesaver.INIT;
                        return;
                    }
                    // don't create more object URLs than needed
                    if (!object_url) {
                        object_url = get_URL().createObjectURL(blob);
                    }
                    if (force) {
                        view.location.href = object_url;
                    } else {
                        var opened = view.open(object_url, "_blank");
                        if (!opened) {
                            // Apple does not allow window.open, see https://developer.apple.com/library/safari/documentation/Tools/Conceptual/SafariExtensionGuide/WorkingwithWindowsandTabs/WorkingwithWindowsandTabs.html
                            view.location.href = object_url;
                        }
                    }
                    filesaver.readyState = filesaver.DONE;
                    dispatch_all();
                    revoke(object_url);
                };
            filesaver.readyState = filesaver.INIT;
 
            if (can_use_save_link) {
                object_url = get_URL().createObjectURL(blob);
                setImmediate(function () {
                    save_link.href = object_url;
                    save_link.download = name;
                    click(save_link);
                    dispatch_all();
                    revoke(object_url);
                    filesaver.readyState = filesaver.DONE;
                }, 0);
                return;
            }
 
            fs_error();
        },
        FS_proto = FileSaver.prototype,
        saveAs = function (blob, name, no_auto_bom) {
            return new FileSaver(blob, name || blob.name || "download", no_auto_bom);
        };
 
    // IE 10+ (native saveAs)
    if (typeof navigator !== "undefined" && navigator.msSaveOrOpenBlob) {
        return function (blob, name, no_auto_bom) {
            name = name || blob.name || "download";
 
            if (!no_auto_bom) {
                blob = auto_bom(blob);
            }
            return navigator.msSaveOrOpenBlob(blob, name);
        };
    }
 
    // todo: detect chrome extensions & packaged apps
    //save_link.target = "_blank";
 
    FS_proto.abort = function () {
    };
    FS_proto.readyState = FS_proto.INIT = 0;
    FS_proto.WRITING = 1;
    FS_proto.DONE = 2;
 
    FS_proto.error =
        FS_proto.onwritestart =
            FS_proto.onprogress =
                FS_proto.onwrite =
                    FS_proto.onabort =
                        FS_proto.onerror =
                            FS_proto.onwriteend =
                                null;
 
    return saveAs;
}(typeof self !== "undefined" && self || typeof window !== "undefined" && window || this));
/*`self` is undefined in Firefox for Android content script context
while `this` is nsIContentFrameMessageManager
with an attribute `content` that corresponds to the window*/
if (typeof module !== "undefined" && module.exports) {
    module.exports.saveAs = saveAs;
} else if ((typeof define !== "undefined" && define !== null) && (define.amd !== null)) {
    define([], function () {
        return saveAs;
    });
}
/*   Example:
 *   var blob = new Blob(["Hello, world!"], {type: "text/plain;charset=utf-8"});
 *   saveAs(blob, "hello world.txt");
 */
unsafeWindow.saveAs = saveAs;
 
 
/* mousetrap v1.6.2 craig.is/killing/mice */
/*global define:false */
/**
 * Copyright 2012-2017 Craig Campbell
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * Mousetrap is a simple keyboard shortcut library for Javascript with
 * no external dependencies
 *
 * @version 1.6.2
 * @url craig.is/killing/mice
 */
(function (window, document, undefined) {
 
    // Check if mousetrap is used inside browser, if not, return
    if (!window) {
        return;
    }
 
    /**
     * mapping of special keycodes to their corresponding keys
     *
     * everything in this dictionary cannot use keypress events
     * so it has to be here to map to the correct keycodes for
     * keyup/keydown events
     *
     * @type {Object}
     */
    var _MAP = {
        8: 'backspace',
        9: 'tab',
        13: 'enter',
        16: 'shift',
        17: 'ctrl',
        18: 'alt',
        20: 'capslock',
        27: 'esc',
        32: 'space',
        33: 'pageup',
        34: 'pagedown',
        35: 'end',
        36: 'home',
        37: 'left',
        38: 'up',
        39: 'right',
        40: 'down',
        45: 'ins',
        46: 'del',
        91: 'meta',
        93: 'meta',
        224: 'meta'
    };
 
    /**
     * mapping for special characters so they can support
     *
     * this dictionary is only used incase you want to bind a
     * keyup or keydown event to one of these keys
     *
     * @type {Object}
     */
    var _KEYCODE_MAP = {
        106: '*',
        107: '+',
        109: '-',
        110: '.',
        111: '/',
        186: ';',
        187: '=',
        188: ',',
        189: '-',
        190: '.',
        191: '/',
        192: '`',
        219: '[',
        220: '\\',
        221: ']',
        222: '\''
    };
 
    /**
     * this is a mapping of keys that require shift on a US keypad
     * back to the non shift equivelents
     *
     * this is so you can use keyup events with these keys
     *
     * note that this will only work reliably on US keyboards
     *
     * @type {Object}
     */
    var _SHIFT_MAP = {
        '~': '`',
        '!': '1',
        '@': '2',
        '#': '3',
        '$': '4',
        '%': '5',
        '^': '6',
        '&': '7',
        '*': '8',
        '(': '9',
        ')': '0',
        '_': '-',
        '+': '=',
        ':': ';',
        '\"': '\'',
        '<': ',',
        '>': '.',
        '?': '/',
        '|': '\\'
    };
 
    /**
     * this is a list of special strings you can use to map
     * to modifier keys when you specify your keyboard shortcuts
     *
     * @type {Object}
     */
    var _SPECIAL_ALIASES = {
        'option': 'alt',
        'command': 'meta',
        'return': 'enter',
        'escape': 'esc',
        'plus': '+',
        'mod': /Mac|iPod|iPhone|iPad/.test(navigator.platform) ? 'meta' : 'ctrl'
    };
 
    /**
     * variable to store the flipped version of _MAP from above
     * needed to check if we should use keypress or not when no action
     * is specified
     *
     * @type {Object|undefined}
     */
    var _REVERSE_MAP;
 
    /**
     * loop through the f keys, f1 to f19 and add them to the map
     * programatically
     */
    for (var i = 1; i < 20; ++i) {
        _MAP[111 + i] = 'f' + i;
    }
 
    /**
     * loop through to map numbers on the numeric keypad
     */
    for (i = 0; i <= 9; ++i) {
 
        // This needs to use a string cause otherwise since 0 is falsey
        // mousetrap will never fire for numpad 0 pressed as part of a keydown
        // event.
        //
        // @see https://github.com/ccampbell/mousetrap/pull/258
        _MAP[i + 96] = i.toString();
    }
 
    /**
     * cross browser add event method
     *
     * @param {Element|HTMLDocument} object
     * @param {string} type
     * @param {Function} callback
     * @returns void
     */
    function _addEvent(object, type, callback) {
        if (object.addEventListener) {
            object.addEventListener(type, callback, false);
            return;
        }
 
        try {
            object.attachEvent('on' + type, callback);
        } catch (e) {
            console.error(e);
        }
    }
 
    /**
     * takes the event and returns the key character
     *
     * @param {Event} e
     * @return {string}
     */
    function _characterFromEvent(e) {
 
        // for keypress events we should return the character as is
        if (e.type == 'keypress') {
            var character = String.fromCharCode(e.which);
 
            // if the shift key is not pressed then it is safe to assume
            // that we want the character to be lowercase.  this means if
            // you accidentally have caps lock on then your key bindings
            // will continue to work
            //
            // the only side effect that might not be desired is if you
            // bind something like 'A' cause you want to trigger an
            // event when capital A is pressed caps lock will no longer
            // trigger the event.  shift+a will though.
            if (!e.shiftKey) {
                character = character.toLowerCase();
            }
 
            return character;
        }
 
        // for non keypress events the special maps are needed
        if (_MAP[e.which]) {
            return _MAP[e.which];
        }
 
        if (_KEYCODE_MAP[e.which]) {
            return _KEYCODE_MAP[e.which];
        }
 
        // if it is not in the special map
 
        // with keydown and keyup events the character seems to always
        // come in as an uppercase character whether you are pressing shift
        // or not.  we should make sure it is always lowercase for comparisons
        return String.fromCharCode(e.which).toLowerCase();
    }
 
    /**
     * checks if two arrays are equal
     *
     * @param {Array} modifiers1
     * @param {Array} modifiers2
     * @returns {boolean}
     */
    function _modifiersMatch(modifiers1, modifiers2) {
        return modifiers1.sort().join(',') === modifiers2.sort().join(',');
    }
 
    /**
     * takes a key event and figures out what the modifiers are
     *
     * @param {Event} e
     * @returns {Array}
     */
    function _eventModifiers(e) {
        var modifiers = [];
 
        if (e.shiftKey) {
            modifiers.push('shift');
        }
 
        if (e.altKey) {
            modifiers.push('alt');
        }
 
        if (e.ctrlKey) {
            modifiers.push('ctrl');
        }
 
        if (e.metaKey) {
            modifiers.push('meta');
        }
 
        return modifiers;
    }
 
    /**
     * prevents default for this event
     *
     * @param {Event} e
     * @returns void
     */
    function _preventDefault(e) {
        if (e.preventDefault) {
            e.preventDefault();
            return;
        }
 
        e.returnValue = false;
    }
 
    /**
     * stops propogation for this event
     *
     * @param {Event} e
     * @returns void
     */
    function _stopPropagation(e) {
        if (e.stopPropagation) {
            e.stopPropagation();
            return;
        }
 
        e.cancelBubble = true;
    }
 
    /**
     * determines if the keycode specified is a modifier key or not
     *
     * @param {string} key
     * @returns {boolean}
     */
    function _isModifier(key) {
        return key == 'shift' || key == 'ctrl' || key == 'alt' || key == 'meta';
    }
 
    /**
     * reverses the map lookup so that we can look for specific keys
     * to see what can and can't use keypress
     *
     * @return {Object}
     */
    function _getReverseMap() {
        if (!_REVERSE_MAP) {
            _REVERSE_MAP = {};
            for (var key in _MAP) {
 
                // pull out the numeric keypad from here cause keypress should
                // be able to detect the keys from the character
                if (key > 95 && key < 112) {
                    continue;
                }
 
                if (_MAP.hasOwnProperty(key)) {
                    _REVERSE_MAP[_MAP[key]] = key;
                }
            }
        }
        return _REVERSE_MAP;
    }
 
    /**
     * picks the best action based on the key combination
     *
     * @param {string} key - character for key
     * @param {Array} modifiers
     * @param {string=} action passed in
     */
    function _pickBestAction(key, modifiers, action) {
 
        // if no action was picked in we should try to pick the one
        // that we think would work best for this key
        if (!action) {
            action = _getReverseMap()[key] ? 'keydown' : 'keypress';
        }
 
        // modifier keys don't work as expected with keypress,
        // switch to keydown
        if (action == 'keypress' && modifiers.length) {
            action = 'keydown';
        }
 
        return action;
    }
 
    /**
     * Converts from a string key combination to an array
     *
     * @param  {string} combination like "command+shift+l"
     * @return {Array}
     */
    function _keysFromString(combination) {
        if (combination === '+') {
            return ['+'];
        }
 
        combination = combination.replace(/\+{2}/g, '+plus');
        return combination.split('+');
    }
 
    /**
     * Gets info for a specific key combination
     *
     * @param  {string} combination key combination ("command+s" or "a" or "*")
     * @param  {string=} action
     * @returns {Object}
     */
    function _getKeyInfo(combination, action) {
        var keys;
        var key;
        var i;
        var modifiers = [];
 
        // take the keys from this pattern and figure out what the actual
        // pattern is all about
        keys = _keysFromString(combination);
 
        for (i = 0; i < keys.length; ++i) {
            key = keys[i];
 
            // normalize key names
            if (_SPECIAL_ALIASES[key]) {
                key = _SPECIAL_ALIASES[key];
            }
 
            // if this is not a keypress event then we should
            // be smart about using shift keys
            // this will only work for US keyboards however
            if (action && action != 'keypress' && _SHIFT_MAP[key]) {
                key = _SHIFT_MAP[key];
                modifiers.push('shift');
            }
 
            // if this key is a modifier then add it to the list of modifiers
            if (_isModifier(key)) {
                modifiers.push(key);
            }
        }
 
        // depending on what the key combination is
        // we will try to pick the best event for it
        action = _pickBestAction(key, modifiers, action);
 
        return {
            key: key,
            modifiers: modifiers,
            action: action
        };
    }
 
    function _belongsTo(element, ancestor) {
        if (element === null || element === document) {
            return false;
        }
 
        if (element === ancestor) {
            return true;
        }
 
        return _belongsTo(element.parentNode, ancestor);
    }
 
    function Mousetrap(targetElement) {
        var self = this;
 
        targetElement = targetElement || document;
 
        if (!(self instanceof Mousetrap)) {
            return new Mousetrap(targetElement);
        }
 
        /**
         * element to attach key events to
         *
         * @type {Element}
         */
        self.target = targetElement;
 
        /**
         * a list of all the callbacks setup via Mousetrap.bind()
         *
         * @type {Object}
         */
        self._callbacks = {};
 
        /**
         * direct map of string combinations to callbacks used for trigger()
         *
         * @type {Object}
         */
        self._directMap = {};
 
        /**
         * keeps track of what level each sequence is at since multiple
         * sequences can start out with the same sequence
         *
         * @type {Object}
         */
        var _sequenceLevels = {};
 
        /**
         * variable to store the setTimeout call
         *
         * @type {null|number}
         */
        var _resetTimer;
 
        /**
         * temporary state where we will ignore the next keyup
         *
         * @type {boolean|string}
         */
        var _ignoreNextKeyup = false;
 
        /**
         * temporary state where we will ignore the next keypress
         *
         * @type {boolean}
         */
        var _ignoreNextKeypress = false;
 
        /**
         * are we currently inside of a sequence?
         * type of action ("keyup" or "keydown" or "keypress") or false
         *
         * @type {boolean|string}
         */
        var _nextExpectedAction = false;
 
        /**
         * resets all sequence counters except for the ones passed in
         *
         * @param {Object} doNotReset
         * @returns void
         */
        function _resetSequences(doNotReset) {
            doNotReset = doNotReset || {};
 
            var activeSequences = false,
                key;
 
            for (key in _sequenceLevels) {
                if (doNotReset[key]) {
                    activeSequences = true;
                    continue;
                }
                _sequenceLevels[key] = 0;
            }
 
            if (!activeSequences) {
                _nextExpectedAction = false;
            }
        }
 
        /**
         * finds all callbacks that match based on the keycode, modifiers,
         * and action
         *
         * @param {string} character
         * @param {Array} modifiers
         * @param {Event|Object} e
         * @param {string=} sequenceName - name of the sequence we are looking for
         * @param {string=} combination
         * @param {number=} level
         * @returns {Array}
         */
        function _getMatches(character, modifiers, e, sequenceName, combination, level) {
            var i;
            var callback;
            var matches = [];
            var action = e.type;
 
            // if there are no events related to this keycode
            if (!self._callbacks[character]) {
                return [];
            }
 
            // if a modifier key is coming up on its own we should allow it
            if (action == 'keyup' && _isModifier(character)) {
                modifiers = [character];
            }
 
            // loop through all callbacks for the key that was pressed
            // and see if any of them match
            for (i = 0; i < self._callbacks[character].length; ++i) {
                callback = self._callbacks[character][i];
 
                // if a sequence name is not specified, but this is a sequence at
                // the wrong level then move onto the next match
                if (!sequenceName && callback.seq && _sequenceLevels[callback.seq] != callback.level) {
                    continue;
                }
 
                // if the action we are looking for doesn't match the action we got
                // then we should keep going
                if (action != callback.action) {
                    continue;
                }
 
                // if this is a keypress event and the meta key and control key
                // are not pressed that means that we need to only look at the
                // character, otherwise check the modifiers as well
                //
                // chrome will not fire a keypress if meta or control is down
                // safari will fire a keypress if meta or meta+shift is down
                // firefox will fire a keypress if meta or control is down
                if ((action == 'keypress' && !e.metaKey && !e.ctrlKey) || _modifiersMatch(modifiers, callback.modifiers)) {
 
                    // when you bind a combination or sequence a second time it
                    // should overwrite the first one.  if a sequenceName or
                    // combination is specified in this call it does just that
                    //
                    // @todo make deleting its own method?
                    var deleteCombo = !sequenceName && callback.combo == combination;
                    var deleteSequence = sequenceName && callback.seq == sequenceName && callback.level == level;
                    if (deleteCombo || deleteSequence) {
                        self._callbacks[character].splice(i, 1);
                    }
 
                    matches.push(callback);
                }
            }
 
            return matches;
        }
 
        /**
         * actually calls the callback function
         *
         * if your callback function returns false this will use the jquery
         * convention - prevent default and stop propogation on the event
         *
         * @param {Function} callback
         * @param {Event} e
         * @returns void
         */
        function _fireCallback(callback, e, combo, sequence) {
 
            // if this event should not happen stop here
            if (self.stopCallback(e, e.target || e.srcElement, combo, sequence)) {
                return;
            }
 
            if (callback(e, combo) === false) {
                _preventDefault(e);
                _stopPropagation(e);
            }
        }
 
        /**
         * handles a character key event
         *
         * @param {string} character
         * @param {Array} modifiers
         * @param {Event} e
         * @returns void
         */
        self._handleKey = function (character, modifiers, e) {
            var callbacks = _getMatches(character, modifiers, e);
            var i;
            var doNotReset = {};
            var maxLevel = 0;
            var processedSequenceCallback = false;
 
            // Calculate the maxLevel for sequences so we can only execute the longest callback sequence
            for (i = 0; i < callbacks.length; ++i) {
                if (callbacks[i].seq) {
                    maxLevel = Math.max(maxLevel, callbacks[i].level);
                }
            }
 
            // loop through matching callbacks for this key event
            for (i = 0; i < callbacks.length; ++i) {
 
                // fire for all sequence callbacks
                // this is because if for example you have multiple sequences
                // bound such as "g i" and "g t" they both need to fire the
                // callback for matching g cause otherwise you can only ever
                // match the first one
                if (callbacks[i].seq) {
 
                    // only fire callbacks for the maxLevel to prevent
                    // subsequences from also firing
                    //
                    // for example 'a option b' should not cause 'option b' to fire
                    // even though 'option b' is part of the other sequence
                    //
                    // any sequences that do not match here will be discarded
                    // below by the _resetSequences call
                    if (callbacks[i].level != maxLevel) {
                        continue;
                    }
 
                    processedSequenceCallback = true;
 
                    // keep a list of which sequences were matches for later
                    doNotReset[callbacks[i].seq] = 1;
                    _fireCallback(callbacks[i].callback, e, callbacks[i].combo, callbacks[i].seq);
                    continue;
                }
 
                // if there were no sequence matches but we are still here
                // that means this is a regular match so we should fire that
                if (!processedSequenceCallback) {
                    _fireCallback(callbacks[i].callback, e, callbacks[i].combo);
                }
            }
 
            // if the key you pressed matches the type of sequence without
            // being a modifier (ie "keyup" or "keypress") then we should
            // reset all sequences that were not matched by this event
            //
            // this is so, for example, if you have the sequence "h a t" and you
            // type "h e a r t" it does not match.  in this case the "e" will
            // cause the sequence to reset
            //
            // modifier keys are ignored because you can have a sequence
            // that contains modifiers such as "enter ctrl+space" and in most
            // cases the modifier key will be pressed before the next key
            //
            // also if you have a sequence such as "ctrl+b a" then pressing the
            // "b" key will trigger a "keypress" and a "keydown"
            //
            // the "keydown" is expected when there is a modifier, but the
            // "keypress" ends up matching the _nextExpectedAction since it occurs
            // after and that causes the sequence to reset
            //
            // we ignore keypresses in a sequence that directly follow a keydown
            // for the same character
            var ignoreThisKeypress = e.type == 'keypress' && _ignoreNextKeypress;
            if (e.type == _nextExpectedAction && !_isModifier(character) && !ignoreThisKeypress) {
                _resetSequences(doNotReset);
            }
 
            _ignoreNextKeypress = processedSequenceCallback && e.type == 'keydown';
        };
 
        /**
         * handles a keydown event
         *
         * @param {Event} e
         * @returns void
         */
        function _handleKeyEvent(e) {
 
            // normalize e.which for key events
            // @see http://stackoverflow.com/questions/4285627/javascript-keycode-vs-charcode-utter-confusion
            if (typeof e.which !== 'number') {
                e.which = e.keyCode;
            }
 
            var character = _characterFromEvent(e);
 
            // no character found then stop
            if (!character) {
                return;
            }
 
            // need to use === for the character check because the character can be 0
            if (e.type == 'keyup' && _ignoreNextKeyup === character) {
                _ignoreNextKeyup = false;
                return;
            }
 
            self.handleKey(character, _eventModifiers(e), e);
        }
 
        /**
         * called to set a 1 second timeout on the specified sequence
         *
         * this is so after each key press in the sequence you have 1 second
         * to press the next key before you have to start over
         *
         * @returns void
         */
        function _resetSequenceTimer() {
            clearTimeout(_resetTimer);
            _resetTimer = setTimeout(_resetSequences, 1000);
        }
 
        /**
         * binds a key sequence to an event
         *
         * @param {string} combo - combo specified in bind call
         * @param {Array} keys
         * @param {Function} callback
         * @param {string=} action
         * @returns void
         */
        function _bindSequence(combo, keys, callback, action) {
 
            // start off by adding a sequence level record for this combination
            // and setting the level to 0
            _sequenceLevels[combo] = 0;
 
            /**
             * callback to increase the sequence level for this sequence and reset
             * all other sequences that were active
             *
             * @param {string} nextAction
             * @returns {Function}
             */
            function _increaseSequence(nextAction) {
                return function () {
                    _nextExpectedAction = nextAction;
                    ++_sequenceLevels[combo];
                    _resetSequenceTimer();
                };
            }
 
            /**
             * wraps the specified callback inside of another function in order
             * to reset all sequence counters as soon as this sequence is done
             *
             * @param {Event} e
             * @returns void
             */
            function _callbackAndReset(e) {
                _fireCallback(callback, e, combo);
 
                // we should ignore the next key up if the action is key down
                // or keypress.  this is so if you finish a sequence and
                // release the key the final key will not trigger a keyup
                if (action !== 'keyup') {
                    _ignoreNextKeyup = _characterFromEvent(e);
                }
 
                // weird race condition if a sequence ends with the key
                // another sequence begins with
                setTimeout(_resetSequences, 10);
            }
 
            // loop through keys one at a time and bind the appropriate callback
            // function.  for any key leading up to the final one it should
            // increase the sequence. after the final, it should reset all sequences
            //
            // if an action is specified in the original bind call then that will
            // be used throughout.  otherwise we will pass the action that the
            // next key in the sequence should match.  this allows a sequence
            // to mix and match keypress and keydown events depending on which
            // ones are better suited to the key provided
            for (var i = 0; i < keys.length; ++i) {
                var isFinal = i + 1 === keys.length;
                var wrappedCallback = isFinal ? _callbackAndReset : _increaseSequence(action || _getKeyInfo(keys[i + 1]).action);
                _bindSingle(keys[i], wrappedCallback, action, combo, i);
            }
        }
 
        /**
         * binds a single keyboard combination
         *
         * @param {string} combination
         * @param {Function} callback
         * @param {string=} action
         * @param {string=} sequenceName - name of sequence if part of sequence
         * @param {number=} level - what part of the sequence the command is
         * @returns void
         */
        function _bindSingle(combination, callback, action, sequenceName, level) {
 
            // store a direct mapped reference for use with Mousetrap.trigger
            self._directMap[combination + ':' + action] = callback;
 
            // make sure multiple spaces in a row become a single space
            combination = combination.replace(/\s+/g, ' ');
 
            var sequence = combination.split(' ');
            var info;
 
            // if this pattern is a sequence of keys then run through this method
            // to reprocess each pattern one key at a time
            if (sequence.length > 1) {
                _bindSequence(combination, sequence, callback, action);
                return;
            }
 
            info = _getKeyInfo(combination, action);
 
            // make sure to initialize array if this is the first time
            // a callback is added for this key
            self._callbacks[info.key] = self._callbacks[info.key] || [];
 
            // remove an existing match if there is one
            _getMatches(info.key, info.modifiers, {type: info.action}, sequenceName, combination, level);
 
            // add this call back to the array
            // if it is a sequence put it at the beginning
            // if not put it at the end
            //
            // this is important because the way these are processed expects
            // the sequence ones to come first
            self._callbacks[info.key][sequenceName ? 'unshift' : 'push']({
                callback: callback,
                modifiers: info.modifiers,
                action: info.action,
                seq: sequenceName,
                level: level,
                combo: combination
            });
        }
 
        /**
         * binds multiple combinations to the same callback
         *
         * @param {Array} combinations
         * @param {Function} callback
         * @param {string|undefined} action
         * @returns void
         */
        self._bindMultiple = function (combinations, callback, action) {
            for (var i = 0; i < combinations.length; ++i) {
                _bindSingle(combinations[i], callback, action);
            }
        };
 
        // start!
        _addEvent(targetElement, 'keypress', _handleKeyEvent);
        _addEvent(targetElement, 'keydown', _handleKeyEvent);
        _addEvent(targetElement, 'keyup', _handleKeyEvent);
    }
 
    /**
     * binds an event to mousetrap
     *
     * can be a single key, a combination of keys separated with +,
     * an array of keys, or a sequence of keys separated by spaces
     *
     * be sure to list the modifier keys first to make sure that the
     * correct key ends up getting bound (the last key in the pattern)
     *
     * @param {string|Array} keys
     * @param {Function} callback
     * @param {string=} action - 'keypress', 'keydown', or 'keyup'
     * @returns void
     */
    Mousetrap.prototype.bind = function (keys, callback, action) {
        var self = this;
        keys = keys instanceof Array ? keys : [keys];
        self._bindMultiple.call(self, keys, callback, action);
        return self;
    };
 
    /**
     * unbinds an event to mousetrap
     *
     * the unbinding sets the callback function of the specified key combo
     * to an empty function and deletes the corresponding key in the
     * _directMap dict.
     *
     * TODO: actually remove this from the _callbacks dictionary instead
     * of binding an empty function
     *
     * the keycombo+action has to be exactly the same as
     * it was defined in the bind method
     *
     * @param {string|Array} keys
     * @param {string} action
     * @returns void
     */
    Mousetrap.prototype.unbind = function (keys, action) {
        var self = this;
        return self.bind.call(self, keys, function () {
        }, action);
    };
 
    /**
     * triggers an event that has already been bound
     *
     * @param {string} keys
     * @param {string=} action
     * @returns void
     */
    Mousetrap.prototype.trigger = function (keys, action) {
        var self = this;
        if (self._directMap[keys + ':' + action]) {
            self._directMap[keys + ':' + action]({}, keys);
        }
        return self;
    };
 
    /**
     * resets the library back to its initial state.  this is useful
     * if you want to clear out the current keyboard shortcuts and bind
     * new ones - for example if you switch to another page
     *
     * @returns void
     */
    Mousetrap.prototype.reset = function () {
        var self = this;
        self._callbacks = {};
        self._directMap = {};
        return self;
    };
 
    /**
     * should we stop this event before firing off callbacks
     *
     * @param {Event} e
     * @param {Element} element
     * @return {boolean}
     */
    Mousetrap.prototype.stopCallback = function (e, element) {
        var self = this;
 
        // if the element has the class "mousetrap" then no need to stop
        if ((' ' + element.className + ' ').indexOf(' mousetrap ') > -1) {
            return false;
        }
 
        if (_belongsTo(element, self.target)) {
            return false;
        }
 
        // stop for input, select, and textarea
        return element.tagName == 'INPUT' || element.tagName == 'SELECT' || element.tagName == 'TEXTAREA' || element.isContentEditable;
    };
 
    /**
     * exposes _handleKey publicly so it can be overwritten by extensions
     */
    Mousetrap.prototype.handleKey = function () {
        var self = this;
        return self._handleKey.apply(self, arguments);
    };
 
    /**
     * allow custom key mappings
     */
    Mousetrap.addKeycodes = function (object) {
        for (var key in object) {
            if (object.hasOwnProperty(key)) {
                _MAP[key] = object[key];
            }
        }
        _REVERSE_MAP = null;
    };
 
    /**
     * Init the global mousetrap functions
     *
     * This method is needed to allow the global mousetrap functions to work
     * now that mousetrap is a constructor function.
     */
    Mousetrap.init = function () {
        var documentMousetrap = Mousetrap(document);
        for (var method in documentMousetrap) {
            if (method.charAt(0) !== '_') {
                Mousetrap[method] = (function (method) {
                    return function () {
                        return documentMousetrap[method].apply(documentMousetrap, arguments);
                    };
                }(method));
            }
        }
    };
 
    Mousetrap.init();
 
    // expose mousetrap to the global object
    window.Mousetrap = Mousetrap;
 
    // expose as a common js module
    if (typeof module !== 'undefined' && module.exports) {
        module.exports = Mousetrap;
    }
 
    // expose mousetrap as an AMD module
    if (typeof define === 'function' && define.amd) {
        define(function () {
            return Mousetrap;
        });
    }
})(typeof window !== 'undefined' ? window : null, typeof window !== 'undefined' ? document : null);
unsafeWindow.Mousetrap = Mousetrap;
 
unsafeWindow.fetchSimilarHeaders = fetchSimilarHeaders;
function fetchSimilarHeaders(callback) {
    var request = new XMLHttpRequest();
    request.onreadystatechange = function () {
        if (request.readyState === 4) {
            //
            // The following headers may often be similar
            // to those of the original page request...
            //
            if (callback && typeof callback === 'function') {
                callback(request.getAllResponseHeaders());
            }
        }
    };
 
    //
    // Re-request the same page (document.location)
    // We hope to get the same or similar response headers to those which 
    // came with the current page, but we have no guarantee.
    // Since we are only after the headers, a HEAD request may be sufficient.
    //
    request.open('HEAD', document.location, true);
    request.send(null);
}
 
String.prototype.escapeSpecialChars = function () {
    return this.replace(/\\n/g, "\\n")
        .replace(/\\'/g, "\\'")
        .replace(/\\"/g, '\\"')
        .replace(/\\&/g, "\\&")
        .replace(/\\r/g, "\\r")
        .replace(/\\t/g, "\\t")
        .replace(/\\b/g, "\\b")
        .replace(/\\f/g, "\\f");
};
function headers2Object(headers) {
    if (!headers) return {};
    const jsonParseEscape = function (str) {
        return str.replace(/\n/g, "\\n")
            .replace(/\'/g, "\\'")
            .replace(/\"/g, '\\"')
            .replace(/\&/g, "\\&")
            .replace(/\r/g, "\\r")
            .replace(/\t/g, "\\t")
            .replace(/\f/g, "\\f");
    };
    var jsonStr = '{\n' +
        headers.trim().split("\n").filter(line => line.length > 2)
            .map(
                line => "   " + [line.slice(0, line.indexOf(':')), line.slice(line.indexOf(':') + 1)]
                    .map(part => '"' + jsonParseEscape(part.trim()) + '"').join(':')
            )
            .join(",\n") +
        '\n}';
    console.log('jsonStr:', jsonStr);
    return JSON.parse(jsonStr);
}
 
 
unsafeWindow.fetchUsingProxy = fetchUsingProxy;
/**
 * @param url
 * Found from:    https://stackoverflow.com/questions/43871637/no-access-control-allow-origin-header-is-present-on-the-requested-resource-whe
 * @param callback
 * @see     https://cors-anywhere.herokuapp.com/
 */
function fetchUsingProxy(url, callback) {
    const proxyurl = "https://cors-anywhere.herokuapp.com/";
    callback = callback || (contents => console.log(contents));
    fetch(proxyurl + url) // https://cors-anywhere.herokuapp.com/https://example.com
        .then(response => response.text())
        .then(callback)
        .catch(() => console.error(`Can’t access ${url} response. Blocked by browser?`))
}
 
unsafeWindow.getModKeys = getModifierKeys;
unsafeWindow.KeyEvent = {
    DOM_VK_BACKSPACE: 8,
    DOM_VK_TAB: 9,
    DOM_VK_ENTER: 13,
    DOM_VK_SHIFT: 16,
    DOM_VK_CTRL: 17,
    DOM_VK_ALT: 18,
    DOM_VK_PAUSE_BREAK: 19,
    DOM_VK_CAPS_LOCK: 20,
    DOM_VK_ESCAPE: 27,
    DOM_VK_PGUP: 33, DOM_VK_PAGE_UP: 33,
    DOM_VK_PGDN: 34, DOM_VK_PAGE_DOWN: 34,
    DOM_VK_END: 35,
    DOM_VK_HOME: 36,
    DOM_VK_LEFT: 37, DOM_VK_LEFT_ARROW: 37,
    DOM_VK_UP: 38, DOM_VK_UP_ARROW: 38,
    DOM_VK_RIGHT: 39, DOM_VK_RIGHT_ARROW: 39,
    DOM_VK_DOWN: 40, DOM_VK_DOWN_ARROW: 40,
    DOM_VK_INSERT: 45,
    DOM_VK_DEL: 46, DOM_VK_DELETE: 46,
    DOM_VK_0: 48, DOM_VK_ALPHA0: 48,
    DOM_VK_1: 49, DOM_VK_ALPHA1: 49,
    DOM_VK_2: 50, DOM_VK_ALPHA2: 50,
    DOM_VK_3: 51, DOM_VK_ALPHA3: 51,
    DOM_VK_4: 52, DOM_VK_ALPHA4: 52,
    DOM_VK_5: 53, DOM_VK_ALPHA5: 53,
    DOM_VK_6: 54, DOM_VK_ALPHA6: 54,
    DOM_VK_7: 55, DOM_VK_ALPHA7: 55,
    DOM_VK_8: 56, DOM_VK_ALPHA8: 56,
    DOM_VK_9: 57, DOM_VK_ALPHA9: 57,
    DOM_VK_A: 65,
    DOM_VK_B: 66,
    DOM_VK_C: 67,
    DOM_VK_D: 68,
    DOM_VK_E: 69,
    DOM_VK_F: 70,
    DOM_VK_G: 71,
    DOM_VK_H: 72,
    DOM_VK_I: 73,
    DOM_VK_J: 74,
    DOM_VK_K: 75,
    DOM_VK_L: 76,
    DOM_VK_M: 77,
    DOM_VK_N: 78,
    DOM_VK_O: 79,
    DOM_VK_P: 80,
    DOM_VK_Q: 81,
    DOM_VK_R: 82,
    DOM_VK_S: 83,
    DOM_VK_T: 84,
    DOM_VK_U: 85,
    DOM_VK_V: 86,
    DOM_VK_W: 87,
    DOM_VK_X: 88,
    DOM_VK_Y: 89,
    DOM_VK_Z: 90,
    DOM_VK_LWIN: 91, DOM_VK_LEFT_WINDOW: 91,
    DOM_VK_RWIN: 92, DOM_VK_RIGHT_WINDOW: 92,
    DOM_VK_SELECT: 93,
 
    DOM_VK_NUMPAD0: 96,
    DOM_VK_NUMPAD1: 97,
    DOM_VK_NUMPAD2: 98,
    DOM_VK_NUMPAD3: 99,
    DOM_VK_NUMPAD4: 100,
    DOM_VK_NUMPAD5: 101,
    DOM_VK_NUMPAD6: 102,
    DOM_VK_NUMPAD7: 103,
    DOM_VK_NUMPAD8: 104,
    DOM_VK_NUMPAD9: 105,
    DOM_VK_MULTIPLY: 106,
 
    DOM_VK_ADD: 107,
    DOM_VK_SUBTRACT: 109,
    DOM_VK_DECIMAL_POINT: 110,
    DOM_VK_DIVIDE: 111,
    DOM_VK_F1: 112,
    DOM_VK_F2: 113,
    DOM_VK_F3: 114,
    DOM_VK_F4: 115,
    DOM_VK_F5: 116,
    DOM_VK_F6: 117,
    DOM_VK_F7: 118,
    DOM_VK_F8: 119,
    DOM_VK_F9: 120,
    DOM_VK_F10: 121,
    DOM_VK_F11: 122,
    DOM_VK_F12: 123,
    DOM_VK_NUM_LOCK: 144,
    DOM_VK_SCROLL_LOCK: 145,
    DOM_VK_SEMICOLON: 186,
    DOM_VK_EQUALS: 187, DOM_VK_EQUAL_SIGN: 187,
    DOM_VK_COMMA: 188,
    DOM_VK_DASH: 189,
    DOM_VK_PERIOD: 190,
    DOM_VK_FORWARD_SLASH: 191,
    DOM_VK_GRAVE_ACCENT: 192,
    DOM_VK_OPEN_BRACKET: 219,
    DOM_VK_BACK_SLASH: 220,
    DOM_VK_CLOSE_BRACKET: 221,
    DOM_VK_SINGLE_QUOTE: 222
};
/**
 * Order of key strokes in naming convention:   Ctrl > Shift > Alt >  Meta
 * @param keyEvent
 * @returns {{CTRL_ONLY: boolean, SHIFT_ONLY: boolean, ALT_ONLY: boolean, META_ONLY: boolean, NONE: boolean}}
 */
function getModifierKeys(keyEvent) {
    /** @type {{CTRL_ONLY: boolean, SHIFT_ONLY: boolean, ALT_ONLY: boolean, NONE: boolean}} */
    return {
        CTRL_SHIFT: keyEvent.ctrlKey && !keyEvent.altKey && keyEvent.shiftKey && !keyEvent.metaKey,
        CTRL_ALT: keyEvent.ctrlKey && keyEvent.altKey && !keyEvent.shiftKey && !keyEvent.metaKey,
        ALT_SHIFT: !keyEvent.ctrlKey && keyEvent.altKey && keyEvent.shiftKey && !keyEvent.metaKey,
        CTRL_ONLY: keyEvent.ctrlKey && !keyEvent.altKey && !keyEvent.shiftKey && !keyEvent.metaKey,
        CTRL_ALT_SHIFT: keyEvent.ctrlKey && keyEvent.altKey && keyEvent.shiftKey && !keyEvent.metaKey,
 
        SHIFT_ONLY: !keyEvent.ctrlKey && !keyEvent.altKey && keyEvent.shiftKey && !keyEvent.metaKey,
        ALT_ONLY: !keyEvent.ctrlKey && keyEvent.altKey && !keyEvent.shiftKey && !keyEvent.metaKey,
        META_ONLY: !keyEvent.ctrlKey && !keyEvent.altKey && !keyEvent.shiftKey && keyEvent.metaKey,
 
        NONE: !keyEvent.ctrlKey && !keyEvent.shiftKey && !keyEvent.altKey && !keyEvent.metaKey,
 
        targetIsInput: (function targetIsInput() {
            const ignores = document.getElementsByTagName('input');
            const target = keyEvent.target;
            for (let ignore of ignores)
                if (target === ignore || ignore.contains(target)) {
                    // console.log('The target recieving the keycode is of type "input", so it will not recieve your keystroke', target);
                    return true;
                }
            return false;
        })()
    };
}
 
function publicizeSymbols(...parameters) {
    for (const parameter of parameters) {
        unsafeWindow[parameter] = parameter;
    }
}
 
function mapObject(o) {
    var map = new Map();
    for (const key in (o)) {
        if (o.hasOwnProperty(key))
            map.set(key, o[key]);
    }
    return map;
}
function getObjOfType(targetInstance, parentObj) {
    var list = [];
    for (const o in parentObj) if (o instanceof targetInstance) {
        return o;
    }
    return list;
}
function getNestedMembers(parentObject, targetType, list) {
    if (!parentObject) {
        console.error("parentObject is not defined:", parent);
        return;
    }
    list = list || [];
    for (const member in parentObject) {
 
        const typeofObj = typeof member;
 
        if (typeofObj === "object") {
            getNestedMembers(member, targetType, list);
        } else if (typeofObj !== 'undefined') {
            if (targetType && typeofObj !== targetType)
                continue;
            list.push(member);
        }
    }
    return list;
}