"use strict";
window['scriptCache'] = window['scriptCache'] || {};
function require(src, token) {
    "use strict";
    var getDep = function (t) { return t && window[t] ? window[t] : undefined };
    var existing = getDep(token);
    if (existing) return existing;
    var scriptCache = window['scriptCache'];
    if (!!scriptCache[src]) return;
    scriptCache[src] = true;
    var req = new XMLHttpRequest();
    req.open('GET', src, false);
    req.send('');
    var props = {};
    for (var prop in window) props[prop] = true;

    try {
        window['Function'](req.responseText)();
    } catch (e) {
        console.warn('[util: error loading script sync]', e)
    }
    var dep = getDep(token);
    if (dep) return dep;

    for (var prop in window) {
        if (!props[prop]) {
            var dep = window[prop];
            return dep;
        }
    }
}
requireCommonDependencies();
function requireCommonDependencies() {
    if (!window['prependEnvironmentPath']) {
        window['prependEnvironmentPath'] = function prependEnvironmentPath(absolutePath) {
            if (!!absolutePath.length && absolutePath[0] !== '/') throw new Error('Path must be absolute');
            if (window.location.host.indexOf('localhost') > -1) return absolutePath;
            var root = window.location.pathname.split('/')[1];
            return '/' + root + absolutePath;
        }
    }
    if (typeof Promise === 'undefined') {
        require("https://cdnjs.cloudflare.com/ajax/libs/core-js/2.6.11/core.min.js")
    }
    if (!String.prototype.startsWith) {
        String.prototype.startsWith = function (searchString, position) {
            position = position || 0;
            return this.substr(position, searchString.length) === searchString;
        };
    }
    if (!String.prototype.includes) {
        String.prototype.includes = function (searchString) {
            return this.indexOf(searchString) > -1;
        };
    }
    if (typeof fetch === 'undefined') {
        require(prependEnvironmentPath("/node_modules/whatwg-fetch/dist/fetch.umd.js"));
    }
    if (!window['htmlDecode']) {
        window['htmlDecode'] = function htmlDecode(input) {
            var e = document.createElement('textarea');
            e.innerHTML = input;
            return e.childNodes.length === 0 ? "" : e.childNodes[0].nodeValue;
        }
    }
    if (typeof $ === 'undefined') {
        window['$'] = require(prependEnvironmentPath('/SyncFusion/Scripts/jquery-1.10.2.min.js'), '$');
    }
    if (typeof Rx === 'undefined') {
        window['Rx'] = require(prependEnvironmentPath('/node_modules/rxjs/bundles/rxjs.umd.min.js'), 'Rx');
    }
    if (typeof Popover === 'undefined') {
        window['Popover'] = require(prependEnvironmentPath('/clientcode/services/popover/popover.js'), 'Popover');
    }
    if (typeof auth === 'undefined') {
        require(prependEnvironmentPath('/scripts/auth.js'));
    }
    if (typeof snapshot === 'undefined') {
        require(prependEnvironmentPath('/node_modules/@soleran/markup-snapshot-universal/bundles/soleran-markup-snapshot-universal.umd.js'));
    }
    if (typeof inactivity === 'undefined') {
        require(prependEnvironmentPath('/node_modules/@soleran/inactivity/fesm2015/soleran-inactivity.min.mjs'));
    }
}
function runAsync(work) {
    return setTimeout(function () { if (work) work(); }, 0);
}

function wait(ms) {
    return new Promise(function (res, rej) { setTimeout(res, ms); });
}
function postAsync(url, body) {
    return new Promise(function (resolve, reject) {
        runAsync(function () {
            var rejectWithError = function (res) { reject(new Error(res.responseText)) };
            $.post(url, body, resolve).fail(rejectWithError);
        });
    });
}
function getAsync(url) {
    return new Promise(function (resolve, reject) {
        runAsync(function () {
            var options = { url: url };
            $.ajax(options).done(resolve).fail(reject);
        });
    });
}

function mapQueryParams(url) {
    var parts = url.split('?');
    if (!parts.length > 0) return {};
    var paramParts = parts[1].split('&');
    var lookup = paramParts.reduce(function (a, c) {
        var kvp = c.split('=');
        var key = kvp[0];
        var value = kvp[1];
        a[key] = value;
        return a;
    }, {});
    return lookup;
}
function findFrame(urlPattern) {
    var root = top || window;
    for (var i = 0; i < root.frames.length; i++) {
        var frame = root.frames[i];
        var frameLocation = frame.window.location.href;
        if (frameLocation.toLowerCase().indexOf(urlPattern) > -1) return frame;
    }
}
function replaceAllOccurencesOfTag(html, oldTagStr, newTagStr) {
    var replaceElement = function (oldElement$, newElement$) {
        var tagName = oldElement$.prop('tagName');
        var replacement$ = newElement$.clone();
        replacement$.html(oldElement$.html());
        var firstEl$ = replacement$.find(tagName).first();
        var all$ = firstEl$.add(firstEl$.siblings(tagName));
        all$.each(function (i) { return replaceElement($(all$[i]), newElement$.clone()) });
        oldElement$.replaceWith(replacement$);
    }
    var wrapperElement$ = $('<div>');
    wrapperElement$.html(html);
    var firstRootEl$ = wrapperElement$.find(oldTagStr).first();
    var allRoot$ = firstRootEl$.add(firstRootEl$.siblings(oldTagStr));
    allRoot$.each(function (i) { return replaceElement($(allRoot$[i]), $('<' + newTagStr + '>')) });
    return wrapperElement$.html();
}
function flattenFrames() {
    var allFrames = [];
    function recurseFrames(context) {
        for (let i = 0; i < context.frames.length; i++) {
            allFrames.push(context.frames[i]);
            recurseFrames(context.frames[i]);
        }
    }
    recurseFrames(window);
    return allFrames;
}
function frameChanges() {
    var interval = Rx.interval;
    var distinctUntilChanged = Rx.operators.distinctUntilChanged;
    var map = Rx.operators.map;
    return interval(0).pipe(
        map(function (_) { return flattenFrames() }),
        distinctUntilChanged(function (a, b) { return a.length === b.length })
    );
}


function getSoleranUser() {
    var tokenJson = localStorage.getItem('soleran_token');
    return tokenJson ? new auth.SoleranUser(JSON.parse(tokenJson)) : new auth.SoleranUser();
}
function appendTokenToUrl(url) {
    return appendQueryParameterToUrl(url, 'soleranToken', getSoleranUser().raw);
}
function appendQueryParameterToUrl(url, name, value) {
    var delemiter = (url + '').includes('?') ? '&' : '?';
    return url + delemiter + name + '=' + value;
}
function appendQueryParametersToUrl(url, paramObj) {
    return Object.keys(paramObj).reduce(function (u, param) {
        return appendQueryParameterToUrl(u, param, paramObj[param]);
    }, url);
}



function getAllowedOrigins() {
    if (window['__allowedOrigins']) {
        return window['__allowedOrigins'];
    } else {

    }
    var allowedOrigins = new Set();
    for (var i = 0; i < 2000; i++) {
        var host = 'localhost:' + (4100 + i);
        allowedOrigins.add('http://' + host);
        allowedOrigins.add('https://' + host);
    }
    ['localhost', 'admin.soleran.net', 'reports.soleran.net', 'dev65.soleran.net', 'soleran.net'].forEach(function (v) {
        allowedOrigins.add("http://" + v);
        allowedOrigins.add("https://" + v);
    });
    window['__allowedOrigins'] = allowedOrigins;
    return window['__allowedOrigins'];
}