{"version":3,"sources":["webpack://zoid/webpack/universalModuleDefinition","webpack://zoid/webpack/bootstrap","webpack://zoid/./node_modules/@babel/runtime/helpers/esm/extends.js","webpack://zoid/./node_modules/zalgo-promise/src/utils.js","webpack://zoid/./node_modules/zalgo-promise/src/exceptions.js","webpack://zoid/./node_modules/zalgo-promise/src/flush.js","webpack://zoid/./node_modules/zalgo-promise/src/promise.js","webpack://zoid/./node_modules/cross-domain-utils/src/util.js","webpack://zoid/./node_modules/cross-domain-utils/src/constants.js","webpack://zoid/./node_modules/cross-domain-utils/src/utils.js","webpack://zoid/./node_modules/cross-domain-safe-weakmap/src/util.js","webpack://zoid/./node_modules/cross-domain-safe-weakmap/src/weakmap.js","webpack://zoid/./node_modules/belter/src/util.js","webpack://zoid/./node_modules/belter/src/dom.js","webpack://zoid/./node_modules/cross-domain-safe-weakmap/src/native.js","webpack://zoid/./node_modules/belter/src/css.js","webpack://zoid/./node_modules/post-robot/src/conf/config.js","webpack://zoid/./node_modules/post-robot/src/conf/constants.js","webpack://zoid/./node_modules/post-robot/src/global.js","webpack://zoid/./node_modules/post-robot/src/lib/hello.js","webpack://zoid/./node_modules/post-robot/src/lib/windows.js","webpack://zoid/./node_modules/universal-serialize/src/constants.js","webpack://zoid/./node_modules/universal-serialize/src/common.js","webpack://zoid/./node_modules/universal-serialize/src/serialize.js","webpack://zoid/./node_modules/universal-serialize/src/serializers/function.js","webpack://zoid/./node_modules/universal-serialize/src/serializers/error.js","webpack://zoid/./node_modules/universal-serialize/src/serializers/promise.js","webpack://zoid/./node_modules/universal-serialize/src/serializers/regex.js","webpack://zoid/./node_modules/universal-serialize/src/serializers/date.js","webpack://zoid/./node_modules/universal-serialize/src/serializers/array.js","webpack://zoid/./node_modules/universal-serialize/src/serializers/object.js","webpack://zoid/./node_modules/universal-serialize/src/serializers/string.js","webpack://zoid/./node_modules/universal-serialize/src/serializers/number.js","webpack://zoid/./node_modules/universal-serialize/src/serializers/boolean.js","webpack://zoid/./node_modules/universal-serialize/src/serializers/null.js","webpack://zoid/./node_modules/universal-serialize/src/deserialize.js","webpack://zoid/./node_modules/post-robot/src/bridge/common.js","webpack://zoid/./node_modules/post-robot/src/bridge/parent.js","webpack://zoid/./node_modules/post-robot/src/bridge/setup.js","webpack://zoid/./node_modules/post-robot/src/bridge/bridge.js","webpack://zoid/./node_modules/post-robot/src/bridge/child.js","webpack://zoid/./node_modules/post-robot/src/serialize/window.js","webpack://zoid/./node_modules/post-robot/src/serialize/function.js","webpack://zoid/./node_modules/post-robot/src/serialize/serialize.js","webpack://zoid/./node_modules/post-robot/src/serialize/promise.js","webpack://zoid/./node_modules/post-robot/src/drivers/send/strategies.js","webpack://zoid/./node_modules/post-robot/src/drivers/send/index.js","webpack://zoid/./node_modules/post-robot/src/lib/compat.js","webpack://zoid/./node_modules/post-robot/src/drivers/listeners.js","webpack://zoid/./node_modules/post-robot/src/drivers/receive/types.js","webpack://zoid/./node_modules/post-robot/src/drivers/receive/index.js","webpack://zoid/./node_modules/post-robot/src/public/on.js","webpack://zoid/./node_modules/post-robot/src/public/send.js","webpack://zoid/./node_modules/post-robot/src/index.js","webpack://zoid/./node_modules/post-robot/src/setup.js","webpack://zoid/./node_modules/post-robot/src/clean.js","webpack://zoid/./src/lib/global.js","webpack://zoid/./src/lib/serialize.js","webpack://zoid/./src/constants.js","webpack://zoid/./src/child/props.js","webpack://zoid/./src/child/window.js","webpack://zoid/./src/child/index.js","webpack://zoid/./src/parent/drivers.js","webpack://zoid/./src/parent/props.js","webpack://zoid/./src/parent/index.js","webpack://zoid/./src/delegate/index.js","webpack://zoid/./src/component/templates/container.js","webpack://zoid/./src/component/templates/component.js","webpack://zoid/./src/component/props.js","webpack://zoid/./src/component/component.js","webpack://zoid/./src/component/validate.js","webpack://zoid/./src/index.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","_extends","assign","target","arguments","length","source","apply","isPromise","item","Promise","window","Window","constructor","toString","then","err","flushPromise","dispatchedErrors","possiblyUnhandledPromiseHandlers","activeCount","flushActive","promise","resolve","startActive","endActive","ZalgoPromise","handler","resolved","rejected","errorHandled","error","handlers","dispatching","stack","result","isAsync","res","reject","Error","dispatch","setTimeout","indexOf","push","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","delay","flush","isRegex","PROTOCOL","MOCK","FILE","ABOUT","WILDCARD","WINDOW_TYPE","IFRAME","POPUP","IE_WIN_ACCESS_ERROR","isAboutProtocol","win","location","protocol","getParent","parent","getOpener","opener","canReadFromWindow","getActualDomain","host","getDomain","domain","mockDomain","isSameDomain","desc","getOwnPropertyDescriptor","isActuallySameDomain","assertSameDomain","isAncestorParent","child","childParent","getParents","getFrames","frames","len","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","getDistanceFromTop","distance","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","onCloseWindow","callback","maxtime","Infinity","check","isWindow","obj","__cross_domain_utils_window_check__","normalizeMockUrl","closeWindow","close","objectIDs","awaitFrameLoadPromises","CrossDomainSafeWeakMap","weakmap","values","Math","random","WeakMap","freeze","testWeakMap","testKey","set","hasNativeWeakMap","_cleanupClosedWindows","delete","isSafeToReadWrite","entry","writable","index","has","getOrSet","getFunctionName","fn","__name__","displayName","setFunctionName","base64encode","str","btoa","encodeURIComponent","replace","p1","String","fromCharCode","parseInt","Buffer","from","uniqueID","chars","charAt","floor","Date","toISOString","toLowerCase","serializeArgs","subkey","val","uid","getObjectID","memoizePromise","cache","memoizedPromiseFunction","reset","inlineMemoize","logic","__inline_memoize_cache__","noop","once","called","stringifyError","level","newErr","extend","safeInterval","loop","arrayFrom","isDefined","cleanup","tasks","cleaned","register","task","pop","assertExists","thing","isDocumentReady","document","body","readyState","urlEncode","waitForDocumentReady","interval","setInterval","clearInterval","parseQuery","queryString","params","pair","decodeURIComponent","extendQuery","originalQuery","props","filter","appendChild","container","isElement","element","Element","nodeType","style","getElementSafe","id","querySelector","elementReady","el","PopupOpenError","awaitFrameLoad","addEventListener","cleanIframes","linkFrameWindow","awaitFrameWindow","loadedFrame","iframe","options","tag","styleText","createElement","class","className","setAttribute","attributes","styleSheet","cssText","createTextNode","html","innerHTML","allowTransparency","backgroundColor","border","isIE","hasAttribute","getElement","event","removeEventListener","prototype","STYLE","DISPLAY","NONE","BLOCK","VISIBILITY","VISIBLE","HIDDEN","IMPORTANT","showElement","setProperty","hideElement","destroyElement","removeChild","isElementClosed","onResize","width","height","currentWidth","offsetWidth","currentHeight","offsetHeight","observer","newWidth","newHeight","ResizeObserver","observe","MutationObserver","childList","subtree","characterData","disconnect","isPerc","test","isPx","toNum","toPx","toCSS","normalizeDimension","dim","max","MESSAGE_NAME","METHOD","HELLO","OPEN_TUNNEL","BRIDGE_NAME_PREFIX","SERIALIZATION_TYPE","CROSS_DOMAIN_ZALGO_PROMISE","CROSS_DOMAIN_FUNCTION","CROSS_DOMAIN_WINDOW","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","TYPE","FUNCTION","ERROR","PROMISE","REGEX","DATE","ARRAY","OBJECT","STRING","NUMBER","BOOLEAN","NULL","UNDEFINED","isSerializedType","__type__","determineType","serializeType","type","__val__","SERIALIZER","code","toJSON","defaultSerializers","DESERIALIZER","RegExp","defaultDeserializers","needsBridgeForBrowser","needsBridgeForWin","needsBridgeForDomain","needsBridge","getBridgeName","sanitizedDomain","isBridge","documentBodyReady","registerRemoteWindow","findRemoteWindow","remoteWinPromise","registerRemoteSendMessage","sendMessage","remoteWin","remoteDomain","fireAndForget","rejectRemoteSendMessage","linkWindow","popupWindowsByName","popupWindowsByWin","winName","details","setupBridge","windowOpen","on","receiveMessage","open","last","bridgePromise","bridge","winDetails","listenForOpenTunnel","openTunnelToParent","canary","tunnelWindows","parentWindow","cleanTunnelWindows","addTunnelWindow","tunnelWindow","setupOpenTunnelToParent","openTunnelToOpener","cleanupProxyWindows","idToProxyWindow","shouldClean","getSerializedWindow","winPromise","windowNamePromise","getType","getName","focus","isClosed","setLocation","href","setName","sameDomain","frameElement","querySelectorAll","getFrameForWindow","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","__id__","serializeMessage","serializers","serializer","serializePromise","deserializeMessage","deserializers","parse","deserializer","serializedPromise","deserializePromise","serializedFunction","getDeserializedFunction","opts","crossDomainFunctionWrapper","__origin__","__source__","deserializeFunction","SEND_MESSAGE_STRATEGIES","serializedMessage","strategies","errors","strategyName","dom","forEach","postMessage","messagingChild","messagingParent","sendBridgeMessage","foreignGlobal","__DOMAIN_REGEX__","getResponseListener","deleteResponseListener","isResponseListenerErrored","getRequestListener","requestListeners","winQualifier","nameListeners","domainListeners","listener","regex","RECEIVE_MESSAGE_TYPES","logName","sendResponse","ack","response","pathname","handleError","receivedMessages","parsedMessage","parseMessage","requestListener","addRequestListener","listenersCollection","existingListener","regexListeners","regexListener","strDomain","errorHandler","responseTimeout","childTimeout","validateOptions","actualParent","isAncestor","targetDomain","actualDomain","normalizedDomain","normalizeDomain","responseListener","addResponseListener","reqPromises","markResponseListenerErrored","totalAckTimeout","isWindowKnown","totalResTimeout","ackTimeout","resTimeout","cancelled","internalSerializeMessage","internalDeserializeMessage","cleanUpWindow","getProxyObject","openBridge","bridges","bridgeFrames","src","openBridgeFrame","linkUrl","hasBridge","destroyBridges","ZOID","POST_MESSAGE","PROP_TYPE","PROP_SERIALIZATION","DOTIFY","BASE64","CONTEXT","DEFAULT_DIMENSIONS","WIDTH","HEIGHT","EVENT","RENDER","RENDERED","CLOSE","PROPS","RESIZE","FOCUS","normalizeChildProp","component","helpers","prop","getPropDefinition","childDecorate","onProps","resize","getParentDomain","show","hide","parseChildWindowName","windowName","zoidcomp","encodedPayload","atob","charCodeAt","base64decode","getChildPayload","ChildComponent","parentDomain","parentComponentWindow","onPropHandlers","autoResize","childPayload","__ZOID__","version","getParentComponentWindow","checkParentDomain","initialProps","getPropsByRef","setProps","watchForClose","init","buildExports","watchForResize","getHelpers","allowedParentDomains","ref","getNthParent","ancestor","windows","getProps","isUpdate","existingProps","alias","getPropNames","normalizeChildProps","checkClose","destroy","getAutoResize","updateProps","RENDER_DRIVERS","getQueryParam","queryParam","getQueryValue","queryValue","openFrame","title","proxyFrame","frameWatcher","clean","openPrerenderFrame","openPrerender","proxyWin","proxyPrerenderFrame","prerenderFrame","prerenderFrameWindow","delegate","dimensions","outerWidth","left","round","screenX","screen","outerHeight","screenY","status","toolbar","menubar","resizable","scrollbars","popup","ParentComponent","driver","initPromise","handledErrors","state","proxyContainer","visible","setupEvents","registerActiveComponent","destroyActiveComponent","watchForUnload","triggered","eventName","handlerList","trigger","triggerOnce","onRender","onDisplay","onRendered","onClose","onFocus","render","log","childDomain","getChildDomain","checkAllowRender","windowProp","buildUrl","getProxyContainer","getProxyWindow","buildWindowName","renderContainer","setState","setProxyWin","prerender","proxyPrerenderWin","setWindowName","loadUrl","runTimeout","containerElement","buildChildPayload","getPropsRef","getPropsForChild","propRef","getWindowRef","buildParentExports","validate","inputProps","propNames","aliases","propDef","default","decorate","required","extendProps","propsDef","builtinProps","serialization","dotify","prefix","newobj","every","dotkey","query","originalUrl","originalHash","hashString","extendUrl","getUrl","sendToChild","propName","allowDelegate","overridesPromise","overrides","unloadWindowListener","initChild","secondClosed","prerenderTemplate","prerenderWindow","isBlankDomain","renderTemplate","tagName","children","writeElementToWindow","renderer","innerContainer","containerTemplate","bridgeUrl","getBridgeUrl","bridgeDomain","DelegateComponent","watchForSourceClose","getDelegate","getOverrides","closeSourceWindowListener","CLASS","INVISIBLE","defaultContainerTemplate","div","cspNonce","classList","add","remove","defaultPrerenderTemplate","spinner","defaultNoop","decorateOnce","Component","defaultContext","driverCache","xprops","logger","PROP_TYPE_LIST","validatePropDefinitions","components","debug","info","warn","registerChild","listenDelegate","dep","isChild","canRenderTo","payload","getDefaultContainer","getDefaultContext","finalContext","renderTo","instance","activeComponents","initialized","sourceElement","originalEvent","messageListener","listenForMessages","initHello","destroyAll","destroyComponents","responseListeners","cancelResponseListeners"],"mappings":"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","file":"zoid.min.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(\"zoid\", [], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"zoid\"] = factory();\n\telse\n\t\troot[\"zoid\"] = 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","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 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","/* @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\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/* 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 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/* 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.pop();\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) {\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\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\nexport function isPerc(str : string) : boolean {\n    return typeof str === 'string' && (/^[0-9]+%$/).test(str);\n}\n\nexport function isPx(str : string) : boolean {\n    return typeof str === 'string' && (/^[0-9]+px$/).test(str);\n}\n\nexport function toNum(val : string | number) : number {\n\n    if (typeof val === 'number') {\n        return val;\n    }\n\n    let match = val.match(/^([0-9]+)(px|%)$/);\n\n    if (!match) {\n        throw new Error(`Could not match css value from ${ val }`);\n    }\n\n    return parseInt(match[1], 10);\n}\n\nexport function toPx(val : number | string) : string {\n    return `${ toNum(val) }px`;\n}\n\nexport function toCSS(val : number | string) : string {\n\n    if (typeof val === 'number') {\n        return toPx(val);\n    }\n\n    return isPerc(val) ? val : toPx(val);\n}\n\nexport function percOf(num : number, perc : string) : number {\n    return parseInt(num * toNum(perc)  / 100, 10);\n}\n\nexport function normalizeDimension(dim : string | number, max : number) : number {\n    if (typeof dim === 'number') {\n        return dim;\n    } else if (isPerc(dim)) {\n        return percOf(max, dim);\n    } else if (isPx(dim)) {\n        return toNum(dim);\n    } else {\n        throw new Error(`Can not normalize dimension: ${ dim }`);\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\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, 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\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\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 { 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\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 } 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 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 }()\\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 = `${ 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 { 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 { 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 { 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\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 { 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 } 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 cleaned up before response`)).catch(noop);\n    }\n}\n","/* @flow */\n\nimport { isSameDomain, type CrossDomainWindowType } from 'cross-domain-utils/src';\n\nexport function getGlobal(win? : CrossDomainWindowType = window) : Object {\n\n    if (!isSameDomain(win)) {\n        throw new Error(`Can not get global for window on different domain`);\n    }\n\n    if (!win[__ZOID__.__GLOBAL_KEY__]) {\n        win[__ZOID__.__GLOBAL_KEY__] = {};\n    }\n\n    return win[__ZOID__.__GLOBAL_KEY__];\n}\n\nexport function destroyGlobal() {\n    delete window[__ZOID__.__GLOBAL_KEY__];\n}\n","/* @flow */\n\nimport { ZalgoPromise } from 'zalgo-promise/src';\n\nexport type ProxyObject<T> = {|\n    get : () => ZalgoPromise<T>\n|};\n\nexport function getProxyObject<T>(obj : T) : ProxyObject<T> {\n    return {\n        get() : ZalgoPromise<T> {\n            return ZalgoPromise.try(() => {\n                if (this.source && this.source !== window) {\n                    throw new Error(`Can not call get on proxy object from a remote window`);\n                }\n    \n                return obj;\n            });\n        }\n    };\n}\n","/* @flow */\n\nimport { WINDOW_TYPE } from 'cross-domain-utils/src';\n\nexport const ZOID = `zoid`;\n\nexport const POST_MESSAGE = {\n    DELEGATE:       `${ ZOID }_delegate`,\n    ALLOW_DELEGATE: `${ ZOID }_allow_delegate`\n};\n\nexport const PROP_TYPE = {\n    STRING:   `string`,\n    OBJECT:   `object`,\n    FUNCTION: `function`,\n    BOOLEAN:  `boolean`,\n    NUMBER:   `number`,\n    ARRAY:    `array`\n};\n\nexport const INITIAL_PROPS = {\n    RAW: 'raw',\n    UID: 'uid'\n};\n\nexport const WINDOW_REFERENCES = {\n    OPENER: ('opener' : 'opener'),\n    PARENT: ('parent' : 'parent'),\n    GLOBAL: ('global' : 'global')\n};\n\nexport const PROP_SERIALIZATION = {\n    JSON:   ('json' : 'json'),\n    DOTIFY: ('dotify' : 'dotify'),\n    BASE64: ('base64' : 'base64')\n};\n\nexport const CONTEXT = WINDOW_TYPE;\n\nexport const WILDCARD = '*';\n\nexport const DEFAULT_DIMENSIONS = {\n    WIDTH:  '300px',\n    HEIGHT: '150px'\n};\n\nexport const EVENT = {\n    RENDER:   'zoid-render',\n    RENDERED: 'zoid-rendered',\n    DISPLAY:  'zoid-display',\n    ERROR:    'zoid-error',\n    CLOSE:    'zoid-close',\n    PROPS:    'zoid-props',\n    RESIZE:   'zoid-resize',\n    FOCUS:    'zoid-focus'\n};\n","/* @flow */\n\nimport { getDomain, isSameDomain, type CrossDomainWindowType } from 'cross-domain-utils/src';\n\nimport type { Component } from '../component';\nimport type { PropsType, MixedPropDefinitionType } from '../component/props';\n\nimport type { ChildHelpers } from './index';\n\nexport function normalizeChildProp<T, P>(component : Component<P>, props : (PropsType<P>), key : string, value : T, helpers : ChildHelpers<P>) : ?T  {\n\n    // $FlowFixMe\n    const prop : MixedPropDefinitionType<P> = component.getPropDefinition(key);\n\n    if (!prop) {\n        return value;\n    }\n\n    if (typeof prop.childDecorate === 'function') {\n        const { close, focus, onError, onProps, resize, getParent, getParentDomain, show, hide } = helpers;\n        return prop.childDecorate({ value, close, focus, onError, onProps, resize, getParent, getParentDomain, show, hide });\n    }\n\n    return value;\n}\n\n// eslint-disable-next-line max-params\nexport function normalizeChildProps<P>(parentComponentWindow : CrossDomainWindowType, component : Component<P>, props : (PropsType<P>), origin : string, helpers : ChildHelpers<P>, isUpdate : boolean = false) : (PropsType<P>) {\n\n    const result = {};\n\n    for (const key of Object.keys(props)) {\n        const prop = component.getPropDefinition(key);\n\n        if (prop && prop.sameDomain && (origin !== getDomain(window) || !isSameDomain(parentComponentWindow))) {\n            continue;\n        }\n\n        // $FlowFixMe\n        const value = normalizeChildProp(component, props, key, props[key], helpers);\n\n        result[key] = value;\n        if (prop && prop.alias && !result[prop.alias]) {\n            result[prop.alias] = value;\n        }\n    }\n\n    if (!isUpdate) {\n        for (const key of component.getPropNames()) {\n            if (!props.hasOwnProperty(key)) {\n                result[key] = normalizeChildProp(component, props, key, props[key], helpers);\n            }\n        }\n    }\n\n    // $FlowFixMe\n    return result;\n}\n","/* @flow */\n\nimport { inlineMemoize, stringifyError, base64decode } from 'belter/src';\n\nimport { ZOID } from '../constants';\nimport type { ChildPayload } from '../parent';\n\nfunction parseChildWindowName(windowName : string) : ChildPayload {\n    return inlineMemoize(parseChildWindowName, () => {\n        if (!windowName) {\n            throw new Error(`No window name`);\n        }\n    \n        const [ , zoidcomp, name, encodedPayload ] = windowName.split('__');\n    \n        if (zoidcomp !== ZOID) {\n            throw new Error(`Window not rendered by zoid - got ${ zoidcomp }`);\n        }\n    \n        if (!name) {\n            throw new Error(`Expected component name`);\n        }\n    \n        if (!encodedPayload) {\n            throw new Error(`Expected encoded payload`);\n        }\n    \n        try {\n            return JSON.parse(base64decode(encodedPayload));\n        } catch (err) {\n            throw new Error(`Can not decode window name payload: ${ encodedPayload }: ${ stringifyError(err) }`);\n        }\n    }, [ windowName ]);\n}\n\nexport function getChildPayload() : ?ChildPayload {\n    try {\n        return parseChildWindowName(window.name);\n    } catch (err) {\n        // pass\n    }\n}\n","/* @flow */\n/* eslint max-lines: 0 */\n\nimport { isSameDomain, matchDomain, getDomain, getOpener,\n    getNthParentFromTop, getAncestor, getAllFramesInWindow,\n    type CrossDomainWindowType, onCloseWindow } from 'cross-domain-utils/src';\nimport { markWindowKnown, deserializeMessage, type CrossDomainFunctionType } from 'post-robot/src';\nimport { ZalgoPromise } from 'zalgo-promise/src';\nimport { extend, waitForDocumentBody, onResize, getElementSafe, assertExists } from 'belter/src';\n\nimport { getGlobal } from '../lib';\nimport { CONTEXT, INITIAL_PROPS, WINDOW_REFERENCES } from '../constants';\nimport type { Component } from '../component';\nimport type { PropsType } from '../component/props';\nimport type { WindowRef, PropRef, ParentExportsType } from '../parent';\n\nimport { normalizeChildProps } from './props';\nimport { getChildPayload } from './window';\n\nexport * from './window';\n\nexport type ChildExportsType<P> = {|\n    updateProps : CrossDomainFunctionType<[ PropsType<P> ], void>,\n    close : CrossDomainFunctionType<[], void>\n|};\n\nexport type ChildHelpers<P> = {|\n    close : () => ZalgoPromise<void>,\n    focus : () => ZalgoPromise<void>,\n    resize : ({ width : ?number, height : ?number }) => ZalgoPromise<void>,\n    onError : (mixed) => ZalgoPromise<void>,\n    onProps : ((PropsType<P>) => void) => void,\n    getParent : () => CrossDomainWindowType,\n    getParentDomain : () => string,\n    show : () => ZalgoPromise<void>,\n    hide : () => ZalgoPromise<void>\n|};\n\n/*  Child Component\n    ---------------\n\n    This is the portion of code which runs inside the frame or popup window containing the component's implementation.\n\n    When the component author calls myComponent.attach(), it creates a new instance of ChildComponent, which is then\n    responsible for managing the state and messaging back up to the parent, and providing props for the component to\n    utilize.\n*/\n\nexport class ChildComponent<P> {\n\n    component : Component<P>\n    props : PropsType<P>\n    context : string\n    parent : ParentExportsType<P>\n    parentDomain : string\n    parentComponentWindow : CrossDomainWindowType\n\n    onPropHandlers : Array<(PropsType<P>) => void> // eslint-disable-line flowtype/no-mutable-array\n    autoResize : { width : boolean, height : boolean, element? : string }\n\n    constructor(component : Component<P>) {\n        ZalgoPromise.try(() => {\n            this.component = component;\n            this.onPropHandlers = [];\n            \n            const childPayload = getChildPayload();\n\n            if (!childPayload) {\n                throw new Error(`No child payload found`);\n            }\n\n            if (childPayload.version !== __ZOID__.__VERSION__) {\n                throw new Error(`Parent window has zoid version ${ childPayload.version }, child window has version ${ __ZOID__.__VERSION__ }`);\n            }\n\n            const { parent, parentDomain, exports, context, props } = childPayload;\n\n            this.context = context;\n            this.parentComponentWindow = this.getParentComponentWindow(parent);\n            this.parentDomain = parentDomain;\n            this.parent = deserializeMessage(this.parentComponentWindow, parentDomain, exports);\n\n            this.checkParentDomain(parentDomain);\n\n            const initialProps = this.getPropsByRef(this.parentComponentWindow, parentDomain, props);\n            this.setProps(initialProps, parentDomain);\n            markWindowKnown(this.parentComponentWindow);\n            \n            this.watchForClose();\n\n            return this.parent.init(this.buildExports());\n\n        }).then(() => {\n            return this.watchForResize();\n\n        }).catch(err => {\n            this.onError(err);\n        });\n    }\n\n    getHelpers() : ChildHelpers<P> {\n        return {\n            focus:           () => this.focus(),\n            close:           () => this.close(),\n            resize:          ({ width, height }) => this.resize({ width, height }),\n            onError:         (err) => this.onError(err),\n            onProps:         (handler) => this.onProps(handler),\n            getParent:       () => this.parentComponentWindow,\n            getParentDomain: () => this.parentDomain,\n            show:            () => this.show(),\n            hide:            () => this.hide()\n        };\n    }\n\n    show() : ZalgoPromise<void> {\n        return this.parent.show();\n    }\n\n    hide() : ZalgoPromise<void> {\n        return this.parent.hide();\n    }\n\n    checkParentDomain(domain : string) {\n        if (!matchDomain(this.component.allowedParentDomains, domain)) {\n            throw new Error(`Can not be rendered by domain: ${ domain }`);\n        }\n    }\n\n    onProps(handler : Function) {\n        this.onPropHandlers.push(handler);\n    }\n\n    getPropsByRef(parentComponentWindow : CrossDomainWindowType, domain : string, { type, value, uid } : PropRef) : (PropsType<P>) {\n        let props;\n\n        if (type === INITIAL_PROPS.RAW) {\n            props = value;\n        } else if (type === INITIAL_PROPS.UID) {\n            if (!isSameDomain(parentComponentWindow)) {\n                throw new Error(`Parent component window is on a different domain - expected ${ getDomain() } - can not retrieve props`);\n            }\n\n            const global = getGlobal(parentComponentWindow);\n            props = assertExists('props', global && global.props[uid]);\n        }\n\n        if (!props) {\n            throw new Error(`Could not find props`);\n        }\n\n        return deserializeMessage(parentComponentWindow, domain, props);\n    }\n\n    getParentComponentWindow(ref : WindowRef) : CrossDomainWindowType {\n        const { type } = ref;\n    \n        if (type === WINDOW_REFERENCES.OPENER) {\n            return assertExists('opener', getOpener(window));\n    \n        } else if (type === WINDOW_REFERENCES.PARENT && typeof ref.distance === 'number') {\n            return assertExists('parent', getNthParentFromTop(window, ref.distance));\n\n        } else if (type === WINDOW_REFERENCES.GLOBAL && ref.uid && typeof ref.uid === 'string') {\n            const { uid } = ref;\n            const ancestor = getAncestor(window);\n\n            if (!ancestor) {\n                throw new Error(`Can not find ancestor window`);\n            }\n\n            for (const frame of getAllFramesInWindow(ancestor)) {\n                if (isSameDomain(frame)) {\n                    const global = getGlobal(frame);\n\n                    if (global && global.windows && global.windows[uid]) {\n                        return global.windows[uid];\n                    }\n                }\n            }\n        }\n    \n        throw new Error(`Unable to find ${ type } parent component window`);\n    }\n\n    getProps() : PropsType<P> {\n        // $FlowFixMe\n        this.props = this.props || {};\n        return this.props;\n    }\n\n    setProps(props : PropsType<P>, origin : string, isUpdate : boolean = false) {\n        const helpers = this.getHelpers();\n        const existingProps = this.getProps();\n        const normalizedProps = normalizeChildProps(this.parentComponentWindow, this.component, props, origin, helpers, isUpdate);\n\n        extend(existingProps, normalizedProps);\n\n        for (const handler of this.onPropHandlers) {\n            handler.call(this, existingProps);\n        }\n    }\n\n    watchForClose() {\n        window.addEventListener('beforeunload', () => {\n            this.parent.checkClose.fireAndForget();\n        });\n\n        window.addEventListener('unload', () => {\n            this.parent.checkClose.fireAndForget();\n        });\n\n        onCloseWindow(this.parentComponentWindow, () => {\n            this.destroy();\n        });\n    }\n\n    getAutoResize() : { width : boolean, height : boolean, element : ?HTMLElement } {\n        let { width = false, height = false, element = 'body' } = this.autoResize || this.component.autoResize || {};\n        element = getElementSafe(element);\n        return { width, height, element };\n    }\n\n    watchForResize() : ?ZalgoPromise<void> {\n        return waitForDocumentBody().then(() => {\n            const { width, height, element } = this.getAutoResize();\n\n            if (!element || (!width && !height) || this.context === CONTEXT.POPUP) {\n                return;\n            }\n\n            onResize(element, ({ width: newWidth, height: newHeight }) => {\n                this.resize({\n                    width:  width ? newWidth : undefined,\n                    height: height ? newHeight : undefined\n                });\n            }, { width, height });\n        });\n    }\n\n    buildExports() : ChildExportsType<P> {\n\n        const self = this;\n\n        return {\n            updateProps(props : (PropsType<P>)) : ZalgoPromise<void> {\n                return ZalgoPromise.try(() => self.setProps(props, this.__origin__, true));\n            },\n\n            close() : ZalgoPromise<void> {\n                return ZalgoPromise.try(() => self.destroy());\n            }\n        };\n    }\n\n    resize({ width, height } : { width : ?number, height : ?number }) : ZalgoPromise<void> {\n        return this.parent.resize.fireAndForget({ width, height });\n    }\n\n    close() : ZalgoPromise<void> {\n        return this.parent.close();\n    }\n    \n    destroy() : ZalgoPromise<void> {\n        return ZalgoPromise.try(() => {\n            window.close();\n        });\n    }\n\n    focus() : ZalgoPromise<void> {\n        return ZalgoPromise.try(() => {\n            window.focus();\n        });\n    }\n\n    onError(err : mixed) : ZalgoPromise<void> {\n        return ZalgoPromise.try(() => {\n            if (this.parent && this.parent.onError) {\n                return this.parent.onError(err);\n            } else {\n                throw err;\n            }\n        });\n    }\n}\n","/* @flow */\n\nimport { ZalgoPromise } from 'zalgo-promise/src';\nimport { cleanUpWindow, ProxyWindow, toProxyWindow } from 'post-robot/src';\nimport { assertSameDomain, closeWindow, type CrossDomainWindowType } from 'cross-domain-utils/src';\nimport { iframe, popup, destroyElement, normalizeDimension, watchElementForClose,\n    awaitFrameWindow, uniqueID } from 'belter/src';\n\nimport { CONTEXT } from '../constants';\nimport { getProxyObject, type ProxyObject } from '../lib';\n\n\nexport type ContextDriverType = {|\n    openFrame? : ({ windowName : string }) => ProxyObject<HTMLIFrameElement>,\n    open : ({ windowName : string, proxyFrame : ?ProxyObject<HTMLIFrameElement> }) => ZalgoPromise<CrossDomainWindowType>,\n    openPrerenderFrame? : () => ProxyObject<HTMLIFrameElement>,\n    openPrerender : (ProxyWindow, ?ProxyObject<HTMLIFrameElement>) => ZalgoPromise<ProxyWindow>,\n    resize? : ({ width : ?number, height : ?number }) => void,\n    delegate : $ReadOnlyArray<string>\n|};\n\nexport const RENDER_DRIVERS : { [string] : ContextDriverType } = {};\n\nRENDER_DRIVERS[CONTEXT.IFRAME] = {\n    openFrame({ windowName } : { windowName : string }) : ProxyObject<HTMLIFrameElement> {\n        return getProxyObject(iframe({\n            attributes: {\n                name:  windowName,\n                title: this.component.name,\n                ...this.component.attributes.iframe\n            }\n        }));\n    },\n\n    open({ proxyFrame } : { proxyFrame : ?ProxyObject<HTMLIFrameElement> }) : ZalgoPromise<CrossDomainWindowType> {\n        if (!proxyFrame) {\n            throw new Error(`Expected proxy frame to be passed`);\n        }\n\n        return proxyFrame.get().then(frame => {\n            return awaitFrameWindow(frame).then(win => {\n\n                const frameWatcher = watchElementForClose(frame, () => this.close());\n                this.clean.register(() => frameWatcher.cancel());\n                this.clean.register(() => destroyElement(frame));\n                this.clean.register(() => cleanUpWindow(win));\n\n                return win;\n            });\n        });\n    },\n\n    openPrerenderFrame() : ProxyObject<HTMLIFrameElement> {\n        return getProxyObject(iframe({\n            attributes: {\n                name:  `__zoid_prerender_frame__${ this.component.name }_${ uniqueID() }__`,\n                title: `prerender__${ this.component.name }`,\n                ...this.component.attributes.iframe\n            }\n        }));\n    },\n\n    openPrerender(proxyWin : ProxyWindow, proxyPrerenderFrame : ?ProxyObject<HTMLIFrameElement>) : ZalgoPromise<ProxyWindow> {\n        if (!proxyPrerenderFrame) {\n            throw new Error(`Expected proxy frame to be passed`);\n        }\n        \n        return proxyPrerenderFrame.get().then(prerenderFrame => {\n            this.clean.register(() => destroyElement(prerenderFrame));\n\n            return awaitFrameWindow(prerenderFrame).then(prerenderFrameWindow => {\n                return assertSameDomain(prerenderFrameWindow);\n            }).then(win => {\n                return toProxyWindow(win);\n            });\n        });\n    },\n\n    delegate: [\n        'getProxyWindow',\n        'getProxyContainer',\n        'renderContainer',\n        'openFrame',\n        'openPrerenderFrame',\n        'prerender',\n        'open',\n        'openPrerender',\n        'show',\n        'hide'\n    ]\n};\n\nif (__ZOID__.__POPUP_SUPPORT__) {\n    RENDER_DRIVERS[CONTEXT.POPUP] = {\n        open({ windowName } : { windowName : string }) : ZalgoPromise<CrossDomainWindowType> {\n            return ZalgoPromise.try(() => {\n                let { width, height } = this.component.dimensions;\n\n                width = normalizeDimension(width, window.outerWidth);\n                height = normalizeDimension(height, window.outerWidth);\n\n                const win = popup('', {\n                    name: windowName,\n                    width,\n                    height,\n                    ...this.component.attributes.popup\n                });\n\n                this.clean.register(() => {\n                    closeWindow(win);\n                    cleanUpWindow(win);\n                });\n\n                return win;\n            });\n        },\n\n        openPrerender(proxyWin : ProxyWindow) : ZalgoPromise<ProxyWindow> {\n            return ZalgoPromise.try(() => {\n                return proxyWin;\n            });\n        },\n\n        delegate: [\n            'getProxyContainer',\n            'renderContainer',\n            'setProxyWin',\n            'show',\n            'hide'\n        ]\n    };\n}\n","/* @flow */\n\nimport { ZalgoPromise } from 'zalgo-promise/src';\nimport { dotify, isDefined, extend } from 'belter/src';\n\nimport type { Component } from '../component';\nimport type { BuiltInPropsDefinitionType, PropsInputType, PropsType, MixedPropDefinitionType } from '../component/props';\nimport { PROP_SERIALIZATION } from '../constants';\n\nimport type { ParentHelpers } from './index';\n\n/*  Normalize Props\n    ---------------\n\n    Turn props into normalized values, using defaults, function options, etc.\n*/\n\nexport function extendProps<P>(component : Component<P>, props : PropsType<P>, inputProps : PropsInputType<P>, helpers : ParentHelpers<P>, isUpdate : boolean = false) { // eslint-disable-line complexity\n\n    // $FlowFixMe\n    inputProps = inputProps || {};\n    extend(props, inputProps);\n\n    const propNames = isUpdate ? [] : [ ...component.getPropNames() ];\n\n    for (const key of Object.keys(inputProps)) {\n        if (propNames.indexOf(key) === -1) {\n            propNames.push(key);\n        }\n    }\n\n    const aliases = [];\n\n    const { state, close, focus, event, onError } = helpers;\n\n    for (const key of propNames) {\n        const propDef = component.getPropDefinition(key);\n        let value = inputProps[key];\n\n        if (!propDef) {\n            continue;\n        }\n\n        const alias = propDef.alias;\n        if (alias) {\n            if (!isDefined(value) && isDefined(inputProps[alias])) {\n                value = inputProps[alias];\n            }\n            aliases.push(alias);\n        }\n\n        if (propDef.value) {\n            value = propDef.value({ props, state, close, focus, event, onError });\n        }\n\n        if (!isDefined(value) && propDef.default) {\n            value = propDef.default({ props, state, close, focus, event, onError });\n        }\n\n        if (isDefined(value)) {\n            if (propDef.type === 'array' ? !Array.isArray(value) : (typeof value !== propDef.type)) {\n                throw new TypeError(`Prop is not of type ${ propDef.type }: ${ key }`);\n            }\n        }\n        \n        // $FlowFixMe\n        props[key] = value;\n    }\n\n    for (const alias of aliases) {\n        delete props[alias];\n    }\n\n    // $FlowFixMe\n    for (const key of Object.keys(props)) {\n        const propDef = component.getPropDefinition(key);\n        const value = props[key];\n\n        if (!propDef) {\n            continue;\n        }\n\n        if (isDefined(value) && propDef.validate) {\n            // $FlowFixMe\n            propDef.validate({ value, props });\n        }\n\n        if (isDefined(value) && propDef.decorate) {\n            props[key] = propDef.decorate({ value, props, state, close, focus, event, onError });\n        }\n    }\n\n    for (const key of component.getPropNames()) {\n        const propDef = component.getPropDefinition(key);\n        if (propDef.required !== false && !isDefined(props[key])) {\n            throw new Error(`Expected prop \"${ key }\" to be defined`);\n        }\n    }\n}\n\n// $FlowFixMe\nfunction getQueryParam<T, P>(prop : MixedPropDefinitionType<P>, key : string, value : T) : ZalgoPromise<string> {\n    return ZalgoPromise.try(() => {\n        if (typeof prop.queryParam === 'function') {\n            return prop.queryParam({ value });\n        } else if (typeof prop.queryParam === 'string') {\n            return prop.queryParam;\n        } else {\n            return key;\n        }\n    });\n}\n\n// $FlowFixMe\nfunction getQueryValue<T, P>(prop : MixedPropDefinitionType<P>, key : string, value : T) : ZalgoPromise<mixed> {\n    return ZalgoPromise.try(() => {\n        if (typeof prop.queryValue === 'function' && isDefined(value)) {\n            return prop.queryValue({ value });\n        } else {\n            return value;\n        }\n    });\n}\n\nexport function propsToQuery<P>(propsDef : BuiltInPropsDefinitionType<P>, props : (PropsType<P>)) : ZalgoPromise<{ [string] : string }> {\n\n    const params = {};\n\n    // $FlowFixMe\n    const keys = Object.keys(props);\n    \n    return ZalgoPromise.all(keys.map(key => {\n\n        const prop = propsDef[key];\n\n        if (!prop) {\n            return; // eslint-disable-line array-callback-return\n        }\n\n        return ZalgoPromise.resolve().then(() => {\n\n            const value = props[key];\n\n            if (!value) {\n                return;\n            }\n\n            if (!prop.queryParam) {\n                return;\n            }\n\n            return value;\n\n        }).then(value => {\n\n            if (value === null || typeof value === 'undefined') {\n                return;\n            }\n\n            return ZalgoPromise.all([\n                getQueryParam(prop, key, value),\n                getQueryValue(prop, key, value)\n            ]).then(([ queryParam, queryValue ]) => {\n\n                let result;\n\n                if (typeof queryValue === 'boolean') {\n                    result = queryValue.toString();\n                } else if (typeof queryValue === 'string') {\n                    result = queryValue.toString();\n                } else if (typeof queryValue === 'object' && queryValue !== null) {\n\n                    if (prop.serialization === PROP_SERIALIZATION.JSON) {\n                        result = JSON.stringify(queryValue);\n                    } else if (prop.serialization === PROP_SERIALIZATION.BASE64) {\n                        result = btoa(JSON.stringify(queryValue));\n                    } else if (prop.serialization === PROP_SERIALIZATION.DOTIFY || !prop.serialization) {\n                        result = dotify(queryValue, key);\n\n                        for (const dotkey of Object.keys(result)) {\n                            params[dotkey] = result[dotkey];\n                        }\n\n                        return;\n                    }\n\n                } else if (typeof queryValue === 'number') {\n                    result = queryValue.toString();\n                }\n\n                params[queryParam] = result;\n            });\n        });\n\n    })).then(() => {\n        return params;\n    });\n}\n","/* @flow */\n/* eslint max-lines: 0 */\n\nimport { send, bridge, serializeMessage, ProxyWindow, toProxyWindow, type CrossDomainFunctionType } from 'post-robot/src';\nimport { isSameDomain, matchDomain, getDomainFromUrl, isBlankDomain,\n    getDomain, type CrossDomainWindowType,\n    getDistanceFromTop, normalizeMockUrl, assertSameDomain } from 'cross-domain-utils/src';\nimport { ZalgoPromise } from 'zalgo-promise/src';\nimport { addEventListener, uniqueID, elementReady, writeElementToWindow, eventEmitter, type EventEmitterType,\n    noop, onResize, extendUrl, appendChild, cleanup, type CleanupType, base64encode,\n    once, stringifyError, destroyElement, getElementSafe, showElement, hideElement } from 'belter/src';\n\nimport { ZOID, POST_MESSAGE, CONTEXT, EVENT,\n    INITIAL_PROPS, WINDOW_REFERENCES } from '../constants';\nimport type { Component, onErrorPropType } from '../component';\nimport { getGlobal, getProxyObject, type ProxyObject } from '../lib';\nimport type { PropsInputType, PropsType } from '../component/props';\nimport type { ChildExportsType } from '../child';\nimport type { DimensionsType } from '../types';\n\nimport { RENDER_DRIVERS, type ContextDriverType } from './drivers';\nimport { propsToQuery, extendProps } from './props';\n\nexport type RenderOptionsType<P> = {|\n    uid : string,\n    props : PropsInputType<P>,\n    tag : string,\n    context : string,\n    close : (?string) => ZalgoPromise<void>,\n    focus : () => ZalgoPromise<ProxyWindow>,\n    doc : Document,\n    container? : HTMLElement,\n    dimensions : DimensionsType,\n    state : Object,\n    event : EventEmitterType,\n    frame : ?HTMLIFrameElement,\n    prerenderFrame : ?HTMLIFrameElement\n|};\n\nexport type ParentExportsType<P> = {|\n    init : (ChildExportsType<P>) => ZalgoPromise<void>,\n    close : () => ZalgoPromise<void>,\n    checkClose : CrossDomainFunctionType<[], void>,\n    resize : CrossDomainFunctionType<[{ width? : ?number, height? : ?number }], void>,\n    onError : (mixed) => ZalgoPromise<void>,\n    show : () => ZalgoPromise<void>,\n    hide : () => ZalgoPromise<void>\n|};\n\nexport type PropRef =\n    {| type : typeof INITIAL_PROPS.RAW, uid? : string, value? : string |};\n\nexport type WindowRef =\n    {| type : typeof WINDOW_REFERENCES.OPENER |} |\n    {| type : typeof WINDOW_REFERENCES.PARENT, distance : number |} |\n    {| type : typeof WINDOW_REFERENCES.GLOBAL, uid : string |};\n\nexport type ChildPayload = {|\n    uid : string,\n    tag : string,\n    version : string,\n    context : $Values<typeof CONTEXT>,\n    parentDomain : string,\n    childDomain : string,\n    parent : WindowRef,\n    props : PropRef,\n    exports : string\n|};\n\nexport type StateType = Object;\n\nexport type ParentHelpers<P> = {|\n    state : StateType,\n    close : () => ZalgoPromise<void>,\n    focus : () => ZalgoPromise<void>,\n    resize : ({ width : ?number, height : ?number }) => ZalgoPromise<void>,\n    onError : (mixed) => ZalgoPromise<void>,\n    updateProps : PropsInputType<P> => ZalgoPromise<void>,\n    event : EventEmitterType,\n    show : () => ZalgoPromise<void>,\n    hide : () => ZalgoPromise<void>\n|};\n\nexport class ParentComponent<P> {\n\n    component : Component<P>\n    driver : ContextDriverType\n    clean : CleanupType\n    event : EventEmitterType\n\n    initPromise : ZalgoPromise<void>\n    handledErrors : Array<mixed> // eslint-disable-line flowtype/no-mutable-array\n    \n    props : PropsType<P>\n    state : StateType\n    child : ?ChildExportsType<P>\n\n    proxyContainer : ?ProxyObject<HTMLElement>\n    proxyWin : ?ProxyWindow\n\n    visible : boolean = true\n\n    constructor(component : Component<P>, props : PropsInputType<P>) {\n        this.initPromise = new ZalgoPromise();\n        this.handledErrors = [];\n\n        // $FlowFixMe\n        this.props = {};\n\n        this.clean = cleanup(this);\n        this.state = {};\n\n        this.component = component;\n\n        this.setupEvents(props.onError);\n        this.setProps(props);\n        this.component.registerActiveComponent(this);\n        this.clean.register(() => this.component.destroyActiveComponent(this));\n        this.watchForUnload();\n    }\n\n    setupEvents(onError : ?onErrorPropType) {\n        this.event = eventEmitter();\n        \n        this.event.on(EVENT.RENDER,   () => this.props.onRender());\n        this.event.on(EVENT.DISPLAY,  () => this.props.onDisplay());\n        this.event.on(EVENT.RENDERED, () => this.props.onRendered());\n        this.event.on(EVENT.CLOSE,    () => this.props.onClose());\n        this.event.on(EVENT.RESIZE,   () => this.props.onResize());\n        this.event.on(EVENT.FOCUS,    () => this.props.onFocus());\n        this.event.on(EVENT.PROPS,    (props) => this.props.onProps(props));\n\n        this.event.on(EVENT.ERROR, err => {\n            if (this.props && this.props.onError) {\n                return this.props.onError(err);\n            } else if (onError) {\n                return onError(err);\n            } else {\n                return this.initPromise.reject(err).then(() => {\n                    setTimeout(() => {\n                        throw err;\n                    }, 1);\n                });\n            }\n        });\n\n        this.clean.register(() => this.event.reset());\n    }\n\n    render(target : CrossDomainWindowType, container : string | HTMLElement, context : $Values<typeof CONTEXT>) : ZalgoPromise<void> {\n        return ZalgoPromise.try(() => {\n            this.component.log(`render`);\n\n            this.driver = RENDER_DRIVERS[context];\n            const uid = `${ ZOID }-${ this.component.tag }-${ uniqueID() }`;\n            const domain = this.getDomain();\n            const childDomain = this.getChildDomain();\n            \n            this.component.checkAllowRender(target, domain, container);\n\n            if (target !== window) {\n                this.delegate(context, target);\n            }\n\n            const windowProp = this.props.window;\n\n            const init = this.initPromise;\n            const buildUrl = this.buildUrl();\n            const onRender = this.event.trigger(EVENT.RENDER);\n\n            const getProxyContainer = this.getProxyContainer(container);\n            const getProxyWindow = this.getProxyWindow();\n\n            const buildWindowName = getProxyWindow.then(proxyWin => {\n                return this.buildWindowName({ proxyWin, childDomain, domain, target, context, uid });\n            });\n\n            const openFrame = buildWindowName.then(windowName => this.openFrame({ windowName }));\n            const openPrerenderFrame = this.openPrerenderFrame();\n\n            const renderContainer = ZalgoPromise.hash({ proxyContainer: getProxyContainer, proxyFrame: openFrame, proxyPrerenderFrame: openPrerenderFrame }).then(({ proxyContainer, proxyFrame, proxyPrerenderFrame }) => {\n                return this.renderContainer(proxyContainer, { context, uid, proxyFrame, proxyPrerenderFrame, visible: this.visible });\n            }).then(proxyContainer => {\n                this.proxyContainer = proxyContainer;\n                return proxyContainer;\n            });\n\n            const open = ZalgoPromise.hash({ windowName: buildWindowName, proxyFrame: openFrame, proxyWin: getProxyWindow }).then(({ windowName, proxyWin, proxyFrame }) => {\n                return windowProp\n                    ? proxyWin\n                    : this.open({ windowName, proxyWin, proxyFrame });\n            });\n\n            const openPrerender = ZalgoPromise.hash({ proxyWin: open, proxyPrerenderFrame: openPrerenderFrame }).then(({ proxyWin, proxyPrerenderFrame }) => {\n                return this.openPrerender(proxyWin, proxyPrerenderFrame);\n            });\n\n            const setState = open.then(proxyWin => {\n                this.proxyWin = proxyWin;\n                return this.setProxyWin(proxyWin);\n            });\n            \n            const prerender = ZalgoPromise.hash({ proxyPrerenderWin: openPrerender, state: setState }).then(({ proxyPrerenderWin }) => {\n                return this.prerender(proxyPrerenderWin, { context, uid });\n            });\n\n            const setWindowName =  ZalgoPromise.hash({ proxyWin: open, windowName: buildWindowName }).then(({ proxyWin, windowName }) => {\n                if (windowProp) {\n                    return proxyWin.setName(windowName);\n                }\n            });\n\n            const loadUrl = ZalgoPromise.hash({ proxyWin: open, url: buildUrl, windowName: setWindowName, prerender }).then(({ proxyWin, url }) => {\n                return proxyWin.setLocation(url);\n            });\n\n            const watchForClose = open.then(proxyWin => {\n                this.watchForClose(proxyWin);\n            });\n\n            const onDisplay = ZalgoPromise.hash({ container: renderContainer, prerender }).then(() => {\n                return this.event.trigger(EVENT.DISPLAY);\n            });\n\n            const openBridge = open.then(proxyWin => {\n                return this.openBridge(proxyWin, childDomain, context);\n            });\n\n            const runTimeout = loadUrl.then(() => {\n                return this.runTimeout();\n            });\n\n            const onRendered = init.then(() => {\n                return this.event.trigger(EVENT.RENDERED);\n            });\n\n            return ZalgoPromise.hash({\n                init, buildUrl, onRender, getProxyContainer, openFrame, openPrerenderFrame, renderContainer, open,\n                openPrerender, setState, prerender, loadUrl, buildWindowName, setWindowName, watchForClose, onDisplay,\n                openBridge, runTimeout, onRendered\n            });\n            \n        }).catch(err => {\n            return ZalgoPromise.all([\n                this.onError(err),\n                this.destroy(err)\n            ]).then(() => {\n                throw err;\n            }, () => {\n                throw err;\n            });\n        }).then(noop);\n    }\n\n    getProxyWindow() : ZalgoPromise<ProxyWindow> {\n        return ZalgoPromise.try(() => {\n            const windowProp = this.props.window;\n\n            if (windowProp) {\n                const proxyWin = toProxyWindow(windowProp);\n                this.clean.register(() => windowProp.close());\n                return proxyWin;\n            }\n\n            return new ProxyWindow({ send });\n        });\n    }\n\n    getProxyContainer(container : string | HTMLElement) : ZalgoPromise<ProxyObject<HTMLElement>> {\n        return ZalgoPromise.try(() => {\n            return elementReady(container);\n        }).then(containerElement => {\n            return getProxyObject(containerElement);\n        });\n    }\n\n    buildWindowName({ proxyWin, childDomain, domain, target, uid, context } : { proxyWin : ProxyWindow, childDomain : string, domain : string | RegExp, target : CrossDomainWindowType, context : $Values<typeof CONTEXT>, uid : string }) : string {\n        const childPayload = this.buildChildPayload({ proxyWin, childDomain, domain, target, context, uid });\n        return `__${ ZOID }__${ this.component.name }__${ base64encode(JSON.stringify(childPayload)) }__`;\n    }\n\n    getPropsRef(proxyWin : ProxyWindow, childDomain : string, domain : string | RegExp, uid : string) : PropRef {\n        const value = serializeMessage(proxyWin, domain, this.getPropsForChild(domain));\n\n        const propRef = (childDomain === getDomain())\n            ? { type: INITIAL_PROPS.UID, uid }\n            : { type: INITIAL_PROPS.RAW, value };\n\n        if (propRef.type === INITIAL_PROPS.UID) {\n            const global = getGlobal(window);\n            global.props = global.props || {};\n            global.props[uid] = value;\n\n            this.clean.register(() => {\n                delete global.props[uid];\n            });\n        }\n\n        return propRef;\n    }\n\n    buildChildPayload({ proxyWin, childDomain, domain, target = window, context, uid } : { proxyWin : ProxyWindow, childDomain : string, domain : string | RegExp, target : CrossDomainWindowType, context : $Values<typeof CONTEXT>, uid : string } = {}) : ChildPayload {\n        return {\n            uid,\n            context,\n            version:      __ZOID__.__VERSION__,\n            childDomain,\n            parentDomain: getDomain(window),\n            tag:          this.component.tag,\n            parent:       this.getWindowRef(target, childDomain, uid, context),\n            props:        this.getPropsRef(proxyWin, childDomain, domain, uid),\n            exports:      serializeMessage(proxyWin, domain, this.buildParentExports(proxyWin))\n        };\n    }\n\n    setProxyWin(proxyWin : ProxyWindow) : ZalgoPromise<void> {\n        return ZalgoPromise.try(() => {\n            this.proxyWin = proxyWin;\n        });\n    }\n\n    getHelpers() : ParentHelpers<P> {\n        return {\n            state:       this.state,\n            event:       this.event,\n            close:       () => this.close(),\n            focus:       () => this.focus(),\n            resize:      ({ width, height }) => this.resize({ width, height }),\n            onError:     (err) => this.onError(err),\n            updateProps: (props) => this.updateProps(props),\n            show:        () => this.show(),\n            hide:        () => this.hide()\n        };\n    }\n\n    show() : ZalgoPromise<void> {\n        return ZalgoPromise.try(() => {\n            this.visible = true;\n            if (this.proxyContainer) {\n                return this.proxyContainer.get()\n                    .then(showElement);\n            }\n        });\n    }\n\n    hide() : ZalgoPromise<void> {\n        return ZalgoPromise.try(() => {\n            this.visible = false;\n            if (this.proxyContainer) {\n                return this.proxyContainer.get()\n                    .then(hideElement);\n            }\n        });\n    }\n\n    setProps(props : PropsInputType<P>, isUpdate : boolean = false) {\n        if (this.component.validate) {\n            this.component.validate({ props });\n        }\n\n        const helpers = this.getHelpers();\n        extendProps(this.component, this.props, props, helpers, isUpdate);\n    }\n\n    buildUrl() : ZalgoPromise<string> {\n        return propsToQuery({ ...this.component.props, ...this.component.builtinProps }, this.props).then(query => {\n            return extendUrl(normalizeMockUrl(this.component.getUrl(this.props)), { query });\n        });\n    }\n\n    getDomain() : string | RegExp {\n        return this.component.getDomain(this.props);\n    }\n\n    getChildDomain() : string {\n        return this.component.getChildDomain(this.props);\n    }\n\n    getPropsForChild(domain : string | RegExp) : (PropsType<P>) {\n        const result = {};\n\n        for (const key of Object.keys(this.props)) {\n            const prop = this.component.getPropDefinition(key);\n\n            if (prop && prop.sendToChild === false) {\n                continue;\n            }\n\n            if (prop && prop.sameDomain && !matchDomain(domain, getDomain(window))) {\n                continue;\n            }\n            \n            result[key] = this.props[key];\n        }\n\n        // $FlowFixMe\n        return result;\n    }\n\n    updateProps(props : PropsInputType<P>) : ZalgoPromise<void> {\n        this.setProps(props, true);\n\n        return this.initPromise.then(() => {\n            if (this.child) {\n                return this.child.updateProps(this.getPropsForChild(this.getDomain())).catch(err => {\n                    if (!this.child || !this.proxyWin) {\n                        return;\n                    }\n\n                    return this.checkClose(this.proxyWin).then(() => {\n                        if (this.child) {\n                            throw err;\n                        }\n                    });\n                });\n            }\n        });\n    }\n\n    openFrame({ windowName } : { windowName : string }) : ZalgoPromise<?ProxyObject<HTMLIFrameElement>> {\n        return ZalgoPromise.try(() => {\n            if (this.driver.openFrame) {\n                return this.driver.openFrame.call(this, { windowName });\n            }\n        });\n    }\n\n    openPrerenderFrame() : ZalgoPromise<?ProxyObject<HTMLIFrameElement>> {\n        return ZalgoPromise.try(() => {\n            if (this.driver.openPrerenderFrame) {\n                return this.driver.openPrerenderFrame.call(this);\n            }\n        });\n    }\n    \n    open({ proxyWin, proxyFrame, windowName } : { proxyWin : ProxyWindow, proxyFrame : ?ProxyObject<HTMLIFrameElement>, windowName : string }) : ZalgoPromise<ProxyWindow> {\n        return ZalgoPromise.try(() => {\n            this.component.log(`open`);\n\n            return this.driver.open.call(this, { windowName, proxyFrame }).then(win => {\n                proxyWin.setWindow(win, { send });\n                return proxyWin;\n            });\n        });\n    }\n\n    openPrerender(proxyWin : ProxyWindow, proxyPrerenderFrame : ?ProxyObject<HTMLIFrameElement>) : ZalgoPromise<ProxyWindow> {\n        return ZalgoPromise.try(() => {\n            return this.driver.openPrerender.call(this, proxyWin, proxyPrerenderFrame);\n        });\n    }\n\n    focus() : ZalgoPromise<void> {\n        return ZalgoPromise.try(() => {\n            const proxyWin = this.proxyWin;\n            if (proxyWin) {\n                this.event.trigger(EVENT.FOCUS);\n                return proxyWin.focus().then(noop);\n            }\n        });\n    }\n\n    delegate(context : $Values<typeof CONTEXT>, target : CrossDomainWindowType) {\n        this.component.log(`delegate`);\n\n        const props = {};\n        for (const propName of this.component.getPropNames()) {\n            if (this.component.getPropDefinition(propName).allowDelegate) {\n                props[propName] = this.props[propName];\n            }\n        }\n\n        const overridesPromise = send(target, `${ POST_MESSAGE.DELEGATE }_${ this.component.name }`, {\n            context,\n            props,\n            overrides: {\n                event:   this.event,\n                close:   () => this.close(),\n                onError: (err) => this.onError(err)\n            }\n\n        }).then(({ data }) => {\n            this.clean.register(data.destroy);\n            return data.overrides;\n\n        }).catch(err => {\n            throw new Error(`Unable to delegate rendering. Possibly the component is not loaded in the target window.\\n\\n${ stringifyError(err) }`);\n        });\n\n        for (const key of this.driver.delegate) {\n            // $FlowFixMe\n            this[key] = function overriddenFunction() : ZalgoPromise<mixed> {\n                return overridesPromise.then(overrides => {\n                    return overrides[key].apply(this, arguments);\n                });\n            };\n        }\n    }\n\n    getWindowRef(target : CrossDomainWindowType, domain : string, uid : string, context : $Values<typeof CONTEXT>) : WindowRef {\n        \n        if (domain === getDomain(window)) {\n            const global = getGlobal(window);\n            global.windows = global.windows || {};\n            global.windows[uid] = window;\n            this.clean.register(() => {\n                delete global.windows[uid];\n            });\n    \n            return { type: WINDOW_REFERENCES.GLOBAL, uid };\n        }\n\n        if (context === CONTEXT.POPUP) {\n            return { type: WINDOW_REFERENCES.OPENER };\n        }\n\n        return { type: WINDOW_REFERENCES.PARENT, distance: getDistanceFromTop(window) };\n    }\n\n    watchForClose(proxyWin : ProxyWindow) : ZalgoPromise<void> {\n        let cancelled = false;\n\n        this.clean.register(() => {\n            cancelled = true;\n        });\n\n        return ZalgoPromise.delay(2000).then(() => {\n            return proxyWin.isClosed();\n        }).then(isClosed => {\n            if (isClosed) {\n                this.component.log(`detect_close_child`);\n                return this.close();\n            } else if (!cancelled) {\n                return this.watchForClose(proxyWin);\n            }\n        });\n    }\n\n    watchForUnload() {\n        const unloadWindowListener = addEventListener(window, 'unload', once(() => {\n            this.component.log(`navigate_away`);\n            this.destroy(new Error(`Window navigated away`));\n        }));\n\n        this.clean.register(unloadWindowListener.cancel);\n    }\n\n    runTimeout() : ZalgoPromise<void> {\n        return ZalgoPromise.try(() => {\n            const timeout = this.props.timeout;\n\n            if (timeout) {\n                return this.initPromise.timeout(timeout, new Error(`Loading component timed out after ${ timeout } milliseconds`));\n            }\n        });\n    }\n\n    initChild(child : ChildExportsType<P>) : ZalgoPromise<void> {\n        return ZalgoPromise.try(() => {\n            this.clean.set('child', child);\n            this.initPromise.resolve();\n        });\n    }\n\n    buildParentExports(win : ProxyWindow) : ParentExportsType<P> {\n        const onError    = (err) => this.onError(err);\n        const init       = (child) => this.initChild(child);\n        const close      = () => this.close();\n        const checkClose = () => this.checkClose(win);\n        const resize     = ({ width, height }) => this.resize({ width, height });\n        const show       = () => this.show();\n        const hide       = () => this.hide();\n\n        init.onError = onError;\n\n        return { init, close, checkClose, resize, onError, show, hide };\n    }\n\n    resize({ width, height } : { width? : ?number, height? : ?number }) : ZalgoPromise<void> {\n        return ZalgoPromise.try(() => {\n            this.event.trigger(EVENT.RESIZE, { width, height });\n        });\n    }\n\n    checkClose(win : ProxyWindow) : ZalgoPromise<void> {\n        return win.isClosed().then(closed => {\n            if (closed) {\n                return this.close();\n            }\n\n            return ZalgoPromise.delay(200)\n                .then(() => win.isClosed())\n                .then(secondClosed => {\n                    if (secondClosed) {\n                        return this.close();\n                    }\n                });\n        });\n    }\n\n    close() : ZalgoPromise<void> {\n        return ZalgoPromise.try(() => {\n            this.component.log(`close`);\n            return this.event.trigger(EVENT.CLOSE);\n\n        }).then(() => {\n            if (this.child) {\n                this.child.close.fireAndForget().catch(noop);\n            }\n\n            return this.destroy(new Error(`Window closed`));\n        });\n    }\n\n    prerender(proxyPrerenderWin : ProxyWindow, { context, uid } : { context : $Values<typeof CONTEXT>, uid : string }) : ZalgoPromise<void> {\n        return ZalgoPromise.try(() => {\n            const prerenderTemplate = this.component.prerenderTemplate;\n\n            if (!prerenderTemplate) {\n                return;\n            }\n\n            let prerenderWindow = proxyPrerenderWin.getWindow();\n\n            if (!prerenderWindow || !isSameDomain(prerenderWindow) || !isBlankDomain(prerenderWindow)) {\n                return;\n            }\n\n            prerenderWindow = assertSameDomain(prerenderWindow);\n    \n            const doc = prerenderWindow.document;\n            const el = this.renderTemplate(prerenderTemplate, { context, uid, doc });\n\n            if (!el) {\n                return;\n            }\n\n            if (el.ownerDocument !== doc) {\n                throw new Error(`Expected prerender template to have been created with document from child window`);\n            }\n\n            writeElementToWindow(prerenderWindow, el);\n\n            let { width = false, height = false, element = 'body' } = this.component.autoResize || {};\n            element = getElementSafe(element, doc);\n            \n            if (element && (width || height)) {\n                onResize(element, ({ width: newWidth, height: newHeight }) => {\n                    this.resize({\n                        width:  width ? newWidth : undefined,\n                        height: height ? newHeight : undefined\n                    });\n                }, { width, height, win: prerenderWindow });\n            }\n        });\n    }\n\n    renderTemplate(renderer : (RenderOptionsType<P>) => ?HTMLElement, { context, uid, container, doc, frame, prerenderFrame } : { context : $Values<typeof CONTEXT>, uid : string, container? : HTMLElement, doc : Document, frame? : ?HTMLIFrameElement, prerenderFrame? : ?HTMLIFrameElement }) : ?HTMLElement {\n        // $FlowFixMe\n        return renderer.call(this, {\n            container,\n            context,\n            uid,\n            doc,\n            frame,\n            prerenderFrame,\n            focus:      () => this.focus(),\n            close:      () => this.close(),\n            state:      this.state,\n            props:      this.props,\n            tag:        this.component.tag,\n            dimensions: this.component.dimensions,\n            event:      this.event\n        });\n    }\n\n    renderContainer(proxyContainer : ProxyObject<HTMLElement>, { proxyFrame, proxyPrerenderFrame, context, uid, visible } :\n        { context : $Values<typeof CONTEXT>, uid : string, proxyFrame : ?ProxyObject<HTMLIFrameElement>, proxyPrerenderFrame : ?ProxyObject<HTMLIFrameElement>, visible : boolean }) : ZalgoPromise<?ProxyObject<HTMLElement>> {\n        \n\n        return ZalgoPromise.hash({\n            container:      proxyContainer.get().then(elementReady),\n            // $FlowFixMe\n            frame:          proxyFrame ? proxyFrame.get() : null,\n            // $FlowFixMe\n            prerenderFrame: proxyPrerenderFrame ? proxyPrerenderFrame.get() : null\n        }).then(({ container, frame, prerenderFrame }) => {\n            const innerContainer = this.renderTemplate(this.component.containerTemplate, { context, uid, container, frame, prerenderFrame, doc: document });\n            if (innerContainer) {\n                if (!visible) {\n                    hideElement(innerContainer);\n                }\n                appendChild(container, innerContainer);\n                this.clean.register(() => destroyElement(innerContainer));\n                this.proxyContainer = getProxyObject(innerContainer);\n                return getProxyObject(innerContainer);\n            }\n        });\n    }\n\n    destroy(err? : mixed) : ZalgoPromise<void> {\n        return ZalgoPromise.try(() => {\n            return this.clean.all();\n        }).then(() => {\n            this.initPromise.asyncReject(err || new Error('Component destroyed'));\n            this.component.log(`destroy`);\n        });\n    }\n\n    onError(err : mixed) : ZalgoPromise<void> {\n        return ZalgoPromise.try(() => {\n            if (this.handledErrors.indexOf(err) !== -1) {\n                return;\n            }\n\n            this.handledErrors.push(err);\n            this.initPromise.asyncReject(err);\n\n            return this.event.trigger(EVENT.ERROR, err);\n        });\n    }\n\n    openBridge(proxyWin : ProxyWindow, domain : string, context : $Values<typeof CONTEXT>) : ?ZalgoPromise<?CrossDomainWindowType> {\n        if (__POST_ROBOT__.__IE_POPUP_SUPPORT__) {\n            return ZalgoPromise.try(() => {\n                return proxyWin.awaitWindow();\n                \n            }).then(win => {\n                if (!bridge || !bridge.needsBridge({ win, domain }) || bridge.hasBridge(domain, domain)) {\n                    return;\n                }\n\n                const bridgeUrl = this.component.getBridgeUrl();\n\n                if (!bridgeUrl) {\n                    throw new Error(`Bridge needed to render ${ context }`);\n                }\n\n                const bridgeDomain = getDomainFromUrl(bridgeUrl);\n                bridge.linkUrl(win, domain);\n                return bridge.openBridge(normalizeMockUrl(bridgeUrl), bridgeDomain);\n            });\n        }\n    }\n}\n","/* @flow */\n\nimport { onCloseWindow, type CrossDomainWindowType } from 'cross-domain-utils/src';\nimport { ZalgoPromise } from 'zalgo-promise/src';\nimport { ProxyWindow } from 'post-robot/src';\nimport { cleanup, type CleanupType, type EventEmitterType } from 'belter/src';\n\nimport { ParentComponent } from '../parent';\nimport { RENDER_DRIVERS, type ContextDriverType } from '../parent/drivers';\nimport type { Component } from '../component';\n\nexport type DelegatePropsType = {|\n    onClose : () => ?ZalgoPromise<void>,\n    onDisplay : () => ?ZalgoPromise<void>,\n    window : ?ProxyWindow\n|};\n\nexport type DelegateOptionsType = {|\n    context : string,\n    props : DelegatePropsType,\n    overrides : {\n        close : () => ZalgoPromise<void>,\n        onError : (mixed) => ZalgoPromise<void>,\n        event : EventEmitterType\n    }\n|};\n\nexport type DelegateReturnType = {|\n    overrides : Object,\n    destroy : () => ZalgoPromise<void>\n|};\n\nexport class DelegateComponent<P>  {\n\n    component : Component<P>\n    source : CrossDomainWindowType\n    context : string\n    driver : ContextDriverType\n    props : DelegatePropsType\n    clean : CleanupType\n\n    focus : () => ZalgoPromise<void>\n    resize : ({ width? : ?number, height? : ?number }) => ZalgoPromise<void>\n    renderTemplate : Function\n\n    close : () => ZalgoPromise<void>\n    onError : (mixed) => ZalgoPromise<void>\n    event : EventEmitterType\n\n    constructor(component : Component<P>, source : CrossDomainWindowType, options : DelegateOptionsType) {\n        this.component = component;\n        this.context = options.context;\n        this.driver = RENDER_DRIVERS[options.context];\n        this.clean = cleanup(this);\n        \n        this.focus = ParentComponent.prototype.focus;\n        this.resize = ParentComponent.prototype.resize;\n        this.renderTemplate = ParentComponent.prototype.renderTemplate;\n\n        // $FlowFixMe\n        this.props = {};\n        \n        for (const propName of Object.keys(options.props)) {\n            const propDef = this.component.getPropDefinition(propName);\n            if (propDef && propDef.allowDelegate && options.props[propName]) {\n                // $FlowFixMe\n                this.props[propName] = options.props[propName];\n            }\n        }\n\n        this.close   = options.overrides.close;\n        this.onError = options.overrides.onError;\n        this.event   = options.overrides.event;\n\n        this.component.registerActiveComponent(this);\n        this.clean.register(() => this.component.destroyActiveComponent(this));\n\n        this.watchForSourceClose(source);\n    }\n\n    getDelegate() : DelegateReturnType {\n        return {\n            overrides: this.getOverrides(),\n            destroy:   () => this.destroy()\n        };\n    }\n\n    watchForSourceClose(source : CrossDomainWindowType) {\n        const closeSourceWindowListener = onCloseWindow(source, () => this.destroy(), 3000);\n        this.clean.register(closeSourceWindowListener.cancel);\n    }\n\n    getOverrides() : { [string] : mixed } {\n        const overrides = {};\n        const self = this;\n\n        for (const key of this.driver.delegate) {\n            overrides[key] = function delegateOverride() : mixed {\n                // $FlowFixMe\n                return ParentComponent.prototype[key].apply(self, arguments);\n            };\n            overrides[key].__name__ = key;\n        }\n\n        return overrides;\n    }\n\n    destroy() : ZalgoPromise<void> {\n        return this.clean.all();\n    }\n}\n","/* @flow */\n/* eslint react/react-in-jsx-scope: off */\n\nimport { destroyElement, toCSS } from 'belter/src';\n\nimport { type RenderOptionsType } from '../../parent';\nimport { EVENT } from '../../constants';\n\nconst CLASS = {\n    VISIBLE:   'visible',\n    INVISIBLE: 'invisible'\n};\n\nexport function defaultContainerTemplate<P>({ uid, frame, prerenderFrame, doc, props, event, dimensions : { width, height } } : RenderOptionsType<P>) : ?HTMLElement {\n    if (__ZOID__.__DEFAULT_CONTAINER__) {\n        if (!frame || !prerenderFrame) {\n            return;\n        }\n\n        const div = doc.createElement('div');\n        div.setAttribute('id', uid);\n        const style = doc.createElement('style');\n        if (props.cspNonce) {\n            style.setAttribute('nonce', props.cspNonce);\n        }\n\n        style.appendChild(doc.createTextNode(`\n            #${ uid } {\n                display: inline-block;\n                position: relative;\n                width: ${ width };\n                height: ${ height };\n            }\n\n            #${ uid } > iframe {\n                display: inline-block;\n                position: absolute;\n                width: 100%;\n                height: 100%;\n                top: 0;\n                left: 0;\n                transition: opacity .2s ease-in-out;\n            }\n\n            #${ uid } > iframe.${ CLASS.INVISIBLE } {\n                opacity: 0;\n            }\n\n            #${ uid } > iframe.${ CLASS.VISIBLE } {\n                opacity: 1;\n        }\n        `));\n\n        div.appendChild(frame);\n        div.appendChild(prerenderFrame);\n        div.appendChild(style);\n\n        prerenderFrame.classList.add(CLASS.VISIBLE);\n        frame.classList.add(CLASS.INVISIBLE);\n    \n        event.on(EVENT.RENDERED, () => {\n            prerenderFrame.classList.remove(CLASS.VISIBLE);\n            prerenderFrame.classList.add(CLASS.INVISIBLE);\n    \n            frame.classList.remove(CLASS.INVISIBLE);\n            frame.classList.add(CLASS.VISIBLE);\n    \n            setTimeout(() => {\n                destroyElement(prerenderFrame);\n            }, 1);\n        });\n\n        event.on(EVENT.RESIZE, ({ width: newWidth, height: newHeight }) => {\n            if (typeof newWidth === 'number') {\n                div.style.width = toCSS(newWidth);\n            }\n    \n            if (typeof newHeight === 'number') {\n                div.style.height = toCSS(newHeight);\n            }\n        });\n\n        return div;\n    }\n}\n","/* @flow */\n/* eslint react/react-in-jsx-scope: off */\n\nimport { type RenderOptionsType } from '../../parent';\n\nexport function defaultPrerenderTemplate<P>({ doc, props } : RenderOptionsType<P>) : ?HTMLElement {\n    if (__ZOID__.__DEFAULT_PRERENDER__) {\n        const html = doc.createElement('html');\n        const body = doc.createElement('body');\n        const style = doc.createElement('style');\n        const spinner = doc.createElement('div');\n        spinner.classList.add('spinner');\n\n        if (props.cspNonce) {\n            style.setAttribute('nonce', props.cspNonce);\n        }\n\n        html.appendChild(body);\n        body.appendChild(spinner);\n        body.appendChild(style);\n        style.appendChild(doc.createTextNode(`\n            html, body {\n                width: 100%;\n                height: 100%;\n            }\n\n            .spinner {\n                position: fixed;\n                max-height: 60vmin;\n                max-width: 60vmin;\n                height: 40px;\n                width: 40px;\n                top: 50%;\n                left: 50%;\n                box-sizing: border-box;\n                border: 3px solid rgba(0, 0, 0, .2);\n                border-top-color: rgba(33, 128, 192, 0.8);\n                border-radius: 100%;\n                animation: rotation .7s infinite linear;\n            }\n\n            @keyframes rotation {\n                from {\n                    transform: translateX(-50%) translateY(-50%) rotate(0deg);\n                }\n                to {\n                    transform: translateX(-50%) translateY(-50%) rotate(359deg);\n                }\n            }\n        `));\n\n        return html;\n    }\n}\n","/* @flow */\n\nimport { ZalgoPromise } from 'zalgo-promise/src';\nimport { once, noop, type EventEmitterType } from 'belter/src';\nimport { isWindow, type CrossDomainWindowType, isWindowClosed, isSameDomain } from 'cross-domain-utils/src';\nimport { ProxyWindow, toProxyWindow } from 'post-robot/src';\n\nimport { PROP_SERIALIZATION } from '../constants';\n\nexport type EventHandlerType<T> = (T) => void | ZalgoPromise<void>;\n\nexport type timeoutPropType = number;\nexport type windowPropType = CrossDomainWindowType | ProxyWindow;\nexport type cspNoncePropType = string;\nexport type closePropType = () => ZalgoPromise<void>;\nexport type focusPropType = () => ZalgoPromise<void>;\nexport type resizePropType = ({ width : ?number, height : ?number }) => ZalgoPromise<void>;\n\nexport type onDisplayPropType = EventHandlerType<void>;\nexport type onRenderedPropType = EventHandlerType<void>;\nexport type onRenderPropType = EventHandlerType<void>;\nexport type onClosePropType = EventHandlerType<void>;\nexport type onResizePropType = EventHandlerType<void>;\nexport type onFocusPropType = EventHandlerType<void>;\nexport type onErrorPropType = EventHandlerType<mixed>;\nexport type onPropsPropType<P> = ((PropsType<P>) => void) => void; // eslint-disable-line no-use-before-define\n\nexport type PropsInputType<P> = {\n    timeout? : timeoutPropType,\n    window? : windowPropType,\n    cspNonce? : cspNoncePropType,\n\n    onDisplay? : onDisplayPropType,\n    onRendered? : onRenderedPropType,\n    onRender? : onRenderPropType,\n    onClose? : onClosePropType,\n    onResize? : onResizePropType,\n    onFocus? : onFocusPropType,\n    onError? : onErrorPropType,\n    onProps? : onPropsPropType<P>\n} & P;\n\nexport type PropsType<P> = {|\n    timeout? : timeoutPropType,\n    window? : ?windowPropType,\n    close? : ?closePropType,\n    focus? : ?focusPropType,\n    resize? : ?resizePropType,\n    cspNonce? : ?cspNoncePropType,\n\n    onDisplay : onDisplayPropType,\n    onRendered : onRenderedPropType,\n    onRender : onRenderPropType,\n    onClose : onClosePropType,\n    onResize : onResizePropType,\n    onFocus : onFocusPropType,\n    onError : onErrorPropType,\n    onProps : onPropsPropType<P>\n|} & P;\n\ntype PropDefinitionType<T, P, S : string> = {|\n    type : S,\n    alias? : string,\n    value? : ({|\n        props : P,\n        state : Object,\n        close : () => ZalgoPromise<void>,\n        focus : () => ZalgoPromise<void>,\n        onError : (mixed) => ZalgoPromise<void>,\n        event : EventEmitterType\n    |}) => ?T,\n    default? : ({|\n        props : P,\n        state : Object,\n        close : () => ZalgoPromise<void>,\n        focus : () => ZalgoPromise<void>,\n        onError : (mixed) => ZalgoPromise<void>,\n        event : EventEmitterType\n    |}) => ?T,\n    decorate? : ({|\n        value : T,\n        props : PropsType<P>,\n        state : Object,\n        close : () => ZalgoPromise<void>,\n        focus : () => ZalgoPromise<void>,\n        onError : (mixed) => ZalgoPromise<void>,\n        event : EventEmitterType\n    |}) => T,\n    childDecorate? : ({|\n        value : T,\n        close : () => ZalgoPromise<void>,\n        focus : () => ZalgoPromise<void>,\n        onError : (mixed) => ZalgoPromise<void>,\n        onProps : ((PropsType<P>) => void) => void,\n        resize : ({ width : ?number, height : ?number }) => ZalgoPromise<void>,\n        getParentDomain : () => string,\n        getParent : () => CrossDomainWindowType,\n        show : () => ZalgoPromise<void>,\n        hide : () => ZalgoPromise<void>\n    |}) => ?T,\n    required? : boolean,\n    queryParam? : boolean | string | ({ value : T }) => (string | ZalgoPromise<string>),\n    queryValue? : ({| value : T |}) => (ZalgoPromise<mixed> | mixed),\n    sendToChild? : boolean,\n    allowDelegate? : boolean,\n    validate? : ({| value : T, props : PropsInputType<P> |}) => void,\n    sameDomain? : boolean,\n    serialization? : $Values<typeof PROP_SERIALIZATION>\n|};\n\nexport type BooleanPropDefinitionType<T : boolean, P> = PropDefinitionType<T, P, 'boolean'>;\nexport type StringPropDefinitionType<T : string, P> = PropDefinitionType<T, P, 'string'>;\nexport type NumberPropDefinitionType<T : number, P> = PropDefinitionType<T, P, 'number'>;\nexport type FunctionPropDefinitionType<T : Function, P> = PropDefinitionType<T, P, 'function'>;\nexport type ArrayPropDefinitionType<T : Array<*> | $ReadOnlyArray<*>, P> = PropDefinitionType<T, P, 'array'>; // eslint-disable-line flowtype/no-mutable-array\nexport type ObjectPropDefinitionType<T : Object, P> = PropDefinitionType<T, P, 'object'>;\n\nexport type MixedPropDefinitionType<P> = BooleanPropDefinitionType<*, P> | StringPropDefinitionType<*, P> | NumberPropDefinitionType<*, P> | FunctionPropDefinitionType<*, P> | ObjectPropDefinitionType<*, P> | ArrayPropDefinitionType<*, P>;\n\nexport type UserPropsDefinitionType<P> = {\n    [string] : MixedPropDefinitionType<P>\n};\n\n// eslint-disable-next-line flowtype/require-exact-type\nexport type BuiltInPropsDefinitionType<P> = {\n    timeout : NumberPropDefinitionType<timeoutPropType, P>,\n    window : ObjectPropDefinitionType<windowPropType, P>,\n    close : FunctionPropDefinitionType<closePropType, P>,\n    focus : FunctionPropDefinitionType<focusPropType, P>,\n    resize : FunctionPropDefinitionType<resizePropType, P>,\n\n    onDisplay : FunctionPropDefinitionType<onDisplayPropType, P>,\n    onRendered : FunctionPropDefinitionType<onRenderedPropType, P>,\n    onRender : FunctionPropDefinitionType<onRenderPropType, P>,\n    onClose : FunctionPropDefinitionType<onClosePropType, P>,\n    onResize : FunctionPropDefinitionType<onClosePropType, P>,\n    onFocus : FunctionPropDefinitionType<onFocusPropType, P>,\n    onError : FunctionPropDefinitionType<onErrorPropType, P>,\n    onProps : FunctionPropDefinitionType<onPropsPropType<P>, P>\n};\n\nconst defaultNoop = () => noop;\nconst decorateOnce = ({ value }) => once(value);\n\nexport function getBuiltInProps<P>() : BuiltInPropsDefinitionType<P> {\n    return {\n        window: {\n            type:          'object',\n            sendToChild:   false,\n            required:      false,\n            allowDelegate: true,\n            validate({ value } : { value : CrossDomainWindowType | ProxyWindow }) {\n                if (!isWindow(value) && !ProxyWindow.isProxyWindow(value)) {\n                    throw new Error(`Expected Window or ProxyWindow`);\n                }\n\n                if (isWindow(value)) {\n                    // $FlowFixMe\n                    if (isWindowClosed(value)) {\n                        throw new Error(`Window is closed`);\n                    }\n\n                    // $FlowFixMe\n                    if (!isSameDomain(value)) {\n                        throw new Error(`Window is not same domain`);\n                    }\n                }\n            },\n            decorate({ value } : { value : CrossDomainWindowType | ProxyWindow }) : ProxyWindow {\n                return toProxyWindow(value);\n            }\n        },\n\n        timeout: {\n            type:        'number',\n            required:    false,\n            sendToChild: false\n        },\n\n        close: {\n            type:          'function',\n            required:      false,\n            sendToChild:   false,\n            childDecorate: ({ close }) => close\n        },\n\n        focus: {\n            type:          'function',\n            required:      false,\n            sendToChild:   false,\n            childDecorate: ({ focus }) => focus\n        },\n\n        resize: {\n            type:          'function',\n            required:      false,\n            sendToChild:   false,\n            childDecorate: ({ resize }) => resize\n        },\n\n        cspNonce: {\n            type:     'string',\n            required: false\n        },\n\n        getParent: {\n            type:          'function',\n            required:      false,\n            sendToChild:   false,\n            childDecorate: ({ getParent }) => getParent\n        },\n\n        getParentDomain: {\n            type:          'function',\n            required:      false,\n            sendToChild:   false,\n            childDecorate: ({ getParentDomain }) => getParentDomain\n        },\n\n        show: {\n            type:          'function',\n            required:      false,\n            sendToChild:   false,\n            childDecorate: ({ show }) => show\n        },\n\n        hide: {\n            type:          'function',\n            required:      false,\n            sendToChild:   false,\n            childDecorate: ({ hide }) => hide\n        },\n\n        onDisplay: {\n            type:          'function',\n            required:      false,\n            sendToChild:   false,\n            allowDelegate: true,\n            default:       defaultNoop,\n            decorate:      decorateOnce\n        },\n\n        onRendered: {\n            type:        'function',\n            required:    false,\n            sendToChild: false,\n            default:     defaultNoop,\n            decorate:    decorateOnce\n        },\n\n        onRender: {\n            type:        'function',\n            required:    false,\n            sendToChild: false,\n            default:     defaultNoop,\n            decorate:    decorateOnce\n        },\n\n        onClose: {\n            type:          'function',\n            required:      false,\n            sendToChild:   false,\n            allowDelegate: true,\n            default:       defaultNoop,\n            decorate:      decorateOnce\n        },\n\n        onResize: {\n            type:          'function',\n            required:      false,\n            sendToChild:   false,\n            allowDelegate: true,\n            default:       defaultNoop\n        },\n\n        onFocus: {\n            type:          'function',\n            required:      false,\n            sendToChild:   false,\n            allowDelegate: true,\n            default:       defaultNoop\n        },\n\n        onError: {\n            type:          'function',\n            required:      false,\n            sendToChild:   false,\n            childDecorate: ({ onError }) => onError\n        },\n\n        onProps: {\n            type:          'function',\n            required:      false,\n            sendToChild:   false,\n            default:       defaultNoop,\n            childDecorate: ({ onProps }) => onProps\n        }\n    };\n}\n","/* @flow */\n/* eslint max-lines: 0 */\n\nimport { setup as setupPostRobot, on, send, bridge, toProxyWindow, destroy as destroyPostRobot } from 'post-robot/src';\nimport { ZalgoPromise } from 'zalgo-promise/src';\nimport { isWindow, getDomainFromUrl, type CrossDomainWindowType, isSameTopWindow, getDomain, matchDomain, isSameDomain } from 'cross-domain-utils/src';\nimport { isRegex, noop, isElement } from 'belter/src';\n\nimport { ChildComponent, getChildPayload } from '../child';\nimport { ParentComponent, type RenderOptionsType, type ParentHelpers } from '../parent';\nimport { DelegateComponent } from '../delegate';\nimport { CONTEXT, POST_MESSAGE, WILDCARD, DEFAULT_DIMENSIONS } from '../constants';\nimport { react, angular, vue, angular2 } from '../drivers';\nimport { getGlobal, destroyGlobal } from '../lib';\nimport type { CssDimensionsType, StringMatcherType } from '../types';\n\nimport { validate } from './validate';\nimport { defaultContainerTemplate, defaultPrerenderTemplate } from './templates';\nimport { getBuiltInProps, type UserPropsDefinitionType, type BuiltInPropsDefinitionType, type PropsInputType, type PropsType, type MixedPropDefinitionType } from './props';\n\ntype LoggerPayload = { [string] : ?string };\n\n// eslint-disable-next-line flowtype/require-exact-type\ntype Logger = {\n    debug : (event : string, payload? : LoggerPayload) => any, // eslint-disable-line flowtype/no-weak-types\n    info : (event : string, payload? : LoggerPayload) => any, // eslint-disable-line flowtype/no-weak-types\n    warn : (event : string, payload? : LoggerPayload) => any, // eslint-disable-line flowtype/no-weak-types\n    error : (event : string, payload? : LoggerPayload) => any // eslint-disable-line flowtype/no-weak-types\n};\n\n/*  Component\n    ---------\n\n    This is the spec for the component. The idea is, when I call zoid.create(), it will create a new instance\n    of Component with the blueprint needed to set up ParentComponents and ChildComponents.\n\n    This is the one portion of code which is required by -- and shared to -- both the parent and child windows, and\n    contains all of the configuration needed for them to set themselves up.\n*/\n\nexport type ComponentOptionsType<P> = {|\n\n    tag : string,\n\n    url : string | ({ props : PropsType<P> }) => string,\n    domain? : string | RegExp,\n    bridgeUrl? : string,\n\n    props? : UserPropsDefinitionType<P>,\n\n    dimensions? : CssDimensionsType,\n    autoResize? : { width? : boolean, height? : boolean, element? : string },\n\n    allowedParentDomains? : StringMatcherType,\n\n    attributes? : {\n        iframe? : { [string] : string },\n        popup? : { [string] : string }\n    },\n\n    defaultContext? : $Values<typeof CONTEXT>,\n\n    containerTemplate? : (RenderOptionsType<P>) => ?HTMLElement,\n    prerenderTemplate? : (RenderOptionsType<P>) => ?HTMLElement,\n\n    validate? : ({ props : PropsInputType<P> }) => void,\n\n    logger? : Logger\n|};\n\ntype ZoidRenderer = {|\n    render : (container? : string | HTMLElement, context? : $Values<typeof CONTEXT>) => ZalgoPromise<void>,\n    renderTo : (target : CrossDomainWindowType, container? : string, context? : $Values<typeof CONTEXT>) => ZalgoPromise<void>\n|};\n\nexport type ZoidComponentInstance<P> = {| ...ParentHelpers<P>, ...ZoidRenderer |};\n\n// eslint-disable-next-line flowtype/require-exact-type\nexport type ZoidComponent<P> = {\n    (PropsInputType<P>) : ZoidComponentInstance<P>,\n    driver : (string, mixed) => mixed,\n    isChild : () => boolean,\n    xprops? : PropsType<P>,\n    canRenderTo : (CrossDomainWindowType) => ZalgoPromise<boolean>\n};\n\nexport class Component<P> {\n\n    tag : string\n    name : string\n    \n    url : string | ({ props : PropsType<P> }) => string\n    domain : void | string | RegExp\n    bridgeUrl : void | string\n\n    props : UserPropsDefinitionType<P>\n    builtinProps : BuiltInPropsDefinitionType<P>\n\n    dimensions : CssDimensionsType\n    autoResize : void | { width? : boolean, height? : boolean, element? : string }\n\n    allowedParentDomains : StringMatcherType\n\n    defaultContext : $Values<typeof CONTEXT>\n    \n    attributes : {\n        iframe? : { [string] : string },\n        popup? : { [string] : string }\n    }\n\n    containerTemplate : (RenderOptionsType<P>) => ?HTMLElement\n    prerenderTemplate : ?(RenderOptionsType<P>) => ?HTMLElement\n\n    validate : void | ({ props : PropsInputType<P> }) => void\n\n    driverCache : { [string] : mixed }\n\n    xprops : ?PropsType<P>\n\n    logger : Logger\n\n    propNames : $ReadOnlyArray<string>\n\n    constructor(options : ComponentOptionsType<P>) {\n        validate(options);\n\n        // The tag name of the component. Used by some drivers (e.g. angular) to turn the component into an html element,\n        // e.g. <my-component>\n\n        this.tag = options.tag;\n        this.name = this.tag.replace(/-/g, '_');\n\n        this.allowedParentDomains = options.allowedParentDomains || WILDCARD;\n\n        const global = getGlobal();\n        global.components = global.components || {};\n\n        if (global.components[this.tag]) {\n            throw new Error(`Can not register multiple components with the same tag: ${ this.tag }`);\n        }\n\n        // A json based spec describing what kind of props the component accepts. This is used to validate any props before\n        // they are passed down to the child.\n\n        this.builtinProps = getBuiltInProps();\n        this.props = options.props || {};\n\n        // The dimensions of the component, e.g. { width: '300px', height: '150px' }\n\n        const { width = DEFAULT_DIMENSIONS.WIDTH, height = DEFAULT_DIMENSIONS.HEIGHT } = options.dimensions || {};\n        this.dimensions = { width, height };\n\n        this.url = options.url;\n        this.domain = options.domain;\n        this.bridgeUrl = options.bridgeUrl;\n\n        this.attributes = options.attributes || {};\n        this.attributes.iframe = this.attributes.iframe || {};\n        this.attributes.popup = this.attributes.popup || {};\n\n        this.defaultContext = options.defaultContext || CONTEXT.IFRAME;\n\n        this.autoResize = options.autoResize;\n\n        if (options.containerTemplate) {\n            this.containerTemplate = options.containerTemplate;\n        } else if (__ZOID__.__DEFAULT_CONTAINER__) {\n            this.containerTemplate = defaultContainerTemplate;\n        }\n\n        if (options.prerenderTemplate) {\n            this.prerenderTemplate = options.prerenderTemplate;\n        } else if (__ZOID__.__DEFAULT_PRERENDER__) {\n            this.prerenderTemplate = defaultPrerenderTemplate;\n        }\n\n        this.validate = options.validate;\n\n        this.logger = options.logger || {\n            debug: noop,\n            info:  noop,\n            warn:  noop,\n            error: noop\n        };\n\n        this.registerChild();\n        this.listenDelegate();\n\n        global.components[this.tag] = this;\n    }\n\n    getPropNames() : $ReadOnlyArray<string> {\n        if (this.propNames) {\n            return this.propNames;\n        }\n\n        const propNames = Object.keys(this.props);\n        for (const key of Object.keys(this.builtinProps)) {\n            if (propNames.indexOf(key) === -1) {\n                propNames.push(key);\n            }\n        }\n\n        this.propNames = propNames;\n        return propNames;\n    }\n\n    getPropDefinition(name : string) : MixedPropDefinitionType<P> {\n        return this.props[name] || this.builtinProps[name];\n    }\n\n    driver(name : string, dep : mixed) : mixed {\n        if (__ZOID__.__FRAMEWORK_SUPPORT__) {\n            const drivers = { react, angular, vue, angular2 };\n\n            if (!drivers[name]) {\n                throw new Error(`Could not find driver for framework: ${ name }`);\n            }\n    \n            this.driverCache = this.driverCache || {};\n    \n            if (!this.driverCache[name]) {\n                this.driverCache[name] = drivers[name].register(this, dep);\n            }\n    \n            return this.driverCache[name];\n        } else {\n            throw new Error(`Driver support not enabled`);\n        }\n    }\n\n    registerChild() {\n        if (this.isChild()) {\n            if (window.xprops) {\n                throw new Error(`Can not register ${ this.name } as child - can not attach multiple components to the same window`);\n            }\n\n            const child = new ChildComponent(this);\n            window.xprops = this.xprops = child.getProps();\n        }\n    }\n\n    listenDelegate() {\n        on(`${ POST_MESSAGE.ALLOW_DELEGATE }_${ this.name }`, () => {\n            return true;\n        });\n\n        on(`${ POST_MESSAGE.DELEGATE }_${ this.name }`, ({ source, data: { context, props, overrides } }) => {\n            const delegate = new DelegateComponent(this, source, { context, props, overrides });\n            return delegate.getDelegate();\n        });\n    }\n\n    canRenderTo(win : CrossDomainWindowType) : ZalgoPromise<boolean> {\n        return send(win, `${ POST_MESSAGE.ALLOW_DELEGATE }_${ this.name }`).then(({ data }) => {\n            return data;\n        }).catch(() => {\n            return false;\n        });\n    }\n\n    getUrl(props : PropsType<P>) : string {\n        if (typeof this.url === 'function') {\n            return this.url({ props });\n        }\n\n        return this.url;\n    }\n\n    getChildDomain(props : PropsType<P>) : string {\n        if (this.domain && typeof this.domain === 'string') {\n            return this.domain;\n        }\n\n        return getDomainFromUrl(this.getUrl(props));\n    }\n\n    getDomain(props : PropsType<P>) : string | RegExp {\n        if (this.domain && isRegex(this.domain)) {\n            return this.domain;\n        }\n\n        return this.getChildDomain(props);\n    }\n\n    getBridgeUrl() : ?string {\n        if (this.bridgeUrl) {\n            return this.bridgeUrl;\n        }\n    }\n\n    isChild() : boolean {\n        const payload = getChildPayload();\n        return Boolean(payload && payload.tag === this.tag && payload.childDomain === getDomain());\n    }\n\n    getDefaultContainer(context : $Values<typeof CONTEXT>, container? : string | HTMLElement) : string | HTMLElement {\n        if (container) {\n            if (typeof container !== 'string' && !isElement(container)) {\n                throw new TypeError(`Expected string or element selector to be passed`);\n            }\n\n            return container;\n        }\n\n        if (context === CONTEXT.POPUP) {\n            return 'body';\n        }\n\n        throw new Error(`Expected element to be passed to render iframe`);\n    }\n\n    getDefaultContext(context : ?$Values<typeof CONTEXT>, props : PropsInputType<P>) : ZalgoPromise<$Values<typeof CONTEXT>> {\n        return ZalgoPromise.try(() => {\n            if (props.window) {\n                return toProxyWindow(props.window).getType();\n            }\n    \n            if (context) {\n                if (context !== CONTEXT.IFRAME && context !== CONTEXT.POPUP) {\n                    throw new Error(`Unrecognized context: ${ context }`);\n                }\n                \n                return context;\n            }\n    \n            return this.defaultContext;\n        });\n    }\n\n    init(props : PropsInputType<P>) : ZoidComponentInstance<P> {\n\n        // $FlowFixMe\n        props = props || {};\n        \n        const parent = new ParentComponent(this, props);\n\n        const render = (target, container, context) => {\n            return ZalgoPromise.try(() => {\n                if (!isWindow(target)) {\n                    throw new Error(`Must pass window to renderTo`);\n                }\n\n                return this.getDefaultContext(context, props);\n                \n            }).then(finalContext => {\n                container = this.getDefaultContainer(finalContext, container);\n                return parent.render(target, container, finalContext);\n            });\n        };\n\n        return {\n            ...parent.getHelpers(),\n            render:   (container, context) => render(window, container, context),\n            renderTo: (target, container, context) => render(target, container, context)\n        };\n    }\n\n    checkAllowRender(target : CrossDomainWindowType, domain : string | RegExp, container : string | HTMLElement) {\n        if (target === window) {\n            return;\n        }\n\n        if (!isSameTopWindow(window, target)) {\n            throw new Error(`Can only renderTo an adjacent frame`);\n        }\n\n        const origin = getDomain();\n\n        if (!matchDomain(domain, origin) && !isSameDomain(target)) {\n            throw new Error(`Can not render remotely to ${ domain.toString() } - can only render to ${ origin }`);\n        }\n\n        if (container && typeof container !== 'string') {\n            throw new Error(`Container passed to renderTo must be a string selector, got ${ typeof container } }`);\n        }\n    }\n\n    log(event : string, payload? : LoggerPayload) {\n        this.logger.info(`${ this.name }_${ event }`, payload);\n    }\n\n    registerActiveComponent<Q>(instance : ParentComponent<Q> | DelegateComponent<Q>) {\n        const global = getGlobal();\n        global.activeComponents = global.activeComponents || [];\n        global.activeComponents.push(instance);\n    }\n\n    destroyActiveComponent<Q>(instance : ParentComponent<Q> | DelegateComponent<Q>) {\n        const global = getGlobal();\n        global.activeComponents = global.activeComponents || [];\n        global.activeComponents.splice(global.activeComponents.indexOf(instance), 1);\n    }\n}\n\nexport type ComponentDriverType<P, T : mixed> = {|\n    register : (Component<P>, T) => mixed\n|};\n\nexport function create<P>(options : ComponentOptionsType<P>) : ZoidComponent<P> {\n    setupPostRobot();\n\n    const component : Component<P> = new Component(options);\n\n    const init = (props) => component.init(props);\n    init.driver = (name, dep) => component.driver(name, dep);\n    init.isChild = () => component.isChild();\n    init.canRenderTo = (win) => component.canRenderTo(win);\n    init.xprops = component.xprops;\n    \n    return init;\n}\n\nexport function destroyAll() : ZalgoPromise<void> {\n    if (bridge) {\n        bridge.destroyBridges();\n    }\n\n    const results = [];\n\n    const global = getGlobal();\n    global.activeComponents = global.activeComponents || [];\n    while (global.activeComponents.length) {\n        results.push(global.activeComponents[0].destroy(new Error(`zoid destroyed all`), false));\n    }\n\n    return ZalgoPromise.all(results).then(noop);\n}\n\nexport const destroyComponents = destroyAll;\n\nexport function destroy() {\n    destroyAll();\n    destroyGlobal();\n    destroyPostRobot();\n}\n","/* @flow */\n\nimport { isPerc, isPx, values } from 'belter/src';\n\nimport { CONTEXT, PROP_TYPE } from '../constants';\n\nimport type { ComponentOptionsType } from './index';\n\nfunction validatePropDefinitions<P>(options : ComponentOptionsType<P>) {\n\n    if (options.props && !(typeof options.props === 'object')) {\n        throw new Error(`Expected options.props to be an object`);\n    }\n\n    const PROP_TYPE_LIST = values(PROP_TYPE);\n\n    if (options.props) {\n        for (const key of Object.keys(options.props)) {\n            const prop = options.props[key];\n\n            if (!prop || !(typeof prop === 'object')) {\n                throw new Error(`Expected options.props.${ key } to be an object`);\n            }\n\n            if (!prop.type) {\n                throw new Error(`Expected prop.type`);\n            }\n\n            if (PROP_TYPE_LIST.indexOf(prop.type) === -1) {\n                throw new Error(`Expected prop.type to be one of ${ PROP_TYPE_LIST.join(', ') }`);\n            }\n\n            if (prop.required && prop.default) {\n                throw new Error(`Required prop can not have a default value`);\n            }\n\n            if (prop.type === PROP_TYPE.FUNCTION && prop.queryParam && !prop.queryValue) {\n                throw new Error(`Do not pass queryParam for function prop`);\n            }\n        }\n    }\n}\n\n// eslint-disable-next-line complexity\nexport function validate<P>(options : ?ComponentOptionsType<P>) { // eslint-ignore-line\n\n    if (!options) {\n        throw new Error(`Expected options to be passed`);\n    }\n\n    // eslint-disable-next-line security/detect-unsafe-regex, unicorn/no-unsafe-regex\n    if (!options.tag || !options.tag.match(/^([a-z0-9][a-z0-9-]*)+[a-z0-9]+$/)) {\n        throw new Error(`Invalid options.tag: ${ options.tag }`);\n    }\n\n    validatePropDefinitions(options);\n\n    if (options.dimensions) {\n        if (options.dimensions && !isPx(options.dimensions.width) && !isPerc(options.dimensions.width)) {\n            throw new Error(`Expected options.dimensions.width to be a px or % string value`);\n        }\n\n        if (options.dimensions && !isPx(options.dimensions.height) && !isPerc(options.dimensions.height)) {\n            throw new Error(`Expected options.dimensions.height to be a px or % string value`);\n        }\n    }\n\n    if (options.defaultContext) {\n        if (options.defaultContext !== CONTEXT.IFRAME && options.defaultContext !== CONTEXT.POPUP) {\n            throw new Error(`Unsupported context type: ${ options.defaultContext || 'unknown' }`);\n        }\n    }\n\n    if (!options.url) {\n        throw new Error(`Must pass url`);\n    }\n\n    if (typeof options.url !== 'string' && typeof options.url !== 'function') {\n        throw new TypeError(`Expected url to be string or function`);\n    }\n\n    if (options.prerenderTemplate && typeof options.prerenderTemplate !== 'function') {\n        throw new Error(`Expected options.prerenderTemplate to be a function`);\n    }\n\n    if ((options.containerTemplate || !__ZOID__.__DEFAULT_CONTAINER__) && typeof options.containerTemplate !== 'function') {\n        throw new Error(`Expected options.containerTemplate to be a function`);\n    }\n}\n","/* @flow */\n\nexport { PopupOpenError } from 'belter/src';\nexport { create, destroy, destroyComponents, destroyAll, Component } from './component';\nexport type { ZoidComponent, ZoidComponentInstance } from './component';\nexport type { RenderOptionsType } from './parent';\nexport { PROP_TYPE, PROP_SERIALIZATION, CONTEXT, EVENT } from './constants';\n"],"sourceRoot":""}