{"version":3,"sources":["webpack://postRobot/webpack/universalModuleDefinition","webpack://postRobot/webpack/bootstrap","webpack://postRobot/./node_modules/cross-domain-utils/src/util.js","webpack://postRobot/./node_modules/cross-domain-utils/src/utils.js","webpack://postRobot/./node_modules/cross-domain-utils/src/constants.js","webpack://postRobot/./node_modules/zalgo-promise/src/utils.js","webpack://postRobot/./node_modules/zalgo-promise/src/exceptions.js","webpack://postRobot/./node_modules/zalgo-promise/src/flush.js","webpack://postRobot/./node_modules/zalgo-promise/src/promise.js","webpack://postRobot/./node_modules/@babel/runtime/helpers/esm/extends.js","webpack://postRobot/./node_modules/cross-domain-safe-weakmap/src/util.js","webpack://postRobot/./node_modules/cross-domain-safe-weakmap/src/weakmap.js","webpack://postRobot/./node_modules/cross-domain-safe-weakmap/src/native.js","webpack://postRobot/./node_modules/belter/src/util.js","webpack://postRobot/./node_modules/belter/src/dom.js","webpack://postRobot/./src/global.js","webpack://postRobot/./src/lib/hello.js","webpack://postRobot/./src/conf/constants.js","webpack://postRobot/./src/lib/windows.js","webpack://postRobot/./node_modules/universal-serialize/src/common.js","webpack://postRobot/./node_modules/universal-serialize/src/constants.js","webpack://postRobot/./node_modules/universal-serialize/src/serialize.js","webpack://postRobot/./node_modules/universal-serialize/src/serializers/function.js","webpack://postRobot/./node_modules/universal-serialize/src/serializers/error.js","webpack://postRobot/./node_modules/universal-serialize/src/serializers/promise.js","webpack://postRobot/./node_modules/universal-serialize/src/serializers/regex.js","webpack://postRobot/./node_modules/universal-serialize/src/serializers/date.js","webpack://postRobot/./node_modules/universal-serialize/src/serializers/array.js","webpack://postRobot/./node_modules/universal-serialize/src/serializers/object.js","webpack://postRobot/./node_modules/universal-serialize/src/serializers/string.js","webpack://postRobot/./node_modules/universal-serialize/src/serializers/number.js","webpack://postRobot/./node_modules/universal-serialize/src/serializers/boolean.js","webpack://postRobot/./node_modules/universal-serialize/src/serializers/null.js","webpack://postRobot/./node_modules/universal-serialize/src/deserialize.js","webpack://postRobot/./src/bridge/common.js","webpack://postRobot/./src/bridge/parent.js","webpack://postRobot/./src/bridge/setup.js","webpack://postRobot/./src/bridge/bridge.js","webpack://postRobot/./src/bridge/child.js","webpack://postRobot/./src/serialize/window.js","webpack://postRobot/./src/serialize/function.js","webpack://postRobot/./src/serialize/serialize.js","webpack://postRobot/./src/serialize/promise.js","webpack://postRobot/./src/drivers/send/strategies.js","webpack://postRobot/./src/lib/compat.js","webpack://postRobot/./src/drivers/send/index.js","webpack://postRobot/./src/drivers/listeners.js","webpack://postRobot/./src/drivers/receive/types.js","webpack://postRobot/./src/drivers/receive/index.js","webpack://postRobot/./src/public/on.js","webpack://postRobot/./src/public/send.js","webpack://postRobot/./src/conf/config.js","webpack://postRobot/./src/setup.js","webpack://postRobot/./src/clean.js","webpack://postRobot/./src/index.js","webpack://postRobot/./src/types.js"],"names":["root","factory","exports","module","define","amd","self","this","installedModules","__webpack_require__","moduleId","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","hasOwnProperty","p","s","isRegex","item","toString","IE_WIN_ACCESS_ERROR","isAboutProtocol","win","window","location","protocol","getParent","parent","err","getOpener","opener","canReadFromWindow","getActualDomain","Error","PROTOCOL","host","getDomain","domain","mockDomain","indexOf","isSameDomain","desc","getOwnPropertyDescriptor","isActuallySameDomain","assertSameDomain","isAncestorParent","child","childParent","result","push","getParents","getFrames","frames","len","length","frame","getAllChildFrames","getTop","top","getAllFramesInWindow","iframeWindows","iframeFrames","isWindowClosed","allowMock","closed","message","mockclosed","iframeIndex","collection","safeIndexOf","contentWindow","parentNode","doc","ownerDocument","documentElement","contains","isFrameWindowClosed","getUserAgent","navigator","mockUserAgent","userAgent","getFrameByName","winFrames","childFrame","isOpener","getAncestor","anyMatch","collection1","collection2","item1","isSameTopWindow","win1","win2","top1","top2","allFrames1","allFrames2","opener1","opener2","matchDomain","pattern","origin","Array","isArray","Boolean","match","JSON","stringify","some","subpattern","getDomainFromUrl","url","split","slice","join","isWindow","obj","Window","__cross_domain_utils_window_check__","closeWindow","close","isPromise","Promise","constructor","then","dispatchedErrors","possiblyUnhandledPromiseHandlers","activeCount","flushPromise","flushActive","promise","resolve","startActive","endActive","ZalgoPromise","handler","resolved","rejected","errorHandled","error","handlers","dispatching","stack","isAsync","res","reject","dispatch","setTimeout","j","dispatchPossiblyUnhandledError","asyncReject","chain","firstPromise","secondPromise","onSuccess","onError","catch","undefined","finally","onFinally","try","timeout","time","clearTimeout","toPromise","TypeError","all","promises","count","results","prom","hash","keys","map","items","method","onPossiblyUnhandledException","cancel","splice","context","args","apply","delay","flush","Zalgo","awaitActive","_extends","assign","target","arguments","source","CrossDomainSafeWeakMap","weakmap","values","Math","random","WeakMap","freeze","testWeakMap","testKey","set","hasNativeWeakMap","_cleanupClosedWindows","delete","isSafeToReadWrite","entry","writable","index","has","getOrSet","uniqueID","chars","replace","charAt","floor","str","btoa","encodeURIComponent","p1","String","fromCharCode","parseInt","Buffer","from","base64encode","Date","toISOString","toLowerCase","objectIDs","serializeArgs","subkey","val","uid","getObjectID","memoizePromise","cache","memoizedPromiseFunction","reset","fn","__name__","displayName","setFunctionName","noop","stringifyError","level","newErr","prototype","getGlobal","getObj","globalStore","defStore","store","storeKey","defVal","del","WildCard","getWildcard","global","WINDOW_WILDCARD","windowStore","winStore","getStore","getInstanceID","resolveHelloPromise","helloPromises","existingPromise","newPromise","sayHello","send","instanceID","data","getWindowInstanceID","awaitWindowHello","getHelloPromise","markWindowKnown","isSerializedType","__type__","determineType","serializeType","type","__val__","SERIALIZER","code","toJSON","defaultSerializers","DESERIALIZER","RegExp","defaultDeserializers","needsBridgeForBrowser","needsBridgeForWin","needsBridgeForDomain","needsBridge","getBridgeName","BRIDGE_NAME_PREFIX","isBridge","documentBodyReady","document","body","interval","setInterval","clearInterval","registerRemoteWindow","findRemoteWindow","remoteWinPromise","registerRemoteSendMessage","sendMessage","remoteWin","remoteDomain","fireAndForget","rejectRemoteSendMessage","linkWindow","popupWindowsByName","popupWindowsByWin","winName","details","setupBridge","on","receiveMessage","windowOpen","open","options","last","normalizeMockUrl","bridgePromise","bridge","winDetails","listenForOpenTunnel","openTunnelToParent","canary","tunnelWindows","parentWindow","id","cleanTunnelWindows","addTunnelWindow","tunnelWindow","setupOpenTunnelToParent","openTunnelToOpener","cleanupProxyWindows","idToProxyWindow","shouldClean","getSerializedWindow","winPromise","windowNamePromise","getType","getName","focus","isClosed","setLocation","href","setName","sameDomain","frameElement","querySelectorAll","getFrameForWindow","setAttribute","ProxyWindow","serializedWindow","isProxyWindow","actualWindow","actualWindowPromise","getID","setWindow","isPopup","isPopupPromise","getNamePromise","reopenPromise","focusPromise","getWindow","awaitWindow","matchWindow","proxyInstanceID","knownWindowInstanceID","unwrap","serialize","toProxyWindow","deserialize","addMethod","methodStore","proxyWindowMethods","lookupMethod","serializeFunction","destination","meth","methodSource","arg","stringifyArguments","__id__","serializeMessage","serializers","serializer","serializePromise","deserializeMessage","deserializers","parse","deserializer","serializedPromise","deserializePromise","serializedFunction","getDeserializedFunction","opts","crossDomainFunctionWrapper","__origin__","__source__","deserializeFunction","SEND_MESSAGE_STRATEGIES","serializedMessage","dom","forEach","postMessage","messagingChild","messagingParent","sendBridgeMessage","foreignGlobal","strategies","errors","strategyName","getResponseListener","deleteResponseListener","isResponseListenerErrored","getRequestListener","requestListeners","winQualifier","nameListeners","domainListeners","listener","regex","RECEIVE_MESSAGE_TYPES","logName","sendResponse","ack","response","pathname","handleError","event","receivedMessages","parsedMessage","parseMessage","requestListener","addRequestListener","listenersCollection","existingListener","strDomain","regexListeners","regexListener","errorHandler","once","responseTimeout","childTimeout","validateOptions","actualParent","isAncestor","targetDomain","actualDomain","normalizedDomain","normalizeDomain","responseListener","addResponseListener","reqPromises","markResponseListenerErrored","totalAckTimeout","isWindowKnown","totalResTimeout","ackTimeout","resTimeout","loop","cancelled","max","safeInterval","internalSerializeMessage","internalDeserializeMessage","createProxyWindow","setup","initialized","addEventListener","removeEventListener","sourceElement","originalEvent","messageListener","listenForMessages","initHello","destroy","responseListeners","cancelResponseListeners","cleanUpWindow","openBridge","bridges","bridgeFrames","iframe","createElement","src","openBridgeFrame","appendChild","linkUrl","hasBridge","destroyBridges","removeChild"],"mappings":"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","file":"post-robot.ie.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine(\"postRobot\", [], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"postRobot\"] = factory();\n\telse\n\t\troot[\"postRobot\"] = factory();\n})((typeof self !== 'undefined' ? self : this), function() {\nreturn "," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 0);\n","/* @flow */\n\nexport function isRegex(item : mixed) : boolean {\n    return Object.prototype.toString.call(item) === '[object RegExp]';\n}\n\n// eslint-disable-next-line no-unused-vars\nexport function noop(...args : Array<mixed>) {\n    // pass\n}\n","/* @flow */\n/* eslint max-lines: 0 */\n\nimport { isRegex, noop } from './util';\nimport type { CrossDomainWindowType, SameDomainWindowType, DomainMatcher } from './types';\nimport { PROTOCOL, WILDCARD } from './constants';\n\nlet IE_WIN_ACCESS_ERROR = 'Call was rejected by callee.\\r\\n';\n\nexport function isFileProtocol(win : SameDomainWindowType = window) : boolean {\n    return win.location.protocol === PROTOCOL.FILE;\n}\n\nexport function isAboutProtocol(win : SameDomainWindowType = window) : boolean {\n    return win.location.protocol === PROTOCOL.ABOUT;\n}\n\nexport function getParent(win? : CrossDomainWindowType = window) : ?CrossDomainWindowType {\n\n    if (!win) {\n        return;\n    }\n\n    try {\n        if (win.parent && win.parent !== win) {\n            return win.parent;\n        }\n    } catch (err) {\n        // pass\n    }\n}\n\nexport function getOpener(win? : CrossDomainWindowType = window) : ?CrossDomainWindowType {\n\n    if (!win) {\n        return;\n    }\n\n    // Make sure we're not actually an iframe which has had window.open() called on us\n    if (getParent(win)) {\n        return;\n    }\n\n    try {\n        return win.opener;\n    } catch (err) {\n        // pass\n    }\n}\n\nexport function canReadFromWindow(win : CrossDomainWindowType | SameDomainWindowType) : boolean {\n    try {\n        // $FlowFixMe\n        noop(win && win.location && win.location.href);\n        return true;\n    } catch (err) {\n        // pass\n    }\n\n    return false;\n}\n\nexport function getActualDomain(win? : SameDomainWindowType = window) : string {\n\n    let location = win.location;\n\n    if (!location) {\n        throw new Error(`Can not read window location`);\n    }\n\n    let protocol = location.protocol;\n\n    if (!protocol) {\n        throw new Error(`Can not read window protocol`);\n    }\n\n    if (protocol === PROTOCOL.FILE) {\n        return `${ PROTOCOL.FILE }//`;\n    }\n\n    if (protocol === PROTOCOL.ABOUT) {\n\n        let parent = getParent(win);\n        if (parent && canReadFromWindow(parent)) {\n            // $FlowFixMe\n            return getActualDomain(parent);\n        }\n\n        return `${ PROTOCOL.ABOUT }//`;\n    }\n\n    let host = location.host;\n\n    if (!host) {\n        throw new Error(`Can not read window host`);\n    }\n\n    return `${ protocol }//${ host }`;\n}\n\nexport function getDomain(win? : SameDomainWindowType = window) : string {\n\n    let domain = getActualDomain(win);\n\n    if (domain && win.mockDomain && win.mockDomain.indexOf(PROTOCOL.MOCK) === 0) {\n        return win.mockDomain;\n    }\n\n    return domain;\n}\n\nexport function isBlankDomain(win : CrossDomainWindowType) : boolean {\n    try {\n        // $FlowFixMe\n        if (!win.location.href) {\n            return true;\n        }\n\n        if (win.location.href === 'about:blank') {\n            return true;\n        }\n    } catch (err) {\n        // pass\n    }\n\n    return false;\n}\n\nexport function isActuallySameDomain(win : CrossDomainWindowType) : boolean {\n\n    try {\n        if (win === window) {\n            return true;\n        }\n\n    } catch (err) {\n        // pass\n    }\n\n    try {\n        let desc = Object.getOwnPropertyDescriptor(win, 'location');\n\n        if (desc && desc.enumerable === false) {\n            return false;\n        }\n\n    } catch (err) {\n        // pass\n    }\n\n    try {\n        // $FlowFixMe\n        if (isAboutProtocol(win) && canReadFromWindow(win)) {\n            return true;\n        }\n    } catch (err) {\n        // pass\n    }\n\n    try {\n        // $FlowFixMe\n        if (getActualDomain(win) === getActualDomain(window)) {\n            return true;\n        }\n\n    } catch (err) {\n        // pass\n    }\n\n    return false;\n}\n\nexport function isSameDomain(win : CrossDomainWindowType | SameDomainWindowType) : boolean {\n\n    if (!isActuallySameDomain(win)) {\n        return false;\n    }\n\n    try {\n\n        if (win === window) {\n            return true;\n        }\n\n        // $FlowFixMe\n        if (isAboutProtocol(win) && canReadFromWindow(win)) {\n            return true;\n        }\n\n        // $FlowFixMe\n        if (getDomain(window) === getDomain(win)) {\n            return true;\n        }\n\n    } catch (err) {\n        // pass\n    }\n\n    return false;\n}\n\n\nexport function assertSameDomain(win : CrossDomainWindowType | SameDomainWindowType) : SameDomainWindowType {\n    if (!isSameDomain(win)) {\n        throw new Error(`Expected window to be same domain`);\n    }\n\n    // $FlowFixMe\n    return win;\n}\n\nexport function getParents(win : CrossDomainWindowType) : Array<CrossDomainWindowType> {\n\n    let result = [];\n\n    try {\n\n        while (win.parent !== win) {\n            result.push(win.parent);\n            win = win.parent;\n        }\n\n    } catch (err) {\n        // pass\n    }\n\n    return result;\n}\n\nexport function isAncestorParent(parent : CrossDomainWindowType, child : CrossDomainWindowType) : boolean {\n\n    if (!parent || !child) {\n        return false;\n    }\n\n    let childParent = getParent(child);\n\n    if (childParent) {\n        return childParent === parent;\n    }\n\n    if (getParents(child).indexOf(parent) !== -1) {\n        return true;\n    }\n\n    return false;\n}\n\nexport function getFrames(win : CrossDomainWindowType) : Array<CrossDomainWindowType> {\n\n    let result = [];\n\n    let frames;\n\n    try {\n        frames = win.frames;\n    } catch (err) {\n        frames = win;\n    }\n\n    let len;\n\n    try {\n        len = frames.length;\n    } catch (err) {\n        // pass\n    }\n\n    if (len === 0) {\n        return result;\n    }\n\n    if (len) {\n        for (let i = 0; i < len; i++) {\n\n            let frame;\n\n            try {\n                frame = frames[i];\n            } catch (err) {\n                continue;\n            }\n\n            result.push(frame);\n        }\n\n        return result;\n    }\n\n    for (let i = 0; i < 100; i++) {\n        let frame;\n\n        try {\n            frame = frames[i];\n        } catch (err) {\n            return result;\n        }\n\n        if (!frame) {\n            return result;\n        }\n\n        result.push(frame);\n    }\n\n    return result;\n}\n\n\nexport function getAllChildFrames(win : CrossDomainWindowType) : Array<CrossDomainWindowType> {\n\n    let result = [];\n\n    for (let frame of getFrames(win)) {\n        result.push(frame);\n\n        for (let childFrame of getAllChildFrames(frame)) {\n            result.push(childFrame);\n        }\n    }\n\n    return result;\n}\n\nexport function getTop(win? : CrossDomainWindowType = window) : ?CrossDomainWindowType {\n\n    try {\n        if (win.top) {\n            return win.top;\n        }\n    } catch (err) {\n        // pass\n    }\n\n    if (getParent(win) === win) {\n        return win;\n    }\n\n    try {\n        if (isAncestorParent(window, win) && window.top) {\n            return window.top;\n        }\n    } catch (err) {\n        // pass\n    }\n\n    try {\n        if (isAncestorParent(win, window) && window.top) {\n            return window.top;\n        }\n    } catch (err) {\n        // pass\n    }\n\n    for (let frame of getAllChildFrames(win)) {\n        try {\n            if (frame.top) {\n                return frame.top;\n            }\n        } catch (err) {\n            // pass\n        }\n\n        if (getParent(frame) === frame) {\n            return frame;\n        }\n    }\n}\n\nexport function getNextOpener(win? : CrossDomainWindowType = window) : ?CrossDomainWindowType {\n    return getOpener(getTop(win) || win);\n}\n\nexport function getUltimateTop(win? : CrossDomainWindowType = window) : CrossDomainWindowType {\n    let opener = getNextOpener(win);\n\n    if (opener) {\n        return getUltimateTop(opener);\n    }\n\n    return top;\n}\n\nexport function getAllFramesInWindow(win : CrossDomainWindowType) : Array<CrossDomainWindowType> {\n    let top = getTop(win);\n\n    if (!top) {\n        throw new Error(`Can not determine top window`);\n    }\n\n    return [ ...getAllChildFrames(top), top ];\n}\n\nexport function getAllWindows(win? : CrossDomainWindowType = window) : $ReadOnlyArray<CrossDomainWindowType> {\n    let frames = getAllFramesInWindow(win);\n    let opener = getNextOpener(win);\n\n    if (opener) {\n        return [ ...getAllWindows(opener), ...frames ];\n    } else {\n        return frames;\n    }\n}\n\nexport function isTop(win : CrossDomainWindowType) : boolean {\n    return win === getTop(win);\n}\n\nexport function isFrameWindowClosed(frame : HTMLIFrameElement) : boolean {\n\n    if (!frame.contentWindow) {\n        return true;\n    }\n\n    if (!frame.parentNode) {\n        return true;\n    }\n\n    let doc = frame.ownerDocument;\n\n    if (doc && doc.documentElement && !doc.documentElement.contains(frame)) {\n        return true;\n    }\n\n    return false;\n}\n\nfunction safeIndexOf<T>(collection : Array<T>, item : T) : number {\n    for (let i = 0; i < collection.length; i++) {\n\n        try {\n            if (collection[i] === item) {\n                return i;\n            }\n        } catch (err) {\n            // pass\n        }\n    }\n\n    return -1;\n}\n\nlet iframeWindows = [];\nlet iframeFrames = [];\n\nexport function isWindowClosed(win : CrossDomainWindowType, allowMock : boolean = true) : boolean {\n\n    try {\n        if (win === window) {\n            return false;\n        }\n    } catch (err) {\n        return true;\n    }\n\n    try {\n        if (!win) {\n            return true;\n        }\n\n    } catch (err) {\n        return true;\n    }\n\n    try {\n        if (win.closed) {\n            return true;\n        }\n\n    } catch (err) {\n\n        // I love you so much IE\n\n        if (err && err.message === IE_WIN_ACCESS_ERROR) {\n            return false;\n        }\n\n        return true;\n    }\n\n\n    if (allowMock && isSameDomain(win)) {\n        try {\n            // $FlowFixMe\n            if (win.mockclosed) {\n                return true;\n            }\n        } catch (err) {\n            // pass\n        }\n    }\n\n    // Mobile safari\n\n    try {\n        if (!win.parent || !win.top) {\n            return true;\n        }\n    } catch (err) {\n        // pass\n    }\n\n    // Yes, this actually happens in IE. win === win errors out when the window\n    // is from an iframe, and the iframe was removed from the page.\n\n    try {\n        noop(win === win); // eslint-disable-line no-self-compare\n    } catch (err) {\n        return true;\n    }\n\n    // IE orphaned frame\n\n    let iframeIndex = safeIndexOf(iframeWindows, win);\n\n    if (iframeIndex !== -1) {\n        let frame = iframeFrames[iframeIndex];\n\n        if (frame && isFrameWindowClosed(frame)) {\n            return true;\n        }\n    }\n\n    return false;\n}\n\nfunction cleanIframes() {\n    for (let i = 0; i < iframeWindows.length; i++) {\n        let closed = false;\n\n        try {\n            closed = iframeWindows[i].closed;\n        } catch (err) {\n            // pass\n        }\n\n        if (closed) {\n            iframeFrames.splice(i, 1);\n            iframeWindows.splice(i, 1);\n        }\n    }\n}\n\nexport function linkFrameWindow(frame : HTMLIFrameElement) {\n\n    cleanIframes();\n\n    if (frame && frame.contentWindow) {\n        try {\n            iframeWindows.push(frame.contentWindow);\n            iframeFrames.push(frame);\n        } catch (err) {\n            // pass\n        }\n    }\n}\n\nexport function getUserAgent(win : ?SameDomainWindowType) : string {\n    win = win || window;\n    return win.navigator.mockUserAgent || win.navigator.userAgent;\n}\n\n\nexport function getFrameByName(win : CrossDomainWindowType, name : string) : ?CrossDomainWindowType {\n\n    let winFrames = getFrames(win);\n\n    for (let childFrame of winFrames) {\n        try {\n            // $FlowFixMe\n            if (isSameDomain(childFrame) && childFrame.name === name && winFrames.indexOf(childFrame) !== -1) {\n                return childFrame;\n            }\n        } catch (err) {\n            // pass\n        }\n    }\n\n    try {\n        // $FlowFixMe\n        if (winFrames.indexOf(win.frames[name]) !== -1) {\n            // $FlowFixMe\n            return win.frames[name];\n        }\n    } catch (err) {\n        // pass\n    }\n\n    try {\n        if (winFrames.indexOf(win[name]) !== -1) {\n            return win[name];\n        }\n    } catch (err) {\n        // pass\n    }\n}\n\nexport function findChildFrameByName(win : CrossDomainWindowType, name : string) : ?CrossDomainWindowType {\n\n    let frame = getFrameByName(win, name);\n\n    if (frame) {\n        return frame;\n    }\n\n    for (let childFrame of getFrames(win)) {\n        let namedFrame = findChildFrameByName(childFrame, name);\n\n        if (namedFrame) {\n            return namedFrame;\n        }\n    }\n}\n\nexport function findFrameByName(win : CrossDomainWindowType, name : string) : ?CrossDomainWindowType {\n\n    let frame;\n\n    frame = getFrameByName(win, name);\n\n    if (frame) {\n        return frame;\n    }\n\n    let top = getTop(win) || win;\n\n    return findChildFrameByName(top, name);\n}\n\nexport function isParent(win : CrossDomainWindowType, frame : CrossDomainWindowType) : boolean {\n\n    let frameParent = getParent(frame);\n\n    if (frameParent) {\n        return frameParent === win;\n    }\n\n    for (let childFrame of getFrames(win)) {\n        if (childFrame === frame) {\n            return true;\n        }\n    }\n\n    return false;\n}\n\nexport function isOpener(parent : CrossDomainWindowType, child : CrossDomainWindowType) : boolean {\n\n    return parent === getOpener(child);\n}\n\nexport function getAncestor(win? : CrossDomainWindowType = window) : ?CrossDomainWindowType {\n    win = win || window;\n\n    let opener = getOpener(win);\n\n    if (opener) {\n        return opener;\n    }\n\n    let parent = getParent(win);\n\n    if (parent) {\n        return parent;\n    }\n}\n\nexport function getAncestors(win : CrossDomainWindowType) : Array<CrossDomainWindowType> {\n\n    let results = [];\n\n    let ancestor = win;\n\n    while (ancestor) {\n        ancestor = getAncestor(ancestor);\n        if (ancestor) {\n            results.push(ancestor);\n        }\n    }\n\n    return results;\n}\n\n\nexport function isAncestor(parent : CrossDomainWindowType, child : CrossDomainWindowType) : boolean {\n\n    let actualParent = getAncestor(child);\n\n    if (actualParent) {\n        if (actualParent === parent) {\n            return true;\n        }\n\n        return false;\n    }\n\n    if (child === parent) {\n        return false;\n    }\n\n    if (getTop(child) === child) {\n        return false;\n    }\n\n    for (let frame of getFrames(parent)) {\n        if (frame === child) {\n            return true;\n        }\n    }\n\n    return false;\n}\n\nexport function isPopup(win? : CrossDomainWindowType = window) : boolean {\n    return Boolean(getOpener(win));\n}\n\nexport function isIframe(win? : CrossDomainWindowType = window) : boolean {\n    return Boolean(getParent(win));\n}\n\nexport function isFullpage(win? : CrossDomainWindowType = window) : boolean {\n    return Boolean(!isIframe(win) && !isPopup(win));\n}\n\nfunction anyMatch(collection1, collection2) : boolean {\n\n    for (let item1 of collection1) {\n        for (let item2 of collection2) {\n            if (item1 === item2) {\n                return true;\n            }\n        }\n    }\n\n    return false;\n}\n\nexport function getDistanceFromTop(win : CrossDomainWindowType = window) : number {\n    let distance = 0;\n    let parent = win;\n\n    while (parent) {\n        parent = getParent(parent);\n        if (parent) {\n            distance += 1;\n        }\n    }\n\n    return distance;\n}\n\nexport function getNthParent(win : CrossDomainWindowType, n : number = 1) : ?CrossDomainWindowType {\n    let parent = win;\n\n    for (let i = 0; i < n; i++) {\n        if (!parent) {\n            return;\n        }\n\n        parent = getParent(parent);\n    }\n\n    return parent;\n}\n\nexport function getNthParentFromTop(win : CrossDomainWindowType, n : number = 1) : ?CrossDomainWindowType {\n    return getNthParent(win, getDistanceFromTop(win) - n);\n}\n\nexport function isSameTopWindow(win1 : CrossDomainWindowType, win2 : CrossDomainWindowType) : boolean {\n\n    let top1 = getTop(win1) || win1;\n    let top2 = getTop(win2) || win2;\n\n    try {\n        if (top1 && top2) {\n            if (top1 === top2) {\n                return true;\n            }\n\n            return false;\n        }\n    } catch (err) {\n        // pass\n    }\n\n    let allFrames1 = getAllFramesInWindow(win1);\n    let allFrames2 = getAllFramesInWindow(win2);\n\n    if (anyMatch(allFrames1, allFrames2)) {\n        return true;\n    }\n\n    let opener1 = getOpener(top1);\n    let opener2 = getOpener(top2);\n\n    if (opener1 && anyMatch(getAllFramesInWindow(opener1), allFrames2)) {\n        return false;\n    }\n\n    if (opener2 && anyMatch(getAllFramesInWindow(opener2), allFrames1)) {\n        return false;\n    }\n\n    return false;\n}\n\nexport function matchDomain(pattern : DomainMatcher, origin : DomainMatcher) : boolean {\n\n    if (typeof pattern === 'string') {\n\n        if (typeof origin === 'string') {\n            return pattern === WILDCARD || origin === pattern;\n        }\n\n        if (isRegex(origin)) {\n            return false;\n        }\n\n        if (Array.isArray(origin)) {\n            return false;\n        }\n    }\n\n    if (isRegex(pattern)) {\n\n        if (isRegex(origin)) {\n            return pattern.toString() === origin.toString();\n        }\n\n        if (Array.isArray(origin)) {\n            return false;\n        }\n\n        // $FlowFixMe\n        return Boolean(origin.match(pattern));\n    }\n\n    if (Array.isArray(pattern)) {\n\n        if (Array.isArray(origin)) {\n            return JSON.stringify(pattern) === JSON.stringify(origin);\n        }\n\n        if (isRegex(origin)) {\n            return false;\n        }\n\n        return pattern.some(subpattern => matchDomain(subpattern, origin));\n    }\n\n    return false;\n}\n\nexport function stringifyDomainPattern(pattern : DomainMatcher) : string {\n    if (Array.isArray(pattern)) {\n        return `(${ pattern.join(' | ') })`;\n    } else if (isRegex(pattern)) {\n        return `RegExp(${ pattern.toString() }`;\n    } else {\n        return pattern.toString();\n    }\n}\n\nexport function getDomainFromUrl(url : string) : string {\n\n    let domain;\n\n    if (url.match(/^(https?|mock|file):\\/\\//)) {\n        domain = url;\n    } else {\n        return getDomain();\n    }\n\n    domain = domain.split('/').slice(0, 3).join('/');\n\n    return domain;\n}\n\nexport function onCloseWindow(win : CrossDomainWindowType, callback : Function, delay : number = 1000, maxtime : number = Infinity) : { cancel : () => void } {\n\n    let timeout;\n\n    let check = () => {\n\n        if (isWindowClosed(win)) {\n\n            if (timeout) {\n                clearTimeout(timeout);\n            }\n\n            return callback();\n        }\n\n        if (maxtime <= 0) {\n            clearTimeout(timeout);\n        } else {\n            maxtime -= delay;\n            timeout = setTimeout(check, delay);\n        }\n    };\n\n    check();\n\n    return {\n        cancel() {\n            if (timeout) {\n                clearTimeout(timeout);\n            }\n        }\n    };\n}\n\n// eslint-disable-next-line complexity\nexport function isWindow(obj : Object) : boolean {\n\n    try {\n        if (obj === window) {\n            return true;\n        }\n    } catch (err) {\n        if (err && err.message === IE_WIN_ACCESS_ERROR) {\n            return true;\n        }\n    }\n\n    try {\n        if (Object.prototype.toString.call(obj) === '[object Window]') {\n            return true;\n        }\n    } catch (err) {\n        if (err && err.message === IE_WIN_ACCESS_ERROR) {\n            return true;\n        }\n    }\n\n    try {\n        if (window.Window && obj instanceof window.Window) {\n            return true;\n        }\n    } catch (err) {\n        if (err && err.message === IE_WIN_ACCESS_ERROR) {\n            return true;\n        }\n    }\n\n    try {\n        if (obj && obj.self === obj) {\n            return true;\n        }\n    } catch (err) {\n        if (err && err.message === IE_WIN_ACCESS_ERROR) {\n            return true;\n        }\n    }\n\n    try {\n        if (obj && obj.parent === obj) {\n            return true;\n        }\n    } catch (err) {\n        if (err && err.message === IE_WIN_ACCESS_ERROR) {\n            return true;\n        }\n    }\n\n    try {\n        if (obj && obj.top === obj) {\n            return true;\n        }\n    } catch (err) {\n        if (err && err.message === IE_WIN_ACCESS_ERROR) {\n            return true;\n        }\n    }\n\n    try {\n        if (noop(obj === obj) === '__unlikely_value__') { // eslint-disable-line no-self-compare\n            return false;\n        }\n\n    } catch (err) {\n        return true;\n    }\n\n    try {\n        if (obj && obj.__cross_domain_utils_window_check__ === '__unlikely_value__') {\n            return false;\n        }\n\n    } catch (err) {\n        return true;\n    }\n\n    return false;\n}\n\nexport function isBrowser() : boolean {\n    return (typeof window !== 'undefined' && typeof window.location !== 'undefined');\n}\n\nexport function isCurrentDomain(domain : string) : boolean {\n    if (!isBrowser()) {\n        return false;\n    }\n\n    return (getDomain() === domain);\n}\n\nexport function isMockDomain(domain : string) : boolean {\n    return domain.indexOf(PROTOCOL.MOCK) === 0;\n}\n\nexport function normalizeMockUrl(url : string) : string {\n    if (!isMockDomain(getDomainFromUrl(url))) {\n        return url;\n    }\n\n    if (!__TEST__) {\n        throw new Error(`Mock urls not supported out of test mode`);\n    }\n\n    return url.replace(/^mock:\\/\\/[^/]+/, getActualDomain(window));\n}\n\nexport function closeWindow(win : CrossDomainWindowType) {\n    try {\n        win.close();\n    } catch (err) {\n        // pass\n    }\n}\n\nexport function getFrameForWindow(win : CrossDomainWindowType) : ?HTMLElement {\n    if (isSameDomain(win)) {\n        return assertSameDomain(win).frameElement;\n    }\n\n    for (const frame of document.querySelectorAll('iframe')) {\n        if (frame && frame.contentWindow && frame.contentWindow === win) {\n            return frame;\n        }\n    }\n}\n","/* @flow */\n\nexport const PROTOCOL = {\n    MOCK:  ('mock:' : 'mock:'),\n    FILE:  ('file:' : 'file:'),\n    ABOUT: ('about:' : 'about:')\n};\n\nexport const WILDCARD = '*';\n\nexport const WINDOW_TYPE = {\n    IFRAME: ('iframe' : 'iframe'),\n    POPUP:  ('popup' : 'popup')\n};\n","/* @flow */\n\nexport function isPromise(item : mixed) : boolean {\n    try {\n        if (!item) {\n            return false;\n        }\n\n        if (typeof Promise !== 'undefined' && item instanceof Promise) {\n            return true;\n        }\n\n        if (typeof window !== 'undefined' && typeof window.Window === 'function' && item instanceof window.Window) {\n            return false;\n        }\n\n        if (typeof window !== 'undefined' && typeof window.constructor === 'function' && item instanceof window.constructor) {\n            return false;\n        }\n\n        let toString = ({}).toString;\n\n        if (toString) {\n            let name = toString.call(item);\n\n            if (name === '[object Window]' || name === '[object global]' || name === '[object DOMWindow]') {\n                return false;\n            }\n        }\n\n        if (typeof item.then === 'function') {\n            return true;\n        }\n    } catch (err) {\n        return false;\n    }\n\n    return false;\n}\n","/* @flow */\n\nimport type { ZalgoPromise } from './promise';\n\nconst dispatchedErrors = [];\nconst possiblyUnhandledPromiseHandlers : Array<(mixed, promise? : ZalgoPromise<mixed>) => void> = [];\n\nexport function dispatchPossiblyUnhandledError<T>(err : mixed, promise : ZalgoPromise<T>) {\n\n    if (dispatchedErrors.indexOf(err) !== -1) {\n        return;\n    }\n\n    dispatchedErrors.push(err);\n\n    setTimeout(() => {\n        if (__DEBUG__) {\n            // $FlowFixMe\n            throw new Error(`${ err.stack || err.toString() }\\n\\nFrom promise:\\n\\n${ promise.stack }`);\n        }\n\n        throw err;\n    }, 1);\n\n    for (let j = 0; j < possiblyUnhandledPromiseHandlers.length; j++) {\n        // $FlowFixMe\n        possiblyUnhandledPromiseHandlers[j](err, promise);\n    }\n}\n\nexport function onPossiblyUnhandledException(handler : (mixed, promise? : ZalgoPromise<mixed>) => void) : { cancel : () => void } {\n    possiblyUnhandledPromiseHandlers.push(handler);\n\n    return {\n        cancel() {\n            possiblyUnhandledPromiseHandlers.splice(possiblyUnhandledPromiseHandlers.indexOf(handler), 1);\n        }\n    };\n}\n","/* @flow */\n\nimport type { ZalgoPromise } from './promise';\n\nlet activeCount = 0;\nlet flushPromise;\n\nfunction flushActive() {\n    if (!activeCount && flushPromise) {\n        const promise = flushPromise;\n        flushPromise = null;\n        promise.resolve();\n    }\n}\n\nexport function startActive() {\n    activeCount += 1;\n}\n\nexport function endActive() {\n    activeCount -= 1;\n    flushActive();\n}\n\nexport function awaitActive(Zalgo : Class<ZalgoPromise<*>>) : ZalgoPromise<void> { // eslint-disable-line no-undef\n    let promise = flushPromise = flushPromise || new Zalgo();\n    flushActive();\n    return promise;\n}\n","/* @flow */\n\nimport { isPromise } from './utils';\nimport { onPossiblyUnhandledException, dispatchPossiblyUnhandledError } from './exceptions';\nimport { startActive, endActive, awaitActive } from './flush';\n\nexport class ZalgoPromise<R : mixed> {\n\n    resolved : boolean\n    rejected : boolean\n    errorHandled : boolean\n    value : R\n    error : mixed\n    handlers : Array<{\n        promise : ZalgoPromise<*>,\n        onSuccess : void | (result : R) => mixed,\n        onError : void | (error : mixed) => mixed\n    }>\n    dispatching : boolean\n    stack : string\n\n    constructor(handler : ?(resolve : (result : R) => void, reject : (error : mixed) => void) => void) {\n\n        this.resolved = false;\n        this.rejected = false;\n        this.errorHandled = false;\n\n        this.handlers = [];\n\n        if (handler) {\n\n            let result;\n            let error;\n            let resolved = false;\n            let rejected = false;\n            let isAsync = false;\n\n            startActive();\n\n            try {\n                handler(res => {\n                    if (isAsync) {\n                        this.resolve(res);\n                    } else {\n                        resolved = true;\n                        result = res;\n                    }\n\n                }, err => {\n                    if (isAsync) {\n                        this.reject(err);\n                    } else {\n                        rejected = true;\n                        error = err;\n                    }\n                });\n\n            } catch (err) {\n                endActive();\n                this.reject(err);\n                return;\n            }\n\n            endActive();\n\n            isAsync = true;\n\n            if (resolved) {\n                // $FlowFixMe\n                this.resolve(result);\n            } else if (rejected) {\n                this.reject(error);\n            }\n        }\n\n        if (__DEBUG__) {\n            try {\n                throw new Error(`ZalgoPromise`);\n            } catch (err) {\n                this.stack = err.stack;\n            }\n        }\n    }\n\n    resolve(result : R) : ZalgoPromise<R> {\n        if (this.resolved || this.rejected) {\n            return this;\n        }\n\n        if (isPromise(result)) {\n            throw new Error('Can not resolve promise with another promise');\n        }\n\n        this.resolved = true;\n        this.value = result;\n        this.dispatch();\n\n        return this;\n    }\n\n    reject(error : mixed) : ZalgoPromise<R> {\n        if (this.resolved || this.rejected) {\n            return this;\n        }\n\n        if (isPromise(error)) {\n            throw new Error('Can not reject promise with another promise');\n        }\n\n        if (!error) {\n            // $FlowFixMe\n            let err = (error && typeof error.toString === 'function' ? error.toString() : Object.prototype.toString.call(error));\n            error = new Error(`Expected reject to be called with Error, got ${ err }`);\n        }\n\n        this.rejected = true;\n        this.error = error;\n\n        if (!this.errorHandled) {\n            setTimeout(() => {\n                if (!this.errorHandled) {\n                    dispatchPossiblyUnhandledError(error, this);\n                }\n            }, 1);\n        }\n\n        this.dispatch();\n\n        return this;\n    }\n\n    asyncReject(error : mixed) : ZalgoPromise<R> {\n        this.errorHandled = true;\n        this.reject(error);\n        return this;\n    }\n    \n    dispatch() {\n\n        let { dispatching, resolved, rejected, handlers } = this;\n\n        if (dispatching) {\n            return;\n        }\n\n        if (!resolved && !rejected) {\n            return;\n        }\n\n        this.dispatching = true;\n        startActive();\n\n        const chain = <T>(firstPromise : ZalgoPromise<T>, secondPromise : ZalgoPromise<T>) => {\n            return firstPromise.then(res => {\n                secondPromise.resolve(res);\n            }, err => {\n                secondPromise.reject(err);\n            });\n        };\n\n        for (let i = 0; i < handlers.length; i++) {\n\n            let { onSuccess, onError, promise } = handlers[i];\n\n            let result;\n\n            if (resolved) {\n\n                try {\n                    result = onSuccess ? onSuccess(this.value) : this.value;\n                } catch (err) {\n                    promise.reject(err);\n                    continue;\n                }\n\n            } else if (rejected) {\n\n                if (!onError) {\n                    promise.reject(this.error);\n                    continue;\n                }\n\n                try {\n                    result = onError(this.error);\n                } catch (err) {\n                    promise.reject(err);\n                    continue;\n                }\n            }\n\n            if (result instanceof ZalgoPromise && (result.resolved || result.rejected)) {\n\n                if (result.resolved) {\n                    promise.resolve(result.value);\n                } else {\n                    promise.reject(result.error);\n                }\n\n                result.errorHandled = true;\n\n            } else if (isPromise(result)) {\n\n                if (result instanceof ZalgoPromise && (result.resolved || result.rejected)) {\n                    if (result.resolved) {\n                        promise.resolve(result.value);\n                    } else {\n                        promise.reject(result.error);\n                    }\n\n                } else {\n                    // $FlowFixMe\n                    chain(result, promise);\n                }\n\n            } else {\n\n                promise.resolve(result);\n            }\n        }\n\n        handlers.length = 0;\n        this.dispatching = false;\n        endActive();\n    }\n\n    then<X : mixed, Y : mixed>(onSuccess : void | (result : R) => (ZalgoPromise<X> | Y), onError : void | (error : mixed) => (ZalgoPromise<X> | Y)) : ZalgoPromise<X | Y> {\n\n        if (onSuccess && typeof onSuccess !== 'function' && !onSuccess.call) {\n            throw new Error('Promise.then expected a function for success handler');\n        }\n\n        if (onError && typeof onError !== 'function' && !onError.call) {\n            throw new Error('Promise.then expected a function for error handler');\n        }\n\n        let promise : ZalgoPromise<X | Y> = new ZalgoPromise();\n\n        this.handlers.push({\n            promise,\n            onSuccess,\n            onError\n        });\n\n        this.errorHandled = true;\n\n        this.dispatch();\n\n        return promise;\n    }\n\n    catch<X : mixed, Y : mixed>(onError : (error : mixed) => ZalgoPromise<X> | Y) : ZalgoPromise<X | Y> {\n        return this.then(undefined, onError);\n    }\n\n    finally(onFinally : () => mixed) : ZalgoPromise<R> {\n\n        if (onFinally && typeof onFinally !== 'function' && !onFinally.call) {\n            throw new Error('Promise.finally expected a function');\n        }\n\n        return this.then((result) => {\n            return ZalgoPromise.try(onFinally)\n                .then(() => {\n                    return result;\n                });\n        }, (err) => {\n            return ZalgoPromise.try(onFinally)\n                .then(() => {\n                    throw err;\n                });\n        });\n    }\n\n    timeout(time : number, err : ?Error) : ZalgoPromise<R> {\n\n        if (this.resolved || this.rejected) {\n            return this;\n        }\n\n        let timeout = setTimeout(() => {\n\n            if (this.resolved || this.rejected) {\n                return;\n            }\n\n            this.reject(err || new Error(`Promise timed out after ${ time }ms`));\n\n        }, time);\n\n        return this.then(result => {\n            clearTimeout(timeout);\n            return result;\n        });\n    }\n\n    // $FlowFixMe\n    toPromise() : Promise<R> {\n        // $FlowFixMe\n        if (typeof Promise === 'undefined') {\n            throw new TypeError(`Could not find Promise`);\n        }\n        // $FlowFixMe\n        return Promise.resolve(this); // eslint-disable-line compat/compat\n    }\n\n    static resolve<X : mixed>(value : X | ZalgoPromise<X>) : ZalgoPromise<X> {\n\n        if (value instanceof ZalgoPromise) {\n            return value;\n        }\n\n        if (isPromise(value)) {\n            // $FlowFixMe\n            return new ZalgoPromise((resolve, reject) => value.then(resolve, reject));\n        }\n\n        return new ZalgoPromise().resolve(value);\n    }\n\n    static reject(error : mixed) : ZalgoPromise<R> {\n        return new ZalgoPromise().reject(error);\n    }\n\n    static asyncReject(error : mixed) : ZalgoPromise<R> {\n        return new ZalgoPromise().asyncReject(error);\n    }\n\n    static all<X : Array<mixed>>(promises : X) : ZalgoPromise<$TupleMap<X, <Y>(ZalgoPromise<Y> | Y) => Y>> { // eslint-disable-line no-undef\n\n        let promise = new ZalgoPromise();\n        let count = promises.length;\n        let results = [];\n\n        if (!count) {\n            promise.resolve(results);\n            return promise;\n        }\n\n        const chain = <T>(i : number, firstPromise : ZalgoPromise<T>, secondPromise : ZalgoPromise<T>) => {\n            return firstPromise.then(res => {\n                results[i] = res;\n                count -= 1;\n                if (count === 0) {\n                    promise.resolve(results);\n                }\n            }, err => {\n                secondPromise.reject(err);\n            });\n        };\n\n        for (let i = 0; i < promises.length; i++) {\n            let prom = promises[i];\n\n            if (prom instanceof ZalgoPromise) {\n                if (prom.resolved) {\n                    results[i] = prom.value;\n                    count -= 1;\n                    continue;\n                }\n            } else if (!isPromise(prom)) {\n                results[i] = prom;\n                count -= 1;\n                continue;\n            }\n\n            chain(i, ZalgoPromise.resolve(prom), promise);\n        }\n\n        if (count === 0) {\n            promise.resolve(results);\n        }\n\n        return promise;\n    }\n\n    static hash<O : Object>(promises : O) : ZalgoPromise<$ObjMap<O, <Y>(ZalgoPromise<Y> | Y) => Y>> { // eslint-disable-line no-undef\n        let result = {};\n        \n        return ZalgoPromise.all(Object.keys(promises).map(key => {\n            return ZalgoPromise.resolve(promises[key]).then(value => {\n                result[key] = value;\n            });\n        })).then(() => {\n            return result;\n        });\n    }\n\n    static map<T, X>(items : Array<T>, method : (T) => (ZalgoPromise<X> | X)) : ZalgoPromise<Array<X>> {\n        // $FlowFixMe\n        return ZalgoPromise.all(items.map(method));\n    }\n\n    static onPossiblyUnhandledException(handler : (err : mixed) => void) : { cancel : () => void } {\n        return onPossiblyUnhandledException(handler);\n    }\n\n    static try<X : mixed, Y : mixed, C : mixed, A : Array<mixed>>(method : (...args : A) => (ZalgoPromise<X> | Y), context : ?C, args : ?A) : ZalgoPromise<X | Y> {\n\n        if (method && typeof method !== 'function' && !method.call) {\n            throw new Error('Promise.try expected a function');\n        }\n\n        let result;\n\n        startActive();\n        \n        try {\n            // $FlowFixMe\n            result = method.apply(context, args || []);\n        } catch (err) {\n            endActive();\n            return ZalgoPromise.reject(err);\n        }\n\n        endActive();\n\n        return ZalgoPromise.resolve(result);\n    }\n\n    static delay(delay : number) : ZalgoPromise<void> {\n        return new ZalgoPromise(resolve => {\n            setTimeout(resolve, delay);\n        });\n    }\n\n    static isPromise(value : mixed) : boolean {\n\n        if (value && value instanceof ZalgoPromise) {\n            return true;\n        }\n\n        return isPromise(value);\n    }\n\n    static flush() : ZalgoPromise<void> {\n        return awaitActive(ZalgoPromise);\n    }\n}\n","export default function _extends() {\n  _extends = Object.assign || function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n\n    return target;\n  };\n\n  return _extends.apply(this, arguments);\n}","/* @flow */\n\nexport function safeIndexOf<T>(collection : Array<T>, item : T) : number {\n    for (let i = 0; i < collection.length; i++) {\n\n        try {\n            if (collection[i] === item) {\n                return i;\n            }\n        } catch (err) {\n            // pass\n        }\n    }\n\n    return -1;\n}\n\n// eslint-disable-next-line no-unused-vars\nexport function noop(...args : Array<mixed>) {\n    // pass\n}\n","/* @flow */\n\nimport { isWindow, isWindowClosed } from 'cross-domain-utils/src';\n\nimport { hasNativeWeakMap } from './native';\nimport { noop, safeIndexOf } from './util';\n\nexport class CrossDomainSafeWeakMap<K : Object, V : mixed> {\n\n    name : string\n    weakmap : ?WeakMap<K, V>\n    keys : Array<K>\n    values : Array<V>\n\n    constructor() {\n        // eslint-disable-next-line no-bitwise\n        this.name = `__weakmap_${ Math.random() * 1e9 >>> 0 }__`;\n\n        if (hasNativeWeakMap()) {\n            try {\n                this.weakmap = new WeakMap();\n            } catch (err) {\n                // pass\n            }\n        }\n\n        this.keys  = [];\n        this.values = [];\n    }\n\n    _cleanupClosedWindows() {\n\n        let weakmap = this.weakmap;\n        let keys = this.keys;\n\n        for (let i = 0; i < keys.length; i++) {\n            let value = keys[i];\n\n            if (isWindow(value) && isWindowClosed(value)) {\n\n                if (weakmap) {\n                    try {\n                        weakmap.delete(value);\n                    } catch (err) {\n                        // pass\n                    }\n                }\n\n                keys.splice(i, 1);\n                this.values.splice(i, 1);\n\n                i -= 1;\n            }\n        }\n    }\n\n    isSafeToReadWrite(key : K) : boolean {\n\n        if (isWindow(key)) {\n            return false;\n        }\n\n        try {\n            noop(key && key.self);\n            noop(key && key[this.name]);\n        } catch (err) {\n            return false;\n        }\n\n        return true;\n    }\n\n    set(key : K, value : V) {\n\n        if (!key) {\n            throw new Error(`WeakMap expected key`);\n        }\n\n        let weakmap = this.weakmap;\n\n        if (weakmap) {\n            try {\n                weakmap.set(key, value);\n            } catch (err) {\n                delete this.weakmap;\n            }\n        }\n\n        if (this.isSafeToReadWrite(key)) {\n            try {\n                let name = this.name;\n                let entry = key[name];\n\n                if (entry && entry[0] === key) {\n                    entry[1] = value;\n                } else {\n                    Object.defineProperty(key, name, {\n                        value:    [ key, value ],\n                        writable: true\n                    });\n                }\n\n                return;\n\n            } catch (err) {\n                // pass\n            }\n        }\n\n        this._cleanupClosedWindows();\n\n        let keys = this.keys;\n        let values = this.values;\n        let index = safeIndexOf(keys, key);\n\n        if (index === -1) {\n            keys.push(key);\n            values.push(value);\n        } else {\n            values[index] = value;\n        }\n    }\n\n    get(key : K) : V | void {\n\n        if (!key) {\n            throw new Error(`WeakMap expected key`);\n        }\n\n        let weakmap = this.weakmap;\n\n        if (weakmap) {\n            try {\n                if (weakmap.has(key)) {\n                    return weakmap.get(key);\n                }\n                \n            } catch (err) {\n                delete this.weakmap;\n            }\n        }\n\n        if (this.isSafeToReadWrite(key)) {\n            try {\n                let entry = key[this.name];\n\n                if (entry && entry[0] === key) {\n                    return entry[1];\n                }\n\n                return;\n            } catch (err) {\n                // pass\n            }\n        }\n\n        this._cleanupClosedWindows();\n\n        let keys = this.keys;\n        let index = safeIndexOf(keys, key);\n\n        if (index === -1) {\n            return;\n        }\n\n        return this.values[index];\n    }\n\n    delete(key : K) {\n\n        if (!key) {\n            throw new Error(`WeakMap expected key`);\n        }\n\n        let weakmap = this.weakmap;\n\n        if (weakmap) {\n            try {\n                weakmap.delete(key);\n            } catch (err) {\n                delete this.weakmap;\n            }\n        }\n\n        if (this.isSafeToReadWrite(key)) {\n            try {\n                let entry = key[this.name];\n\n                if (entry && entry[0] === key) {\n                    entry[0] = entry[1] = undefined;\n                }\n            } catch (err) {\n                // pass\n            }\n        }\n\n        this._cleanupClosedWindows();\n\n        let keys = this.keys;\n        let index = safeIndexOf(keys, key);\n\n        if (index !== -1) {\n            keys.splice(index, 1);\n            this.values.splice(index, 1);\n        }\n    }\n\n    has(key : K) : boolean {\n\n        if (!key) {\n            throw new Error(`WeakMap expected key`);\n        }\n\n        let weakmap = this.weakmap;\n\n        if (weakmap) {\n            try {\n                if (weakmap.has(key)) {\n                    return true;\n                }\n            } catch (err) {\n                delete this.weakmap;\n            }\n        }\n\n        if (this.isSafeToReadWrite(key)) {\n            try {\n                let entry = key[this.name];\n\n                if (entry && entry[0] === key) {\n                    return true;\n                }\n\n                return false;\n            } catch (err) {\n                // pass\n            }\n        }\n\n        this._cleanupClosedWindows();\n\n        let index = safeIndexOf(this.keys, key);\n        return index !== -1;\n    }\n\n    getOrSet(key : K, getter : () => V) : V {\n        if (this.has(key)) {\n            // $FlowFixMe\n            return this.get(key);\n        }\n\n        let value = getter();\n        this.set(key, value);\n        return value;\n    }\n}\n","/* @flow */\n\nexport function hasNativeWeakMap() : boolean {\n\n    if (typeof WeakMap === 'undefined') {\n        return false;\n    }\n\n    if (typeof Object.freeze === 'undefined') {\n        return false;\n    }\n\n    try {\n\n        let testWeakMap = new WeakMap();\n        let testKey = {};\n        let testValue = '__testvalue__';\n\n        Object.freeze(testKey);\n\n        testWeakMap.set(testKey, testValue);\n\n        if (testWeakMap.get(testKey) === testValue) {\n            return true;\n        }\n\n        return false;\n\n    } catch (err) {\n\n        return false;\n    }\n}\n","/* @flow */\n/* eslint max-lines: 0 */\n\nimport { ZalgoPromise } from 'zalgo-promise/src';\nimport { WeakMap } from 'cross-domain-safe-weakmap/src';\n\nimport type { CancelableType } from './types';\n\nexport function getFunctionName <T : Function>(fn : T) : string {\n    return fn.name || fn.__name__ || fn.displayName || 'anonymous';\n}\n\nexport function setFunctionName <T : Function>(fn : T, name : string) : T {\n    try {\n        delete fn.name;\n        fn.name = name;\n    } catch (err) {\n        // pass\n    }\n\n    fn.__name__ = fn.displayName = name;\n    return fn;\n}\n\nexport function base64encode(str : string) : string {\n    if (typeof btoa === 'function') {\n        return btoa(encodeURIComponent(str).replace(/%([0-9A-F]{2})/g, (m, p1) => {\n            return String.fromCharCode(parseInt(p1, 16));\n        }));\n    }\n\n    if (typeof Buffer !== 'undefined') {\n        return Buffer.from(str, 'utf8').toString('base64');\n    }\n\n    throw new Error(`Can not find window.btoa or Buffer`);\n}\n\nexport function base64decode(str : string) : string {\n    if (typeof atob === 'function') {\n        return decodeURIComponent(Array.prototype.map.call(atob(str), c => {\n            // eslint-disable-next-line prefer-template\n            return '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2);\n        }).join(''));\n    }\n\n    if (typeof Buffer !== 'undefined') {\n        return Buffer.from(str, 'base64').toString('utf8');\n    }\n\n    throw new Error(`Can not find window.atob or Buffer`);\n}\n\nexport function uniqueID() : string {\n\n    let chars = '0123456789abcdef';\n\n    let randomID = 'xxxxxxxxxx'.replace(/./g, () => {\n        return chars.charAt(Math.floor(Math.random() * chars.length));\n    });\n\n    let timeID = base64encode(\n        new Date().toISOString().slice(11, 19).replace('T', '.')\n    ).replace(/[^a-zA-Z0-9]/g, '').toLowerCase();\n\n    return `${ randomID }_${ timeID }`;\n}\n\nexport function getGlobal() : Object {\n    if (typeof window !== 'undefined') {\n        return window;\n    }\n    if (typeof global !== 'undefined') {\n        return global;\n    }\n    if (typeof __GLOBAL__ !== 'undefined') {\n        return __GLOBAL__;\n    }\n    throw new Error(`No global found`);\n}\n\nlet objectIDs;\n\nexport function getObjectID(obj : Object) : string {\n\n    objectIDs = objectIDs || new WeakMap();\n\n    if (obj === null || obj === undefined || (typeof obj !== 'object' && typeof obj !== 'function')) {\n        throw new Error(`Invalid object`);\n    }\n\n    let uid = objectIDs.get(obj);\n\n    if (!uid) {\n        uid = `${ typeof obj }:${ uniqueID() }`;\n        objectIDs.set(obj, uid);\n    }\n\n    return uid;\n}\n\nfunction serializeArgs<T>(args : Array<T>) : string {\n    try {\n        return JSON.stringify(Array.prototype.slice.call(args), (subkey, val) => {\n            if (typeof val === 'function') {\n                return `memoize[${ getObjectID(val) }]`;\n            }\n            return val;\n        });\n    } catch (err) {\n        throw new Error(`Arguments not serializable -- can not be used to memoize`);\n    }\n}\nexport function memoize<A, R, F : (...args : Array<A>) => R, X : { (...args : Array<A>) : R, displayName : string, reset : () => void }>(method : F, options : { time? : number, thisNamespace? : boolean } = {}) : X {\n    let cacheMap = new WeakMap();\n\n    // $FlowFixMe\n    let memoizedFunction : X = function memoizedFunction(...args : Array<A>) : R {\n        let cache = cacheMap.getOrSet(options.thisNamespace ? this : method, () => ({}));\n\n        let key : string = serializeArgs(args);\n\n        let cacheTime = options.time;\n        if (cache[key] && cacheTime && (Date.now() - cache[key].time) < cacheTime) {\n            delete cache[key];\n        }\n\n        if (cache[key]) {\n            return cache[key].value;\n        }\n\n        let time  = Date.now();\n        let value = method.apply(this, arguments);\n\n        cache[key] = { time, value };\n\n        return cache[key].value;\n    };\n\n    memoizedFunction.reset = () => {\n        cacheMap.delete(options.thisNamespace ? this : method);\n    };\n\n    return setFunctionName(memoizedFunction, `${ getFunctionName(method) }::memoized`);\n}\n\nexport function promiseIdentity<T : mixed>(item : ZalgoPromise<T> | T) : ZalgoPromise<T> {\n    // $FlowFixMe\n    return ZalgoPromise.resolve(item);\n}\n\n// eslint-disable-next-line flowtype/no-weak-types\nexport function memoizePromise<R>(method : (...args : Array<any>) => ZalgoPromise<R>) : ((...args : Array<any>) => ZalgoPromise<R>) {\n    let cache = {};\n\n    // eslint-disable-next-line flowtype/no-weak-types\n    function memoizedPromiseFunction(...args : Array<any>) : ZalgoPromise<R> {\n        let key : string = serializeArgs(args);\n\n        if (cache.hasOwnProperty(key)) {\n            return cache[key];\n        }\n\n        cache[key] = ZalgoPromise.try(() => method.apply(this, arguments))\n            .finally(() => {\n                delete cache[key];\n            });\n\n        return cache[key];\n    }\n\n    memoizedPromiseFunction.reset = () => {\n        cache = {};\n    };\n\n    return setFunctionName(memoizedPromiseFunction, `${ getFunctionName(method) }::promiseMemoized`);\n}\n\n// eslint-disable-next-line flowtype/no-weak-types\nexport function promisify<R>(method : (...args : Array<any>) => R, options : { name? : string } = {}) : ((...args : Array<any>) => ZalgoPromise<R>) {\n    function promisifiedFunction() : ZalgoPromise<R> {\n        return ZalgoPromise.try(method, this, arguments);\n    }\n\n    if (options.name) {\n        promisifiedFunction.displayName = `${ options.name }:promisified`;\n    }\n\n    return setFunctionName(promisifiedFunction, `${ getFunctionName(method) }::promisified`);\n}\n\n// eslint-disable-next-line flowtype/no-weak-types\nexport function inlineMemoize<R>(method : (...args : Array<any>) => R, logic : (...args : Array<any>) => R, args : Array<any> = []) : R {\n    // $FlowFixMe\n    let cache = method.__inline_memoize_cache__ = method.__inline_memoize_cache__ || {};\n    let key = serializeArgs(args);\n\n    if (cache.hasOwnProperty(key)) {\n        return cache[key];\n    }\n    \n    let result = cache[key] = logic(...args);\n\n    return result;\n}\n\n// eslint-disable-next-line no-unused-vars\nexport function noop(...args : Array<mixed>) {\n    // pass\n}\n\nexport function once(method : Function) : Function {\n    let called = false;\n\n    const onceFunction = function() : mixed {\n        if (!called) {\n            called = true;\n            return method.apply(this, arguments);\n        }\n    };\n\n    return setFunctionName(onceFunction, `${ getFunctionName(method) }::once`);\n}\n\nexport function hashStr(str : string) : number {\n    let hash = 0;\n    for (let i = 0; i < str.length; i++) {\n        hash += str[i].charCodeAt(0) * Math.pow((i % 10) + 1, 5);\n    }\n    return Math.floor(Math.pow(Math.sqrt(hash), 5));\n}\n\nexport function strHashStr(str : string) : string {\n    let hash = '';\n\n    for (let i = 0; i < str.length; i++) {\n        let total = (str[i].charCodeAt(0) * i);\n\n        if (str[i + 1]) {\n            total += (str[i + 1].charCodeAt(0) * (i - 1));\n        }\n\n        hash += String.fromCharCode(97 + (Math.abs(total) % 26));\n    }\n\n    return hash;\n}\n\nexport function match(str : string, pattern : RegExp) : ?string {\n    let regmatch = str.match(pattern);\n    if (regmatch) {\n        return regmatch[1];\n    }\n}\n\nexport function awaitKey<T: mixed>(obj : Object, key : string) : ZalgoPromise<T> {\n    return new ZalgoPromise(resolve => {\n\n        let value = obj[key];\n\n        if (value) {\n            return resolve(value);\n        }\n\n        delete obj[key];\n\n        Object.defineProperty(obj, key, {\n\n            configurable: true,\n\n            set(item) {\n                value = item;\n\n                if (value) {\n                    resolve(value);\n                }\n            },\n\n            get() : mixed {\n                return value;\n            }\n        });\n    });\n}\n\nexport function stringifyError(err : mixed, level : number = 1) : string {\n\n    if (level >= 3) {\n        return 'stringifyError stack overflow';\n    }\n\n    try {\n        if (!err) {\n            return `<unknown error: ${ Object.prototype.toString.call(err) }>`;\n        }\n\n        if (typeof err === 'string') {\n            return err;\n        }\n\n        if (err instanceof Error) {\n            let stack = err && err.stack;\n            let message = err && err.message;\n\n            if (stack && message) {\n                if (stack.indexOf(message) !== -1) {\n                    return stack;\n                } else {\n                    return `${ message }\\n${ stack }`;\n                }\n            } else if (stack) {\n                return stack;\n            } else if (message) {\n                return message;\n            }\n        }\n\n        if (err && err.toString && typeof err.toString === 'function') {\n            // $FlowFixMe\n            return err.toString();\n        }\n\n        return Object.prototype.toString.call(err);\n\n    } catch (newErr) { // eslint-disable-line unicorn/catch-error-name\n        return `Error while stringifying error: ${ stringifyError(newErr, level + 1) }`;\n    }\n}\n\nexport function stringifyErrorMessage(err : mixed) : string {\n\n    let defaultMessage = `<unknown error: ${ Object.prototype.toString.call(err) }>`;\n\n    if (!err) {\n        return defaultMessage;\n    }\n\n    if (err instanceof Error) {\n        return err.message || defaultMessage;\n    }\n\n    if (typeof err.message === 'string') {\n        return err.message || defaultMessage;\n    }\n\n    return defaultMessage;\n}\n\nexport function stringify(item : mixed) : string {\n    if (typeof item === 'string') {\n        return item;\n    }\n\n    if (item && item.toString && typeof item.toString === 'function') {\n        // $FlowFixMe\n        return item.toString();\n    }\n\n    return Object.prototype.toString.call(item);\n}\n\nexport function domainMatches(hostname : string, domain : string) : boolean {\n    hostname = hostname.split('://')[1];\n    let index = hostname.indexOf(domain);\n    return (index !== -1 && hostname.slice(index) === domain);\n}\n\nexport function patchMethod(obj : Object, name : string, handler : Function) {\n    let original = obj[name];\n\n    obj[name] = function patchedMethod() : mixed {\n        return handler({\n            context:      this,\n            args:         Array.prototype.slice.call(arguments),\n            original,\n            callOriginal: () => original.apply(this, arguments)\n        });\n    };\n}\n\nexport function extend<T : Object | Function>(obj : T, source : Object) : T {\n    if (!source) {\n        return obj;\n    }\n\n    if (Object.assign) {\n        return Object.assign(obj, source);\n    }\n\n    for (let key in source) {\n        if (source.hasOwnProperty(key)) {\n            obj[key] = source[key];\n        }\n    }\n\n    return obj;\n}\n\nexport function values<T>(obj : { [string] : T }) : Array<T> {\n    let result = [];\n    for (let key in obj) {\n        if (obj.hasOwnProperty(key)) {\n            result.push(obj[key]);\n        }\n    }\n    return result;\n}\n\nexport function perc(pixels : number, percentage : number) : number {\n    return Math.round((pixels * percentage) / 100);\n}\n\nexport function min(...args : Array<number>) : number {\n    return Math.min(...args);\n}\n\nexport function max(...args : Array<number>) : number {\n    return Math.max(...args);\n}\n\nexport function regexMap<T>(str : string, regexp : RegExp, handler : () => T) : Array<T> {\n    let results = [];\n\n    // $FlowFixMe\n    str.replace(regexp, function regexMapMatcher(item) {\n        results.push(handler ? handler.apply(null, arguments) : item);\n    });\n\n    // $FlowFixMe\n    return results;\n}\n\nexport function svgToBase64(svg : string) : string {\n    return `data:image/svg+xml;base64,${ base64encode(svg) }`;\n}\n\nexport function objFilter<T, R>(obj : { [string] : T }, filter? : (T, ?string) => mixed = Boolean) : { [string] : R } {\n    let result = {};\n\n    for (let key in obj) {\n        if (!obj.hasOwnProperty(key) || !filter(obj[key], key)) {\n            continue;\n        }\n\n        result[key] = obj[key];\n    }\n\n    return result;\n}\n\nexport function identity <T>(item : T) : T {\n    return item;\n}\n\nexport function regexTokenize(text : string, regexp : RegExp) : Array<string> {\n    let result = [];\n    text.replace(regexp, token => {\n        result.push(token);\n        return '';\n    });\n    return result;\n}\n\nexport function promiseDebounce<T>(method : () => ZalgoPromise<T> | T, delay : number = 50) : () => ZalgoPromise<T> {\n\n    let promise;\n    let timeout;\n\n    const promiseDebounced = function() : ZalgoPromise<T> {\n        if (timeout) {\n            clearTimeout(timeout);\n        }\n\n        let localPromise = promise = promise || new ZalgoPromise();\n\n        timeout = setTimeout(() => {\n            promise = null;\n            timeout = null;\n\n            ZalgoPromise.try(method).then(\n                result => { localPromise.resolve(result); },\n                err => { localPromise.reject(err); }\n            );\n        }, delay);\n\n        return localPromise;\n    };\n\n    return setFunctionName(promiseDebounced, `${ getFunctionName(method) }::promiseDebounced`);\n}\n\nexport function safeInterval(method : Function, time : number) : { cancel : () => void } {\n\n    let timeout;\n\n    function loop() {\n        timeout = setTimeout(() => {\n            method();\n            loop();\n        }, time);\n    }\n\n    loop();\n\n    return {\n        cancel() {\n            clearTimeout(timeout);\n        }\n    };\n}\n\nexport function isInteger(str : string) : boolean {\n    return Boolean(str.match(/^[0-9]+$/));\n}\n\nexport function isFloat(str : string) : boolean {\n    return Boolean(str.match(/^[0-9]+\\.[0-9]+$/));\n}\n\nexport function serializePrimitive(value : string | number | boolean) : string {\n    return value.toString();\n}\n\nexport function deserializePrimitive(value : string) : string | number | boolean {\n    if (value === 'true') {\n        return true;\n    } else if (value === 'false') {\n        return false;\n    } else if (isInteger(value)) {\n        return parseInt(value, 10);\n    } else if (isFloat(value)) {\n        return parseFloat(value);\n    } else {\n        return value;\n    }\n}\n\nexport function dotify(obj : Object, prefix : string = '', newobj : Object = {}) : { [string] : string } {\n    prefix = prefix ? `${ prefix }.` : prefix;\n    for (let key in obj) {\n        if (!obj.hasOwnProperty(key) || obj[key] === undefined || obj[key] === null || typeof obj[key] === 'function') {\n            continue;\n        } else if (obj[key] && Array.isArray(obj[key]) && obj[key].length && obj[key].every(val => typeof val !== 'object')) {\n            newobj[`${ prefix }${ key }[]`] = obj[key].join(',');\n        } else if (obj[key] && typeof obj[key] === 'object') {\n            newobj = dotify(obj[key], `${ prefix }${ key }`, newobj);\n        } else {\n            newobj[`${ prefix }${ key }`] = serializePrimitive(obj[key]);\n        }\n    }\n    return newobj;\n}\n\nexport function undotify(obj : { [string] : string }) : Object {\n    \n    let result = {};\n\n    for (let key in obj) {\n        if (!obj.hasOwnProperty(key) || typeof obj[key] !== 'string') {\n            continue;\n        }\n\n        let value = obj[key];\n\n        if (key.match(/^.+\\[\\]$/)) {\n            key = key.slice(0, key.length - 2);\n            value = value.split(',').map(deserializePrimitive);\n        } else {\n            value = deserializePrimitive(value);\n        }\n\n        let keyResult = result;\n        let parts = key.split('.');\n        for (let i = 0; i < parts.length; i++) {\n            let part = parts[i];\n            let isLast = (i + 1 === parts.length);\n            let isIndex = !isLast && isInteger(parts[i + 1]);\n\n            if (part === 'constructor' || part === 'prototype' || part === '__proto__') {\n                throw new Error(`Disallowed key: ${ part }`);\n            }\n\n            if (isLast) {\n                // $FlowFixMe\n                keyResult[part] = value;\n            } else {\n                // $FlowFixMe\n                keyResult = keyResult[part] = keyResult[part] || (isIndex ? [] : {});\n            }\n        }\n    }\n\n    return result;\n}\n\nexport type EventEmitterType = {\n    on : (eventName : string, handler : Function) => CancelableType,\n    once : (eventName : string, handler : Function) => CancelableType,\n    trigger : (eventName : string, ...args : $ReadOnlyArray<mixed>) => ZalgoPromise<void>,\n    triggerOnce : (eventName : string, ...args : $ReadOnlyArray<mixed>) => ZalgoPromise<void>,\n    reset : () => void\n};\n\nexport function eventEmitter() : EventEmitterType {\n    let triggered = {};\n    let handlers = {};\n\n    return {\n\n        on(eventName : string, handler : Function) : CancelableType {\n            let handlerList = handlers[eventName] = handlers[eventName] || [];\n\n            handlerList.push(handler);\n\n            let cancelled = false;\n\n            return {\n                cancel() {\n                    if (!cancelled) {\n                        cancelled = true;\n                        handlerList.splice(handlerList.indexOf(handler), 1);\n                    }\n\n                }\n            };\n        },\n\n        once(eventName : string, handler : Function) : CancelableType {\n\n            let listener = this.on(eventName, () => {\n                listener.cancel();\n                handler();\n            });\n\n            return listener;\n        },\n\n        trigger(eventName : string, ...args : $ReadOnlyArray<mixed>) : ZalgoPromise<void> {\n\n            let handlerList = handlers[eventName];\n            let promises = [];\n\n            if (handlerList) {\n                for (let handler of handlerList) {\n                    promises.push(ZalgoPromise.try(() => handler(...args)));\n                }\n            }\n\n            return ZalgoPromise.all(promises).then(noop);\n        },\n\n        triggerOnce(eventName : string, ...args : $ReadOnlyArray<mixed>) : ZalgoPromise<void> {\n\n            if (triggered[eventName]) {\n                return ZalgoPromise.resolve();\n            }\n\n            triggered[eventName] = true;\n            return this.trigger(eventName, ...args);\n        },\n\n        reset() {\n            handlers = {};\n        }\n    };\n}\n\nexport function camelToDasherize(string : string) : string {\n    return string.replace(/([A-Z])/g, (g) => {\n        return `-${ g.toLowerCase() }`;\n    });\n}\n\nexport function dasherizeToCamel(string : string) : string {\n    return string.replace(/-([a-z])/g, (g) => {\n        return g[1].toUpperCase();\n    });\n}\n\nexport function capitalizeFirstLetter(string : string) : string {\n    return string.charAt(0).toUpperCase() + string.slice(1).toLowerCase();\n}\n\nexport function get(item : Object, path : string, def : mixed) : mixed {\n\n    if (!path) {\n        return def;\n    }\n\n    let pathParts = path.split('.');\n\n    // Loop through each section of our key path\n\n    for (let i = 0; i < pathParts.length; i++) {\n\n        // If we have an object, we can get the key\n        if (typeof item === 'object' && item !== null) {\n            item = item[pathParts[i]];\n\n        // Otherwise, we should return the default (undefined if not provided)\n        } else {\n            return def;\n        }\n    }\n\n    // If our final result is undefined, we should return the default\n\n    return item === undefined ? def : item;\n}\n\nexport function safeTimeout(method : Function, time : number) {\n\n    let interval = safeInterval(() => {\n        time -= 100;\n        if (time <= 0) {\n            interval.cancel();\n            method();\n        }\n    }, 100);\n}\n\nexport function defineLazyProp<T>(obj : Object | Array<mixed>, key : string | number, getter : () => T) {\n    if (Array.isArray(obj)) {\n        if (typeof key !== 'number') {\n            throw new TypeError(`Array key must be number`);\n        }\n    } else if (typeof obj === 'object' && obj !== null) {\n        if (typeof key !== 'string') {\n            throw new TypeError(`Object key must be string`);\n        }\n    }\n    \n    Object.defineProperty(obj, key, {\n        configurable: true,\n        enumerable:   true,\n        get:          () => {\n            // $FlowFixMe\n            delete obj[key];\n            let value = getter();\n            // $FlowFixMe\n            obj[key] = value;\n            return value;\n        },\n        set: (value : T) => {\n            // $FlowFixMe\n            delete obj[key];\n            // $FlowFixMe\n            obj[key] = value;\n        }\n    });\n}\n\nexport function arrayFrom<T>(item : Iterable<T>) : Array<T> { // eslint-disable-line no-undef\n    return Array.prototype.slice.call(item);\n}\n\nexport function isObject(item : mixed) : boolean {\n    return (typeof item === 'object' && item !== null);\n}\n\nexport function isObjectObject(obj : mixed) : boolean {\n    return isObject(obj) && Object.prototype.toString.call(obj) === '[object Object]';\n}\n\nexport function isPlainObject(obj : mixed) : boolean {\n    if (!isObjectObject(obj)) {\n        return false;\n    }\n\n    // $FlowFixMe\n    let constructor = obj.constructor;\n\n    if (typeof constructor !== 'function') {\n        return false;\n    }\n\n    let prototype = constructor.prototype;\n\n    if (!isObjectObject(prototype)) {\n        return false;\n    }\n\n    if (!prototype.hasOwnProperty('isPrototypeOf')) {\n        return false;\n    }\n\n    return true;\n}\n\nexport function replaceObject<T : Array<mixed> | Object> (item : T, replacer : (mixed, string | number, string) => mixed, fullKey : string = '') : T {\n\n    if (Array.isArray(item)) {\n        let length = item.length;\n        let result : Array<mixed> = [];\n\n        for (let i = 0; i < length; i++) {\n\n            \n            defineLazyProp(result, i, () => {\n                let itemKey = fullKey ? `${ fullKey }.${ i }` : `${ i }`;\n                let el = item[i];\n\n                let child = replacer(el, i, itemKey);\n\n                if (isPlainObject(child) || Array.isArray(child)) {\n                    // $FlowFixMe\n                    child = replaceObject(child, replacer, itemKey);\n                }\n\n                return child;\n            });\n        }\n\n        // $FlowFixMe\n        return result;\n    } else if (isPlainObject(item)) {\n        let result = {};\n\n        for (let key in item) {\n            if (!item.hasOwnProperty(key)) {\n                continue;\n            }\n\n            defineLazyProp(result, key, () => {\n                let itemKey = fullKey ? `${ fullKey }.${ key }` : `${ key }`;\n                // $FlowFixMe\n                let el = item[key];\n\n                let child = replacer(el, key, itemKey);\n\n                if (isPlainObject(child) || Array.isArray(child)) {\n                    // $FlowFixMe\n                    child = replaceObject(child, replacer, itemKey);\n                }\n\n                return child;\n            });\n        }\n\n        // $FlowFixMe\n        return result;\n    } else {\n        throw new Error(`Pass an object or array`);\n    }\n}\n\n\nexport function copyProp(source : Object, target : Object, name : string, def : mixed) {\n    if (source.hasOwnProperty(name)) {\n        let descriptor = Object.getOwnPropertyDescriptor(source, name);\n        // $FlowFixMe\n        Object.defineProperty(target, name, descriptor);\n\n    } else {\n        target[name] = def;\n    }\n}\n\ntype RegexResultType = {\n    text : string,\n    groups : Array<string>,\n    start : number,\n    end : number,\n    length : number,\n    replace : (text : string) => string\n};\n\nexport function regex(pattern : string | RegExp, string : string, start : number = 0) : ?RegexResultType {\n\n    if (typeof pattern === 'string') {\n        // eslint-disable-next-line security/detect-non-literal-regexp\n        pattern = new RegExp(pattern);\n    }\n\n    let result = string.slice(start).match(pattern);\n\n    if (!result) {\n        return;\n    }\n\n    // $FlowFixMe\n    let index : number = result.index;\n    let regmatch = result[0];\n\n    return {\n        text:   regmatch,\n        groups: result.slice(1),\n        start:  start + index,\n        end:    start + index + regmatch.length,\n        length: regmatch.length,\n\n        replace(text : string) : string {\n\n            if (!regmatch) {\n                return '';\n            }\n\n            return `${ regmatch.slice(0, start + index) }${ text }${ regmatch.slice(index + regmatch.length) }`;\n        }\n    };\n}\n\nexport function regexAll(pattern : string | RegExp, string : string) : Array<RegexResultType> {\n\n    let matches = [];\n    let start = 0;\n\n    // eslint-disable-next-line no-constant-condition\n    while (true) {\n        let regmatch = regex(pattern, string, start);\n\n        if (!regmatch) {\n            break;\n        }\n\n        matches.push(regmatch);\n        start = match.end;\n    }\n\n    return matches;\n}\n\nexport function isDefined(value : ?mixed) : boolean {\n    return value !== null && value !== undefined;\n}\n\nexport function cycle(method : Function) : ZalgoPromise<void> {\n    return ZalgoPromise.try(method).then(() => cycle(method));\n}\n\nexport function debounce<T>(method : (...args : Array<mixed>) => T, time : number = 100) : (...args : Array<mixed>) => void {\n\n    let timeout;\n\n    const debounceWrapper = function() {\n        clearTimeout(timeout);\n\n        timeout = setTimeout(() => {\n            return method.apply(this, arguments);\n        }, time);\n    };\n\n    return setFunctionName(debounceWrapper, `${ getFunctionName(method) }::debounced`);\n}\n\nexport function isRegex(item : mixed) : boolean {\n    return Object.prototype.toString.call(item) === '[object RegExp]';\n}\n\ntype FunctionProxy<T : Function> = (method : T) => T;\n\n// eslint-disable-next-line flowtype/no-weak-types\nexport let weakMapMemoize : FunctionProxy<*> = <R : mixed>(method : (arg : any) => R) : ((...args : Array<any>) => R) => {\n\n    let weakmap = new WeakMap();\n\n    // eslint-disable-next-line flowtype/no-weak-types\n    return function weakmapMemoized(arg : any) : R {\n        return weakmap.getOrSet(arg, () => method.call(this, arg));\n    };\n};\n\ntype FunctionPromiseProxy<R : mixed, T : (...args : $ReadOnlyArray<mixed>) => ZalgoPromise<R>> = (T) => T;\n\n// eslint-disable-next-line flowtype/no-weak-types\nexport let weakMapMemoizePromise : FunctionPromiseProxy<*, *> = <R : mixed>(method : (arg : any) => ZalgoPromise<R>) : ((...args : Array<any>) => ZalgoPromise<R>) => {\n\n    let weakmap = new WeakMap();\n\n    // eslint-disable-next-line flowtype/no-weak-types\n    return function weakmapMemoizedPromise(arg : any) : ZalgoPromise<R> {\n        return weakmap.getOrSet(arg, () =>\n            method.call(this, arg).finally(() => {\n                weakmap.delete(arg);\n            })\n        );\n    };\n};\n\nexport function getOrSet<O : Object, T : mixed>(obj : O, key : string, getter : () => T) : T {\n    if (obj.hasOwnProperty(key)) {\n        return obj[key];\n    }\n\n    const val = getter();\n    obj[key] = val;\n    return val;\n}\n\nexport type CleanupType = {|\n    set : <T : mixed>(string, T) => T, // eslint-disable-line no-undef\n    register : (Function) => void,\n    all : () => ZalgoPromise<void>\n|};\n\nexport function cleanup(obj : Object) : CleanupType {\n\n    const tasks = [];\n    let cleaned = false;\n\n    return {\n        set<T : mixed>(name : string, item : T) : T {\n            if (!cleaned) {\n                obj[name] = item;\n                this.register(() => {\n                    delete obj[name];\n                });\n            }\n            return item;\n        },\n\n        register(method : Function) {\n            if (cleaned) {\n                method();\n            } else {\n                tasks.push(once(method));\n            }\n        },\n\n        all() : ZalgoPromise<void> {\n            const results = [];\n            cleaned = true;\n\n            while (tasks.length) {\n                const task = tasks.shift();\n                results.push(task());\n            }\n\n            return ZalgoPromise.all(results).then(noop);\n        }\n    };\n}\n\nexport function tryCatch<T>(fn : () => T) : {| result : T, error : void |} | {| result : void, error : mixed |} {\n    let result;\n    let error;\n\n    try {\n        result = fn();\n    } catch (err) {\n        error = err;\n    }\n    \n    // $FlowFixMe\n    return { result, error };\n}\n\nexport function removeFromArray<X, T : Array<X>>(arr : T, item : X) {\n    const index = arr.indexOf(item);\n    if (index !== -1) {\n        arr.splice(index, 1);\n    }\n}\n\nexport function assertExists<T>(name : string, thing : void | null | T) : T {\n    if (thing === null || typeof thing === 'undefined') {\n        throw new Error(`Expected ${ name } to be present`);\n    }\n                            \n    return thing;\n}\n                            \nexport function unique(arr : $ReadOnlyArray<string>) : $ReadOnlyArray<string> {\n    const result = {};\n    for (const item of arr) {\n        // eslint-disable-next-line const-immutable/no-mutation\n        result[item] = true;\n    }\n    return Object.keys(result);\n}\n","/* @flow */\n/* eslint max-lines: off */\n\nimport { ZalgoPromise } from 'zalgo-promise/src';\nimport { linkFrameWindow, isWindowClosed,\n    type SameDomainWindowType, type CrossDomainWindowType } from 'cross-domain-utils/src';\nimport { WeakMap } from 'cross-domain-safe-weakmap/src';\n\nimport { inlineMemoize, noop, stringify, capitalizeFirstLetter,\n    once, extend, safeInterval, uniqueID, arrayFrom } from './util';\nimport { isDevice } from './device';\nimport { KEY_CODES } from './constants';\nimport type { CancelableType } from './types';\n\ntype ElementRefType = string | HTMLElement;\n\nexport function isDocumentReady() : boolean {\n    return Boolean(document.body) && document.readyState === 'complete';\n}\n\nexport function urlEncode(str : string) : string {\n    return str.replace(/\\?/g, '%3F').replace(/&/g, '%26').replace(/#/g, '%23').replace(/\\+/g, '%2B');\n}\n\nexport function waitForWindowReady() : ZalgoPromise<void> {\n    return inlineMemoize(waitForWindowReady, () : ZalgoPromise<void> => {\n        return new ZalgoPromise(resolve => {\n            if (isDocumentReady()) {\n                resolve();\n            }\n\n            window.addEventListener('load', () => resolve());\n        });\n    });\n}\n\nexport function waitForDocumentReady() : ZalgoPromise<void> {\n    return inlineMemoize(waitForDocumentReady, () : ZalgoPromise<void> => {\n        return new ZalgoPromise(resolve => {\n\n            if (isDocumentReady()) {\n                return resolve();\n            }\n\n            let interval = setInterval(() => {\n                if (isDocumentReady()) {\n                    clearInterval(interval);\n                    return resolve();\n                }\n            }, 10);\n        });\n    });\n}\n\nexport function waitForDocumentBody() : ZalgoPromise<HTMLBodyElement> {\n    return waitForDocumentReady().then(() => {\n        if (document.body) {\n            return document.body;\n        }\n\n        throw new Error('Document ready but document.body not present');\n    });\n}\n\nexport function parseQuery(queryString : string) : Object {\n    return inlineMemoize(parseQuery, () : Object => {\n        let params = {};\n\n        if (!queryString) {\n            return params;\n        }\n\n        if (queryString.indexOf('=') === -1) {\n            return params;\n        }\n\n        for (let pair of queryString.split('&')) {\n            pair = pair.split('=');\n\n            if (pair[0] && pair[1]) {\n                params[decodeURIComponent(pair[0])] = decodeURIComponent(pair[1]);\n            }\n        }\n\n        return params;\n    }, [ queryString ]);\n}\n\n\nexport function getQueryParam(name : string) : string {\n    return parseQuery(window.location.search.slice(1))[name];\n}\n\nexport function urlWillRedirectPage(url : string) : boolean {\n\n    if (url.indexOf('#') === -1) {\n        return true;\n    }\n\n    if (url.indexOf('#') === 0) {\n        return false;\n    }\n\n    if (url.split('#')[0] === window.location.href.split('#')[0]) {\n        return false;\n    }\n\n    return true;\n}\n\nexport function formatQuery(obj : { [ string ] : string } = {}) : string {\n\n    return Object.keys(obj).filter(key => {\n        return typeof obj[key] === 'string';\n    }).map(key => {\n        return `${ urlEncode(key) }=${ urlEncode(obj[key]) }`;\n    }).join('&');\n}\n\nexport function extendQuery(originalQuery : string, props : { [ string ] : string } = {}) : string {\n\n    if (!props || !Object.keys(props).length) {\n        return originalQuery;\n    }\n\n    return formatQuery({\n        ...parseQuery(originalQuery),\n        ...props\n    });\n}\n\nexport function extendUrl(url : string, options : { query? : { [string] : string }, hash? : { [string] : string } } = {}) : string {\n\n    let query = options.query || {};\n    let hash = options.hash || {};\n\n    let originalUrl;\n    let originalQuery;\n    let originalHash;\n\n    [ originalUrl, originalHash ] = url.split('#');\n    [ originalUrl, originalQuery ] = originalUrl.split('?');\n\n    let queryString = extendQuery(originalQuery, query);\n    let hashString = extendQuery(originalHash, hash);\n\n    if (queryString) {\n        originalUrl = `${ originalUrl }?${ queryString }`;\n    }\n\n    if (hashString) {\n        originalUrl = `${ originalUrl }#${ hashString }`;\n    }\n\n    return originalUrl;\n}\n\nexport function redirect(url : string, win : CrossDomainWindowType = window) : ZalgoPromise<void> {\n    return new ZalgoPromise(resolve => {\n        win.location = url;\n        if (!urlWillRedirectPage(url)) {\n            resolve();\n        }\n    });\n}\n\nexport function hasMetaViewPort() : boolean {\n    let meta = document.querySelector('meta[name=viewport]');\n\n    if (isDevice() && window.screen.width < 660 && !meta) {\n        return false;\n    }\n\n    return true;\n}\n\nexport function isElementVisible(el : HTMLElement) : boolean {\n    return Boolean(el.offsetWidth || el.offsetHeight || el.getClientRects().length);\n}\n\nexport function enablePerformance() : boolean {\n    return inlineMemoize(enablePerformance, () : boolean => {\n        /* eslint-disable compat/compat */\n        return Boolean(\n            window.performance &&\n            performance.now &&\n            performance.timing &&\n            performance.timing.connectEnd &&\n            performance.timing.navigationStart &&\n            (Math.abs(performance.now() - Date.now()) > 1000) &&\n            (performance.now() - (performance.timing.connectEnd - performance.timing.navigationStart)) > 0\n        );\n        /* eslint-enable compat/compat */\n    });\n}\n\nexport function getPageRenderTime() : ZalgoPromise<?number> {\n    return waitForDocumentReady().then(() => {\n\n        if (!enablePerformance()) {\n            return;\n        }\n\n        let timing = window.performance.timing;\n\n        if (timing.connectEnd && timing.domInteractive) {\n            return timing.domInteractive - timing.connectEnd;\n        }\n    });\n}\n\nexport function htmlEncode(html : string = '') : string {\n    return html.toString()\n        .replace(/&/g, '&amp;')\n        .replace(/</g, '&lt;')\n        .replace(/>/g, '&gt;')\n        .replace(/\"/g, '&quot;')\n        .replace(/'/g, '&#39;')\n        .replace(/\\//g, '&#x2F;');\n}\n\nexport function isBrowser() : boolean {\n    return (typeof window !== 'undefined');\n}\n\nexport function querySelectorAll(selector : string, doc : HTMLElement = window.document) : Array<HTMLElement> {\n    return Array.prototype.slice.call(doc.querySelectorAll(selector));\n}\n\nexport function onClick(element : HTMLElement, handler : (Event) => void) {\n    element.addEventListener('touchstart', noop);\n    element.addEventListener('click', handler);\n    element.addEventListener('keypress', (event : Event) => {\n        // $FlowFixMe\n        if (event.keyCode === KEY_CODES.ENTER || event.keyCode === KEY_CODES.SPACE) {\n            return handler(event);\n        }\n    });\n}\n\nexport function getScript({ host = window.location.host, path } : { host? : string, path : string }) : ?HTMLScriptElement {\n    return inlineMemoize(getScript, () : ?HTMLScriptElement => {\n\n        let url = `${ host }${ path }`;\n        let scripts = Array.prototype.slice.call(document.getElementsByTagName('script'));\n\n        for (let script of scripts) {\n            if (!script.src) {\n                continue;\n            }\n\n            let src = script.src.replace(/^https?:\\/\\//, '').split('?')[0];\n\n            if (src === url) {\n                return script;\n            }\n        }\n    }, [ path ]);\n}\n\nexport function isLocalStorageEnabled() : boolean {\n    return inlineMemoize(isLocalStorageEnabled, () => {\n        try {\n            if (typeof window === 'undefined') {\n                return false;\n            }\n\n            if (window.localStorage) {\n                let value = Math.random().toString();\n                window.localStorage.setItem('__test__localStorage__', value);\n                let result = window.localStorage.getItem('__test__localStorage__');\n                window.localStorage.removeItem('__test__localStorage__');\n                if (value === result) {\n                    return true;\n                }\n            }\n        } catch (err) {\n            // pass\n        }\n        return false;\n    });\n}\n\nexport function getBrowserLocales() : Array<{ country? : string, lang : string }> {\n    let nav = window.navigator;\n\n    let locales = nav.languages\n        ? Array.prototype.slice.apply(nav.languages)\n        : [];\n\n    if (nav.language) {\n        locales.push(nav.language);\n    }\n\n    if (nav.userLanguage) {\n        locales.push(nav.userLanguage);\n    }\n\n    return locales.map(locale => {\n\n        if (locale && locale.match(/^[a-z]{2}[-_][A-Z]{2}$/)) {\n            let [ lang, country ] = locale.split(/[-_]/);\n            return { country, lang };\n        }\n\n        if (locale && locale.match(/^[a-z]{2}$/)) {\n            return { lang: locale };\n        }\n\n        return null;\n\n    }).filter(Boolean);\n}\n\n\nexport function appendChild(container : HTMLElement, child : HTMLElement | Text) {\n    container.appendChild(child);\n}\n\nexport function isElement(element : mixed) : boolean {\n\n    if (element instanceof window.Element) {\n        return true;\n    }\n\n    if (element !== null && typeof element === 'object' && element.nodeType === 1 && typeof element.style === 'object' && typeof element.ownerDocument === 'object') {\n        return true;\n    }\n\n    return false;\n}\n\nexport function getElementSafe(id : ElementRefType, doc : Document | HTMLElement = document) : ?HTMLElement {\n\n    if (isElement(id)) {\n        // $FlowFixMe\n        return id;\n    }\n\n    if (typeof id === 'string') {\n        return doc.querySelector(id);\n    }\n}\n\nexport function getElement(id : ElementRefType, doc : Document | HTMLElement = document) : HTMLElement {\n\n    let element = getElementSafe(id, doc);\n\n    if (element) {\n        return element;\n    }\n\n    throw new Error(`Can not find element: ${ stringify(id) }`);\n}\n\nexport function elementReady(id : ElementRefType) : ZalgoPromise<window.HTMLElement> {\n    return new ZalgoPromise((resolve, reject) => {\n\n        let name = stringify(id);\n        let el = getElementSafe(id);\n\n        if (el) {\n            return resolve(el);\n        }\n\n        if (isDocumentReady()) {\n            return reject(new Error(`Document is ready and element ${ name } does not exist`));\n        }\n\n        let interval = setInterval(() => {\n\n            el = getElementSafe(id);\n\n            if (el) {\n                clearInterval(interval);\n                return resolve(el);\n            }\n\n            if (isDocumentReady()) {\n                clearInterval(interval);\n                return reject(new Error(`Document is ready and element ${ name } does not exist`));\n            }\n        }, 10);\n    });\n}\n\nexport function PopupOpenError(message : string) {\n    this.message = message;\n}\n\nPopupOpenError.prototype = Object.create(Error.prototype);\n\ntype PopupOptions = {|\n    name? : string,\n    width? : number,\n    height? : number,\n    top? : number,\n    left? : number,\n    status? : 0 | 1,\n    resizable? : 0 | 1,\n    toolbar? : 0 | 1,\n    menubar? : 0 | 1,\n    scrollbars? : 0 | 1\n|};\n\nexport function popup(url : string, options? : PopupOptions) : CrossDomainWindowType {\n\n    // $FlowFixMe\n    options = options || {};\n\n    let { width, height } = options;\n\n    let top = 0;\n    let left = 0;\n\n    if (width) {\n        if (window.outerWidth) {\n            left = Math.round((window.outerWidth - width) / 2) + window.screenX;\n        } else if (window.screen.width) {\n            left = Math.round((window.screen.width - width) / 2);\n        }\n    }\n\n    if (height) {\n        if (window.outerHeight) {\n            top = Math.round((window.outerHeight - height) / 2) + window.screenY;\n        } else if (window.screen.height) {\n            top = Math.round((window.screen.height - height) / 2);\n        }\n    }\n\n    if (width && height) {\n        options = {\n            top,\n            left,\n            width,\n            height,\n            status:     1,\n            toolbar:    0,\n            menubar:    0,\n            resizable:  1,\n            scrollbars: 1,\n            ...options\n        };\n    }\n\n    let name = options.name || '';\n    delete options.name;\n\n    // eslint-disable-next-line array-callback-return\n    let params = Object.keys(options).map(key => {\n        // $FlowFixMe\n        if (options[key] !== null && options[key] !== undefined) {\n            return `${ key }=${ stringify(options[key]) }`;\n        }\n    }).filter(Boolean).join(',');\n\n    let win;\n\n    try {\n        win = window.open(url, name, params, true);\n    } catch (err) {\n        throw new PopupOpenError(`Can not open popup window - ${ err.stack || err.message }`);\n    }\n\n    if (isWindowClosed(win)) {\n        let err = new PopupOpenError(`Can not open popup window - blocked`);\n        throw err;\n    }\n\n    window.addEventListener('unload', () => win.close());\n\n    return win;\n}\n\n\nexport function writeToWindow(win : SameDomainWindowType, html : string) {\n    try {\n        win.document.open();\n        win.document.write(html);\n        win.document.close();\n    } catch (err) {\n        try {\n            win.location = `javascript: document.open(); document.write(${ JSON.stringify(html) }); document.close();`;\n        } catch (err2) {\n            // pass\n        }\n    }\n}\n\nexport function writeElementToWindow(win : SameDomainWindowType, el : HTMLElement) {\n\n    let tag = el.tagName.toLowerCase();\n\n    if (tag !== 'html') {\n        throw new Error(`Expected element to be html, got ${ tag }`);\n    }\n\n    let documentElement = win.document.documentElement;\n\n    for (const child of arrayFrom(documentElement.children)) {\n        documentElement.removeChild(child);\n    }\n\n    for (const child of arrayFrom(el.children)) {\n        documentElement.appendChild(child);\n    }\n}\n\nexport function setStyle(el : HTMLElement, styleText : string, doc : Document = window.document) {\n    // $FlowFixMe\n    if (el.styleSheet) {\n        // $FlowFixMe\n        el.styleSheet.cssText = styleText;\n    } else {\n        el.appendChild(doc.createTextNode(styleText));\n    }\n}\n\nexport type ElementOptionsType = {\n    style? : { [ string ] : string },\n    id? : string,\n    class? : ?Array<string>,\n    attributes? : { [ string ] : string },\n    styleSheet? : ?string,\n    html? : ?string\n};\n\nlet awaitFrameLoadPromises : WeakMap<HTMLIFrameElement, ZalgoPromise<HTMLIFrameElement>>;\n\nexport function awaitFrameLoad(frame : HTMLIFrameElement) : ZalgoPromise<HTMLIFrameElement> {\n    awaitFrameLoadPromises = awaitFrameLoadPromises || new WeakMap();\n\n    if (awaitFrameLoadPromises.has(frame)) {\n        let promise = awaitFrameLoadPromises.get(frame);\n        if (promise) {\n            return promise;\n        }\n    }\n\n    let promise = new ZalgoPromise((resolve, reject) => {\n        frame.addEventListener('load', () => {\n            linkFrameWindow(frame);\n            resolve(frame);\n        });\n\n        frame.addEventListener('error', (err : Event) => {\n            if (frame.contentWindow) {\n                resolve(frame);\n            } else {\n                reject(err);\n            }\n        });\n    });\n\n    awaitFrameLoadPromises.set(frame, promise);\n\n    return promise;\n}\n\nexport function awaitFrameWindow(frame : HTMLIFrameElement) : ZalgoPromise<CrossDomainWindowType> {\n    return awaitFrameLoad(frame).then(loadedFrame => {\n\n        if (!loadedFrame.contentWindow) {\n            throw new Error(`Could not find window in iframe`);\n        }\n\n        return loadedFrame.contentWindow;\n    });\n}\n\nexport function createElement(tag : string = 'div', options : ElementOptionsType = {}, container : ?HTMLElement) : HTMLElement {\n\n    tag = tag.toLowerCase();\n    let element = document.createElement(tag);\n\n    if (options.style) {\n        extend(element.style, options.style);\n    }\n\n    if (options.class) {\n        element.className = options.class.join(' ');\n    }\n\n    if (options.id) {\n        element.setAttribute('id', options.id);\n    }\n\n    if (options.attributes) {\n        for (let key of Object.keys(options.attributes)) {\n            element.setAttribute(key, options.attributes[key]);\n        }\n    }\n\n    if (options.styleSheet) {\n        setStyle(element, options.styleSheet);\n    }\n\n    if (container) {\n        appendChild(container, element);\n    }\n\n    if (options.html) {\n        if (tag === 'iframe') {\n            // $FlowFixMe\n            if (!container || !element.contentWindow) {\n                throw new Error(`Iframe html can not be written unless container provided and iframe in DOM`);\n            }\n\n            // $FlowFixMe\n            writeToWindow(element.contentWindow, options.html);\n\n        } else {\n            element.innerHTML = options.html;\n        }\n    }\n\n    return element;\n}\n\n\nexport type IframeElementOptionsType = {\n    style? : { [ string ] : string },\n    class? : ?Array<string>,\n    attributes? : { [ string ] : string },\n    styleSheet? : ?string,\n    html? : ?string,\n    url? : ?string\n};\n\nexport function iframe(options : IframeElementOptionsType = {}, container : ?HTMLElement) : HTMLIFrameElement {\n\n    let attributes = options.attributes || {};\n    let style = options.style || {};\n\n    let frame = createElement('iframe', {\n        attributes: {\n            allowTransparency: 'true',\n            ...attributes\n        },\n        style: {\n            backgroundColor: 'transparent',\n            border:          'none',\n            ...style\n        },\n        html:  options.html,\n        class: options.class\n    });\n\n    const isIE = window.navigator.userAgent.match(/MSIE|Edge/i);\n\n    if (!frame.hasAttribute('id')) {\n        frame.setAttribute('id', uniqueID());\n    }\n\n    // $FlowFixMe\n    awaitFrameLoad(frame);\n\n    if (container) {\n        let el = getElement(container);\n        el.appendChild(frame);\n    }\n\n    if (options.url || isIE) {\n        frame.setAttribute('src', options.url || 'about:blank');\n    }\n\n    // $FlowFixMe\n    return frame;\n}\n\nexport function addEventListener(obj : HTMLElement, event : string, handler : (event : Event) => void) : CancelableType {\n    obj.addEventListener(event, handler);\n    return {\n        cancel() {\n            obj.removeEventListener(event, handler);\n        }\n    };\n}\n\nexport function bindEvents(element : HTMLElement, eventNames : Array<string>, handler : (event : Event) => void) : CancelableType {\n\n    handler = once(handler);\n\n    for (let eventName of eventNames) {\n        element.addEventListener(eventName, handler);\n    }\n\n    return {\n        cancel: once(() => {\n            for (let eventName of eventNames) {\n                element.removeEventListener(eventName, handler);\n            }\n        })\n    };\n}\n\nconst VENDOR_PREFIXES = [ 'webkit', 'moz', 'ms', 'o' ];\n\nexport function setVendorCSS(element : HTMLElement, name : string, value : string) {\n\n    // $FlowFixMe\n    element.style[name] = value;\n\n    let capitalizedName = capitalizeFirstLetter(name);\n\n    for (let prefix of VENDOR_PREFIXES) {\n        // $FlowFixMe\n        element.style[`${ prefix }${ capitalizedName }`] = value;\n    }\n}\n\nconst ANIMATION_START_EVENTS = [ 'animationstart', 'webkitAnimationStart', 'oAnimationStart', 'MSAnimationStart' ];\nconst ANIMATION_END_EVENTS   = [ 'animationend', 'webkitAnimationEnd', 'oAnimationEnd', 'MSAnimationEnd' ];\n\nexport function animate(element : ElementRefType, name : string, clean : (Function) => void, timeout : number = 1000) : ZalgoPromise<void> {\n    return new ZalgoPromise((resolve, reject) => {\n\n        let el = getElement(element);\n\n        if (!el) {\n            return resolve();\n        }\n\n        let hasStarted = false;\n\n        let startTimeout;\n        let endTimeout;\n        let startEvent;\n        let endEvent;\n\n        function cleanUp() {\n            clearTimeout(startTimeout);\n            clearTimeout(endTimeout);\n            startEvent.cancel();\n            endEvent.cancel();\n        }\n\n        startEvent = bindEvents(el, ANIMATION_START_EVENTS, event => {\n\n            // $FlowFixMe\n            if (event.target !== el || event.animationName !== name) {\n                return;\n            }\n\n            clearTimeout(startTimeout);\n\n            event.stopPropagation();\n\n            startEvent.cancel();\n            hasStarted = true;\n\n            endTimeout = setTimeout(() => {\n                cleanUp();\n                resolve();\n            }, timeout);\n        });\n\n        endEvent = bindEvents(el, ANIMATION_END_EVENTS, event => {\n\n            // $FlowFixMe\n            if (event.target !== el || event.animationName !== name) {\n                return;\n            }\n\n            cleanUp();\n\n            // $FlowFixMe\n            if (typeof event.animationName === 'string' && event.animationName !== name) {\n                return reject(`Expected animation name to be ${ name }, found ${ event.animationName }`);\n            }\n\n            return resolve();\n        });\n\n        setVendorCSS(el, 'animationName', name);\n\n        startTimeout = setTimeout(() => {\n            if (!hasStarted) {\n                cleanUp();\n                return resolve();\n            }\n        }, 200);\n\n        if (clean) {\n            clean(cleanUp);\n        }\n    });\n}\n\nconst STYLE = {\n\n    DISPLAY: {\n        NONE:  'none',\n        BLOCK: 'block'\n    },\n\n    VISIBILITY: {\n        VISIBLE: 'visible',\n        HIDDEN:  'hidden'\n    },\n\n    IMPORTANT: 'important'\n};\n\nexport function makeElementVisible(element : HTMLElement) {\n    element.style.setProperty('visibility', '');\n}\n\nexport function makeElementInvisible(element : HTMLElement) {\n    element.style.setProperty('visibility', STYLE.VISIBILITY.HIDDEN, STYLE.IMPORTANT);\n}\n\n\nexport function showElement(element : HTMLElement) {\n    element.style.setProperty('display', '');\n}\n\nexport function hideElement(element : HTMLElement) {\n    element.style.setProperty('display', STYLE.DISPLAY.NONE, STYLE.IMPORTANT);\n}\n\nexport function destroyElement(element : HTMLElement) {\n    if (element && element.parentNode) {\n        element.parentNode.removeChild(element);\n    }\n}\n\nexport function showAndAnimate(element : HTMLElement, name : string, clean : (Function) => void) : ZalgoPromise<void> {\n    let animation = animate(element, name, clean);\n    showElement(element);\n    return animation;\n}\n\nexport function animateAndHide(element : HTMLElement, name : string, clean : (Function) => void) : ZalgoPromise<void> {\n    return animate(element, name, clean).then(() => {\n        hideElement(element);\n    });\n}\n\nexport function addClass(element : HTMLElement, name : string) {\n    element.classList.add(name);\n}\n\nexport function removeClass(element : HTMLElement, name : string) {\n    element.classList.remove(name);\n}\n\nexport function isElementClosed(el : HTMLElement) : boolean {\n    if (!el || !el.parentNode) {\n        return true;\n    }\n    return false;\n}\n\nexport function watchElementForClose(element : HTMLElement, handler : () => mixed) : CancelableType {\n    handler = once(handler);\n\n    let interval;\n\n    if (isElementClosed(element)) {\n        handler();\n    } else {\n        interval = safeInterval(() => {\n            if (isElementClosed(element)) {\n                interval.cancel();\n                handler();\n            }\n        }, 50);\n    }\n\n    return {\n        cancel() {\n            if (interval) {\n                interval.cancel();\n            }\n        }\n    };\n}\n\nexport function fixScripts(el : HTMLElement, doc : Document = window.document) {\n    for (let script of querySelectorAll('script', el)) {\n        let parentNode = script.parentNode;\n\n        if (!parentNode) {\n            continue;\n        }\n\n        let newScript = doc.createElement('script');\n        newScript.text = script.textContent;\n        parentNode.replaceChild(newScript, script);\n    }\n}\n\ntype OnResizeOptions = {|\n    width? : boolean,\n    height? : boolean,\n    interval? : number,\n    win? : SameDomainWindowType\n|};\n\nexport function onResize(el : HTMLElement, handler : ({ width : number, height : number }) => void, { width = true, height = true, interval = 100, win = window } : OnResizeOptions = {}) : {} {\n    let currentWidth = el.offsetWidth;\n    let currentHeight = el.offsetHeight;\n\n    handler({ width: currentWidth, height: currentHeight });\n\n    let check = () => {\n        let newWidth = el.offsetWidth;\n        let newHeight = el.offsetHeight;\n\n        if ((width && newWidth !== currentWidth) || (height && newHeight !== currentHeight)) {\n            handler({ width: newWidth, height: newHeight });\n        }\n\n        currentWidth = newWidth;\n        currentHeight = newHeight;\n    };\n\n    let observer;\n    let timeout;\n\n    if (typeof win.ResizeObserver !== 'undefined') {\n        observer = new win.ResizeObserver(check);\n        observer.observe(el);\n\n    } else if (typeof win.MutationObserver !== 'undefined') {\n        observer = new win.MutationObserver(check);\n        observer.observe(el, {\n            attributes:    true,\n            childList:     true,\n            subtree:       true,\n            characterData: false\n        });\n        win.addEventListener('resize', check);\n    } else {\n        let loop = () => {\n            check();\n            timeout = setTimeout(loop, interval);\n        };\n        loop();\n    }\n\n    return {\n        cancel: () => {\n            observer.disconnect();\n            window.removeEventListener('resize', check);\n            clearTimeout(timeout);\n        }\n    };\n}\n\nexport function getResourceLoadTime(url : string) : ?number {\n\n    if (!enablePerformance()) {\n        return;\n    }\n\n    if (!window.performance || typeof window.performance.getEntries !== 'function') {\n        return;\n    }\n\n    const entries = window.performance.getEntries();\n\n    for (let i = 0; i < entries.length; i++) {\n        const entry = entries[i];\n\n        if (entry && entry.name && entry.name.indexOf(url) === 0 && typeof entry.duration === 'number') {\n            return Math.floor(entry.duration);\n        }\n    }\n}\n","/* @flow */\n\nimport { type CrossDomainWindowType, type SameDomainWindowType } from 'cross-domain-utils/src';\nimport { WeakMap } from 'cross-domain-safe-weakmap/src';\nimport { getOrSet } from 'belter/src';\n\nexport function getGlobal(win : SameDomainWindowType = window) : Object {\n    if (win !== window) {\n        return win[__POST_ROBOT__.__GLOBAL_KEY__];\n    }\n    const global : Object = win[__POST_ROBOT__.__GLOBAL_KEY__] = win[__POST_ROBOT__.__GLOBAL_KEY__] || {};\n    return global;\n}\n\nexport function deleteGlobal() {\n    delete window[__POST_ROBOT__.__GLOBAL_KEY__];\n}\n\ntype ObjectGetter = () => Object;\nconst getObj : ObjectGetter = () => ({});\n\ntype GetOrSet<T> = ((string, () => T) => T) & ((string, () => void) => void);\n\ntype GlobalStore<T> = {|\n    get : ((string, T) => T) & ((string, void) => T | void),\n    set : (string, T) => T,\n    has : (string) => boolean,\n    del : (string) => void,\n    getOrSet : GetOrSet<T>,\n    reset : () => void,\n    keys : () => $ReadOnlyArray<string>\n|};\n\nexport function globalStore<T : mixed>(key? : string = 'store', defStore? : ObjectGetter = getObj) : GlobalStore<T> {\n    return getOrSet(getGlobal(), key, () => {\n        let store = defStore();\n\n        return {\n            has: (storeKey) => {\n                return store.hasOwnProperty(storeKey);\n            },\n            get: (storeKey, defVal) => {\n                // $FlowFixMe\n                return store.hasOwnProperty(storeKey) ? store[storeKey] : defVal;\n            },\n            set: (storeKey, val) => {\n                store[storeKey] = val;\n                return val;\n            },\n            del: (storeKey) => {\n                delete store[storeKey];\n            },\n            getOrSet: (storeKey, getter) => {\n                // $FlowFixMe\n                return getOrSet(store, storeKey, getter);\n            },\n            reset: () => {\n                store = defStore();\n            },\n            keys: () => {\n                return Object.keys(store);\n            }\n        };\n    });\n}\n\nexport class WildCard {}\n\nexport function getWildcard() : WildCard {\n    const global = getGlobal();\n    global.WINDOW_WILDCARD = global.WINDOW_WILDCARD || new WildCard();\n    return global.WINDOW_WILDCARD;\n}\n\ntype WindowStore<T> = {|\n    get : ((CrossDomainWindowType | WildCard, T) => T) & ((CrossDomainWindowType | WildCard, void) => T | void),\n    set : (CrossDomainWindowType | WildCard, T) => T,\n    has : (CrossDomainWindowType | WildCard) => boolean,\n    del : (CrossDomainWindowType | WildCard) => void,\n    getOrSet : (CrossDomainWindowType | WildCard, () => T) => T\n|};\n\nexport function windowStore<T>(key? : string = 'store', defStore? : ObjectGetter = getObj) : WindowStore<T> {\n    return globalStore('windowStore').getOrSet(key, () => {\n        const winStore = new WeakMap();\n\n        const getStore = (win : CrossDomainWindowType | WildCard) : ObjectGetter => {\n            return winStore.getOrSet(win, defStore);\n        };\n    \n        return {\n            has: (win) => {\n                const store = getStore(win);\n                return store.hasOwnProperty(key);\n            },\n            get: (win, defVal) => {\n                const store = getStore(win);\n                // $FlowFixMe\n                return store.hasOwnProperty(key) ? store[key] : defVal;\n            },\n            set: (win, val) => {\n                const store = getStore(win);\n                store[key] = val;\n                return val;\n            },\n            del: (win) => {\n                const store = getStore(win);\n                delete store[key];\n            },\n            getOrSet: (win, getter) => {\n                const store = getStore(win);\n                return getOrSet(store, key, getter);\n            }\n        };\n    });\n}\n","/* @flow */\n\nimport { getAncestor, type CrossDomainWindowType } from 'cross-domain-utils/src';\nimport { ZalgoPromise } from 'zalgo-promise/src';\nimport { noop, uniqueID } from 'belter/src';\n\nimport { MESSAGE_NAME, WILDCARD } from '../conf';\nimport { windowStore, globalStore } from '../global';\nimport type { OnType, SendType, CancelableType } from '../types';\n\nfunction getInstanceID() : string {\n    return globalStore('instance').getOrSet('instanceID', uniqueID);\n}\n\nfunction getHelloPromise(win : CrossDomainWindowType) : ZalgoPromise<{ domain : string }> {\n    const helloPromises = windowStore('helloPromises');\n    return helloPromises.getOrSet(win, () => new ZalgoPromise());\n}\n\nfunction resolveHelloPromise(win : CrossDomainWindowType, { domain }) : ZalgoPromise<{ domain : string }> {\n    const helloPromises = windowStore('helloPromises');\n    const existingPromise = helloPromises.get(win);\n    if (existingPromise) {\n        existingPromise.resolve({ domain });\n    }\n    const newPromise = ZalgoPromise.resolve({ domain });\n    helloPromises.set(win, newPromise);\n    return newPromise;\n}\n\nfunction listenForHello({ on } : { on : OnType }) : CancelableType {\n    return on(MESSAGE_NAME.HELLO, { domain: WILDCARD }, ({ source, origin }) => {\n        resolveHelloPromise(source, { domain: origin });\n        return { instanceID: getInstanceID() };\n    });\n}\n\nexport function sayHello(win : CrossDomainWindowType, { send } : { send : SendType }) : ZalgoPromise<{ win : CrossDomainWindowType, domain : string, instanceID : string }> {\n    return send(win, MESSAGE_NAME.HELLO, { instanceID: getInstanceID() }, { domain: WILDCARD, timeout: -1 })\n        .then(({ origin, data: { instanceID } }) => {\n            resolveHelloPromise(win, { domain: origin });\n            return { win, domain: origin, instanceID };\n        });\n}\n\nexport function getWindowInstanceID(win : CrossDomainWindowType, { send } : { send : SendType }) : ZalgoPromise<string> {\n    return windowStore('windowInstanceIDPromises').getOrSet(win, () => {\n        return sayHello(win, { send }).then(({ instanceID }) => instanceID);\n    });\n}\n\nexport function initHello({ on, send } : { on : OnType, send : SendType }) : CancelableType {\n    return globalStore('builtinListeners').getOrSet('helloListener', () => {\n        const listener = listenForHello({ on });\n\n        const parent = getAncestor();\n        if (parent) {\n            sayHello(parent, { send }).catch(noop);\n        }\n\n        return listener;\n    });\n}\n\nexport function awaitWindowHello(win : CrossDomainWindowType, timeout : number = 5000, name : string = 'Window') : ZalgoPromise<{ domain : string }> {\n    let promise = getHelloPromise(win);\n\n    if (timeout !== -1) {\n        promise = promise.timeout(timeout, new Error(`${ name } did not load after ${ timeout }ms`));\n    }\n\n    return promise;\n}\n","/* @flow */\n\nexport const MESSAGE_TYPE = {\n    REQUEST:  ('postrobot_message_request' : 'postrobot_message_request'),\n    RESPONSE: ('postrobot_message_response' : 'postrobot_message_response'),\n    ACK:      ('postrobot_message_ack' : 'postrobot_message_ack')\n};\n\nexport const MESSAGE_ACK = {\n    SUCCESS: ('success' : 'success'),\n    ERROR:   ('error' : 'error')\n};\n\nexport const MESSAGE_NAME = {\n    METHOD:      ('postrobot_method' : 'postrobot_method'),\n    HELLO:       ('postrobot_hello' : 'postrobot_hello'),\n    OPEN_TUNNEL: ('postrobot_open_tunnel' : 'postrobot_open_tunnel')\n};\n\nexport const SEND_STRATEGY = {\n    POST_MESSAGE: ('postrobot_post_message' : 'postrobot_post_message'),\n    BRIDGE:       ('postrobot_bridge' : 'postrobot_bridge'),\n    GLOBAL:       ('postrobot_global' : 'postrobot_global')\n};\n\nexport const BRIDGE_NAME_PREFIX = '__postrobot_bridge__';\nexport const POSTROBOT_PROXY =    '__postrobot_proxy__';\n\nexport const WILDCARD = '*';\n\nexport const SERIALIZATION_TYPE = {\n    CROSS_DOMAIN_ZALGO_PROMISE: ('cross_domain_zalgo_promise' : 'cross_domain_zalgo_promise'),\n    CROSS_DOMAIN_FUNCTION:      ('cross_domain_function' : 'cross_domain_function'),\n    CROSS_DOMAIN_WINDOW:        ('cross_domain_window' : 'cross_domain_window')\n};\n","/* @flow */\n\nimport { type CrossDomainWindowType } from 'cross-domain-utils/src';\n\nimport { windowStore } from '../global';\n\nexport function markWindowKnown(win : CrossDomainWindowType) {\n    const knownWindows = windowStore('knownWindows');\n    knownWindows.set(win, true);\n}\n\nexport function isWindowKnown(win : CrossDomainWindowType) : boolean {\n    const knownWindows = windowStore('knownWindows');\n    return knownWindows.get(win, false);\n}\n","/* @flow */\n\nimport { TYPE } from './constants';\nimport type { CustomSerializedType } from './types';\n\nexport function isSerializedType(item : mixed) : boolean {\n    return (typeof item === 'object' && item !== null && typeof item.__type__ === 'string');\n}\n\nexport function determineType(val : mixed) : $Values<typeof TYPE> | void {\n    if (typeof val === 'undefined') {\n        return TYPE.UNDEFINED;\n    }\n\n    if (val === null) {\n        return TYPE.NULL;\n    }\n\n    if (Array.isArray(val)) {\n        return TYPE.ARRAY;\n    }\n\n    if (typeof val === 'function') {\n        return TYPE.FUNCTION;\n    }\n\n    if (typeof val === 'object') {\n\n        if (val instanceof Error) {\n            return TYPE.ERROR;\n        }\n\n        if (typeof val.then === 'function') {\n            return TYPE.PROMISE;\n        }\n\n        if (Object.prototype.toString.call(val) === '[object RegExp]') {\n            return TYPE.REGEX;\n        }\n\n        if (Object.prototype.toString.call(val) === '[object Date]') {\n            return TYPE.DATE;\n        }\n\n        return TYPE.OBJECT;\n    }\n\n    if (typeof val === 'string') {\n        return TYPE.STRING;\n    }\n\n    if (typeof val === 'number') {\n        return TYPE.NUMBER;\n    }\n\n    if (typeof val === 'boolean') {\n        return TYPE.BOOLEAN;\n    }\n}\n\nexport function serializeType<T : string, V : mixed>(type : T, val : V) : CustomSerializedType<T, V> {\n    return {\n        __type__: type,\n        __val__:  val\n    };\n}\n","/* @flow */\n\nexport const TYPE = {\n    FUNCTION:  ('function' : 'function'),\n    ERROR:     ('error' : 'error'),\n    PROMISE:   ('promise' : 'promise'),\n    REGEX:     ('regex' : 'regex'),\n    DATE:      ('date' : 'date'),\n    ARRAY:     ('array' : 'array'),\n    OBJECT:    ('object' : 'object'),\n    STRING:    ('string' : 'string'),\n    NUMBER:    ('number' : 'number'),\n    BOOLEAN:   ('boolean' : 'boolean'),\n    NULL:      ('null' : 'null'),\n    UNDEFINED: ('undefined' : 'undefined')\n};\n","/* @flow */\n\nimport { TYPE } from './constants';\nimport type { Thenable, CustomSerializedType, NativeSerializedType } from './types';\nimport { determineType, isSerializedType } from './common';\nimport {\n    serializeFunction,\n    serializeError, type SerializedError,\n    serializePromise,\n    serializeRegex, type SerializedRegex,\n    serializeDate, type SerializedDate,\n    serializeArray,\n    serializeObject,\n    serializeString,\n    serializeNumber,\n    serializeBoolean,\n    serializeNull\n} from './serializers';\n\ntype NativeSerializer<V : mixed, S : mixed, T : $Values<typeof TYPE>> = (value : V, key : string) => NativeSerializedType<T, S>;\ntype CustomSerializer<V : mixed, S : mixed, T : string> = (value : V, key : string) => CustomSerializedType<T, S>;\ntype PrimitiveSerializer<V : mixed, S : mixed> = (value : V, key : string) => S;\ntype CustomOrPrimitiveSerializer<V : mixed, T : string> = CustomSerializer<V, *, T> | PrimitiveSerializer<V, *>;\ntype NativeOrCustomOrPrimitiveSerializer<V : mixed, S : mixed, T : string> = NativeSerializer<V, S, T> | CustomOrPrimitiveSerializer<V, T>;\n\ntype Serializers = {|\n    function? : CustomOrPrimitiveSerializer<Function, typeof TYPE.FUNCTION>,\n    error? : NativeOrCustomOrPrimitiveSerializer<Error, SerializedError, typeof TYPE.ERROR>,\n    promise? : CustomOrPrimitiveSerializer<Thenable, typeof TYPE.PROMISE>,\n    regex? : NativeOrCustomOrPrimitiveSerializer<RegExp, SerializedRegex, typeof TYPE.REGEX>,\n    date? : NativeOrCustomOrPrimitiveSerializer<Date, SerializedDate, typeof TYPE.DATE>,\n    array? : CustomOrPrimitiveSerializer<$ReadOnlyArray<mixed>, typeof TYPE.ARRAY>,\n    object? : CustomOrPrimitiveSerializer<Object, typeof TYPE.OBJECT>,\n    string? : CustomOrPrimitiveSerializer<string, typeof TYPE.STRING>,\n    number? : CustomOrPrimitiveSerializer<number, typeof TYPE.NUMBER>,\n    boolean? : CustomOrPrimitiveSerializer<boolean, typeof TYPE.BOOLEAN>,\n    null? : CustomOrPrimitiveSerializer<null, typeof TYPE.NULL>\n|};\n\nconst SERIALIZER : Serializers = {\n    [ TYPE.FUNCTION ]:  serializeFunction,\n    [ TYPE.ERROR ]:     serializeError,\n    [ TYPE.PROMISE ]:   serializePromise,\n    [ TYPE.REGEX ]:     serializeRegex,\n    [ TYPE.DATE ]:      serializeDate,\n    [ TYPE.ARRAY ]:     serializeArray,\n    [ TYPE.OBJECT ]:    serializeObject,\n    [ TYPE.STRING ]:    serializeString,\n    [ TYPE.NUMBER ]:    serializeNumber,\n    [ TYPE.BOOLEAN ]:   serializeBoolean,\n    [ TYPE.NULL ]:      serializeNull\n};\n\n// $FlowFixMe\nconst defaultSerializers : Serializers = {};\n\nexport function serialize<T : mixed>(obj : T, serializers : Serializers = defaultSerializers) : string {\n\n    function replacer(key) : ?mixed {\n        const val = this[key];\n\n        if (isSerializedType(this)) {\n            return val;\n        }\n        \n        const type = determineType(val);\n\n        if (!type) {\n            return val;\n        }\n\n        // $FlowFixMe\n        const serializer = serializers[type] || SERIALIZER[type];\n\n        if (!serializer) {\n            return val;\n        }\n\n        return serializer(val, key);\n    }\n\n    const result = JSON.stringify(obj, replacer);\n\n    if (typeof result === 'undefined') {\n        return TYPE.UNDEFINED;\n    }\n\n    return result;\n}\n","/* @flow */\n\nexport type SerializedFunction = void;\n\nexport function serializeFunction() : SerializedFunction {\n    // pass\n}\n\nexport function deserializeFunction() {\n    throw new Error(`Function serialization is not implemented; nothing to deserialize`);\n}\n","/* @flow */\n\nimport { serializeType } from '../common';\nimport { TYPE } from '../constants';\nimport type { NativeSerializedType } from '../types';\n\nexport type SerializedError = {|\n    message : string,\n    stack : string,\n    code : string | number | void\n|};\n\n// $FlowFixMe\nexport function serializeError({ message, stack, code } : Error) : NativeSerializedType<typeof TYPE.ERROR, SerializedError> {\n    return serializeType(TYPE.ERROR, { message, stack, code });\n}\n\nexport function deserializeError({ message, stack, code } : SerializedError) : Error {\n    const error = new Error(message);\n    // $FlowFixMe\n    error.code = code;\n    error.stack = `${ stack }\\n\\n${ error.stack }`;\n    return error;\n}\n","/* @flow */\n\nexport type SerializedPromise = void;\n\nexport function serializePromise() : SerializedPromise {\n    // pass\n}\n\nexport function deserializePromise() {\n    throw new Error(`Promise serialization is not implemented; nothing to deserialize`);\n}\n","/* @flow */\n\nimport { serializeType } from '../common';\nimport { TYPE } from '../constants';\nimport type { NativeSerializedType } from '../types';\n\nexport type SerializedRegex = string;\n\nexport function serializeRegex(val : RegExp) : NativeSerializedType<typeof TYPE.REGEX, SerializedRegex> {\n    return serializeType(TYPE.REGEX, val.source);\n}\n\nexport function deserializeRegex(val : string) : RegExp {\n    // eslint-disable-next-line security/detect-non-literal-regexp\n    return new RegExp(val);\n}\n","/* @flow */\n\nimport { serializeType } from '../common';\nimport { TYPE } from '../constants';\nimport type { NativeSerializedType } from '../types';\n\nexport type SerializedDate = string;\n\nexport function serializeDate(val : Date) : NativeSerializedType<typeof TYPE.DATE, SerializedDate> {\n    return serializeType(TYPE.DATE, val.toJSON());\n}\n\nexport function deserializeDate(val : string) : Date {\n    return new Date(val);\n}\n","/* @flow */\n\nexport type SerializedArray<T : mixed = mixed> = $ReadOnlyArray<T>;\n\nexport function serializeArray<T : mixed>(val : $ReadOnlyArray<T>) : SerializedArray<T> {\n    return val;\n}\n\nexport function deserializeArray<T : mixed>(val : SerializedArray<T>) : $ReadOnlyArray<T> {\n    return val;\n}\n","/* @flow */\n\nexport type SerializedObject = Object;\n\nexport function serializeObject(val : Object) : SerializedObject {\n    return val;\n}\n\nexport function deserializeObject(val : SerializedObject) : Object {\n    return val;\n}\n","/* @flow */\n\nexport type SerializedString = string;\n\nexport function serializeString(val : string) : SerializedString {\n    return val;\n}\n\nexport function deserializeString(val : SerializedString) : string {\n    return val;\n}\n","/* @flow */\n\nexport type SerializedNumber = number;\n\nexport function serializeNumber(val : number) : SerializedNumber {\n    return val;\n}\n\nexport function deserializeNumber(val : SerializedNumber) : number {\n    return val;\n}\n","/* @flow */\n\nexport type SerializedBoolean = boolean;\n\nexport function serializeBoolean(val : boolean) : SerializedBoolean {\n    return val;\n}\n\nexport function deserializeBoolean(val : SerializedBoolean) : boolean {\n    return val;\n}\n","/* @flow */\n\nexport type SerializedNull = null;\n\nexport function serializeNull(val : null) : SerializedNull {\n    return val;\n}\n\nexport function deserializeNull(val : SerializedNull) : null {\n    return val;\n}\n","/* @flow */\n\nimport type { Thenable } from './types';\nimport { TYPE } from './constants';\nimport { determineType, isSerializedType } from './common';\nimport {\n    deserializeFunction,\n    deserializeError, type SerializedError,\n    deserializePromise,\n    deserializeRegex, type SerializedRegex,\n    deserializeDate, type SerializedDate,\n    deserializeArray,\n    deserializeObject,\n    deserializeString,\n    deserializeNumber,\n    deserializeBoolean,\n    deserializeNull\n} from './serializers';\n\ntype Deserializer<V : mixed, S : mixed> = (serializedValue : S, key : string) => V;\ntype PrimitiveDeserializer<V, S = V> = (serializedValue : S, key : string) => V;\n\ntype Deserializers = {\n    function? : Deserializer<Function, *>,\n    error? : Deserializer<Error, SerializedError>,\n    promise? : Deserializer<Thenable, *>,\n    regex? : Deserializer<RegExp, SerializedRegex>,\n    date? : Deserializer<Date, SerializedDate>,\n    array? : PrimitiveDeserializer<$ReadOnlyArray<mixed>>,\n    object? : PrimitiveDeserializer<Object>,\n    string? : PrimitiveDeserializer<string>,\n    number? : PrimitiveDeserializer<number>,\n    boolean? : PrimitiveDeserializer<boolean>,\n    null? : PrimitiveDeserializer<null>,\n    [string] : Deserializer<mixed, *>\n};\n\n// $FlowFixMe\nconst DESERIALIZER : Deserializers = {\n    [ TYPE.FUNCTION ]:  deserializeFunction,\n    [ TYPE.ERROR ]:     deserializeError,\n    [ TYPE.PROMISE ]:   deserializePromise,\n    [ TYPE.REGEX ]:     deserializeRegex,\n    [ TYPE.DATE ]:      deserializeDate,\n    [ TYPE.ARRAY ]:     deserializeArray,\n    [ TYPE.OBJECT ]:    deserializeObject,\n    [ TYPE.STRING ]:    deserializeString,\n    [ TYPE.NUMBER ]:    deserializeNumber,\n    [ TYPE.BOOLEAN ]:   deserializeBoolean,\n    [ TYPE.NULL ]:      deserializeNull\n};\n\n// $FlowFixMe\nconst defaultDeserializers : Deserializers = {};\n\nexport function deserialize<T : mixed | null | void>(str : string, deserializers : Deserializers = defaultDeserializers) : T {\n    if (str === TYPE.UNDEFINED) {\n        // $FlowFixMe\n        return;\n    }\n\n    function replacer(key, val) : ?mixed {\n        if (isSerializedType(this)) {\n            return val;\n        }\n\n        let type;\n        let value;\n\n        if (isSerializedType(val)) {\n            type = val.__type__;\n            value = val.__val__;\n        } else {\n            type = determineType(val);\n            value = val;\n        }\n\n        if (!type) {\n            return value;\n        }\n\n        // $FlowFixMe\n        const deserializer = deserializers[type] || DESERIALIZER[type];\n\n        if (!deserializer) {\n            return value;\n        }\n\n        return deserializer(value, key);\n    }\n\n    return JSON.parse(str, replacer);\n}\n","/* @flow */\n\nimport { ZalgoPromise } from 'zalgo-promise/src';\nimport { getDomain, isSameDomain, isOpener, isSameTopWindow, matchDomain, getUserAgent, getDomainFromUrl, type CrossDomainWindowType } from 'cross-domain-utils/src';\nimport { noop } from 'belter/src';\n\nimport { BRIDGE_NAME_PREFIX } from '../conf';\nimport { windowStore } from '../global';\n\nexport function needsBridgeForBrowser() : boolean {\n\n    if (getUserAgent(window).match(/MSIE|trident|edge\\/12|edge\\/13/i)) {\n        return true;\n    }\n\n    return false;\n}\n\nexport function needsBridgeForWin(win : CrossDomainWindowType) : boolean {\n\n    if (!isSameTopWindow(window, win)) {\n        return true;\n    }\n\n    return false;\n}\n\nexport function needsBridgeForDomain(domain : ?string, win : ?CrossDomainWindowType) : boolean {\n\n    if (domain) {\n        if (getDomain() !== getDomainFromUrl(domain)) {\n            return true;\n        }\n    } else if (win) {\n        if (!isSameDomain(win))  {\n            return true;\n        }\n    }\n\n    return false;\n}\n\nexport function needsBridge({ win, domain } : { win? : CrossDomainWindowType, domain? : string }) : boolean {\n\n    if (!needsBridgeForBrowser()) {\n        return false;\n    }\n\n    if (domain && !needsBridgeForDomain(domain, win)) {\n        return false;\n    }\n\n    if (win && !needsBridgeForWin(win)) {\n        return false;\n    }\n\n    return true;\n}\n\nexport function getBridgeName(domain : string) : string {\n\n    domain = domain || getDomainFromUrl(domain);\n\n    const sanitizedDomain = domain.replace(/[^a-zA-Z0-9]+/g, '_');\n\n    const id = `${ BRIDGE_NAME_PREFIX }_${ sanitizedDomain }`;\n\n    return id;\n}\n\nexport function isBridge() : boolean {\n    return Boolean(window.name && window.name === getBridgeName(getDomain()));\n}\n\nexport const documentBodyReady = new ZalgoPromise(resolve => {\n\n    if (window.document && window.document.body) {\n        return resolve(window.document.body);\n    }\n\n    const interval = setInterval(() => {\n        if (window.document && window.document.body) {\n            clearInterval(interval);\n            return resolve(window.document.body);\n        }\n    }, 10);\n});\n\nexport function registerRemoteWindow(win : CrossDomainWindowType) {\n    const remoteWindowPromises = windowStore('remoteWindowPromises');\n    remoteWindowPromises.getOrSet(win, () => new ZalgoPromise());\n}\n\nexport function findRemoteWindow(win : CrossDomainWindowType) : ZalgoPromise<(remoteWin : CrossDomainWindowType, message : string, remoteDomain : string) => void> {\n    const remoteWindowPromises = windowStore('remoteWindowPromises');\n    const remoteWinPromise = remoteWindowPromises.get(win);\n\n    if (!remoteWinPromise) {\n        throw new Error(`Remote window promise not found`);\n    }\n\n    return remoteWinPromise;\n}\n\ntype SendMessageType = {|\n    (string) : void,\n    fireAndForget : (string) => void\n|};\n\nexport function registerRemoteSendMessage(win : CrossDomainWindowType, domain : string, sendMessage : SendMessageType) {\n    const sendMessageWrapper = (remoteWin : CrossDomainWindowType, remoteDomain : string, message : string) => {\n        if (remoteWin !== win) {\n            throw new Error(`Remote window does not match window`);\n        }\n\n        if (!matchDomain(remoteDomain, domain)) {\n            throw new Error(`Remote domain ${ remoteDomain } does not match domain ${ domain }`);\n        }\n\n        sendMessage.fireAndForget(message);\n    };\n\n    findRemoteWindow(win).resolve(sendMessageWrapper);\n}\n\nexport function rejectRemoteSendMessage(win : CrossDomainWindowType, err : Error) {\n    findRemoteWindow(win).reject(err).catch(noop);\n}\n\nexport function sendBridgeMessage(win : CrossDomainWindowType, domain : string, message : string) : ZalgoPromise<void> {\n\n    const messagingChild  = isOpener(window, win);\n    const messagingParent = isOpener(win, window);\n\n    if (!messagingChild && !messagingParent) {\n        throw new Error(`Can only send messages to and from parent and popup windows`);\n    }\n\n    return findRemoteWindow(win).then(sendMessage => {\n        return sendMessage(win, domain, message);\n    });\n}\n","/* @flow */\n\nimport { ZalgoPromise } from 'zalgo-promise/src';\nimport { getDomain, getFrameByName, isWindowClosed, getDomainFromUrl, normalizeMockUrl, type CrossDomainWindowType } from 'cross-domain-utils/src';\n\nimport { BRIDGE_TIMEOUT, MESSAGE_NAME } from '../conf';\nimport { awaitWindowHello } from '../lib';\nimport { windowStore, globalStore } from '../global';\nimport type { OnType, SendType, ReceiveMessageType } from '../types';\n\nimport { getBridgeName, documentBodyReady, registerRemoteSendMessage, registerRemoteWindow } from './common';\n\nexport function listenForOpenTunnel({ on, send, receiveMessage } : { on : OnType, send : SendType, receiveMessage : ReceiveMessageType }) {\n    const popupWindowsByName = globalStore('popupWindowsByName');\n\n    on(MESSAGE_NAME.OPEN_TUNNEL, ({ source, origin, data }) => {\n        const bridgePromise = globalStore('bridges').get(origin);\n\n        if (!bridgePromise) {\n            throw new Error(`Can not find bridge promise for domain ${ origin }`);\n        }\n\n        return bridgePromise.then(bridge => {\n            if (source !== bridge) {\n                throw new Error(`Message source does not matched registered bridge for domain ${ origin }`);\n            }\n\n            if (!data.name) {\n                throw new Error(`Register window expected to be passed window name`);\n            }\n\n            if (!data.sendMessage) {\n                throw new Error(`Register window expected to be passed sendMessage method`);\n            }\n\n            if (!popupWindowsByName.has(data.name)) {\n                throw new Error(`Window with name ${ data.name } does not exist, or was not opened by this window`);\n            }\n\n            if (!popupWindowsByName.get(data.name).domain) {\n                throw new Error(`We do not have a registered domain for window ${ data.name }`);\n            }\n\n            if (popupWindowsByName.get(data.name).domain !== origin) {\n                throw new Error(`Message origin ${ origin } does not matched registered window origin ${ popupWindowsByName.get(data.name).domain }`);\n            }\n\n            registerRemoteSendMessage(popupWindowsByName.get(data.name).win, origin, data.sendMessage);\n\n            return {\n                sendMessage(message) {\n\n                    if (!window || window.closed) {\n                        return;\n                    }\n\n                    const winDetails = popupWindowsByName.get(data.name);\n\n                    if (!winDetails) {\n                        return;\n                    }\n\n                    try {\n                        receiveMessage({\n                            data:   message,\n                            origin: winDetails.domain,\n                            source: winDetails.win\n                        }, { on, send });\n                    } catch (err) {\n                        ZalgoPromise.reject(err);\n                    }\n                }\n            };\n        });\n    });\n}\n\nfunction openBridgeFrame(name : string, url : string) : HTMLIFrameElement {\n\n    const iframe = document.createElement(`iframe`);\n\n    iframe.setAttribute(`name`, name);\n    iframe.setAttribute(`id`,   name);\n\n    iframe.setAttribute(`style`, `display: none; margin: 0; padding: 0; border: 0px none; overflow: hidden;`);\n    iframe.setAttribute(`frameborder`, `0`);\n    iframe.setAttribute(`border`, `0`);\n    iframe.setAttribute(`scrolling`, `no`);\n    iframe.setAttribute(`allowTransparency`, `true`);\n\n    iframe.setAttribute(`tabindex`, `-1`);\n    iframe.setAttribute(`hidden`, `true`);\n    iframe.setAttribute(`title`, ``);\n    iframe.setAttribute(`role`, `presentation`);\n\n    iframe.src = url;\n\n    return iframe;\n}\n\nexport function hasBridge(url : string, domain : string) : boolean {\n    const bridges = globalStore('bridges');\n    return bridges.has(domain || getDomainFromUrl(url));\n}\n\nexport function openBridge(url : string, domain : string) : ZalgoPromise<CrossDomainWindowType> {\n    const bridges = globalStore('bridges');\n    const bridgeFrames = globalStore('bridgeFrames');\n    \n    domain = domain || getDomainFromUrl(url);\n    \n    return bridges.getOrSet(domain, () => ZalgoPromise.try(() => {\n\n        if (getDomain() === domain) {\n            throw new Error(`Can not open bridge on the same domain as current domain: ${ domain }`);\n        }\n\n        const name  = getBridgeName(domain);\n        const frame = getFrameByName(window, name);\n\n        if (frame) {\n            throw new Error(`Frame with name ${ name } already exists on page`);\n        }\n\n        const iframe = openBridgeFrame(name, url);\n        bridgeFrames.set(domain, iframe);\n\n        return documentBodyReady.then(body => {\n\n            body.appendChild(iframe);\n            const bridge = iframe.contentWindow;\n\n            return new ZalgoPromise((resolve, reject) => {\n\n                iframe.addEventListener('load', resolve);\n                iframe.addEventListener('error', reject);\n\n            }).then(() => {\n\n                return awaitWindowHello(bridge, BRIDGE_TIMEOUT, `Bridge ${ url }`);\n\n            }).then(() => {\n\n                return bridge;\n            });\n        });\n    }));\n}\n\ntype WinDetails = {|\n    win : CrossDomainWindowType,\n    domain? : ?string,\n    name? : ?string\n|};\n\nexport function linkWindow({ win, name, domain } : WinDetails) : WinDetails {\n    const popupWindowsByName = globalStore('popupWindowsByName');\n    const popupWindowsByWin = windowStore('popupWindowsByWin');\n\n    for (const winName of popupWindowsByName.keys()) {\n        // $FlowFixMe\n        const details = popupWindowsByName.get(winName);\n        if (!details || isWindowClosed(details.win)) {\n            popupWindowsByName.del(winName);\n        }\n    }\n\n    if (isWindowClosed(win)) {\n        return { win, name, domain };\n    }\n\n    const details = popupWindowsByWin.getOrSet(win, () : WinDetails => {\n        if (!name) {\n            return { win };\n        }\n        \n        return popupWindowsByName.getOrSet(name, () : WinDetails => {\n            return { win, name };\n        });\n    });\n\n    if (details.win && details.win !== win) {\n        throw new Error(`Different window already linked for window: ${ name || 'undefined' }`);\n    }\n\n    if (name) {\n        details.name = name;\n        popupWindowsByName.set(name, details);\n    }\n\n    if (domain) {\n        details.domain = domain;\n        registerRemoteWindow(win);\n    }\n\n    popupWindowsByWin.set(win, details);\n    \n    return details;\n}\n\nexport function linkUrl(win : CrossDomainWindowType, url : string) {\n    linkWindow({ win, domain: getDomainFromUrl(url) });\n}\n\nexport function listenForWindowOpen() {\n    const windowOpen = window.open;\n\n    window.open = function windowOpenWrapper(url : string, name : string, options : string, last : mixed) : mixed {\n        const win = windowOpen.call(this, normalizeMockUrl(url), name, options, last);\n    \n        if (!win) {\n            return win;\n        }\n    \n        linkWindow({ win, name, domain: url ? getDomainFromUrl(url) : null });\n    \n        return win;\n    };\n}\n\nexport function destroyBridges() {\n    const bridges = globalStore('bridges');\n    const bridgeFrames = globalStore('bridgeFrames');\n\n    for (const domain of bridgeFrames.keys()) {\n        const frame = bridgeFrames.get(domain);\n        if (frame && frame.parentNode) {\n            frame.parentNode.removeChild(frame);\n        }\n    }\n    bridgeFrames.reset();\n    bridges.reset();\n}\n","/* @flow */\n\nimport type { OnType, SendType, ReceiveMessageType } from '../types';\n\nimport { listenForWindowOpen, listenForOpenTunnel } from './parent';\nimport { setupOpenTunnelToParent } from './bridge';\nimport { openTunnelToOpener } from './child';\n\nexport function setupBridge({ on, send, receiveMessage } : { on : OnType, send : SendType, receiveMessage : ReceiveMessageType }) {\n    listenForWindowOpen();\n    listenForOpenTunnel({ on, send, receiveMessage });\n    setupOpenTunnelToParent({ on, send });\n    openTunnelToOpener({ on, send, receiveMessage });\n}\n","/* @flow */\n\nimport { type ZalgoPromise } from 'zalgo-promise/src';\nimport { getParent, isWindowClosed, type CrossDomainWindowType } from 'cross-domain-utils/src';\nimport { noop, uniqueID } from 'belter/src';\n\nimport { MESSAGE_NAME, WILDCARD } from '../conf';\nimport { getGlobal, globalStore } from '../global';\nimport type { SendType, ResponseMessageEvent } from '../types';\n\nfunction cleanTunnelWindows() {\n    const tunnelWindows = globalStore('tunnelWindows');\n\n    for (const key of tunnelWindows.keys()) {\n        const tunnelWindow = tunnelWindows[key];\n\n        try {\n            noop(tunnelWindow.source);\n        } catch (err) {\n            tunnelWindows.del(key);\n            continue;\n        }\n\n        if (isWindowClosed(tunnelWindow.source)) {\n            tunnelWindows.del(key);\n        }\n    }\n}\n\ntype TunnelWindowDataType = {|\n    name : string,\n    source : CrossDomainWindowType,\n    canary : () => void,\n    sendMessage : (message : string) => void\n|};\n\nfunction addTunnelWindow({ name, source, canary, sendMessage } : TunnelWindowDataType) : string {\n    cleanTunnelWindows();\n    const id = uniqueID();\n    const tunnelWindows = globalStore('tunnelWindows');\n    tunnelWindows.set(id, { name, source, canary, sendMessage });\n    return id;\n}\n\nexport function setupOpenTunnelToParent({ send } : { send : SendType }) {\n    getGlobal(window).openTunnelToParent = function openTunnelToParent({ name, source, canary, sendMessage } : TunnelWindowDataType) : ZalgoPromise<ResponseMessageEvent> {\n\n        const tunnelWindows = globalStore('tunnelWindows');\n        const parentWindow = getParent(window);\n    \n        if (!parentWindow) {\n            throw new Error(`No parent window found to open tunnel to`);\n        }\n    \n        const id = addTunnelWindow({ name, source, canary, sendMessage });\n    \n        return send(parentWindow, MESSAGE_NAME.OPEN_TUNNEL, {\n    \n            name,\n    \n            sendMessage() {\n    \n                const tunnelWindow = tunnelWindows.get(id);\n    \n                try {\n                    // IE gets antsy if you try to even reference a closed window\n                    noop(tunnelWindow && tunnelWindow.source);\n                } catch (err) {\n                    tunnelWindows.del(id);\n                    return;\n                }\n    \n                if (!tunnelWindow || !tunnelWindow.source || isWindowClosed(tunnelWindow.source)) {\n                    return;\n                }\n    \n                try {\n                    tunnelWindow.canary();\n                } catch (err) {\n                    return;\n                }\n    \n                tunnelWindow.sendMessage.apply(this, arguments);\n            }\n    \n        }, { domain: WILDCARD });\n    };\n}\n","/* @flow */\n\nimport { ZalgoPromise } from 'zalgo-promise/src';\nimport { isSameDomain, getOpener, getDomain, getFrameByName, assertSameDomain, type CrossDomainWindowType } from 'cross-domain-utils/src';\nimport { noop } from 'belter/src';\n\nimport { getGlobal, windowStore } from '../global';\nimport type { OnType, SendType, ReceiveMessageType } from '../types';\n\nimport { needsBridge, registerRemoteWindow, rejectRemoteSendMessage, registerRemoteSendMessage, getBridgeName } from './common';\n\nfunction awaitRemoteBridgeForWindow (win : CrossDomainWindowType) : ZalgoPromise<?CrossDomainWindowType> {\n    return windowStore('remoteBridgeAwaiters').getOrSet(win, () => {\n        return ZalgoPromise.try(() => {\n            const frame = getFrameByName(win, getBridgeName(getDomain()));\n\n            if (!frame) {\n                return;\n            }\n\n            if (isSameDomain(frame) && getGlobal(assertSameDomain(frame))) {\n                return frame;\n            }\n\n            return new ZalgoPromise(resolve => {\n\n                let interval;\n                let timeout; // eslint-disable-line prefer-const\n\n                interval = setInterval(() => { // eslint-disable-line prefer-const\n                    if (frame && isSameDomain(frame) && getGlobal(assertSameDomain(frame))) {\n                        clearInterval(interval);\n                        clearTimeout(timeout);\n                        return resolve(frame);\n                    }\n                }, 100);\n\n                timeout = setTimeout(() => {\n                    clearInterval(interval);\n                    return resolve();\n                }, 2000);\n            });\n        });\n    });\n}\n\nexport function openTunnelToOpener({ on, send, receiveMessage } : { on : OnType, send : SendType, receiveMessage : ReceiveMessageType }) : ZalgoPromise<void> {\n    return ZalgoPromise.try(() => {\n        const opener = getOpener(window);\n        \n        if (!opener || !needsBridge({ win: opener })) {\n            return;\n        }\n\n        registerRemoteWindow(opener);\n\n        return awaitRemoteBridgeForWindow(opener).then(bridge => {\n\n            if (!bridge) {\n                return rejectRemoteSendMessage(opener, new Error(`Can not register with opener: no bridge found in opener`));\n            }\n\n            if (!window.name) {\n                return rejectRemoteSendMessage(opener, new Error(`Can not register with opener: window does not have a name`));\n            }\n\n            return getGlobal(assertSameDomain(bridge)).openTunnelToParent({\n\n                name: window.name,\n\n                source: window,\n\n                canary() {\n                    // pass\n                },\n\n                sendMessage(message) {\n\n                    try {\n                        noop(window);\n                    } catch (err) {\n                        return;\n                    }\n\n                    if (!window || window.closed) {\n                        return;\n                    }\n\n                    try {\n                        receiveMessage({\n                            data:   message,\n                            origin: this.origin,\n                            source: this.source\n                        }, { on, send });\n                    } catch (err) {\n                        ZalgoPromise.reject(err);\n                    }\n                }\n\n            }).then(({ source, origin, data }) => {\n\n                if (source !== opener) {\n                    throw new Error(`Source does not match opener`);\n                }\n\n                registerRemoteSendMessage(source, origin, data.sendMessage);\n\n            }).catch(err => {\n\n                rejectRemoteSendMessage(opener, err);\n                throw err;\n            });\n        });\n    });\n}\n","/* @flow */\n\nimport { isSameDomain, isWindowClosed, type CrossDomainWindowType, closeWindow,\n    type DomainMatcher, getOpener, WINDOW_TYPE, isWindow, assertSameDomain, getFrameForWindow } from 'cross-domain-utils/src';\nimport { ZalgoPromise } from 'zalgo-promise/src';\nimport { uniqueID, memoizePromise } from 'belter/src';\nimport { serializeType, type CustomSerializedType } from 'universal-serialize/src';\n\nimport { SERIALIZATION_TYPE } from '../conf';\nimport { windowStore, globalStore } from '../global';\nimport { getWindowInstanceID } from '../lib';\nimport { linkWindow } from '../bridge';\nimport type { SendType } from '../types';\n\nfunction cleanupProxyWindows() {\n    const idToProxyWindow = globalStore('idToProxyWindow');\n    for (const id of idToProxyWindow.keys()) {\n        // $FlowFixMe\n        if (idToProxyWindow.get(id).shouldClean()) {\n            idToProxyWindow.del(id);\n        }\n    }\n}\n\ntype SerializedWindowType = {|\n    id : string,\n    getType : () => ZalgoPromise<$Values<typeof WINDOW_TYPE>>,\n    close : () => ZalgoPromise<void>,\n    focus : () => ZalgoPromise<void>,\n    isClosed : () => ZalgoPromise<boolean>,\n    setLocation : (string) => ZalgoPromise<void>,\n    getName : () => ZalgoPromise<?string>,\n    setName : (string) => ZalgoPromise<void>,\n    getInstanceID : () => ZalgoPromise<string>\n|};\n\nfunction getSerializedWindow(winPromise : ZalgoPromise<CrossDomainWindowType>, { send, id = uniqueID() } : { send : SendType, id? : string }) : SerializedWindowType {\n    \n    let windowNamePromise = winPromise.then(win => {\n        if (isSameDomain(win)) {\n            return assertSameDomain(win).name;\n        }\n    });\n    \n    return {\n        id,\n        getType: () => winPromise.then(win => {\n            return getOpener(win) ? WINDOW_TYPE.POPUP : WINDOW_TYPE.IFRAME;\n        }),\n        getInstanceID: memoizePromise(() => winPromise.then(win => getWindowInstanceID(win, { send }))),\n        close:         () => winPromise.then(closeWindow),\n        getName:       () => winPromise.then(win => {\n            if (isWindowClosed(win)) {\n                return;\n            }\n\n            if (isSameDomain(win)) {\n                return assertSameDomain(win).name;\n            }\n\n            return windowNamePromise;\n        }),\n        focus:   () => winPromise.then(win => {\n            win.focus();\n        }),\n        isClosed: () => winPromise.then(win => {\n            return isWindowClosed(win);\n        }),\n        setLocation: (href) => winPromise.then(win => {\n            if (isSameDomain(win)) {\n                try {\n                    if (win.location && typeof win.location.replace === 'function') {\n                        // $FlowFixMe\n                        win.location.replace(href);\n                        return;\n                    }\n                } catch (err) {\n                    // pass\n                }\n            }\n\n            win.location = href;\n        }),\n        setName: (name) => winPromise.then(win => {\n            if (__POST_ROBOT__.__IE_POPUP_SUPPORT__) {\n                linkWindow({ win, name });\n            }\n\n            const sameDomain = isSameDomain(win);\n            const frame = getFrameForWindow(win);\n\n            if (!sameDomain) {\n                throw new Error(`Can not set name for cross-domain window: ${ name }`);\n            }\n\n            assertSameDomain(win).name = name;\n            if (frame) {\n                frame.setAttribute('name', name);\n            }\n\n            windowNamePromise = ZalgoPromise.resolve(name);\n        })\n    };\n}\n\nexport class ProxyWindow {\n\n    id : string\n    isProxyWindow : true = true\n    serializedWindow : SerializedWindowType\n    actualWindow : ?CrossDomainWindowType\n    actualWindowPromise : ZalgoPromise<CrossDomainWindowType>\n    send : SendType\n    name : string\n\n    constructor({ send, win, serializedWindow } : { win? : CrossDomainWindowType, serializedWindow? : SerializedWindowType, send : SendType }) {\n        this.actualWindowPromise = new ZalgoPromise();\n        this.serializedWindow = serializedWindow || getSerializedWindow(this.actualWindowPromise, { send });\n        globalStore('idToProxyWindow').set(this.getID(), this);\n        if (win) {\n            this.setWindow(win, { send });\n        }\n    }\n\n    getID() : string {\n        return this.serializedWindow.id;\n    }\n\n    getType() : ZalgoPromise<$Values<typeof WINDOW_TYPE>> {\n        return this.serializedWindow.getType();\n    }\n\n    isPopup() : ZalgoPromise<boolean> {\n        return this.getType().then(type => {\n            return type === WINDOW_TYPE.POPUP;\n        });\n    }\n\n    setLocation(href : string) : ZalgoPromise<ProxyWindow> {\n        return this.serializedWindow.setLocation(href).then(() => this);\n    }\n\n    getName() : ZalgoPromise<?string> {\n        return this.serializedWindow.getName();\n    }\n\n    setName(name : string) : ZalgoPromise<ProxyWindow> {\n        return this.serializedWindow.setName(name).then(() => this);\n    }\n\n    close() : ZalgoPromise<ProxyWindow> {\n        return this.serializedWindow.close().then(() => this);\n    }\n\n    focus() : ZalgoPromise<ProxyWindow> {\n        const isPopupPromise = this.isPopup();\n        const getNamePromise = this.getName();\n\n        const reopenPromise = ZalgoPromise.hash({ isPopup: isPopupPromise, name: getNamePromise }).then(({ isPopup, name }) => {\n            if (isPopup && name) {\n                window.open('', name);\n            }\n        });\n        const focusPromise = this.serializedWindow.focus();\n\n        return ZalgoPromise.all([\n            reopenPromise,\n            focusPromise\n        ]).then(() => this);\n    }\n\n    isClosed() : ZalgoPromise<boolean> {\n        return this.serializedWindow.isClosed();\n    }\n\n    getWindow() : ?CrossDomainWindowType {\n        return this.actualWindow;\n    }\n\n    setWindow(win : CrossDomainWindowType, { send } : { send : SendType }) {\n        this.actualWindow = win;\n        this.actualWindowPromise.resolve(this.actualWindow);\n        this.serializedWindow = getSerializedWindow(this.actualWindowPromise, { send, id: this.getID() });\n        windowStore('winToProxyWindow').set(win, this);\n    }\n\n    awaitWindow() : ZalgoPromise<CrossDomainWindowType> {\n        return this.actualWindowPromise;\n    }\n\n    matchWindow(win : CrossDomainWindowType, { send } : { send : SendType }) : ZalgoPromise<boolean> {\n        return ZalgoPromise.try(() => {\n            if (this.actualWindow) {\n                return win === this.actualWindow;\n            }\n            \n            return ZalgoPromise.hash({\n                proxyInstanceID:       this.getInstanceID(),\n                knownWindowInstanceID: getWindowInstanceID(win, { send })\n            }).then(({ proxyInstanceID, knownWindowInstanceID }) => {\n                const match = proxyInstanceID === knownWindowInstanceID;\n\n                if (match) {\n                    this.setWindow(win, { send });\n                }\n\n                return match;\n            });\n        });\n    }\n\n    unwrap() : CrossDomainWindowType | ProxyWindow {\n        return this.actualWindow || this;\n    }\n\n    getInstanceID() : ZalgoPromise<string> {\n        return this.serializedWindow.getInstanceID();\n    }\n\n    shouldClean() : boolean {\n        return Boolean(this.actualWindow && isWindowClosed(this.actualWindow));\n    }\n\n    serialize() : SerializedWindowType {\n        return this.serializedWindow;\n    }\n\n    static unwrap(win : CrossDomainWindowType | ProxyWindow) : CrossDomainWindowType | ProxyWindow {\n        return ProxyWindow.isProxyWindow(win)\n            // $FlowFixMe\n            ? win.unwrap()\n            : win;\n    }\n\n    static serialize(win : CrossDomainWindowType | ProxyWindow, { send } : { send : SendType }) : SerializedWindowType {\n        cleanupProxyWindows();\n        return ProxyWindow.toProxyWindow(win, { send }).serialize();\n    }\n\n    static deserialize(serializedWindow : SerializedWindowType, { send } : { send : SendType }) : ProxyWindow {\n        cleanupProxyWindows();\n        return globalStore('idToProxyWindow').get(serializedWindow.id) || new ProxyWindow({ serializedWindow, send });\n    }\n\n    static isProxyWindow(obj : CrossDomainWindowType | ProxyWindow) : boolean {\n        // $FlowFixMe\n        return Boolean(obj && !isWindow(obj) && obj.isProxyWindow);\n    }\n\n    static toProxyWindow(win : CrossDomainWindowType | ProxyWindow, { send } : { send : SendType }) : ProxyWindow {\n        cleanupProxyWindows();\n\n        if (ProxyWindow.isProxyWindow(win)) {\n            // $FlowFixMe\n            return win;\n        }\n\n        // $FlowFixMe\n        const actualWindow : CrossDomainWindowType = win;\n        \n        return windowStore('winToProxyWindow').get(actualWindow) || new ProxyWindow({ win: actualWindow, send });\n    }\n}\n\nexport type SerializedWindow = CustomSerializedType<typeof SERIALIZATION_TYPE.CROSS_DOMAIN_WINDOW, SerializedWindowType>;\n\nexport function serializeWindow(destination : CrossDomainWindowType | ProxyWindow, domain : DomainMatcher, win : CrossDomainWindowType, { send } : { send : SendType }) : SerializedWindow {\n    return serializeType(SERIALIZATION_TYPE.CROSS_DOMAIN_WINDOW, ProxyWindow.serialize(win, { send }));\n}\n\nexport function deserializeWindow(source : CrossDomainWindowType | ProxyWindow, origin : string, win : SerializedWindowType, { send } : { send : SendType }) : ProxyWindow {\n    return ProxyWindow.deserialize(win, { send });\n}\n","/* @flow */\n\nimport { matchDomain, getDomain, type CrossDomainWindowType, type DomainMatcher } from 'cross-domain-utils/src';\nimport { ZalgoPromise } from 'zalgo-promise/src';\nimport { uniqueID, isRegex, arrayFrom } from 'belter/src';\nimport { serializeType, type CustomSerializedType } from 'universal-serialize/src';\n\nimport { MESSAGE_NAME, WILDCARD, SERIALIZATION_TYPE } from '../conf';\nimport { windowStore, globalStore } from '../global';\nimport type { OnType, SendType, CancelableType } from '../types';\n\nimport { ProxyWindow } from './window';\n\ntype StoredMethod = {|\n    name : string,\n    domain : DomainMatcher,\n    val : Function,\n    source : CrossDomainWindowType | ProxyWindow\n|};\n\nfunction addMethod(id : string, val : Function, name : string, source : CrossDomainWindowType | ProxyWindow, domain : DomainMatcher) {\n    const methodStore = windowStore('methodStore');\n    const proxyWindowMethods = globalStore('proxyWindowMethods');\n    \n    if (ProxyWindow.isProxyWindow(source)) {\n        proxyWindowMethods.set(id, { val, name, domain, source });\n    } else {\n        proxyWindowMethods.del(id);\n        // $FlowFixMe\n        const methods = methodStore.getOrSet(source, () => ({}));\n        methods[id] = { domain, name, val, source };\n    }\n}\n\nfunction lookupMethod(source : CrossDomainWindowType, id : string) : ?StoredMethod {\n    const methodStore = windowStore('methodStore');\n    const proxyWindowMethods = globalStore('proxyWindowMethods');\n    const methods = methodStore.getOrSet(source, () => ({}));\n    return methods[id] || proxyWindowMethods.get(id);\n}\n\nfunction stringifyArguments(args : $ReadOnlyArray<mixed> = []) : string {\n    return arrayFrom(args).map(arg => {\n        if (typeof arg === 'string') {\n            return `'${ arg }'`;\n        }\n        if (arg === undefined) {\n            return 'undefined';\n        }\n        if (arg === null) {\n            return 'null';\n        }\n        if (typeof arg === 'boolean') {\n            return arg.toString();\n        }\n        if (Array.isArray(arg)) {\n            return '[ ... ]';\n        }\n        if (typeof arg === 'object') {\n            return '{ ... }';\n        }\n        if (typeof arg === 'function') {\n            return '() => { ... }';\n        }\n        return `<${ typeof arg }>`;\n    }).join(', ');\n}\n\nfunction listenForFunctionCalls({ on, send } : { on : OnType, send : SendType }) : CancelableType {\n    return globalStore('builtinListeners').getOrSet('functionCalls', () => {\n        return on(MESSAGE_NAME.METHOD, { domain: WILDCARD }, ({ source, origin, data } : { source : CrossDomainWindowType, origin : string, data : Object }) => {\n            const { id, name } = data;\n\n            const meth = lookupMethod(source, id);\n    \n            if (!meth) {\n                throw new Error(`Could not find method '${ name }' with id: ${ data.id } in ${ getDomain(window) }`);\n            }\n\n            const { source: methodSource, domain, val } = meth;\n            \n            return ZalgoPromise.try(() => {\n                if (!matchDomain(domain, origin)) {\n                    // $FlowFixMe\n                    throw new Error(`Method '${ data.name }' domain ${ JSON.stringify(isRegex(meth.domain) ? meth.domain.source : meth.domain) } does not match origin ${ origin } in ${ getDomain(window) }`);\n                }\n                \n                if (ProxyWindow.isProxyWindow(methodSource)) {\n                    // $FlowFixMe\n                    return methodSource.matchWindow(source, { send }).then(match => {\n                        if (!match) {\n                            throw new Error(`Method call '${ data.name }' failed - proxy window does not match source in ${ getDomain(window) }`);\n                        }\n                    });\n                }\n            }).then(() => {\n                return val.apply({ source, origin }, data.args);\n            }, err => {\n                return ZalgoPromise.try(() => {\n                    if (val.onError) {\n                        return val.onError(err);\n                    }\n                }).then(() => {\n                    // $FlowFixMe\n                    if (err.stack) {\n                        // $FlowFixMe\n                        err.stack = `Remote call to ${ name }(${ stringifyArguments(data.args) }) failed\\n\\n${ err.stack }`;\n                    }\n\n                    throw err;\n                });\n            }).then(result => {\n                return { result, id, name };\n            });\n        });\n    });\n}\n\nexport type SerializedFunction = CustomSerializedType<typeof SERIALIZATION_TYPE.CROSS_DOMAIN_FUNCTION, {\n    id : string,\n    name : string\n}>;\n\n// eslint-disable-next-line flowtype/require-exact-type\ntype SerializableFunction<T> = {\n    () : ZalgoPromise<T> | T,\n    __id__? : string,\n    __name__? : string\n};\n\nexport function serializeFunction<T>(destination : CrossDomainWindowType | ProxyWindow, domain : DomainMatcher, val : SerializableFunction<T>, key : string, { on, send } : { on : OnType, send : SendType }) : SerializedFunction {\n    listenForFunctionCalls({ on, send });\n    \n    const id = val.__id__ || uniqueID();\n    destination = ProxyWindow.unwrap(destination);\n    let name = val.__name__ || val.name || key;\n\n    if (typeof name === 'string' && typeof name.indexOf === 'function' && name.indexOf('anonymous::') === 0) {\n        name = name.replace('anonymous::', `${ key }::`);\n    }\n\n    if (ProxyWindow.isProxyWindow(destination)) {\n        addMethod(id, val, name, destination, domain);\n\n        // $FlowFixMe\n        destination.awaitWindow().then(win => {\n            addMethod(id, val, name, win, domain);\n        });\n    } else {\n        addMethod(id, val, name, destination, domain);\n    }\n\n    return serializeType(SERIALIZATION_TYPE.CROSS_DOMAIN_FUNCTION, { id, name });\n}\n\nexport function deserializeFunction<T>(source : CrossDomainWindowType | ProxyWindow, origin : string, { id, name } : { id : string, name : string }, { send } : { send : SendType }) : (...args : $ReadOnlyArray<mixed>) => ZalgoPromise<T> {\n    const getDeserializedFunction = (opts? : Object = {}) => {\n        function crossDomainFunctionWrapper<X : mixed>() : ZalgoPromise<X> {\n            let originalStack;\n    \n            if (__DEBUG__) {\n                originalStack = (new Error(`Original call to ${ name }():`)).stack;\n            }\n    \n            return ProxyWindow.toProxyWindow(source, { send }).awaitWindow().then(win => {\n                const meth = lookupMethod(win, id);\n    \n                if (meth && meth.val !== crossDomainFunctionWrapper) {\n                    return meth.val.apply({ source: window, origin: getDomain() }, arguments);\n                } else {\n                    // $FlowFixMe\n                    const options = { domain: origin, fireAndForget: opts.fireAndForget };\n                    const args = Array.prototype.slice.call(arguments);\n\n                    return send(win, MESSAGE_NAME.METHOD, { id, name, args }, options)\n                        .then(res => {\n                            if (!opts.fireAndForget) {\n                                return res.data.result;\n                            }\n                        });\n                }\n    \n            }).catch(err => {\n                // $FlowFixMe\n                if (__DEBUG__ && originalStack && err.stack) {\n                    // $FlowFixMe\n                    err.stack = `Remote call to ${ name }(${ stringifyArguments(arguments) }) failed\\n\\n${ err.stack }\\n\\n${ originalStack }`;\n                }\n                throw err;\n            });\n        }\n\n        crossDomainFunctionWrapper.__name__ = name;\n        crossDomainFunctionWrapper.__origin__ = origin;\n        crossDomainFunctionWrapper.__source__ = source;\n        crossDomainFunctionWrapper.__id__ = id;\n\n        crossDomainFunctionWrapper.origin = origin;\n\n        return crossDomainFunctionWrapper;\n    };\n\n    const crossDomainFunctionWrapper = getDeserializedFunction();\n    crossDomainFunctionWrapper.fireAndForget = getDeserializedFunction({ fireAndForget: true });\n\n    return crossDomainFunctionWrapper;\n}\n","/* @flow */\n\nimport { type CrossDomainWindowType, isWindow, type DomainMatcher } from 'cross-domain-utils/src';\nimport { TYPE, serialize, deserialize, type Thenable } from 'universal-serialize/src';\n\nimport { SERIALIZATION_TYPE } from '../conf';\nimport type { OnType, SendType } from '../types';\n\nimport { serializeFunction, deserializeFunction, type SerializedFunction } from './function';\nimport { serializePromise, deserializePromise, type SerializedPromise } from './promise';\nimport { serializeWindow, deserializeWindow, type SerializedWindow, ProxyWindow } from './window';\n\nexport function serializeMessage<T : mixed>(destination : CrossDomainWindowType | ProxyWindow, domain : DomainMatcher, obj : T, { on, send } : { on : OnType, send : SendType }) : string {\n    return serialize(obj, {\n        [ TYPE.PROMISE ]:  (val : Thenable, key : string) : SerializedPromise => serializePromise(destination, domain, val, key, { on, send }),\n        [ TYPE.FUNCTION ]: (val : Function, key : string) : SerializedFunction => serializeFunction(destination, domain, val, key, { on, send }),\n        [ TYPE.OBJECT ]:   (val : CrossDomainWindowType) : Object | SerializedWindow => {\n            return (isWindow(val) || ProxyWindow.isProxyWindow(val)) ? serializeWindow(destination, domain, val, { on, send }) : val;\n        }\n    });\n}\n\nexport function deserializeMessage<T : mixed>(source : CrossDomainWindowType | ProxyWindow, origin : string, message : string, { on, send } : { on : OnType, send : SendType }) : T {\n    return deserialize(message, {\n        [ SERIALIZATION_TYPE.CROSS_DOMAIN_ZALGO_PROMISE ]: (serializedPromise)  => deserializePromise(source, origin, serializedPromise),\n        [ SERIALIZATION_TYPE.CROSS_DOMAIN_FUNCTION ]:      (serializedFunction) => deserializeFunction(source, origin, serializedFunction, { on, send }),\n        [ SERIALIZATION_TYPE.CROSS_DOMAIN_WINDOW ]:        (serializedWindow)   => deserializeWindow(source, origin, serializedWindow, { send })\n    });\n}\n","/* @flow */\n\nimport { type CrossDomainWindowType, type DomainMatcher } from 'cross-domain-utils/src';\nimport { ZalgoPromise } from 'zalgo-promise/src';\nimport { serializeType, type CustomSerializedType, type Thenable } from 'universal-serialize/src';\n\nimport { SERIALIZATION_TYPE } from '../conf';\nimport type { OnType, SendType } from '../types';\n\nimport { serializeFunction, type SerializedFunction } from './function';\nimport { ProxyWindow } from './window';\n\nexport type SerializedPromise = CustomSerializedType<typeof SERIALIZATION_TYPE.CROSS_DOMAIN_ZALGO_PROMISE, {\n    then : SerializedFunction\n}>;\n\nexport function serializePromise(destination : CrossDomainWindowType | ProxyWindow, domain : DomainMatcher, val : Thenable, key : string, { on, send } : { on : OnType, send : SendType }) : SerializedPromise {\n    return serializeType(SERIALIZATION_TYPE.CROSS_DOMAIN_ZALGO_PROMISE, {\n        then: serializeFunction(destination, domain, (resolve, reject) => val.then(resolve, reject), key, { on, send })\n    });\n}\n\nexport function deserializePromise<T>(source : CrossDomainWindowType | ProxyWindow, origin : string, { then } : { then : Function }) : ZalgoPromise<T> {\n    return new ZalgoPromise(then);\n}\n","/* @flow */\n\nimport { isSameDomain, isSameTopWindow, isActuallySameDomain, getActualDomain,\n    getDomain, type CrossDomainWindowType, type DomainMatcher, PROTOCOL } from 'cross-domain-utils/src';\n\nimport { SEND_STRATEGY, WILDCARD } from '../../conf';\nimport { needsGlobalMessagingForBrowser } from '../../lib';\nimport { getGlobal } from '../../global';\nimport { sendBridgeMessage, needsBridgeForBrowser, isBridge } from '../../bridge';\n\nexport const SEND_MESSAGE_STRATEGIES = {};\n\nSEND_MESSAGE_STRATEGIES[SEND_STRATEGY.POST_MESSAGE] = (win : CrossDomainWindowType, serializedMessage : string, domain : DomainMatcher) => {\n\n    if (__TEST__) {\n        if (needsGlobalMessagingForBrowser() && isSameTopWindow(window, win) === false) {\n            return;\n        }\n    }\n\n    let domains;\n\n    if (Array.isArray(domain)) {\n        domains = domain;\n    } else if (typeof domain === 'string') {\n        domains = [ domain ];\n    } else {\n        domains = [ WILDCARD ];\n    }\n\n    domains = domains.map(dom => {\n\n        if (__TEST__) {\n            if (dom.indexOf(PROTOCOL.MOCK) === 0) {\n                if (window.location.protocol === PROTOCOL.FILE) {\n                    return WILDCARD;\n                }\n\n                if (!isActuallySameDomain(win)) {\n                    throw new Error(`Attempting to send messsage to mock domain ${ dom }, but window is actually cross-domain`);\n                }\n\n                // $FlowFixMe\n                const windowDomain = getDomain(win);\n                \n                if (windowDomain !== dom) {\n                    throw new Error(`Mock domain target ${ dom } does not match window domain ${ windowDomain }`);\n                }\n\n                // $FlowFixMe\n                return getActualDomain(win);\n\n            }\n        }\n        \n        if (dom.indexOf(PROTOCOL.FILE) === 0) {\n            return WILDCARD;\n        }\n\n        return dom;\n    });\n\n    domains.forEach(dom => {\n        win.postMessage(serializedMessage, dom);\n    });\n};\n\nif (__POST_ROBOT__.__IE_POPUP_SUPPORT__) {\n\n    SEND_MESSAGE_STRATEGIES[SEND_STRATEGY.BRIDGE] = (win : CrossDomainWindowType, serializedMessage : string, domain : string) => {\n\n        if (!needsBridgeForBrowser() && !isBridge()) {\n            throw new Error(`Bridge not needed for browser`);\n        }\n\n        if (isSameDomain(win)) {\n            throw new Error(`Post message through bridge disabled between same domain windows`);\n        }\n\n        if (isSameTopWindow(window, win) !== false) {\n            throw new Error(`Can only use bridge to communicate between two different windows, not between frames`);\n        }\n\n        sendBridgeMessage(win, domain, serializedMessage);\n    };\n}\n\nif (__POST_ROBOT__.__IE_POPUP_SUPPORT__ || __POST_ROBOT__.__GLOBAL_MESSAGE_SUPPORT__) {\n    \n    SEND_MESSAGE_STRATEGIES[SEND_STRATEGY.GLOBAL] = (win : CrossDomainWindowType, serializedMessage : string) => {\n\n        if (!needsGlobalMessagingForBrowser()) {\n            throw new Error(`Global messaging not needed for browser`);\n        }\n\n        if (!isSameDomain(win)) {\n            throw new Error(`Post message through global disabled between different domain windows`);\n        }\n\n        if (isSameTopWindow(window, win) !== false) {\n            throw new Error(`Can only use global to communicate between two different windows, not between frames`);\n        }\n\n        // $FlowFixMe\n        const foreignGlobal = getGlobal(win);\n\n        if (!foreignGlobal) {\n            throw new Error(`Can not find postRobot global on foreign window`);\n        }\n\n        foreignGlobal.receiveMessage({\n            source: window,\n            origin: getDomain(),\n            data:   serializedMessage\n        });\n    };\n}\n","/* @flow */\n\nimport { getUserAgent } from 'cross-domain-utils/src';\n\nexport function needsGlobalMessagingForBrowser() : boolean {\n\n    if (getUserAgent(window).match(/MSIE|rv:11|trident|edge\\/12|edge\\/13/i)) {\n        return true;\n    }\n\n    return false;\n}\n","/* @flow */\n\nimport { isWindowClosed, getDomain, type CrossDomainWindowType, type DomainMatcher } from 'cross-domain-utils/src';\nimport { uniqueID, stringifyError } from 'belter/src';\n\nimport { serializeMessage } from '../../serialize';\nimport type { Message } from '../types';\nimport type { OnType, SendType } from '../../types';\n\nimport { SEND_MESSAGE_STRATEGIES } from './strategies';\n\nexport function sendMessage(win : CrossDomainWindowType, domain : DomainMatcher, message : Message, { on, send } : { on : OnType, send : SendType }) {\n    if (isWindowClosed(win)) {\n        throw new Error('Window is closed');\n    }\n    \n    const serializedMessage = serializeMessage(win, domain, {\n        [ __POST_ROBOT__.__GLOBAL_KEY__ ]: {\n            id:     uniqueID(),\n            origin: getDomain(window),\n            ...message\n        }\n    }, { on, send });\n\n    const strategies = Object.keys(SEND_MESSAGE_STRATEGIES);\n    const errors = [];\n\n    for (const strategyName of strategies) {\n        try {\n            SEND_MESSAGE_STRATEGIES[strategyName](win, serializedMessage, domain);\n        } catch (err) {\n            errors.push(err);\n        }\n    }\n\n    if (errors.length === strategies.length) {\n        throw new Error(`All post-robot messaging strategies failed:\\n\\n${ errors.map((err, i) => `${ i }. ${ stringifyError(err) }`).join('\\n\\n') }`);\n    }\n}\n","/* @flow */\n\nimport { type ZalgoPromise } from 'zalgo-promise/src';\nimport { matchDomain, type CrossDomainWindowType, type DomainMatcher } from 'cross-domain-utils/src';\nimport { isRegex, getOrSet } from 'belter/src';\n\nimport { getWildcard, type WildCard, globalStore, windowStore } from '../global';\nimport { WILDCARD } from '../conf';\n\nexport function resetListeners() {\n    const responseListeners = globalStore('responseListeners');\n    const erroredResponseListeners = globalStore('erroredResponseListeners');\n    responseListeners.reset();\n    erroredResponseListeners.reset();\n}\n\nconst __DOMAIN_REGEX__ = '__domain_regex__';\n\nexport type RequestListenerType = {|\n    handler : ({ source : CrossDomainWindowType, origin : string, data : mixed }) => (mixed | ZalgoPromise<mixed>),\n    handleError : (err : mixed) => void,\n    window : ?CrossDomainWindowType,\n    name : string,\n    domain : DomainMatcher\n|};\n\nexport type ResponseListenerType = {|\n    name : string,\n    win : CrossDomainWindowType,\n    domain : DomainMatcher,\n    promise : ZalgoPromise<*>,\n    ack? : ?boolean,\n    cancelled? : ?boolean\n|};\n\nexport function addResponseListener(hash : string, listener : ResponseListenerType) {\n    const responseListeners = globalStore('responseListeners');\n    responseListeners.set(hash, listener);\n}\n\nexport function getResponseListener(hash : string) : ?ResponseListenerType {\n    const responseListeners = globalStore('responseListeners');\n    return responseListeners.get(hash);\n}\n\nexport function deleteResponseListener(hash : string) {\n    const responseListeners = globalStore('responseListeners');\n    responseListeners.del(hash);\n}\n\nexport function cancelResponseListeners() {\n    const responseListeners = globalStore('responseListeners');\n    for (const hash of responseListeners.keys()) {\n        const listener = responseListeners.get(hash);\n        if (listener) {\n            listener.cancelled = true;\n        }\n        responseListeners.del(hash);\n    }\n}\n\nexport function markResponseListenerErrored(hash : string) {\n    const erroredResponseListeners = globalStore('erroredResponseListeners');\n    erroredResponseListeners.set(hash, true);\n}\n\nexport function isResponseListenerErrored(hash : string) : boolean {\n    const erroredResponseListeners = globalStore('erroredResponseListeners');\n    return erroredResponseListeners.has(hash);\n}\n\nexport function getRequestListener({ name, win, domain } : { name : string, win : ?(CrossDomainWindowType | WildCard), domain : ?(string | RegExp) }) : ?RequestListenerType {\n    const requestListeners = windowStore('requestListeners');\n\n    if (win === WILDCARD) {\n        win = null;\n    }\n\n    if (domain === WILDCARD) {\n        domain = null;\n    }\n\n    if (!name) {\n        throw new Error(`Name required to get request listener`);\n    }\n\n    for (const winQualifier of [ win, getWildcard() ]) {\n        if (!winQualifier) {\n            continue;\n        }\n\n        const nameListeners = requestListeners.get(winQualifier);\n\n        if (!nameListeners) {\n            continue;\n        }\n\n        const domainListeners = nameListeners[name];\n\n        if (!domainListeners) {\n            continue;\n        }\n\n        if (domain && typeof domain === 'string') {\n            if (domainListeners[domain]) {\n                return domainListeners[domain];\n            }\n\n            if (domainListeners[__DOMAIN_REGEX__]) {\n                for (const { regex, listener } of domainListeners[__DOMAIN_REGEX__]) {\n                    if (matchDomain(regex, domain)) {\n                        return listener;\n                    }\n                }\n            }\n        }\n\n        if (domainListeners[WILDCARD]) {\n            return domainListeners[WILDCARD];\n        }\n    }\n}\n\nexport function addRequestListener({ name, win, domain } : { name : string, win : ?(CrossDomainWindowType | WildCard), domain : ?DomainMatcher }, listener : RequestListenerType) : { cancel : () => void } {\n    const requestListeners = windowStore('requestListeners');\n\n    if (!name || typeof name !== 'string') {\n        throw new Error(`Name required to add request listener`);\n    }\n\n    if (Array.isArray(win)) {\n        const listenersCollection = [];\n\n        for (const item of win) {\n            listenersCollection.push(addRequestListener({ name, domain, win: item }, listener));\n        }\n\n        return {\n            cancel() {\n                for (const cancelListener of listenersCollection) {\n                    cancelListener.cancel();\n                }\n            }\n        };\n    }\n\n    if (Array.isArray(domain)) {\n        const listenersCollection = [];\n\n        for (const item of domain) {\n            listenersCollection.push(addRequestListener({ name, win, domain: item }, listener));\n        }\n\n        return {\n            cancel() {\n                for (const cancelListener of listenersCollection) {\n                    cancelListener.cancel();\n                }\n            }\n        };\n    }\n\n    const existingListener = getRequestListener({ name, win, domain });\n\n    if (!win || win === WILDCARD) {\n        win = getWildcard();\n    }\n\n    domain = domain || WILDCARD;\n\n    if (existingListener) {\n        if (win && domain) {\n            throw new Error(`Request listener already exists for ${ name } on domain ${ domain.toString() } for ${ win === getWildcard() ? 'wildcard' : 'specified' } window`);\n        } else if (win) {\n            throw new Error(`Request listener already exists for ${ name } for ${ win === getWildcard() ? 'wildcard' : 'specified' } window`);\n        } else if (domain) {\n            throw new Error(`Request listener already exists for ${ name } on domain ${ domain.toString() }`);\n        } else {\n            throw new Error(`Request listener already exists for ${ name }`);\n        }\n    }\n\n    const nameListeners = requestListeners.getOrSet(win, () => ({}));\n    const domainListeners = getOrSet(nameListeners, name, () => ({}));\n\n    const strDomain = domain.toString();\n\n    let regexListeners;\n    let regexListener;\n\n    if (isRegex(domain)) {\n        regexListeners = getOrSet(domainListeners, __DOMAIN_REGEX__, () => []);\n        regexListener = { regex: domain, listener };\n        regexListeners.push(regexListener);\n    } else {\n        domainListeners[strDomain] = listener;\n    }\n\n    return {\n        cancel() {\n            delete domainListeners[strDomain];\n\n            if (regexListener) {\n                regexListeners.splice(regexListeners.indexOf(regexListener, 1));\n\n                if (!regexListeners.length) {\n                    delete domainListeners[__DOMAIN_REGEX__];\n                }\n            }\n\n            if (!Object.keys(domainListeners).length) {\n                delete nameListeners[name];\n            }\n\n            if (win && !Object.keys(nameListeners).length) {\n                requestListeners.del(win);\n            }\n        }\n    };\n}\n","/* @flow */\n\nimport { ZalgoPromise } from 'zalgo-promise/src';\nimport { getDomain, isWindowClosed, matchDomain, stringifyDomainPattern, type CrossDomainWindowType } from 'cross-domain-utils/src';\nimport { noop, stringifyError } from 'belter/src';\n\nimport { MESSAGE_TYPE, MESSAGE_ACK, MESSAGE_NAME } from '../../conf';\nimport { sendMessage } from '../send';\nimport { getRequestListener, getResponseListener, deleteResponseListener, isResponseListenerErrored } from '../listeners';\nimport type { RequestMessage, AckResponseMessage, SuccessResponseMessage, ErrorResponseMessage } from '../types';\nimport type { OnType, SendType } from '../../types';\n\nexport const RECEIVE_MESSAGE_TYPES = {\n\n    [ MESSAGE_TYPE.REQUEST ](source : CrossDomainWindowType, origin : string, message : RequestMessage, { on, send } : { on : OnType, send : SendType }) : ZalgoPromise<void> {\n\n        const options = getRequestListener({ name: message.name, win: source, domain: origin });\n\n        const logName = (message.name === MESSAGE_NAME.METHOD && message.data && typeof message.data.name === 'string') ? `${ message.data.name }()` : message.name;\n\n        if (__DEBUG__) {\n            // eslint-disable-next-line no-console\n            console.info('receive::req', logName, origin, '\\n\\n', message.data);\n        }\n\n        function sendResponse(type : $Values<typeof MESSAGE_TYPE>, ack? : $Values<typeof MESSAGE_ACK>, response = {}) {\n\n            if (message.fireAndForget || isWindowClosed(source)) {\n                return;\n            }\n\n            if (__DEBUG__ && type !== MESSAGE_TYPE.ACK) {\n                if (ack === MESSAGE_ACK.SUCCESS) {\n                    // $FlowFixMe\n                    console.info('respond::res', logName, origin, '\\n\\n', response.data);  // eslint-disable-line no-console\n                } else if (ack === MESSAGE_ACK.ERROR) {\n                    // $FlowFixMe\n                    console.error('respond::err', logName, origin, '\\n\\n', response.error); // eslint-disable-line no-console\n                }\n            }\n\n            try {\n                // $FlowFixMe\n                sendMessage(source, origin, {\n                    type,\n                    ack,\n                    hash:   message.hash,\n                    name:   message.name,\n                    ...response\n                }, { on, send });\n            } catch (err) {\n                throw new Error(`Send response message failed for ${ logName } in ${ getDomain() }\\n\\n${ stringifyError(err) }`);\n            }\n        }\n\n        return ZalgoPromise.all([\n\n            sendResponse(MESSAGE_TYPE.ACK),\n\n            ZalgoPromise.try(() => {\n\n                if (!options) {\n                    throw new Error(`No handler found for post message: ${ message.name } from ${ origin } in ${ window.location.protocol }//${ window.location.host }${ window.location.pathname }`);\n                }\n\n                if (!matchDomain(options.domain, origin)) {\n                    throw new Error(`Request origin ${ origin } does not match domain ${ options.domain.toString() }`);\n                }\n\n                const data = message.data;\n\n                return options.handler({ source, origin, data });\n\n            }).then(data => {\n                return sendResponse(MESSAGE_TYPE.RESPONSE, MESSAGE_ACK.SUCCESS, { data });\n\n            }, error => {\n                return sendResponse(MESSAGE_TYPE.RESPONSE, MESSAGE_ACK.ERROR, { error });\n            })\n\n        ]).then(noop).catch(err => {\n            if (options && options.handleError) {\n                return options.handleError(err);\n            } else {\n                throw err;\n            }\n        });\n    },\n\n    [ MESSAGE_TYPE.ACK ](source : CrossDomainWindowType, origin : string, message : AckResponseMessage) {\n\n        if (isResponseListenerErrored(message.hash)) {\n            return;\n        }\n\n        const options = getResponseListener(message.hash);\n\n        if (!options) {\n            throw new Error(`No handler found for post message ack for message: ${ message.name } from ${ origin } in ${ window.location.protocol }//${ window.location.host }${ window.location.pathname }`);\n        }\n\n        try {\n            if (!matchDomain(options.domain, origin)) {\n                throw new Error(`Ack origin ${ origin } does not match domain ${ options.domain.toString() }`);\n            }\n    \n            if (source !== options.win) {\n                throw new Error(`Ack source does not match registered window`);\n            }\n        } catch (err) {\n            options.promise.reject(err);\n        }\n\n        options.ack = true;\n    },\n\n    [ MESSAGE_TYPE.RESPONSE ](source : CrossDomainWindowType, origin : string, message : SuccessResponseMessage | ErrorResponseMessage) : void | ZalgoPromise<void> {\n\n        if (isResponseListenerErrored(message.hash)) {\n            return;\n        }\n\n        const options = getResponseListener(message.hash);\n\n        if (!options) {\n            throw new Error(`No handler found for post message response for message: ${ message.name } from ${ origin } in ${ window.location.protocol }//${ window.location.host }${ window.location.pathname }`);\n        }\n\n        if (!matchDomain(options.domain, origin)) {\n            throw new Error(`Response origin ${ origin } does not match domain ${ stringifyDomainPattern(options.domain) }`);\n        }\n\n        if (source !== options.win) {\n            throw new Error(`Response source does not match registered window`);\n        }\n\n        deleteResponseListener(message.hash);\n\n        const logName = (message.name === MESSAGE_NAME.METHOD && message.data && typeof message.data.name === 'string') ? `${ message.data.name }()` : message.name;\n\n        if (message.ack === MESSAGE_ACK.ERROR) {\n            if (__DEBUG__) {\n                console.error('receive::err', logName, origin, '\\n\\n', message.error); // eslint-disable-line no-console\n            }\n\n            options.promise.reject(message.error);\n\n        } else if (message.ack === MESSAGE_ACK.SUCCESS) {\n            if (__DEBUG__) {\n                console.info('receive::res', logName, origin, '\\n\\n', message.data); // eslint-disable-line no-console\n            }\n\n            options.promise.resolve({ source, origin, data: message.data });\n        }\n    }\n};\n","/* @flow */\n\nimport { isWindowClosed, type CrossDomainWindowType, getDomain, isSameTopWindow, PROTOCOL  } from 'cross-domain-utils/src';\nimport { addEventListener, noop } from 'belter/src';\n\nimport { markWindowKnown, needsGlobalMessagingForBrowser } from '../../lib';\nimport { deserializeMessage } from '../../serialize';\nimport { getGlobal, globalStore } from '../../global';\nimport type { OnType, SendType, MessageEvent, CancelableType } from '../../types';\n\nimport { RECEIVE_MESSAGE_TYPES } from './types';\n\nfunction parseMessage(message : string, source : CrossDomainWindowType, origin : string, { on, send } : { on : OnType, send : SendType }) : ?Object {\n    let parsedMessage;\n\n    try {\n        parsedMessage = deserializeMessage(source, origin, message, { on, send });\n    } catch (err) {\n        return;\n    }\n\n    if (!parsedMessage) {\n        return;\n    }\n\n    if (typeof parsedMessage !== 'object' || parsedMessage === null) {\n        return;\n    }\n\n    parsedMessage = parsedMessage[__POST_ROBOT__.__GLOBAL_KEY__];\n\n    if (!parsedMessage || typeof parsedMessage !== 'object' || parsedMessage === null) {\n        return;\n    }\n\n    if (!parsedMessage.type || typeof parsedMessage.type !== 'string') {\n        return;\n    }\n\n    if (!RECEIVE_MESSAGE_TYPES[parsedMessage.type]) {\n        return;\n    }\n\n    return parsedMessage;\n}\n\nexport function receiveMessage(event : MessageEvent, { on, send } : { on : OnType, send : SendType }) {\n    const receivedMessages = globalStore('receivedMessages');\n\n    try {\n        if (!window || window.closed || !event.source) {\n            return;\n        }\n    } catch (err) {\n        return;\n    }\n\n    let { source, origin, data } = event;\n\n    if (__TEST__) {\n        // $FlowFixMe\n        origin = getDomain(source);\n    }\n\n    const message = parseMessage(data, source, origin, { on, send });\n\n    if (!message) {\n        return;\n    }\n\n    markWindowKnown(source);\n\n    if (receivedMessages.has(message.id)) {\n        return;\n    }\n\n    receivedMessages.set(message.id, true);\n\n    if (isWindowClosed(source) && !message.fireAndForget) {\n        return;\n    }\n\n    if (message.origin.indexOf(PROTOCOL.FILE) === 0) {\n        origin = `${ PROTOCOL.FILE }//`;\n    }\n\n    RECEIVE_MESSAGE_TYPES[message.type](source, origin, message, { on, send });\n}\n\nexport function setupGlobalReceiveMessage({ on, send } : { on : OnType, send : SendType }) {\n    const global = getGlobal();\n    global.receiveMessage = global.receiveMessage || (message => receiveMessage(message, { on, send }));\n}\n\ntype ListenerEvent = {|\n    source : CrossDomainWindowType,\n    origin : string,\n    data : string,\n    sourceElement : CrossDomainWindowType,\n    originalEvent? : { origin : string }\n|};\n\nexport function messageListener(event : ListenerEvent, { on, send } : { on : OnType, send : SendType }) {\n\n    try {\n        noop(event.source);\n    } catch (err) {\n        return;\n    }\n\n    const source = event.source || event.sourceElement;\n    let origin = event.origin || (event.originalEvent && event.originalEvent.origin);\n    const data = event.data;\n\n    if (origin === 'null') {\n        origin = `${ PROTOCOL.FILE }//`;\n    }\n\n    if (!source) {\n        return;\n    }\n\n    if (!origin) {\n        throw new Error(`Post message did not have origin domain`);\n    }\n\n    if (__TEST__) {\n        if (needsGlobalMessagingForBrowser() && isSameTopWindow(source, window) === false) {\n            return;\n        }\n    }\n\n    receiveMessage({ source, origin, data }, { on, send });\n}\n\nexport function listenForMessages({ on, send } : { on : OnType, send : SendType }) : CancelableType {\n    return globalStore().getOrSet('postMessageListener', () => {\n        return addEventListener(window, 'message', event => {\n            // $FlowFixMe\n            messageListener(event, { on, send });\n        });\n    });\n}\n\nexport function stopListenForMessages() {\n    const listener = globalStore().get('postMessageListener');\n    if (listener) {\n        listener.cancel();\n    }\n}\n","/* @flow */\n\nimport { ZalgoPromise } from 'zalgo-promise/src';\n\nimport { addRequestListener, type RequestListenerType } from '../drivers';\nimport { WILDCARD } from '../conf';\nimport type { ServerOptionsType, HandlerType, CancelableType } from '../types';\n\nexport function on(name : string, options : ServerOptionsType | HandlerType, handler : ?HandlerType) : CancelableType {\n\n    if (!name) {\n        throw new Error('Expected name');\n    }\n\n    if (typeof options === 'function') {\n        handler = options;\n        // $FlowFixMe\n        options = {};\n    }\n\n    if (!handler) {\n        throw new Error('Expected handler');\n    }\n\n    options = options || {};\n    options.name = name;\n    options.handler = handler || options.handler;\n\n    const win = options.window;\n    const domain = options.domain;\n\n    const listenerOptions : RequestListenerType = {\n        handler:     options.handler,\n        handleError: options.errorHandler || (err => {\n            throw err;\n        }),\n        window: win,\n        domain: domain || WILDCARD,\n        name\n    };\n\n    const requestListener = addRequestListener({ name, win, domain }, listenerOptions);\n\n    return {\n        cancel() {\n            requestListener.cancel();\n        }\n    };\n}\n\nexport function once(name : string, options? : ServerOptionsType | HandlerType, handler? : HandlerType) : ZalgoPromise<{ source : mixed, origin : string, data : Object }> {\n    \n    // $FlowFixMe\n    options = options || {};\n    if (typeof options === 'function') {\n        handler = options;\n        // $FlowFixMe\n        options = {};\n    }\n\n    const promise = new ZalgoPromise();\n    let listener; // eslint-disable-line prefer-const\n\n    options.errorHandler = (err) => {\n        listener.cancel();\n        promise.reject(err);\n    };\n\n    listener = on(name, options, event => {\n        listener.cancel();\n        promise.resolve(event);\n        if (handler) {\n            return handler(event);\n        }\n    });\n\n    promise.cancel = listener.cancel;\n    return promise;\n}\n","/* @flow */\n\nimport { ZalgoPromise } from 'zalgo-promise/src';\nimport { isAncestor, isWindowClosed, getDomain, matchDomain, type CrossDomainWindowType, type DomainMatcher } from 'cross-domain-utils/src';\nimport { uniqueID, isRegex, noop, safeInterval, stringify, stringifyError } from 'belter/src';\n\n\nimport { CHILD_WINDOW_TIMEOUT, MESSAGE_TYPE, WILDCARD, MESSAGE_NAME, ACK_TIMEOUT, RES_TIMEOUT, ACK_TIMEOUT_KNOWN, RESPONSE_CYCLE_TIME } from '../conf';\nimport { sendMessage, addResponseListener, deleteResponseListener, markResponseListenerErrored, type ResponseListenerType } from '../drivers';\nimport { awaitWindowHello, sayHello, isWindowKnown } from '../lib';\nimport { windowStore } from '../global';\nimport type { SendType } from '../types';\n\nimport { on } from './on';\n\nfunction validateOptions(name : string, win : CrossDomainWindowType, domain : ?DomainMatcher) {\n    if (!name) {\n        throw new Error('Expected name');\n    }\n\n    if (domain) {\n        if (typeof domain !== 'string' && !Array.isArray(domain) && !isRegex(domain)) {\n            throw new TypeError(`Expected domain to be a string, array, or regex`);\n        }\n    }\n\n    if (isWindowClosed(win)) {\n        throw new Error('Target window is closed');\n    }\n}\n\nfunction normalizeDomain(win : CrossDomainWindowType, targetDomain : DomainMatcher, actualDomain : ?string, { send } : { send : SendType }) : ZalgoPromise<string | $ReadOnlyArray<string>> {\n    if (typeof targetDomain === 'string') {\n        return ZalgoPromise.resolve(targetDomain);\n    }\n    \n    return ZalgoPromise.try(() => {\n        return actualDomain || sayHello(win, { send }).then(({ domain }) => domain);\n\n    }).then(normalizedDomain => {\n        if (!matchDomain(targetDomain, targetDomain)) {\n            throw new Error(`Domain ${ stringify(targetDomain) } does not match ${ stringify(targetDomain) }`);\n        }\n\n        return normalizedDomain;\n    });\n}\n\nexport const send : SendType = (win, name, data, options) => {\n    options = options || {};\n    let domain = options.domain || WILDCARD;\n    const responseTimeout = options.timeout || RES_TIMEOUT;\n    const childTimeout = options.timeout || CHILD_WINDOW_TIMEOUT;\n    const fireAndForget = options.fireAndForget || false;\n\n    // $FlowFixMe\n    return ZalgoPromise.try(() => {\n        validateOptions(name, win, domain);\n\n        if (isAncestor(window, win)) {\n            return awaitWindowHello(win, childTimeout);\n        }\n        \n    }).then(({ domain: actualDomain } = {}) => {\n\n        return normalizeDomain(win, domain, actualDomain, { send });\n    }).then(targetDomain => {\n\n        domain = targetDomain;\n\n        const logName = (name === MESSAGE_NAME.METHOD && data && typeof data.name === 'string') ? `${ data.name }()` : name;\n\n        if (__DEBUG__) {\n            console.info('send::req', logName, domain, '\\n\\n', data); // eslint-disable-line no-console\n        }\n\n        const promise = new ZalgoPromise();\n        const hash = `${ name }_${ uniqueID() }`;\n\n        if (!fireAndForget) {\n            const responseListener : ResponseListenerType = { name, win, domain, promise };\n            addResponseListener(hash, responseListener);\n\n            const reqPromises = windowStore('requestPromises').getOrSet(win, () => []);\n            reqPromises.push(promise);\n\n            promise.catch(() => {\n                markResponseListenerErrored(hash);\n                deleteResponseListener(hash);\n            });\n\n            const totalAckTimeout = isWindowKnown(win) ? ACK_TIMEOUT_KNOWN : ACK_TIMEOUT;\n            const totalResTimeout = responseTimeout;\n\n            let ackTimeout = totalAckTimeout;\n            let resTimeout = totalResTimeout;\n        \n            const interval = safeInterval(() => {\n                if (isWindowClosed(win)) {\n                    return promise.reject(new Error(`Window closed for ${ name } before ${ responseListener.ack ? 'response' : 'ack' }`));\n                }\n\n                if (responseListener.cancelled) {\n                    return promise.reject(new Error(`Response listener was cancelled for ${ name }`));\n                }\n\n                ackTimeout = Math.max(ackTimeout - RESPONSE_CYCLE_TIME, 0);\n                if (resTimeout !== -1) {\n                    resTimeout = Math.max(resTimeout - RESPONSE_CYCLE_TIME, 0);\n                }\n\n                if (!responseListener.ack && ackTimeout === 0) {\n                    return promise.reject(new Error(`No ack for postMessage ${ logName } in ${ getDomain() } in ${ totalAckTimeout }ms`));\n\n                } else if (resTimeout === 0) {\n                    return promise.reject(new Error(`No response for postMessage ${ logName } in ${ getDomain() } in ${ totalResTimeout }ms`));\n                }\n            }, RESPONSE_CYCLE_TIME);\n\n            promise.finally(() => {\n                interval.cancel();\n                reqPromises.splice(reqPromises.indexOf(promise, 1));\n            }).catch(noop);\n        }\n\n        try {\n            sendMessage(win, domain, {\n                type: MESSAGE_TYPE.REQUEST,\n                hash,\n                name,\n                data,\n                fireAndForget\n            }, { on, send });\n        } catch (err) {\n            throw new Error(`Send request message failed for ${ logName } in ${ getDomain() }\\n\\n${ stringifyError(err) }`);\n        }\n    \n        return fireAndForget ? promise.resolve() : promise;\n    });\n};\n","/* @flow */\n\nexport const BRIDGE_TIMEOUT = 5000;\nexport const CHILD_WINDOW_TIMEOUT = 5000;\n\nexport const ACK_TIMEOUT = 2000;\nexport const ACK_TIMEOUT_KNOWN = 10000;\nexport const RES_TIMEOUT = __TEST__ ? 2000 : -1;\nexport const RESPONSE_CYCLE_TIME = 500;\n","/* @flow */\n\nimport type { CrossDomainWindowType, DomainMatcher } from 'cross-domain-utils/src';\n\nimport { initHello } from './lib';\nimport { listenForMessages, stopListenForMessages, receiveMessage, setupGlobalReceiveMessage, cancelResponseListeners } from './drivers';\nimport { getGlobal, deleteGlobal } from './global';\nimport { on, send } from './public';\nimport { setupBridge } from './bridge';\nimport { serializeMessage as internalSerializeMessage, deserializeMessage as internalDeserializeMessage, ProxyWindow } from './serialize';\n\nexport function serializeMessage<T>(destination : CrossDomainWindowType | ProxyWindow, domain : DomainMatcher, obj : T) : string {\n    return internalSerializeMessage(destination, domain, obj, { on, send });\n}\n\nexport function deserializeMessage<T : mixed>(source : CrossDomainWindowType | ProxyWindow, origin : string, message : string) : T {\n    return internalDeserializeMessage(source, origin, message, { on, send });\n}\n\nexport function createProxyWindow(win? : CrossDomainWindowType) : ProxyWindow {\n    return new ProxyWindow({ send, win });\n}\n\nexport function toProxyWindow(win : CrossDomainWindowType | ProxyWindow) : ProxyWindow {\n    return ProxyWindow.toProxyWindow(win, { send });\n}\n\nexport function setup() {\n    if (!getGlobal().initialized) {\n        getGlobal().initialized = true;\n    \n        setupGlobalReceiveMessage({ on, send });\n        listenForMessages({ on, send });\n    \n        if (__POST_ROBOT__.__IE_POPUP_SUPPORT__) {\n            setupBridge({ on, send, receiveMessage });\n        }\n\n        initHello({ on, send });\n    }\n}\n\nexport function destroy() {\n    cancelResponseListeners();\n    stopListenForMessages();\n    deleteGlobal();\n}\n","/* @flow */\n\nimport { type CrossDomainWindowType, isWindowClosed } from 'cross-domain-utils/src';\nimport { noop } from 'belter/src';\n\nimport { windowStore } from './global';\n\nexport function cleanUpWindow(win : CrossDomainWindowType) {\n    const requestPromises = windowStore('requestPromises');\n    for (const promise of requestPromises.get(win, [])) {\n        promise.reject(new Error(`Window ${ isWindowClosed(win) ? 'closed' : 'cleaned up' } before response`)).catch(noop);\n    }\n}\n","/* @flow */\n\nimport { setup } from './setup';\nimport { setupBridge, openBridge, linkWindow, linkUrl, isBridge, needsBridge, needsBridgeForBrowser, hasBridge,\n    needsBridgeForWin, needsBridgeForDomain, destroyBridges } from './bridge';\n\nexport { ZalgoPromise as Promise } from 'zalgo-promise/src';\n\nexport * from './types';\nexport { ProxyWindow } from './serialize';\nexport { setup, destroy, serializeMessage, deserializeMessage, createProxyWindow, toProxyWindow } from './setup';\nexport { on, once, send } from './public';\nexport { markWindowKnown } from './lib';\nexport { cleanUpWindow } from './clean';\nexport let bridge;\n\nif (__POST_ROBOT__.__IE_POPUP_SUPPORT__) {\n    bridge = { setupBridge, openBridge, linkWindow, linkUrl, isBridge, needsBridge,\n        needsBridgeForBrowser, hasBridge, needsBridgeForWin, needsBridgeForDomain, destroyBridges };\n}\n\nif (__POST_ROBOT__.__AUTO_SETUP__) {\n    setup();\n}\n","/* @flow */\n\nimport type { ZalgoPromise } from 'zalgo-promise/src';\nimport type { CrossDomainWindowType, DomainMatcher } from 'cross-domain-utils/src';\n\n// export something to force webpack to see this as an ES module\nexport const TYPES = true;\n\n// eslint-disable-next-line flowtype/require-exact-type\nexport type CancelableType = {\n    cancel : () => void\n};\n\nexport type ErrorHandlerType = (err : mixed) => void;\n\nexport type HandlerType = ({\n    source : CrossDomainWindowType,\n    origin : string,\n    data : any // eslint-disable-line flowtype/no-weak-types\n}) => (void | any | ZalgoPromise<any>); // eslint-disable-line flowtype/no-weak-types\n\nexport type ServerOptionsType = {|\n    handler? : ?HandlerType,\n    errorHandler? : ?ErrorHandlerType,\n    window? : CrossDomainWindowType,\n    name? : ?string,\n    domain? : ?DomainMatcher,\n    once? : ?boolean,\n    errorOnClose? : ?boolean\n|};\n\nexport type OnType = (\n    name : string,\n    options : ServerOptionsType | HandlerType,\n    handler : ?HandlerType\n) => CancelableType;\n\ntype RegularRequestOptionsType = {|\n    domain? : ?DomainMatcher,\n    fireAndForget? : false,\n    timeout? : ?number\n|};\n\ntype FireAndForgetRequestOptionsType = {|\n    domain? : ?DomainMatcher,\n    fireAndForget : true,\n    timeout? : ?number\n|};\n\nexport type RequestOptionsType = RegularRequestOptionsType | FireAndForgetRequestOptionsType;\n\nexport type ResponseMessageEvent = {|\n    source : CrossDomainWindowType,\n    origin : string,\n    data : Object\n|};\n\ntype RegularSendType = (\n    win : CrossDomainWindowType,\n    name : string,\n    data : ?Object,\n    options? : RegularRequestOptionsType\n) => ZalgoPromise<ResponseMessageEvent>;\n\ntype FireAndForgetSendType = (\n    win : CrossDomainWindowType,\n    name : string,\n    data : ?Object,\n    options? : FireAndForgetRequestOptionsType\n) => ZalgoPromise<void>;\n\nexport type SendType = RegularSendType & FireAndForgetSendType;\n\nexport type MessageEvent = {|\n    source : CrossDomainWindowType,\n    origin : string,\n    data : string\n|};\n\n// eslint-disable-next-line flowtype/require-exact-type\nexport type CrossDomainFunctionType<A, R> = {\n    (...args : A) : ZalgoPromise<R>,\n    fireAndForget : (...args : A) => ZalgoPromise<void>,\n    __id__? : string,\n    __name__? : string\n};\n\nexport type ReceiveMessageType = (MessageEvent, { on : OnType, send : SendType }) => void;\n"],"sourceRoot":""}