zoid.min.js.map

{"version":3,"sources":["webpack://zoid/webpack/universalModuleDefinition","webpack://zoid/webpack/bootstrap","webpack://zoid/./node_modules/@babel/runtime/helpers/esm/setPrototypeOf.js","webpack://zoid/./node_modules/@babel/runtime/helpers/esm/inheritsLoose.js","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/cross-domain-safe-weakmap/src/native.js","webpack://zoid/./node_modules/@babel/runtime/helpers/esm/getPrototypeOf.js","webpack://zoid/./node_modules/@babel/runtime/helpers/esm/isNativeReflectConstruct.js","webpack://zoid/./node_modules/@babel/runtime/helpers/esm/construct.js","webpack://zoid/./node_modules/@babel/runtime/helpers/esm/wrapNativeSuper.js","webpack://zoid/./node_modules/@babel/runtime/helpers/esm/isNativeFunction.js","webpack://zoid/./node_modules/@babel/runtime/helpers/esm/assertThisInitialized.js","webpack://zoid/./node_modules/belter/src/dom.js","webpack://zoid/./node_modules/belter/src/css.js","webpack://zoid/./node_modules/post-robot/src/global.js","webpack://zoid/./node_modules/belter/src/constants.js","webpack://zoid/./node_modules/post-robot/src/lib/hello.js","webpack://zoid/./node_modules/post-robot/src/conf/constants.js","webpack://zoid/./node_modules/post-robot/src/lib/windows.js","webpack://zoid/./node_modules/universal-serialize/src/common.js","webpack://zoid/./node_modules/universal-serialize/src/constants.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/serializers/undefined.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/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/lib/compat.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/conf/config.js","webpack://zoid/./node_modules/post-robot/src/setup.js","webpack://zoid/./node_modules/post-robot/src/clean.js","webpack://zoid/./node_modules/@krakenjs/cross-domain-utils/src/util.js","webpack://zoid/./node_modules/@krakenjs/cross-domain-utils/src/utils.js","webpack://zoid/./node_modules/@krakenjs/cross-domain-utils/src/constants.js","webpack://zoid/./src/lib/global.js","webpack://zoid/./src/lib/serialize.js","webpack://zoid/./src/constants.js","webpack://zoid/./src/lib/window.js","webpack://zoid/./src/child/props.js","webpack://zoid/./src/child/child.js","webpack://zoid/./src/component/props.js","webpack://zoid/./src/parent/props.js","webpack://zoid/./src/parent/parent.js","webpack://zoid/./src/component/templates/container.js","webpack://zoid/./src/component/templates/component.js","webpack://zoid/./src/component/component.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","_setPrototypeOf","setPrototypeOf","__proto__","_inheritsLoose","subClass","superClass","prototype","constructor","_extends","assign","target","arguments","length","source","apply","isPromise","item","Promise","window","Window","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","promiseResult","catch","undefined","finally","onFinally","try","timeout","time","clearTimeout","toPromise","TypeError","lazy","all","promises","count","results","slice","prom","hash","awaitPromises","map","items","method","onPossiblyUnhandledException","cancel","splice","context","args","delay","flush","isRegex","IE_WIN_ACCESS_ERROR","getActualProtocol","win","location","protocol","getProtocol","mockDomain","split","isAboutProtocol","getParent","parent","getOpener","opener","canReadFromWindow","getActualDomain","PROTOCOL","host","getDomain","domain","isSameDomain","desc","getOwnPropertyDescriptor","isMockProtocol","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","isSameTopWindow","win1","win2","top1","top2","allFrames1","allFrames2","opener1","opener2","matchDomain","pattern","origin","Array","isArray","Boolean","match","JSON","stringify","some","subpattern","getDomainFromUrl","url","join","isWindow","obj","__cross_domain_utils_window_check__","getFrameForWindow","frameElement","document","querySelectorAll","closeWindow","isIframe","parentElement","removeChild","close","objectIDs","CrossDomainSafeWeakMap","weakmap","keys","values","Math","random","WeakMap","freeze","testWeakMap","testKey","set","hasNativeWeakMap","_cleanupClosedWindows","delete","isSafeToReadWrite","entry","writable","index","has","getOrSet","_getPrototypeOf","getPrototypeOf","_isNativeReflectConstruct","Reflect","construct","sham","Proxy","Date","e","_construct","Parent","Class","isNativeReflectConstruct","a","instance","Function","_wrapNativeSuper","_cache","Map","Wrapper","configurable","isElement","element","passed","Element","nodeType","style","_","getFunctionName","fn","__name__","displayName","setFunctionName","base64encode","str","btoa","encodeURIComponent","replace","p1","String","fromCharCode","parseInt","Buffer","from","uniqueID","chars","charAt","floor","toISOString","toLowerCase","serializeArgs","subkey","val","uid","getObjectID","getEmptyObject","memoizeGlobalIndex","memoizeGlobalIndexValidFrom","memoize","options","simpleCache","thisCache","thisNamespace","cacheTime","memoizeIndex","memoizedFunction","cache","cacheKey","cacheResult","now","reset","memoizePromise","memoizedPromiseFunction","noop","once","called","stringifyError","level","newErr","extend","identity","safeInterval","loop","arrayFrom","isDefined","cleanup","cleanErr","tasks","cleaned","cleaner","register","task","shift","assertExists","thing","clear","ExtendableError","captureStackTrace","ReferenceError","getBody","body","isDocumentReady","readyState","isDocumentInteractive","urlEncode","parseQuery","queryString","logic","__inline_memoize_cache__","params","pair","decodeURIComponent","inlineMemoize","extendQuery","originalQuery","props","filter","appendChild","container","getElementSafe","id","querySelector","elementReady","el","interval","setInterval","clearInterval","awaitFrameLoadPromises","PopupOpenError","awaitFrameLoad","addEventListener","cleanIframes","linkFrameWindow","awaitFrameWindow","loadedFrame","iframe","tag","styleText","createElement","class","className","setAttribute","attributes","styleSheet","cssText","createTextNode","html","innerHTML","allowTransparency","backgroundColor","border","isIE","hasAttribute","getElement","event","removeEventListener","showElement","setProperty","hideElement","destroyElement","isElementClosed","onResize","width","height","currentWidth","offsetWidth","currentHeight","offsetHeight","canceled","observer","check","getClientRects","isElementVisible","newWidth","newHeight","ResizeObserver","observe","MutationObserver","childList","subtree","characterData","disconnect","isShadowElement","currentScript","getCurrentScript","getStackTrace","stackDetails","exec","scriptLocation","getElementsByTagName","reverse","script","src","inferCurrentScript","currentUID","isPerc","test","toNum","toPx","toCSS","normalizeDimension","dim","max","getGlobal","globalKey","__POST_ROBOT__","getAttribute","ATTRIBUTES","hashedString","total","charCodeAt","abs","strHashStr","dataset","getObj","globalStore","defStore","store","storeKey","defVal","del","WildCard","getWildcard","global","WINDOW_WILDCARD","windowStore","winStore","getStore","getInstanceID","resolveHelloPromise","helloPromises","existingPromise","newPromise","sayHello","send","instanceID","data","getWindowInstanceID","awaitWindowHello","getHelloPromise","markWindowKnown","isSerializedType","__type__","determineType","serializeType","type","__val__","SERIALIZER","code","toJSON","defaultSerializers","DESERIALIZER","RegExp","defaultDeserializers","needsBridgeForBrowser","needsBridgeForWin","needsBridgeForDomain","needsBridge","getBridgeName","BRIDGE_NAME_PREFIX","isBridge","documentBodyReady","registerRemoteWindow","findRemoteWindow","remoteWinPromise","registerRemoteSendMessage","sendMessage","remoteWin","remoteDomain","fireAndForget","rejectRemoteSendMessage","linkWindow","popupWindowsByName","popupWindowsByWin","winName","details","setupBridge","windowOpen","on","receiveMessage","open","last","normalizeMockUrl","bridgePromise","bridge","getWindowDetails","listenForOpenTunnel","openTunnelToParent","canary","tunnelWindows","parentWindow","cleanTunnelWindows","addTunnelWindow","tunnelWindow","setupOpenTunnelToParent","openTunnelToOpener","cleanupProxyWindows","idToProxyWindow","shouldClean","getSerializedWindow","winPromise","windowNamePromise","windowTypePromise","getName","getType","focus","isClosed","setLocation","href","opts","form","display","input","submit","submitForm","setName","sameDomain","ProxyWindow","serializedWindow","isProxyWindow","actualWindow","actualWindowPromise","getID","setWindow","isPopup","isPopupPromise","getNamePromise","reopenPromise","focusPromise","getWindow","awaitWindow","matchWindow","proxyInstanceID","knownWindowInstanceID","unwrap","serialize","toProxyWindow","deserialize","addMethod","methodStore","proxyWindowMethods","lookupMethod","serializeFunction","destination","meth","methodSource","arg","__id__","serializeMessage","serializers","serializer","serializePromise","deserializeMessage","deserializers","parse","deserializer","serializedPromise","deserializePromise","serializedFunction","getDeserializedFunction","crossDomainFunctionWrapper","__origin__","__source__","deserializeFunction","SEND_MESSAGE_STRATEGIES","domainBuffer","buffer","serializedMessage","strategies","errors","strategyName","getResponseListener","deleteResponseListener","isResponseListenerErrored","getRequestListener","requestListeners","winQualifier","nameListeners","domainListeners","listener","regex","handleRequest","logName","sendResponse","ack","pathname","handleError","handleAck","handleResponse","receivedMessages","messages","parsedMessage","parseMessages","deserializeMessages","requestListener","addRequestListener","winCandidate","requestListenerPromise","actualWin","listenersCollection","existingListener","strDomain","winNameDomainRegexListeners","winNameDomainRegexListener","winNameListeners","winNameDomainListeners","errorHandler","postMessage","messagingChild","messagingParent","sendBridgeMessage","foreignGlobal","winOrProxyWin","domainMatcher","responseTimeout","childTimeout","validateOptions","actualParent","isAncestor","targetDomain","actualDomain","normalizedDomain","normalizeDomain","responseListener","addResponseListener","reqPromises","markResponseListenerErrored","totalAckTimeout","isWindowKnown","totalResTimeout","ackTimeout","resTimeout","cancelled","cleanUpWindow","openBridge","bridges","bridgeFrames","openBridgeFrame","linkUrl","hasBridge","destroyBridges","getDistanceFromTop","distance","onCloseWindow","callback","maxtime","Infinity","tryGlobal","getProxyObject","basicSerialize","getUIDRefStore","references","crossDomainSerialize","metaData","sender","receiver","passByReference","basic","proxyWin","internalSerializeMessage","reference","getRawRef","serializedData","cleanReference","ref","crossDomainDeserialize","atob","base64decode","basicDeserialize","getRefValue","internalDeserializeMessage","PROP_TYPE","STRING","OBJECT","FUNCTION","BOOLEAN","NUMBER","ARRAY","PROP_SERIALIZATION","DOTIFY","BASE64","CONTEXT","IFRAME","POPUP","EVENT","RENDER","RENDERED","DISPLAY","ERROR","CLOSE","DESTROY","PROPS","RESIZE","FOCUS","buildChildWindowName","serializedPayload","parseWindowName","windowName","zoidcomp","serializedInitialPayload","parseInitialParentPayload","windowRef","getNthParent","ancestor","windows","findChildFrameByName","namedFrame","findFrameByName","getWindowByRef","payload","getInitialParentPayload","getWindowRef","targetWindow","currentWindow","normalizeChildProp","propsDef","helpers","prop","childDecorate","onProps","resize","getParentDomain","show","hide","export","getSiblings","destroy","defaultNoop","decorateOnce","eachProp","serializeProps","propDef","getParam","queryParam","bodyParam","getValue","queryValue","bodyValue","finalParam","finalValue","serialization","dotify","prefix","newobj","every","dotkey","mapProps","parentComponent","triggered","emitter","currentProxyWin","currentProxyContainer","childComponent","currentChildDomain","currentContainer","overrides","parentWin","containerTemplate","prerenderTemplate","dimensions","autoResize","domainMatch","xports","initPromise","handledErrors","clean","state","inputProps","internalState","visible","eventName","handlerList","trigger","triggerOnce","onErrorOverride","getProxyContainerOverride","getProxyContainer","showOverride","hideOverride","closeOverride","renderContainerOverride","renderContainer","getProxyWindowOverride","getProxyWindow","setProxyWinOverride","setProxyWin","openFrameOverride","openFrame","openPrerenderFrameOverride","openPrerenderFrame","prerenderOverride","prerender","openOverride","openPrerenderOverride","openPrerender","watchForUnloadOverride","watchForUnload","getInternalStateOverride","getInternalState","setInternalStateOverride","setInternalState","getDimensions","resolveInitPromise","rejectInitPromise","getPropsForChild","initialChildDomain","sendToChild","newInternalState","windowProp","setState","getUrl","getAttributes","getInitialChildDomain","title","proxyPrerenderFrame","prerenderFrame","prerenderFrameWindow","actualComponentWindow","initChild","childDomain","childExports","proxyFrame","outerWidth","closeOnUnload","left","round","screenX","screen","outerHeight","screenY","status","toolbar","menubar","resizable","scrollbars","popup","unloadWindowListener","closeParentWindowListener","checkWindowClose","secondIsClosed","exportsPromise","xport","actualExports","renderTemplate","renderer","proxyPrerenderWin","prerenderWindow","isBlankDomain","tagName","children","writeElementToWindow","prerenderResizeListener","proxyContainer","rerender","innerContainer","containerWatcher","sacrificialFrame","sacrificialFrameWin","mutationObservers","elementClosed","mutationElement","mutationObserver","frameWin","watchElementForClose","removeError","getHelpers","updateProps","setProps","newInputProps","existingProps","valueDetermined","alias","default","required","decorate","getDerivedValue","extendProps","newProps","childProps","containerElement","insertShadowSlot","shadowHost","shadowRoot","getShadowRoot","getShadowHost","slotName","slot","slotProvider","init","onRender","onDisplay","onRendered","onClose","onDestroy","onFocus","render","childDomainMatch","checkAllowRender","delegatePromise","delegateProps","propName","allowDelegate","childOverridesPromise","POST_MESSAGE","parentComp","getDelegateOverrides","childOverrides","delegate","watchForUnloadPromise","buildBodyPromise","onRenderPromise","getProxyContainerPromise","getProxyWindowPromise","finalSetPropsPromise","buildUrlPromise","query","originalUrl","originalHash","hashString","extendUrl","buildWindowNamePromise","version","__ZOID__","checkClose","buildInitialChildPayload","childPayload","buildSerializedChildPayload","openFramePromise","openPrerenderFramePromise","renderContainerPromise","openPromise","openPrerenderPromise","setStatePromise","prerenderPromise","setWindowNamePromise","getMethodPromise","loadUrlPromise","windowUrl","watchForClosePromise","watchForClose","onDisplayPromise","openBridgePromise","bridgeUrl","bridgeDomain","runTimeoutPromise","onRenderedPromise","getProps","getExports","defaultContainerTemplate","div","cspNonce","classList","add","remove","defaultPrerenderTemplate","spinner","cleanInstances","cleanZoid","component","allowDelegateListener","delegateListener","allowedParentDomains","defaultContext","validate","eligible","logger","info","xportsDefinition","valuePromise","normalizeOptions","instances","isChild","isChildComponentWindow","registerChild","xprops","components","onPropHandlers","parentComponentWindow","parentDomain","parentExports","initialProps","parentExport","parentResize","parentInit","anyParent","currentParent","winParent","isUpdate","normalizedProps","normalizeChildProps","componentName","updateChildWindowNameWithRef","checkParentDomain","ZOID","eligibility","reason","clone","getDefaultContext","finalContext","getDefaultContainer","newInstance","renderTo","childComponents","childName","Child","childInputProps","parentProps","getChildren","isEligible","driver","driverName","dep","canRenderTo","initialized","sourceElement","originalEvent","messageListener","listenForMessages","initHello","comp","destroyComponents","destroyPromise","destroyAll","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 _setPrototypeOf(o, p) {\n  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {\n    o.__proto__ = p;\n    return o;\n  };\n\n  return _setPrototypeOf(o, p);\n}","import setPrototypeOf from \"@babel/runtime/helpers/esm/setPrototypeOf\";\nexport default function _inheritsLoose(subClass, superClass) {\n  subClass.prototype = Object.create(superClass.prototype);\n  subClass.prototype.constructor = subClass;\n  setPrototypeOf(subClass, superClass);\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        const toString = ({}).toString;\n\n        if (toString) {\n            const 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    const 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    // eslint-disable-next-line flowtype/no-mutable-array\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            const 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        const { 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            const { 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                const promiseResult : ZalgoPromise<*> = result;\n\n                if (promiseResult.resolved) {\n                    promise.resolve(promiseResult.value);\n                } else {\n                    promise.reject(promiseResult.error);\n                }\n\n                promiseResult.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, Y>(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        const promise = 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, Y>(onError : (error : mixed) => ZalgoPromise<X> | Y) : ZalgoPromise<X | Y> {\n        // $FlowFixMe incompatible-call\n        const resultPromise : ZalgoPromise<X | Y> = this.then(undefined, onError);\n        return resultPromise;\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        const 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    lazy() : ZalgoPromise<R> {\n        this.errorHandled = true;\n        return this;\n    }\n\n    static resolve<X, Y>(value : ZalgoPromise<X> | Y) : ZalgoPromise<X | Y> {\n\n        if (value instanceof ZalgoPromise) {\n            // $FlowFixMe incompatible-type-arg\n            const result : ZalgoPromise<X | Y> = value;\n            return result;\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 : $ReadOnlyArray<mixed>>(promises : X) : ZalgoPromise<$TupleMap<X, <Y>(ZalgoPromise<Y> | Y) => Y>> { // eslint-disable-line no-undef\n\n        const promise = new ZalgoPromise();\n        let count = promises.length;\n        // eslint-disable-next-line no-undef\n        const results = ([] : $TupleMap<X, <Y>(ZalgoPromise<Y> | Y) => Y>).slice();\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            const 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        const result = {};\n        const awaitPromises = [];\n\n        for (const key in promises) {\n            if (promises.hasOwnProperty(key)) {\n                const value = promises[key];\n\n                if (isPromise(value)) {\n                    awaitPromises.push(value.then(res => {\n                        result[key] = res;\n                    }));\n                } else {\n                    result[key] = value;\n                }\n            }\n        }\n        \n        return ZalgoPromise.all(awaitPromises).then(() => result);\n    }\n\n    static map<T, X>(items : $ReadOnlyArray<T>, method : (T) => (ZalgoPromise<X> | X)) : ZalgoPromise<$ReadOnlyArray<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, Y, C : mixed, A : $ReadOnlyArray<mixed>>(method : (...args : $ReadOnlyArray<mixed>) => (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 : ZalgoPromise<X> | Y;\n\n        startActive();\n        \n        try {\n            result = method.apply(context, args || []);\n        } catch (err) {\n            endActive();\n            return ZalgoPromise.reject(err);\n        }\n\n        endActive();\n\n        // $FlowFixMe incompatible-call\n        const resultPromise = ZalgoPromise.resolve(result);\n\n        return resultPromise;\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    // $FlowFixMe method-unbinding\n    return Object.prototype.toString.call(item) === '[object RegExp]';\n}\n\n// eslint-disable-next-line no-unused-vars\nexport function noop(...args : $ReadOnlyArray<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\nconst IE_WIN_ACCESS_ERROR = 'Call was rejected by callee.\\r\\n';\n\nexport function getActualProtocol(win : SameDomainWindowType = window) : ?string {\n    return win.location.protocol;\n}\n\nexport function getProtocol(win : SameDomainWindowType = window) : ?string {\n    if (win.mockDomain) {\n        const protocol = win.mockDomain.split('//')[0];\n\n        if (protocol) {\n            return protocol;\n        }\n    }\n\n    return getActualProtocol(win);\n}\n\nexport function isFileProtocol(win : SameDomainWindowType = window) : boolean {\n    return getProtocol(win) === PROTOCOL.FILE;\n}\n\nexport function isAboutProtocol(win : SameDomainWindowType = window) : boolean {\n    return getProtocol(win) === PROTOCOL.ABOUT;\n}\n\nexport function isMockProtocol(win : SameDomainWindowType = window) : boolean {\n    return getProtocol(win) === PROTOCOL.MOCK;\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    const location = win.location;\n\n    if (!location) {\n        throw new Error(`Can not read window location`);\n    }\n\n    const protocol = getActualProtocol(win);\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        const parent = getParent(win);\n        if (parent && canReadFromWindow(parent)) {\n            // $FlowFixMe\n            return getActualDomain(parent);\n        }\n\n        return `${ PROTOCOL.ABOUT }//`;\n    }\n\n    const 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    const 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        const 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 (isMockProtocol(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        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) : $ReadOnlyArray<CrossDomainWindowType> {\n\n    const 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    const 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) : $ReadOnlyArray<CrossDomainWindowType> {\n\n    const 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) : $ReadOnlyArray<CrossDomainWindowType> {\n\n    const result = [];\n\n    for (const frame of getFrames(win)) {\n        result.push(frame);\n\n        for (const 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 (const 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    const opener = getNextOpener(win);\n\n    if (opener) {\n        return getUltimateTop(opener);\n    }\n\n    return top;\n}\n\nexport function getAllFramesInWindow(win : CrossDomainWindowType) : $ReadOnlyArray<CrossDomainWindowType> {\n    const top = getTop(win);\n\n    if (!top) {\n        throw new Error(`Can not determine top window`);\n    }\n\n    let result = [ ...getAllChildFrames(top), top ];\n\n    // Win may be in shadow dom\n    if (result.indexOf(win) === -1) {\n        result = [ ...result, win, ...getAllChildFrames(win) ];\n    }\n\n    return result;\n}\n\nexport function getAllWindows(win? : CrossDomainWindowType = window) : $ReadOnlyArray<CrossDomainWindowType> {\n    const frames = getAllFramesInWindow(win);\n    const 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    const doc = frame.ownerDocument;\n\n    if (doc && doc.documentElement && !doc.documentElement.contains(frame)) {\n        let parent = frame;\n\n        while (parent.parentNode && parent.parentNode !== parent) {\n            parent = parent.parentNode;\n        }\n\n        // $FlowFixMe\n        if (!parent.host || !doc.documentElement.contains(parent.host)) {\n            return true;\n        }\n    }\n\n    return false;\n}\n\nfunction safeIndexOf<T>(collection : $ReadOnlyArray<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\nconst iframeWindows = [];\nconst 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    const iframeIndex = safeIndexOf(iframeWindows, win);\n\n    if (iframeIndex !== -1) {\n        const 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    const winFrames = getFrames(win);\n\n    for (const 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    const frame = getFrameByName(win, name);\n\n    if (frame) {\n        return frame;\n    }\n\n    for (const childFrame of getFrames(win)) {\n        const namedFrame = findChildFrameByName(childFrame, name);\n\n        if (namedFrame) {\n            return namedFrame;\n        }\n    }\n}\n\nexport function findFrameByName(win : CrossDomainWindowType, name : string) : ?CrossDomainWindowType {\n    const frame = getFrameByName(win, name);\n\n    if (frame) {\n        return frame;\n    }\n\n    const top = getTop(win) || win;\n\n    return findChildFrameByName(top, name);\n}\n\nexport function isParent(win : CrossDomainWindowType, frame : CrossDomainWindowType) : boolean {\n\n    const frameParent = getParent(frame);\n\n    if (frameParent) {\n        return frameParent === win;\n    }\n\n    for (const 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    const opener = getOpener(win);\n\n    if (opener) {\n        return opener;\n    }\n\n    const parent = getParent(win);\n\n    if (parent) {\n        return parent;\n    }\n}\n\nexport function getAncestors(win : CrossDomainWindowType) : $ReadOnlyArray<CrossDomainWindowType> {\n\n    const 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    const 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 (const 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 (const item1 of collection1) {\n        for (const 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    const top1 = getTop(win1) || win1;\n    const 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    const allFrames1 = getAllFramesInWindow(win1);\n    const allFrames2 = getAllFramesInWindow(win2);\n\n    if (anyMatch(allFrames1, allFrames2)) {\n        return true;\n    }\n\n    const opener1 = getOpener(top1);\n    const 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    const 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        // $FlowFixMe method-unbinding\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    try {\n        if ('postMessage' in obj && 'self' in obj && 'location' in obj) {\n            return true;\n        }\n    } catch (err) {\n        // pass\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 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\nexport function closeWindow(win : CrossDomainWindowType) {\n    if (isIframe(win)) {\n        const frame = getFrameForWindow(win);\n        if (frame && frame.parentElement) {\n            frame.parentElement.removeChild(frame);\n            return;\n        }\n    }\n\n    try {\n        win.close();\n    } catch (err) {\n        // pass\n    }\n}\n","/* @flow */\n\nexport function safeIndexOf<T>(collection : $ReadOnlyArray<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 : $ReadOnlyArray<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    // eslint-disable-next-line flowtype/no-mutable-array\n    keys : Array<K>\n    // eslint-disable-next-line flowtype/no-mutable-array\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        const weakmap = this.weakmap;\n        const keys = this.keys;\n\n        for (let i = 0; i < keys.length; i++) {\n            const 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        const 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                const name = this.name;\n                const 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        const keys = this.keys;\n        const values = this.values;\n        const 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        const 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                const 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        const keys = this.keys;\n        const 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        const 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                const 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        const keys = this.keys;\n        const 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        const 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                const 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        const 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        const value = getter();\n        this.set(key, value);\n        return value;\n    }\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 isElement(element : mixed) : boolean {\n    let passed = false;\n\n    try {\n        if (element instanceof window.Element) {\n            passed = true;\n        } else if (element !== null && typeof element === 'object' && element.nodeType === 1 && typeof element.style === 'object' && typeof element.ownerDocument === 'object') {\n            passed = true;\n        }\n    } catch (_) {\n        // we don't have an element\n    }\n\n    return passed;\n}\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        })).replace(/[=]/g, '');\n    }\n\n    if (typeof Buffer !== 'undefined') {\n        return Buffer.from(str, 'utf8').toString('base64').replace(/[=]/g, '');\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        // $FlowFixMe[method-unbinding]\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    const chars = '0123456789abcdef';\n\n    const randomID = 'xxxxxxxxxx'.replace(/./g, () => {\n        return chars.charAt(Math.floor(Math.random() * chars.length));\n    });\n\n    const timeID = base64encode(\n        new Date().toISOString().slice(11, 19).replace('T', '.')\n    ).replace(/[^a-zA-Z0-9]/g, '').toLowerCase();\n\n    return `uid_${ 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 : $ReadOnlyArray<T>) : string {\n    try {\n        // $FlowFixMe[method-unbinding]\n        return JSON.stringify(Array.prototype.slice.call(args), (subkey, val) => {\n\n            // Treat each distinct function as unique for purposes of memoization\n            // e.g. even if someFunction.stringify() is the same, we may use a different memoize cache\n            // if the actual function is different.\n            if (typeof val === 'function') {\n                return `memoize[${ getObjectID(val) }]`;\n            }\n\n            // By default JSON.stringify(domElement) returns '{}'. This ensures that stays true even for non-standard\n            // elements (e.g. React-rendered dom elements) with custom properties\n            if (isElement(val)) {\n                return {};\n            }\n\n            return val;\n        });\n    } catch (err) {\n        throw new Error(`Arguments not serializable -- can not be used to memoize`);\n    }\n}\n\nexport function getEmptyObject() : {||} {\n    // $FlowFixMe\n    return {};\n}\n\ntype MemoizeOptions = {|\n    name? : string,\n    time? : number,\n    thisNamespace? : boolean\n|};\n\nconst getDefaultMemoizeOptions = () : MemoizeOptions => {\n    // $FlowFixMe\n    return {};\n};\n\nexport type Memoized<F> = F & {| reset : () => void |};\n\nlet memoizeGlobalIndex = 0;\nlet memoizeGlobalIndexValidFrom = 0;\n\nexport function memoize<F : Function>(method : F, options? : MemoizeOptions = getDefaultMemoizeOptions()) : Memoized<F> {\n    const { thisNamespace = false, time: cacheTime } = options;\n\n    let simpleCache;\n    let thisCache;\n\n    let memoizeIndex = memoizeGlobalIndex;\n    memoizeGlobalIndex += 1;\n\n    const memoizedFunction = function memoizedFunction(...args) : mixed {\n        if (memoizeIndex < memoizeGlobalIndexValidFrom) {\n            simpleCache = null;\n            thisCache = null;\n            memoizeIndex = memoizeGlobalIndex;\n            memoizeGlobalIndex += 1;\n        }\n\n        let cache;\n\n        if (thisNamespace) {\n            thisCache = thisCache || new WeakMap();\n            cache = thisCache.getOrSet(this, getEmptyObject);\n        } else {\n            cache = simpleCache = simpleCache || {};\n        }\n\n        let cacheKey;\n\n        try {\n            cacheKey = serializeArgs(args);\n        } catch {\n            return method.apply(this, arguments);\n        }\n\n        let cacheResult = cache[cacheKey];\n\n        if (cacheResult && cacheTime && (Date.now() - cacheResult.time) < cacheTime) {\n            delete cache[cacheKey];\n            cacheResult = null;\n        }\n\n        if (cacheResult) {\n            return cacheResult.value;\n        }\n\n        const time  = Date.now();\n        const value = method.apply(this, arguments);\n\n        cache[cacheKey] = { time, value };\n\n        return value;\n    };\n\n    memoizedFunction.reset = () => {\n        simpleCache = null;\n        thisCache = null;\n    };\n\n    // $FlowFixMe\n    const result : F = memoizedFunction;\n\n    return setFunctionName(result, `${ options.name || getFunctionName(method) }::memoized`);\n}\n\nmemoize.clear = () => {\n    memoizeGlobalIndexValidFrom = memoizeGlobalIndex;\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 : $ReadOnlyArray<any>) => ZalgoPromise<R>) : ((...args : $ReadOnlyArray<any>) => ZalgoPromise<R>) {\n    let cache = {};\n\n    // eslint-disable-next-line flowtype/no-weak-types\n    function memoizedPromiseFunction(...args : $ReadOnlyArray<any>) : ZalgoPromise<R> {\n        const 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\ntype PromisifyOptions = {|\n    name ? : string\n|};\n\nconst getDefaultPromisifyOptions = () : PromisifyOptions => {\n    // $FlowFixMe\n    return {};\n};\n\n// eslint-disable-next-line flowtype/no-weak-types\nexport function promisify<R>(method : (...args : $ReadOnlyArray<any>) => R, options : PromisifyOptions = getDefaultPromisifyOptions()) : ((...args : $ReadOnlyArray<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 : $ReadOnlyArray<any>) => R, logic : (...args : $ReadOnlyArray<any>) => R, args : $ReadOnlyArray<any> = []) : R {\n    // $FlowFixMe\n    const cache : {| [string] : R |} = method.__inline_memoize_cache__ = method.__inline_memoize_cache__ || {};\n    const key = serializeArgs(args);\n\n    if (cache.hasOwnProperty(key)) {\n        return cache[key];\n    }\n\n    const result = cache[key] = logic(...args);\n\n    return result;\n}\n\n// eslint-disable-next-line no-unused-vars\nexport function noop(...args : $ReadOnlyArray<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    const 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() : T {\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            // $FlowFixMe[method-unbinding]\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            const stack = err && err.stack;\n            const 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        // $FlowFixMe[method-unbinding]\n        return Object.prototype.toString.call(err);\n\n    } catch (newErr) {\n        return `Error while stringifying error: ${ stringifyError(newErr, level + 1) }`;\n    }\n}\n\nexport function stringifyErrorMessage(err : mixed) : string {\n\n    // $FlowFixMe[method-unbinding]\n    const 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    // $FlowFixMe[method-unbinding]\n    return Object.prototype.toString.call(item);\n}\n\nexport function domainMatches(hostname : string, domain : string) : boolean {\n    hostname = hostname.split('://')[1];\n    const index = hostname.indexOf(domain);\n    return (index !== -1 && hostname.slice(index) === domain);\n}\n\nexport function patchMethod(obj : Object, name : string, handler : Function) {\n    const original = obj[name];\n\n    obj[name] = function patchedMethod() : mixed {\n        return handler({\n            context:      this,\n            // $FlowFixMe[method-unbinding]\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 (const 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 }) : $ReadOnlyArray<T> {\n    if (Object.values) {\n        // $FlowFixMe\n        return Object.values(obj);\n    }\n\n    const result : Array<T> = [];\n    for (const key in obj) {\n        if (obj.hasOwnProperty(key)) {\n            // $FlowFixMe[escaped-generic]\n            result.push(obj[key]);\n        }\n    }\n\n    // $FlowFixMe\n    return result;\n}\n\n// eslint-disable-next-line no-undef\nexport const memoizedValues : <T>({ [string] : T }) => $ReadOnlyArray<T> = memoize(values);\n\nexport function perc(pixels : number, percentage : number) : number {\n    return Math.round((pixels * percentage) / 100);\n}\n\nexport function min(...args : $ReadOnlyArray<number>) : number {\n    return Math.min(...args);\n}\n\nexport function max(...args : $ReadOnlyArray<number>) : number {\n    return Math.max(...args);\n}\n\nexport function roundUp(num : number, nearest : number) : number {\n    const remainder = num % nearest;\n    return remainder\n        ? (num - remainder) + nearest\n        : num;\n}\n\nexport function regexMap<T>(str : string, regexp : RegExp, handler : () => T) : $ReadOnlyArray<T> {\n    const 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    const result = {};\n\n    for (const 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) : $ReadOnlyArray<string> {\n    const 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        const 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 (const 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    const 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, -2);\n            value = value.split(',').map(deserializePrimitive);\n        } else {\n            value = deserializePrimitive(value);\n        }\n\n        let keyResult = result;\n        const parts = key.split('.');\n        for (let i = 0; i < parts.length; i++) {\n            const part = parts[i];\n            const isLast = (i + 1 === parts.length);\n            const 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    const triggered = {};\n    let handlers = {};\n\n    const emitter = {\n\n        on(eventName : string, handler : Function) : CancelableType {\n            const 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            const listener = emitter.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            const handlerList = handlers[eventName];\n            const promises = [];\n\n            if (handlerList) {\n                for (const 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 emitter.trigger(eventName, ...args);\n        },\n\n        reset() {\n            handlers = {};\n        }\n    };\n\n    return emitter;\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    const 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    const 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 | $ReadOnlyArray<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            const 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>) : $ReadOnlyArray<T> { // eslint-disable-line no-undef\n    // $FlowFixMe[method-unbinding]\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    // $FlowFixMe[method-unbinding]\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    const constructor = obj.constructor;\n\n    if (typeof constructor !== 'function') {\n        return false;\n    }\n\n    const 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 : $ReadOnlyArray<mixed> | Object> (item : T, replacer : (mixed, string | number, string) => mixed, fullKey : string = '') : T {\n\n    if (Array.isArray(item)) {\n        const length = item.length;\n        const result : Array<mixed> = [];\n\n        for (let i = 0; i < length; i++) {\n\n\n            defineLazyProp(result, i, () => {\n                const itemKey = fullKey ? `${ fullKey }.${ i }` : `${ i }`;\n                const 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        const result = {};\n\n        for (const key in item) {\n            if (!item.hasOwnProperty(key)) {\n                continue;\n            }\n\n            defineLazyProp(result, key, () => {\n                const itemKey = fullKey ? `${ fullKey }.${ key }` : `${ key }`;\n                // $FlowFixMe\n                const 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        const 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 : $ReadOnlyArray<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    const result = string.slice(start).match(pattern);\n\n    if (!result) {\n        return;\n    }\n\n    // $FlowFixMe\n    const index : number = result.index;\n    const 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) : $ReadOnlyArray<RegexResultType> {\n\n    const matches = [];\n    let start = 0;\n\n    // eslint-disable-next-line no-constant-condition\n    while (true) {\n        const 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 : $ReadOnlyArray<mixed>) => T, time : number = 100) : (...args : $ReadOnlyArray<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    // $FlowFixMe[method-unbinding]\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 const weakMapMemoize : FunctionProxy<*> = <R : mixed>(method : (arg : any) => R) : ((...args : $ReadOnlyArray<any>) => R) => {\n\n    const 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 const weakMapMemoizePromise : FunctionPromiseProxy<*, *> = <R : mixed>(method : (arg : any) => ZalgoPromise<R>) : ((...args : $ReadOnlyArray<any>) => ZalgoPromise<R>) => {\n\n    const 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\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) => {| cancel : () => void |},\n    all : (err? : mixed) => ZalgoPromise<void>\n|};\n\nexport function cleanup(obj : Object) : CleanupType {\n\n    const tasks = [];\n    let cleaned = false;\n    let cleanErr;\n\n    const cleaner = {\n        set<T : mixed>(name : string, item : T) : T {\n            if (!cleaned) {\n                obj[name] = item;\n                cleaner.register(() => {\n                    delete obj[name];\n                });\n            }\n            return item;\n        },\n\n        register(method : Function) : {| cancel : () => void |} {\n            const task = once(() => method(cleanErr));\n\n            if (cleaned) {\n                method(cleanErr);\n            } else {\n                tasks.push(task);\n            }\n\n            return {\n                cancel: () => {\n                    const index = tasks.indexOf(task);\n                    if (index !== -1) {\n                        tasks.splice(index, 1);\n                    }\n                }\n            };\n        },\n\n        all(err? : mixed) : ZalgoPromise<void> {\n            cleanErr = err;\n\n            const results = [];\n            cleaned = true;\n\n            while (tasks.length) {\n                const task = tasks.shift();\n                results.push(task());\n            }\n\n            return ZalgoPromise.all(results).then(noop);\n        }\n    };\n\n    return cleaner;\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\n// eslint-disable-next-line flowtype/no-mutable-array\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        result[item] = true;\n    }\n    return Object.keys(result);\n}\n\nexport const constHas = <X : (string | boolean | number), T : { [string] : X }>(constant : T, value : X) : boolean => {\n    return memoizedValues(constant).indexOf(value) !== -1;\n};\n\nexport function dedupeErrors<T>(handler : (mixed) => T) : (mixed) => (T | void) {\n    const seenErrors = [];\n    const seenStringifiedErrors = {};\n\n    return (err) => {\n        if (seenErrors.indexOf(err) !== -1) {\n            return;\n        }\n\n        seenErrors.push(err);\n\n        const stringifiedError = stringifyError(err);\n        if (seenStringifiedErrors[stringifiedError]) {\n            return;\n        }\n\n        seenStringifiedErrors[stringifiedError] = true;\n        return handler(err);\n    };\n}\n\nexport class ExtendableError extends Error {\n    constructor(message : string) {\n        super(message);\n        // eslint-disable-next-line unicorn/custom-error-definition\n        this.name = this.constructor.name;\n        if (typeof Error.captureStackTrace === 'function') {\n            Error.captureStackTrace(this, this.constructor);\n        } else {\n            this.stack = (new Error(message)).stack;\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        const testWeakMap = new WeakMap();\n        const testKey = {};\n        const 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","export default function _getPrototypeOf(o) {\n  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {\n    return o.__proto__ || Object.getPrototypeOf(o);\n  };\n  return _getPrototypeOf(o);\n}","export default function _isNativeReflectConstruct() {\n  if (typeof Reflect === \"undefined\" || !Reflect.construct) return false;\n  if (Reflect.construct.sham) return false;\n  if (typeof Proxy === \"function\") return true;\n\n  try {\n    Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));\n    return true;\n  } catch (e) {\n    return false;\n  }\n}","import setPrototypeOf from \"@babel/runtime/helpers/esm/setPrototypeOf\";\nimport isNativeReflectConstruct from \"@babel/runtime/helpers/esm/isNativeReflectConstruct\";\nexport default function _construct(Parent, args, Class) {\n  if (isNativeReflectConstruct()) {\n    _construct = Reflect.construct;\n  } else {\n    _construct = function _construct(Parent, args, Class) {\n      var a = [null];\n      a.push.apply(a, args);\n      var Constructor = Function.bind.apply(Parent, a);\n      var instance = new Constructor();\n      if (Class) setPrototypeOf(instance, Class.prototype);\n      return instance;\n    };\n  }\n\n  return _construct.apply(null, arguments);\n}","import getPrototypeOf from \"@babel/runtime/helpers/esm/getPrototypeOf\";\nimport setPrototypeOf from \"@babel/runtime/helpers/esm/setPrototypeOf\";\nimport isNativeFunction from \"@babel/runtime/helpers/esm/isNativeFunction\";\nimport construct from \"@babel/runtime/helpers/esm/construct\";\nexport default function _wrapNativeSuper(Class) {\n  var _cache = typeof Map === \"function\" ? new Map() : undefined;\n\n  _wrapNativeSuper = function _wrapNativeSuper(Class) {\n    if (Class === null || !isNativeFunction(Class)) return Class;\n\n    if (typeof Class !== \"function\") {\n      throw new TypeError(\"Super expression must either be null or a function\");\n    }\n\n    if (typeof _cache !== \"undefined\") {\n      if (_cache.has(Class)) return _cache.get(Class);\n\n      _cache.set(Class, Wrapper);\n    }\n\n    function Wrapper() {\n      return construct(Class, arguments, getPrototypeOf(this).constructor);\n    }\n\n    Wrapper.prototype = Object.create(Class.prototype, {\n      constructor: {\n        value: Wrapper,\n        enumerable: false,\n        writable: true,\n        configurable: true\n      }\n    });\n    return setPrototypeOf(Wrapper, Class);\n  };\n\n  return _wrapNativeSuper(Class);\n}","export default function _isNativeFunction(fn) {\n  return Function.toString.call(fn).indexOf(\"[native code]\") !== -1;\n}","export default function _assertThisInitialized(self) {\n  if (self === void 0) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n\n  return self;\n}","/* @flow */\n/* eslint max-lines: off */\nimport { ZalgoPromise } from 'zalgo-promise/src';\nimport { linkFrameWindow, isWindowClosed, assertSameDomain,\n    type SameDomainWindowType, type CrossDomainWindowType } from 'cross-domain-utils/src';\nimport { WeakMap } from 'cross-domain-safe-weakmap/src';\n\nimport { isElement, inlineMemoize, memoize, noop, stringify, capitalizeFirstLetter,\n    once, extend, safeInterval, uniqueID, arrayFrom, ExtendableError, strHashStr } from './util';\nimport { isDevice } from './device';\nimport { KEY_CODES, ATTRIBUTES, UID_HASH_LENGTH } from './constants';\nimport type { CancelableType } from './types';\n\ntype ElementRefType = string | HTMLElement;\n\nexport function getBody() : HTMLBodyElement {\n    // eslint-disable-next-line compat/compat\n    const body = document.body;\n\n    if (!body) {\n        throw new Error(`Body element not found`);\n    }\n\n    return body;\n}\n\nexport function isDocumentReady() : boolean {\n    // eslint-disable-next-line compat/compat\n    return Boolean(document.body) && (document.readyState === 'complete');\n}\n\nexport function isDocumentInteractive() : boolean {\n    // eslint-disable-next-line compat/compat\n    return Boolean(document.body) && (document.readyState === 'interactive');\n}\n\nexport function urlEncode(str : string) : string {\n    return encodeURIComponent(str);\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\ntype WaitForDocumentReady = () => ZalgoPromise<void>;\n\nexport const waitForDocumentReady : WaitForDocumentReady = memoize(() => {\n    return new ZalgoPromise(resolve => {\n\n        if (isDocumentReady() || isDocumentInteractive()) {\n            return resolve();\n        }\n\n        const interval = setInterval(() => {\n            if (isDocumentReady() || isDocumentInteractive()) {\n                clearInterval(interval);\n                return resolve();\n            }\n        }, 10);\n    });\n});\n\nexport function waitForDocumentBody() : ZalgoPromise<HTMLBodyElement> {\n    return ZalgoPromise.try(() => {\n        if (document.body) {\n            return document.body;\n        }\n\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}\n\nexport function parseQuery(queryString : string) : Object {\n    return inlineMemoize(parseQuery, () : Object => {\n        const 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 type Query = {\n    [ string ] : boolean | string\n};\n\nexport function formatQuery(obj : Query = {}) : string {\n\n    return Object.keys(obj).filter(key => {\n        return typeof obj[key] === 'string' || typeof obj[key] === 'boolean';\n    }).map(key => {\n        const val = obj[key];\n\n        if (typeof val !== 'string' && typeof val !== 'boolean') {\n            throw new TypeError(`Invalid type for query`);\n        }\n\n        return `${ urlEncode(key) }=${ urlEncode(val.toString()) }`;\n    }).join('&');\n}\n\nexport function extendQuery(originalQuery : string, props : Query = {}) : 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? : Query, hash? : Query |}) : string {\n\n    const query = options.query || {};\n    const 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    const queryString = extendQuery(originalQuery, query);\n    const 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    const 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 getPerformance() : ?Performance {\n    return inlineMemoize(getPerformance, () : ?Performance => {\n        const performance = window.performance;\n\n        if (\n            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            return performance;\n        }\n    });\n}\n\nexport function enablePerformance() : boolean {\n    return Boolean(getPerformance());\n}\n\nexport function getPageRenderTime() : ZalgoPromise<?number> {\n    return waitForDocumentReady().then(() => {\n        const performance = getPerformance();\n\n        if (!performance) {\n            return;\n        }\n\n        const timing = 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') && window.location !== undefined;\n}\n\nexport function querySelectorAll(selector : string, doc : HTMLElement = window.document) : $ReadOnlyArray<HTMLElement> {\n    // $FlowFixMe[method-unbinding]\n    return Array.prototype.slice.call(doc.querySelectorAll(selector));\n}\n\nexport function onClick(element : HTMLElement, handler : (Event) => void) {\n    element.addEventListener('touchstart', noop);\n    element.addEventListener('click', handler);\n    element.addEventListener('keypress', (event : Event) => {\n        // $FlowFixMe\n        if (event.keyCode === KEY_CODES.ENTER || event.keyCode === KEY_CODES.SPACE) {\n            return handler(event);\n        }\n    });\n}\n\nexport function getScript({ host = window.location.host, path, reverse = false } : {| host? : string, path : string, reverse? : boolean |}) : ?HTMLScriptElement {\n    return inlineMemoize(getScript, () : ?HTMLScriptElement => {\n\n        const url = `${ host }${ path }`;\n        // $FlowFixMe[method-unbinding]\n        const scripts = Array.prototype.slice.call(document.getElementsByTagName('script'));\n\n        if (reverse) {\n            scripts.reverse();\n        }\n\n        for (const script of scripts) {\n            if (!script.src) {\n                continue;\n            }\n\n            const 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                const value = Math.random().toString();\n                window.localStorage.setItem('__test__localStorage__', value);\n                const 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() : $ReadOnlyArray<{| country? : string, lang : string |}> {\n    const nav = window.navigator;\n\n    const locales = nav.languages\n        ? [ ...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            const [ 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 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    const 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<HTMLElement> {\n    return new ZalgoPromise((resolve, reject) => {\n\n        const 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        const interval = setInterval(() => {\n\n            el = getElementSafe(id);\n\n            if (el) {\n                resolve(el);\n                clearInterval(interval);\n                return;\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\n// eslint-disable-next-line unicorn/custom-error-definition\nexport class PopupOpenError extends ExtendableError {}\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    closeOnUnload? : 0 | 1\n|};\n\nexport function popup(url : string, options? : PopupOptions) : CrossDomainWindowType {\n\n    // $FlowFixMe\n    options = options || {};\n\n    const { closeOnUnload = 1, name = '', 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    delete options.closeOnUnload;\n    delete options.name;\n\n    if (width && height) {\n        // $FlowFixMe\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    // eslint-disable-next-line array-callback-return\n    const 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);\n    } catch (err) {\n        throw new PopupOpenError(`Can not open popup window - ${ err.stack || err.message }`);\n    }\n\n    if (isWindowClosed(win)) {\n        const err = new PopupOpenError(`Can not open popup window - blocked`);\n        throw err;\n    }\n\n    if (closeOnUnload) {\n        window.addEventListener('unload', () => win.close());\n    }\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    const tag = el.tagName.toLowerCase();\n\n    if (tag !== 'html') {\n        throw new Error(`Expected element to be html, got ${ tag }`);\n    }\n\n    const 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? : ?$ReadOnlyArray<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        const promise = awaitFrameLoadPromises.get(frame);\n        if (promise) {\n            return promise;\n        }\n    }\n\n    const 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\nconst getDefaultCreateElementOptions = () : ElementOptionsType => {\n    // $FlowFixMe\n    return {};\n};\n\nexport function createElement(tag : string = 'div', options : ElementOptionsType = getDefaultCreateElementOptions(), container : ?HTMLElement) : HTMLElement {\n\n    tag = tag.toLowerCase();\n    const 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 (const 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\ntype StringMap = {|\n    [ string ] : string\n|};\n\nexport type IframeElementOptionsType = {|\n    style? : StringMap,\n    class? : ?$ReadOnlyArray<string>,\n    attributes? : StringMap,\n    styleSheet? : ?string,\n    html? : ?string,\n    url? : ?string\n|};\n\nconst getDefaultIframeOptions = () : IframeElementOptionsType => {\n    // $FlowFixMe\n    return {};\n};\n\nconst getDefaultStringMap = () : StringMap => {\n    // $FlowFixMe\n    return {};\n};\n\nexport function iframe(options : IframeElementOptionsType = getDefaultIframeOptions(), container : ?HTMLElement) : HTMLIFrameElement {\n\n    const attributes = options.attributes || getDefaultStringMap();\n    const style = options.style || getDefaultStringMap();\n\n    // $FlowFixMe\n    const newAttributes = {\n        allowTransparency: 'true',\n        ...attributes\n    };\n\n    // $FlowFixMe\n    const newStyle = {\n        backgroundColor: 'transparent',\n        border:          'none',\n        ...style\n    };\n\n    const frame = createElement('iframe', {\n        attributes: newAttributes,\n        style:      newStyle,\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        const 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 : $ReadOnlyArray<string>, handler : (event : Event) => void) : CancelableType {\n\n    handler = once(handler);\n\n    for (const eventName of eventNames) {\n        element.addEventListener(eventName, handler);\n    }\n\n    return {\n        cancel: once(() => {\n            for (const 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    const capitalizedName = capitalizeFirstLetter(name);\n\n    for (const 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        const el = getElement(element);\n\n        if (!el) {\n            return resolve();\n        }\n\n        let hasStarted = false;\n\n        // eslint-disable-next-line prefer-const\n        let startTimeout;\n        let endTimeout;\n        // eslint-disable-next-line prefer-const\n        let startEvent;\n        // eslint-disable-next-line prefer-const\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\nexport function makeElementVisible(element : HTMLElement) {\n    element.style.setProperty('visibility', '');\n}\n\nexport function makeElementInvisible(element : HTMLElement) {\n    element.style.setProperty('visibility', 'hidden', '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', 'none', '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    const 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 || !el.ownerDocument || !el.ownerDocument.documentElement || !el.ownerDocument.documentElement.contains(el)) {\n        return true;\n    }\n    return false;\n}\n\nexport function watchElementForClose(element : HTMLElement, handler : () => mixed) : CancelableType {\n    handler = once(handler);\n\n    let cancelled = false;\n    const mutationObservers = [];\n    // eslint-disable-next-line prefer-const\n    let interval;\n    // eslint-disable-next-line prefer-const\n    let sacrificialFrame;\n    let sacrificialFrameWin;\n\n    const cancel = () => {\n        cancelled = true;\n        for (const observer of mutationObservers) {\n            observer.disconnect();\n        }\n        if (interval) {\n            interval.cancel();\n        }\n        if (sacrificialFrameWin) {\n            // eslint-disable-next-line no-use-before-define\n            sacrificialFrameWin.removeEventListener('unload', elementClosed);\n        }\n        if (sacrificialFrame) {\n            destroyElement(sacrificialFrame);\n        }\n    };\n\n    const elementClosed = () => {\n        if (!cancelled) {\n            handler();\n            cancel();\n        }\n    };\n\n    if (isElementClosed(element)) {\n        elementClosed();\n        return { cancel };\n    }\n\n    // Strategy 1: Mutation observer\n\n    if (window.MutationObserver) {\n        let mutationElement = element.parentElement;\n        while (mutationElement) {\n            const mutationObserver = new window.MutationObserver(() => {\n                if (isElementClosed(element)) {\n                    elementClosed();\n                }\n            });\n\n            mutationObserver.observe(mutationElement, { childList: true });\n            mutationObservers.push(mutationObserver);\n            mutationElement = mutationElement.parentElement;\n        }\n    }\n\n    // Strategy 2: Sacrificial iframe\n\n    sacrificialFrame = document.createElement('iframe');\n    sacrificialFrame.setAttribute('name', `__detect_close_${ uniqueID() }__`);\n    sacrificialFrame.style.display = 'none';\n    awaitFrameWindow(sacrificialFrame).then(frameWin => {\n        sacrificialFrameWin = assertSameDomain(frameWin);\n        sacrificialFrameWin.addEventListener('unload', elementClosed);\n    });\n    element.appendChild(sacrificialFrame);\n\n    // Strategy 3: Poller\n\n    const check = () => {\n        if (isElementClosed(element)) {\n            elementClosed();\n        }\n    };\n    interval = safeInterval(check, 1000);\n\n    return { cancel };\n}\n\nexport function fixScripts(el : HTMLElement, doc : Document = window.document) {\n    for (const script of querySelectorAll('script', el)) {\n        const parentNode = script.parentNode;\n\n        if (!parentNode) {\n            continue;\n        }\n\n        const 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 = {}) : {| cancel : () => void |} {\n    let currentWidth = el.offsetWidth;\n    let currentHeight = el.offsetHeight;\n    let canceled = false;\n\n    handler({ width: currentWidth, height: currentHeight });\n\n    const check = () => {\n        if (canceled || !isElementVisible(el)) {\n            return;\n        }\n\n        const newWidth = el.offsetWidth;\n        const 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    win.addEventListener('resize', check);\n\n    if (typeof win.ResizeObserver !== 'undefined') {\n        observer = new win.ResizeObserver(check);\n        observer.observe(el);\n        timeout = safeInterval(check, interval * 10);\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        timeout = safeInterval(check, interval * 10);\n    } else {\n        timeout = safeInterval(check, interval);\n    }\n\n    return {\n        cancel: () => {\n            canceled = true;\n            observer.disconnect();\n            window.removeEventListener('resize', check);\n            timeout.cancel();\n        }\n    };\n}\n\nexport function getResourceLoadTime(url : string) : ?number {\n    const performance = getPerformance();\n\n    if (!performance) {\n        return;\n    }\n\n    // $FlowFixMe[method-unbinding]\n    if (typeof performance.getEntries !== 'function') {\n        return;\n    }\n\n    const entries = 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\nexport function isShadowElement(element : Node) : boolean {\n    while (element.parentNode) {\n        element = element.parentNode;\n    }\n\n    return element.toString() === '[object ShadowRoot]';\n}\n\nexport function getShadowRoot(element : Node) : ?Node {\n    while (element.parentNode) {\n        element = element.parentNode;\n    }\n\n    if (isShadowElement(element)) {\n        return element;\n    }\n}\n\nexport function getShadowHost(element : Node) : ?HTMLElement {\n    const shadowRoot = getShadowRoot(element);\n\n    // $FlowFixMe\n    if (shadowRoot && shadowRoot.host) {\n        // $FlowFixMe\n        return shadowRoot.host;\n    }\n}\n\n\nexport function insertShadowSlot(element : HTMLElement) : HTMLElement {\n    const shadowHost = getShadowHost(element);\n\n    if (!shadowHost) {\n        throw new Error(`Element is not in shadow dom`);\n    }\n\n    const slotName = `shadow-slot-${ uniqueID() }`;\n    const slot = document.createElement('slot');\n    slot.setAttribute('name', slotName);\n    element.appendChild(slot);\n\n    const slotProvider = document.createElement('div');\n    slotProvider.setAttribute('slot', slotName);\n    shadowHost.appendChild(slotProvider);\n\n    if (isShadowElement(shadowHost)) {\n        return insertShadowSlot(slotProvider);\n    }\n\n    return slotProvider;\n}\n\nexport function preventClickFocus(el : HTMLElement) {\n    const onFocus = (event : Event) => {\n        el.removeEventListener('focus', onFocus);\n        event.preventDefault();\n        el.blur();\n        return false;\n    };\n\n    el.addEventListener('mousedown', () => {\n        el.addEventListener('focus', onFocus);\n        setTimeout(() => {\n            el.removeEventListener('focus', onFocus);\n        }, 1);\n    });\n}\n\nexport function getStackTrace() : string {\n    try {\n        throw new Error('_');\n    }\n    catch (err) {\n        return err.stack || '';\n    }\n}\n\nfunction inferCurrentScript() : ?HTMLScriptElement {\n    try {\n        const stack = getStackTrace();\n        const stackDetails = (/.*at [^(]*\\((.*):(.+):(.+)\\)$/ig).exec(stack);\n        const scriptLocation = stackDetails && stackDetails[1];\n\n        if (!scriptLocation) {\n            return;\n        }\n\n        // $FlowFixMe[method-unbinding]\n        for (const script of Array.prototype.slice.call(document.getElementsByTagName('script')).reverse()) {\n            if (script.src && script.src === scriptLocation) {\n                return script;\n            }\n        }\n\n    } catch (err) {\n        // pass\n    }\n}\n\n// eslint-disable-next-line compat/compat\nlet currentScript = typeof document !== 'undefined' ? document.currentScript : null;\n\ntype GetCurrentScript = () => HTMLScriptElement;\n\nexport const getCurrentScript : GetCurrentScript = memoize(() => {\n    if (currentScript) {\n        return currentScript;\n    }\n\n    currentScript = inferCurrentScript();\n\n    if (currentScript) {\n        return currentScript;\n    }\n\n    throw new Error('Can not determine current script');\n});\n\nconst currentUID = uniqueID();\n\ntype GetCurrentScriptUID = () => string;\n\nexport const getCurrentScriptUID : GetCurrentScriptUID = memoize(() => {\n    let script;\n\n    try {\n        script = getCurrentScript();\n    } catch (err) {\n        return currentUID;\n    }\n\n    let uid = script.getAttribute(ATTRIBUTES.UID);\n\n    if (uid && typeof uid === 'string') {\n        return uid;\n    }\n\n    uid = script.getAttribute(`${ ATTRIBUTES.UID }-auto`);\n\n    if (uid && typeof uid === 'string') {\n        return uid;\n    }\n\n    if (script.src) {\n\n        const { src, dataset } = script;\n        const stringToHash = JSON.stringify({ src, dataset });\n        const hashedString = strHashStr(stringToHash);\n        const hashResult = hashedString.slice(hashedString.length - UID_HASH_LENGTH);\n\n        uid = `uid_${ hashResult }`;\n    } else {\n        uid = uniqueID();\n    }\n\n    script.setAttribute(`${ ATTRIBUTES.UID }-auto`, uid);\n\n    return uid;\n});\n\ntype SubmitFormOptions = {|\n    url : string,\n    target : string,\n    body? : {| [string] : string | boolean |},\n    method? : string\n|};\n\nexport function submitForm({ url, target, body, method = 'post' } : SubmitFormOptions) {\n    const form = document.createElement('form');\n    form.setAttribute('target', target);\n    form.setAttribute('method', method);\n    form.setAttribute('action', url);\n    form.style.display = 'none';\n\n    if (body) {\n        for (const key of Object.keys(body)) {\n            const input = document.createElement('input');\n            input.setAttribute('name', key);\n            input.setAttribute('value', body[key]?.toString());\n            form.appendChild(input);\n        }\n    }\n\n    getBody().appendChild(form);\n    form.submit();\n    getBody().removeChild(form);\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    const 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\nimport { type CrossDomainWindowType, type SameDomainWindowType } from 'cross-domain-utils/src';\nimport { WeakMap } from 'cross-domain-safe-weakmap/src';\nimport { getOrSet, getCurrentScriptUID } from 'belter/src';\n\nexport function getGlobalKey() : string {\n    if (__POST_ROBOT__.__SCRIPT_NAMESPACE__) {\n        return `${ __POST_ROBOT__.__GLOBAL_KEY__ }_${ getCurrentScriptUID() }`;\n    } else {\n        return __POST_ROBOT__.__GLOBAL_KEY__;\n    }\n}\n\nexport function getGlobal(win : SameDomainWindowType = window) : Object {\n    const globalKey = getGlobalKey();\n\n    if (win !== window) {\n        return win[globalKey];\n    }\n    const global : Object = win[globalKey] = win[globalKey] || {};\n    return global;\n}\n\nexport function deleteGlobal() {\n    const globalKey = getGlobalKey();\n    delete window[globalKey];\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\nexport const KEY_CODES = {\n    ENTER: 13,\n    SPACE: 32\n};\n\nexport const ATTRIBUTES = {\n    UID: 'data-uid'\n};\n\nexport const UID_HASH_LENGTH = 30;\n","/* @flow */\n\nimport { getAncestor, type CrossDomainWindowType } from 'cross-domain-utils/src';\nimport { ZalgoPromise } from 'zalgo-promise/src';\nimport { uniqueID } from 'belter/src';\n\nimport { MESSAGE_NAME, WILDCARD } from '../conf';\nimport { windowStore, globalStore, getGlobal } 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(err => {\n                // $FlowFixMe\n                if (__TEST__ && getGlobal(parent)) {\n                    throw err;\n                }\n            });\n        }\n\n        return listener;\n    });\n}\n\nexport function awaitWindowHello(win : CrossDomainWindowType, timeout : number = 5000, name : string = 'Window') : ZalgoPromise<{| domain : string |}> {\n    let promise = getHelloPromise(win);\n\n    if (timeout !== -1) {\n        promise = promise.timeout(timeout, new Error(`${ name } did not load after ${ timeout }ms`));\n    }\n\n    return promise;\n}\n","/* @flow */\n\nexport const MESSAGE_TYPE = {\n    REQUEST:  ('postrobot_message_request' : 'postrobot_message_request'),\n    RESPONSE: ('postrobot_message_response' : 'postrobot_message_response'),\n    ACK:      ('postrobot_message_ack' : 'postrobot_message_ack')\n};\n\nexport const MESSAGE_ACK = {\n    SUCCESS: ('success' : 'success'),\n    ERROR:   ('error' : 'error')\n};\n\nexport const MESSAGE_NAME = {\n    METHOD:      ('postrobot_method' : 'postrobot_method'),\n    HELLO:       ('postrobot_hello' : 'postrobot_hello'),\n    OPEN_TUNNEL: ('postrobot_open_tunnel' : 'postrobot_open_tunnel')\n};\n\nexport const SEND_STRATEGY = {\n    POST_MESSAGE: ('postrobot_post_message' : 'postrobot_post_message'),\n    BRIDGE:       ('postrobot_bridge' : 'postrobot_bridge'),\n    GLOBAL:       ('postrobot_global' : 'postrobot_global')\n};\n\nexport const BRIDGE_NAME_PREFIX = '__postrobot_bridge__';\nexport const POSTROBOT_PROXY =    '__postrobot_proxy__';\n\nexport const WILDCARD = '*';\n\nexport const SERIALIZATION_TYPE = {\n    CROSS_DOMAIN_ZALGO_PROMISE: ('cross_domain_zalgo_promise' : 'cross_domain_zalgo_promise'),\n    CROSS_DOMAIN_FUNCTION:      ('cross_domain_function' : 'cross_domain_function'),\n    CROSS_DOMAIN_WINDOW:        ('cross_domain_window' : 'cross_domain_window')\n};\n\nexport const METHOD = {\n    GET:  ('get' : 'get'),\n    POST: ('post' : 'post')\n};\n","/* @flow */\n\nimport { type CrossDomainWindowType } from 'cross-domain-utils/src';\n\nimport { windowStore } from '../global';\n\nexport function markWindowKnown(win : CrossDomainWindowType) {\n    const knownWindows = windowStore('knownWindows');\n    knownWindows.set(win, true);\n}\n\nexport function isWindowKnown(win : CrossDomainWindowType) : boolean {\n    const knownWindows = windowStore('knownWindows');\n    return knownWindows.get(win, false);\n}\n","/* @flow */\n\nimport { TYPE } from './constants';\nimport type { CustomSerializedType } from './types';\n\nexport function isSerializedType(item : mixed) : boolean {\n    return (typeof item === 'object' && item !== null && typeof item.__type__ === 'string');\n}\n\nexport function determineType(val : mixed) : $Values<typeof TYPE> | void {\n    if (typeof val === 'undefined') {\n        return TYPE.UNDEFINED;\n    }\n\n    if (val === null) {\n        return TYPE.NULL;\n    }\n\n    if (Array.isArray(val)) {\n        return TYPE.ARRAY;\n    }\n\n    if (typeof val === 'function') {\n        return TYPE.FUNCTION;\n    }\n\n    if (typeof val === 'object') {\n\n        if (val instanceof Error) {\n            return TYPE.ERROR;\n        }\n\n        if (typeof val.then === 'function') {\n            return TYPE.PROMISE;\n        }\n\n        // $FlowFixMe method-unbinding\n        if (Object.prototype.toString.call(val) === '[object RegExp]') {\n            return TYPE.REGEX;\n        }\n\n        // $FlowFixMe method-unbinding\n        if (Object.prototype.toString.call(val) === '[object Date]') {\n            return TYPE.DATE;\n        }\n\n        return TYPE.OBJECT;\n    }\n\n    if (typeof val === 'string') {\n        return TYPE.STRING;\n    }\n\n    if (typeof val === 'number') {\n        return TYPE.NUMBER;\n    }\n\n    if (typeof val === 'boolean') {\n        return TYPE.BOOLEAN;\n    }\n}\n\nexport function serializeType<T : string, V : mixed>(type : T, val : V) : CustomSerializedType<T, V> {\n    return {\n        __type__: type,\n        __val__:  val\n    };\n}\n","/* @flow */\n\nexport const TYPE = {\n    FUNCTION:  ('function' : 'function'),\n    ERROR:     ('error' : 'error'),\n    PROMISE:   ('promise' : 'promise'),\n    REGEX:     ('regex' : 'regex'),\n    DATE:      ('date' : 'date'),\n    ARRAY:     ('array' : 'array'),\n    OBJECT:    ('object' : 'object'),\n    STRING:    ('string' : 'string'),\n    NUMBER:    ('number' : 'number'),\n    BOOLEAN:   ('boolean' : 'boolean'),\n    NULL:      ('null' : 'null'),\n    UNDEFINED: ('undefined' : 'undefined')\n};\n","/* @flow */\n\nimport { TYPE } from './constants';\nimport type { Thenable, CustomSerializedType, NativeSerializedType } from './types';\nimport { determineType, isSerializedType } from './common';\nimport {\n    serializeFunction,\n    serializeError, type SerializedError,\n    serializePromise,\n    serializeRegex, type SerializedRegex,\n    serializeDate, type SerializedDate,\n    serializeArray,\n    serializeObject,\n    serializeString,\n    serializeNumber,\n    serializeBoolean,\n    serializeNull,\n    serializeUndefined\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    undefined? : CustomOrPrimitiveSerializer<void, typeof TYPE.UNDEFINED>\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    [ TYPE.UNDEFINED ]: serializeUndefined\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\nimport { serializeObject } from './object';\n\nexport type SerializedError = {|\n    message : string,\n    stack : string,\n    code : string | number | void,\n    data : mixed\n|};\n\n// $FlowFixMe\nexport function serializeError({ message, stack, code, data } : Error) : NativeSerializedType<typeof TYPE.ERROR, SerializedError> {\n    return serializeType(TYPE.ERROR, { message, stack, code, data });\n}\n\nexport function deserializeError({ message, stack, code, data } : SerializedError) : Error {\n    const error = new Error(message);\n    // $FlowFixMe\n    error.code = code;\n\n    if (data) {\n        // $FlowFixMe\n        error.data = serializeObject(data);\n    }\n\n    error.stack = `${ stack }\\n\\n${ error.stack }`;\n    return error;\n}\n","/* @flow */\n\nimport type { Thenable } from '../types';\n\nexport type SerializedPromise = void;\n\nexport function serializePromise() : SerializedPromise {\n    // pass\n}\n\nexport function deserializePromise() : Thenable {\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 { NativeSerializedType } from '../types';\nimport { serializeType } from '../common';\nimport { TYPE } from '../constants';\n\nexport type SerializedUndefined = void;\n\nexport function serializeUndefined(val : void) : NativeSerializedType<typeof TYPE.UNDEFINED, SerializedUndefined> {\n    return serializeType(TYPE.UNDEFINED, val);\n}\n\nexport function deserializeUndefined() : void {\n    // pass\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    deserializeUndefined\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    undefined? : PrimitiveDeserializer<void>\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    [ TYPE.UNDEFINED ]: deserializeUndefined\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 : ZalgoPromise<HTMLBodyElement> = 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\ntype WinDetails = {|\n    win : CrossDomainWindowType,\n    domain? : ?string,\n    name? : ?string\n|};\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            const getWindowDetails = () : WinDetails => {\n                const winDetails = popupWindowsByName.get(data.name);\n                // $FlowFixMe\n                return winDetails;\n            };\n\n            if (!getWindowDetails().domain) {\n                throw new Error(`We do not have a registered domain for window ${ data.name }`);\n            }\n\n            if (getWindowDetails().domain !== origin) {\n                throw new Error(`Message origin ${ origin } does not matched registered window origin ${ getWindowDetails().domain || 'unknown' }`);\n            }\n\n            registerRemoteSendMessage(getWindowDetails().win, origin, data.sendMessage);\n\n            return {\n                sendMessage(message) {\n\n                    if (!window || window.closed) {\n                        return;\n                    }\n\n                    if (!getWindowDetails()) {\n                        return;\n                    }\n\n                    const domain = getWindowDetails().domain;\n\n                    if (!domain) {\n                        return;\n                    }\n\n                    try {\n                        receiveMessage({\n                            data:   message,\n                            origin: domain,\n                            source: getWindowDetails().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\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        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        // $FlowFixMe\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({ 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                // $FlowFixMe[object-this-reference]\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                            // $FlowFixMe[object-this-reference]\n                            origin: this.origin,\n                            // $FlowFixMe[object-this-reference]\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, noop, submitForm } from 'belter/src';\nimport { serializeType, type CustomSerializedType } from 'universal-serialize/src';\n\nimport { SERIALIZATION_TYPE, METHOD } 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 SetLocationOptions = {|\n    method? : $Values<typeof METHOD>,\n    body? : {|\n        [string] : string | boolean\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 : (url : string, opts? : SetLocationOptions) => 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    const windowTypePromise = winPromise.then(window => {\n        if (!isWindowClosed(window)) {\n            return getOpener(window) ? WINDOW_TYPE.POPUP : WINDOW_TYPE.IFRAME;\n        } else {\n            throw new Error(`Window is closed, can not determine type`);\n        }\n    });\n\n    windowNamePromise.catch(noop);\n    windowTypePromise.catch(noop);\n\n    const 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\n    const getDefaultSetLocationOptions = () => {\n        // $FlowFixMe\n        return {};\n    };\n\n    const setLocation = (href : string, opts? : SetLocationOptions = getDefaultSetLocationOptions()) => winPromise.then(win => {\n        const domain = `${ window.location.protocol }//${ window.location.host }`;\n        const { method = METHOD.GET, body } = opts;\n\n        if (href.indexOf('/') === 0) {\n            href = `${ domain }${ href }`;\n        } else if (!href.match(/^https?:\\/\\//) && href.indexOf(domain) !== 0) {\n            throw new Error(`Expected url to be http or https url, or absolute path, got ${ JSON.stringify(href) }`);\n        }\n\n        if (method === METHOD.POST) {\n            return getName().then(name => {\n                if (!name) {\n                    throw new Error(`Can not post to window without target name`);\n                }\n\n                submitForm({\n                    url:    href,\n                    target: name,\n                    method,\n                    body\n                });\n            });\n        } else if (method === METHOD.GET) {\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        } else {\n            throw new Error(`Unsupported method: ${ method }`);\n        }\n    });\n\n    return {\n        id,\n        getType: () => {\n            return windowTypePromise;\n        },\n        getInstanceID: memoizePromise(() => winPromise.then(win => getWindowInstanceID(win, { send }))),\n        close:         () => winPromise.then(closeWindow),\n        getName,\n        focus:         () => winPromise.then(win => {\n            win.focus();\n        }),\n        isClosed: () => winPromise.then(win => {\n            return isWindowClosed(win);\n        }),\n        setLocation,\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        \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, opts? : SetLocationOptions) : ZalgoPromise<ProxyWindow> {\n        return this.serializedWindow.setLocation(href, opts).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, 'noopener');\n            }\n        });\n        const focusPromise = this.serializedWindow.focus();\n\n        return ZalgoPromise.all([\n            reopenPromise,\n            focusPromise\n        ]).then(() => this);\n    }\n\n    isClosed() : ZalgoPromise<boolean> {\n        return this.serializedWindow.isClosed();\n    }\n\n    getWindow() : ?CrossDomainWindowType {\n        return this.actualWindow;\n    }\n\n    setWindow(win : CrossDomainWindowType, { send } : {| send : SendType |}) {\n        this.actualWindow = win;\n        this.actualWindowPromise.resolve(this.actualWindow);\n        this.serializedWindow = getSerializedWindow(this.actualWindowPromise, { send, id: this.getID() });\n        windowStore('winToProxyWindow').set(win, this);\n    }\n\n    awaitWindow() : ZalgoPromise<CrossDomainWindowType> {\n        return this.actualWindowPromise;\n    }\n\n    matchWindow(win : CrossDomainWindowType, { send } : {| send : SendType |}) : ZalgoPromise<boolean> {\n        return ZalgoPromise.try(() => {\n            if (this.actualWindow) {\n                return win === this.actualWindow;\n            }\n            \n            return ZalgoPromise.hash({\n                proxyInstanceID:       this.getInstanceID(),\n                knownWindowInstanceID: getWindowInstanceID(win, { send })\n            }).then(({ proxyInstanceID, knownWindowInstanceID }) => {\n                const match = proxyInstanceID === knownWindowInstanceID;\n\n                if (match) {\n                    this.setWindow(win, { send });\n                }\n\n                return match;\n            });\n        });\n    }\n\n    unwrap() : CrossDomainWindowType | ProxyWindow {\n        return this.actualWindow || this;\n    }\n\n    getInstanceID() : ZalgoPromise<string> {\n        return this.serializedWindow.getInstanceID();\n    }\n\n    shouldClean() : boolean {\n        return Boolean(this.actualWindow && isWindowClosed(this.actualWindow));\n    }\n\n    serialize() : SerializedWindowType {\n        return this.serializedWindow;\n    }\n\n    static unwrap(win : CrossDomainWindowType | ProxyWindow) : CrossDomainWindowType | ProxyWindow {\n        return ProxyWindow.isProxyWindow(win)\n            // $FlowFixMe\n            ? win.unwrap()\n            : win;\n    }\n\n    static serialize(win : CrossDomainWindowType | ProxyWindow, { send } : {| send : SendType |}) : SerializedWindowType {\n        cleanupProxyWindows();\n        return ProxyWindow.toProxyWindow(win, { send }).serialize();\n    }\n\n    static deserialize(serializedWindow : SerializedWindowType, { send } : {| send : SendType |}) : ProxyWindow {\n        cleanupProxyWindows();\n        return globalStore('idToProxyWindow').get(serializedWindow.id) || new ProxyWindow({ serializedWindow, send });\n    }\n\n    static isProxyWindow(obj : CrossDomainWindowType | ProxyWindow) : boolean {\n        // $FlowFixMe\n        return Boolean(obj && !isWindow(obj) && obj.isProxyWindow);\n    }\n\n    static toProxyWindow(win : CrossDomainWindowType | ProxyWindow, { send } : {| send : SendType |}) : ProxyWindow {\n        cleanupProxyWindows();\n\n        if (ProxyWindow.isProxyWindow(win)) {\n            // $FlowFixMe\n            return win;\n        }\n\n        // $FlowFixMe\n        const actualWindow : CrossDomainWindowType = win;\n        \n        return windowStore('winToProxyWindow').get(actualWindow) || new ProxyWindow({ win: actualWindow, send });\n    }\n}\n\nexport type SerializedWindow = CustomSerializedType<typeof SERIALIZATION_TYPE.CROSS_DOMAIN_WINDOW, SerializedWindowType>;\n\nexport function serializeWindow(destination : CrossDomainWindowType | ProxyWindow, domain : DomainMatcher, win : CrossDomainWindowType, { send } : {| send : SendType |}) : SerializedWindow {\n    return serializeType(SERIALIZATION_TYPE.CROSS_DOMAIN_WINDOW, ProxyWindow.serialize(win, { send }));\n}\n\nexport function deserializeWindow(source : CrossDomainWindowType | ProxyWindow, origin : string, win : SerializedWindowType, { send } : {| send : SendType |}) : ProxyWindow {\n    return ProxyWindow.deserialize(win, { send });\n}\n","/* @flow */\n\nimport { matchDomain, getDomain, type CrossDomainWindowType, type DomainMatcher } from 'cross-domain-utils/src';\nimport { ZalgoPromise } from 'zalgo-promise/src';\nimport { uniqueID, isRegex, arrayFrom } from 'belter/src';\nimport { serializeType, type CustomSerializedType } from 'universal-serialize/src';\n\nimport { MESSAGE_NAME, WILDCARD, SERIALIZATION_TYPE } from '../conf';\nimport { windowStore, globalStore } from '../global';\nimport type { OnType, SendType, CancelableType } from '../types';\n\nimport { ProxyWindow } from './window';\n\ntype StoredMethod = {|\n    name : string,\n    domain : DomainMatcher,\n    val : Function,\n    source : CrossDomainWindowType | ProxyWindow\n|};\n\nfunction addMethod(id : string, val : Function, name : string, source : CrossDomainWindowType | ProxyWindow, domain : DomainMatcher) {\n    const methodStore = windowStore('methodStore');\n    const proxyWindowMethods = globalStore('proxyWindowMethods');\n    \n    if (ProxyWindow.isProxyWindow(source)) {\n        proxyWindowMethods.set(id, { val, name, domain, source });\n    } else {\n        proxyWindowMethods.del(id);\n        // $FlowFixMe\n        const methods = methodStore.getOrSet(source, () => ({}));\n        methods[id] = { domain, name, val, source };\n    }\n}\n\nfunction lookupMethod(source : CrossDomainWindowType, id : string) : ?StoredMethod {\n    const methodStore = windowStore('methodStore');\n    const proxyWindowMethods = globalStore('proxyWindowMethods');\n    const methods = methodStore.getOrSet(source, () => ({}));\n    return methods[id] || proxyWindowMethods.get(id);\n}\n\nfunction stringifyArguments(args : $ReadOnlyArray<mixed> = []) : string {\n    return arrayFrom(args).map(arg => {\n        if (typeof arg === 'string') {\n            return `'${ arg }'`;\n        }\n        if (arg === undefined) {\n            return 'undefined';\n        }\n        if (arg === null) {\n            return 'null';\n        }\n        if (typeof arg === 'boolean') {\n            return arg.toString();\n        }\n        if (Array.isArray(arg)) {\n            return '[ ... ]';\n        }\n        if (typeof arg === 'object') {\n            return '{ ... }';\n        }\n        if (typeof arg === 'function') {\n            return '() => { ... }';\n        }\n        return `<${ typeof arg }>`;\n    }).join(', ');\n}\n\nfunction listenForFunctionCalls({ on, send } : {| on : OnType, send : SendType |}) : CancelableType {\n    return globalStore('builtinListeners').getOrSet('functionCalls', () => {\n        return on(MESSAGE_NAME.METHOD, { domain: WILDCARD }, ({ source, origin, data } : {| source : CrossDomainWindowType, origin : string, data : Object |}) => {\n            const { id, name } = data;\n\n            const meth = lookupMethod(source, id);\n    \n            if (!meth) {\n                throw new Error(`Could not find method '${ name }' with id: ${ data.id } in ${ getDomain(window) }`);\n            }\n\n            const { source: methodSource, domain, val } = meth;\n            \n            return ZalgoPromise.try(() => {\n                if (!matchDomain(domain, origin)) {\n                    // $FlowFixMe\n                    throw new Error(`Method '${ data.name }' domain ${ JSON.stringify(isRegex(meth.domain) ? meth.domain.source : meth.domain) } does not match origin ${ origin } in ${ getDomain(window) }`);\n                }\n                \n                if (ProxyWindow.isProxyWindow(methodSource)) {\n                    // $FlowFixMe\n                    return methodSource.matchWindow(source, { send }).then(match => {\n                        if (!match) {\n                            throw new Error(`Method call '${ data.name }' failed - proxy window does not match source in ${ getDomain(window) }`);\n                        }\n                    });\n                }\n            }).then(() => {\n                return val.apply({ source, origin }, data.args);\n            }, err => {\n                return ZalgoPromise.try(() => {\n                    if (val.onError) {\n                        return val.onError(err);\n                    }\n                }).then(() => {\n                    // $FlowFixMe\n                    if (err.stack) {\n                        // $FlowFixMe\n                        err.stack = `Remote call to ${ name }(${ stringifyArguments(data.args) }) failed\\n\\n${ err.stack }`;\n                    }\n\n                    throw err;\n                });\n            }).then(result => {\n                return { result, id, name };\n            });\n        });\n    });\n}\n\nexport type SerializedFunction = CustomSerializedType<typeof SERIALIZATION_TYPE.CROSS_DOMAIN_FUNCTION, {|\n    id : string,\n    name : string\n|}>;\n\n// eslint-disable-next-line flowtype/require-exact-type\ntype SerializableFunction<T> = {\n    () : ZalgoPromise<T> | T,\n    __id__? : string,\n    __name__? : string\n};\n\nexport function serializeFunction<T>(destination : CrossDomainWindowType | ProxyWindow, domain : DomainMatcher, val : SerializableFunction<T>, key : string, { on, send } : {| on : OnType, send : SendType |}) : SerializedFunction {\n    listenForFunctionCalls({ on, send });\n    \n    const id = val.__id__ || uniqueID();\n    destination = ProxyWindow.unwrap(destination);\n    let name = val.__name__ || val.name || key;\n\n    if (typeof name === 'string' && typeof name.indexOf === 'function' && name.indexOf('anonymous::') === 0) {\n        name = name.replace('anonymous::', `${ key }::`);\n    }\n\n    if (ProxyWindow.isProxyWindow(destination)) {\n        addMethod(id, val, name, destination, domain);\n\n        // $FlowFixMe\n        destination.awaitWindow().then(win => {\n            addMethod(id, val, name, win, domain);\n        });\n    } else {\n        addMethod(id, val, name, destination, domain);\n    }\n\n    return serializeType(SERIALIZATION_TYPE.CROSS_DOMAIN_FUNCTION, { id, name });\n}\n\nexport function deserializeFunction<T>(source : CrossDomainWindowType | ProxyWindow, origin : string, { id, name } : {| id : string, name : string |}, { send } : {| send : SendType |}) : (...args : $ReadOnlyArray<mixed>) => ZalgoPromise<T> {\n    const getDeserializedFunction = (opts? : Object = {}) => {\n        function crossDomainFunctionWrapper<X : mixed>() : ZalgoPromise<X> {\n            let originalStack;\n    \n            if (__DEBUG__) {\n                originalStack = (new Error(`Original call to ${ name }():`)).stack;\n            }\n    \n            return ProxyWindow.toProxyWindow(source, { send }).awaitWindow().then(win => {\n                const meth = lookupMethod(win, id);\n    \n                if (meth && meth.val !== crossDomainFunctionWrapper) {\n                    return meth.val.apply({ source: window, origin: getDomain() }, arguments);\n                } else {\n                    // $FlowFixMe[method-unbinding]\n                    const args = Array.prototype.slice.call(arguments);\n\n                    if (opts.fireAndForget) {\n                        return send(win, MESSAGE_NAME.METHOD, { id, name, args }, { domain: origin, fireAndForget: true });\n                    } else {\n                        return send(win, MESSAGE_NAME.METHOD, { id, name, args }, { domain: origin, fireAndForget: false })\n                            .then(res => res.data.result);\n                    }\n                }\n    \n            }).catch(err => {\n                // $FlowFixMe\n                if (__DEBUG__ && originalStack && err.stack) {\n                    // $FlowFixMe\n                    err.stack = `Remote call to ${ name }(${ stringifyArguments(arguments) }) failed\\n\\n${ err.stack }\\n\\n${ originalStack }`;\n                }\n                throw err;\n            });\n        }\n\n        crossDomainFunctionWrapper.__name__ = name;\n        crossDomainFunctionWrapper.__origin__ = origin;\n        crossDomainFunctionWrapper.__source__ = source;\n        crossDomainFunctionWrapper.__id__ = id;\n\n        crossDomainFunctionWrapper.origin = origin;\n\n        return crossDomainFunctionWrapper;\n    };\n\n    const crossDomainFunctionWrapper = getDeserializedFunction();\n    crossDomainFunctionWrapper.fireAndForget = getDeserializedFunction({ fireAndForget: true });\n\n    return crossDomainFunctionWrapper;\n}\n","/* @flow */\n\nimport { type CrossDomainWindowType, isWindow, type DomainMatcher } from 'cross-domain-utils/src';\nimport { TYPE, serialize, deserialize, type Thenable } from 'universal-serialize/src';\n\nimport { SERIALIZATION_TYPE } from '../conf';\nimport type { OnType, SendType } from '../types';\n\nimport { serializeFunction, deserializeFunction, type SerializedFunction } from './function';\nimport { serializePromise, deserializePromise, type SerializedPromise } from './promise';\nimport { serializeWindow, deserializeWindow, type SerializedWindow, ProxyWindow } from './window';\n\nexport function serializeMessage<T : mixed>(destination : CrossDomainWindowType | ProxyWindow, domain : DomainMatcher, obj : T, { on, send } : {| on : OnType, send : SendType |}) : string {\n    return serialize(obj, {\n        [ TYPE.PROMISE ]:  (val : Thenable, key : string) : SerializedPromise => serializePromise(destination, domain, val, key, { on, send }),\n        [ TYPE.FUNCTION ]: (val : Function, key : string) : SerializedFunction => serializeFunction(destination, domain, val, key, { on, send }),\n        [ TYPE.OBJECT ]:   (val : CrossDomainWindowType) : Object | SerializedWindow => {\n            return (isWindow(val) || ProxyWindow.isProxyWindow(val)) ? serializeWindow(destination, domain, val, { send }) : val;\n        }\n    });\n}\n\nexport function deserializeMessage<T : mixed>(source : CrossDomainWindowType | ProxyWindow, origin : string, message : string, { 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, { 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, 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\ntype SendStrategies = {|\n    [$Values<typeof SEND_STRATEGY>] : (CrossDomainWindowType, string, string) => void\n|};\n\nexport const SEND_MESSAGE_STRATEGIES : SendStrategies = {};\n\nSEND_MESSAGE_STRATEGIES[SEND_STRATEGY.POST_MESSAGE] = (win : CrossDomainWindowType, serializedMessage : string, domain : string) => {\n    if (domain.indexOf(PROTOCOL.FILE) === 0) {\n        domain = WILDCARD;\n    }\n\n    if (__TEST__) {\n        if (needsGlobalMessagingForBrowser() && isSameTopWindow(window, win) === false) {\n            return;\n        }\n\n        if (domain.indexOf(PROTOCOL.MOCK) === 0) {\n            if (!isActuallySameDomain(win)) {\n                throw new Error(`Attempting to send message to mock domain ${ domain }, but window is actually cross-domain`);\n            }\n\n            // $FlowFixMe\n            const windowDomain = getDomain(win);\n                \n            if (windowDomain !== domain) {\n                throw new Error(`Mock domain target ${ domain } does not match window domain ${ windowDomain }`);\n            }\n\n            // $FlowFixMe\n            domain = getActualDomain(win);\n\n        }\n    }\n\n    win.postMessage(serializedMessage, domain);\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 { ZalgoPromise } from 'zalgo-promise/src';\nimport { isWindowClosed, type CrossDomainWindowType } from 'cross-domain-utils/src';\nimport { stringifyError, noop } from 'belter/src';\n\nimport { serializeMessage } from '../../serialize';\nimport { windowStore, getGlobalKey } from '../../global';\nimport type { Message, PackedMessages } from '../types';\nimport type { OnType, SendType } from '../../types';\n\nimport { SEND_MESSAGE_STRATEGIES } from './strategies';\n\nfunction packMessages(messages : $ReadOnlyArray<Message>) : PackedMessages {\n    return {\n        [ getGlobalKey() ]: messages\n    };\n}\n\nexport function sendMessage(win : CrossDomainWindowType, domain : string, message : Message, { on, send } : {| on : OnType, send : SendType |}) : ZalgoPromise<void> {\n    return ZalgoPromise.try(() => {\n        const messageBuffer = windowStore();\n\n        const domainBuffer = messageBuffer.getOrSet(win, () => ({}));\n\n        domainBuffer.buffer = domainBuffer.buffer || [];\n        domainBuffer.buffer.push(message);\n\n        domainBuffer.flush = domainBuffer.flush || ZalgoPromise.flush().then(() => {\n            if (isWindowClosed(win)) {\n                throw new Error('Window is closed');\n            }\n\n            const serializedMessage = serializeMessage(win, domain, packMessages(domainBuffer.buffer || []), { on, send });\n            delete domainBuffer.buffer;\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\n        return domainBuffer.flush.then(() => {\n            delete domainBuffer.flush;\n        });\n    }).then(noop);\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, noop } from 'belter/src';\n\nimport { getWildcard, type WildCard, globalStore, windowStore } from '../global';\nimport { WILDCARD } from '../conf';\nimport { ProxyWindow } from '../serialize/window';\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|};\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\n// eslint-disable-next-line complexity\nexport function addRequestListener({ name, win: winCandidate, domain } : {| name : string, win : ?(CrossDomainWindowType | WildCard | ProxyWindow), 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    // $FlowFixMe\n    if (winCandidate && winCandidate !== WILDCARD && ProxyWindow.isProxyWindow(winCandidate)) {\n        // $FlowFixMe\n        const proxyWin : ProxyWindow = winCandidate;\n\n        const requestListenerPromise = proxyWin.awaitWindow().then(actualWin => {\n            return addRequestListener({ name, win: actualWin, domain }, listener);\n        });\n\n        return {\n            cancel: () => {\n                requestListenerPromise.then(requestListener => requestListener.cancel(), noop);\n            }\n        };\n    }\n\n    // $FlowFixMe\n    let win : ?(CrossDomainWindowType | WildCard) = winCandidate;\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    const strDomain = domain.toString();\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 winNameListeners = requestListeners.getOrSet(win, () => ({}));\n    const winNameDomainListeners = getOrSet(winNameListeners, name, () => ({}));\n\n    let winNameDomainRegexListeners;\n    let winNameDomainRegexListener;\n\n    if (isRegex(domain)) {\n        winNameDomainRegexListeners = getOrSet(winNameDomainListeners, __DOMAIN_REGEX__, () => []);\n        winNameDomainRegexListener = { regex: domain, listener };\n        winNameDomainRegexListeners.push(winNameDomainRegexListener);\n    } else {\n        winNameDomainListeners[strDomain] = listener;\n    }\n\n    return {\n        cancel() {\n            delete winNameDomainListeners[strDomain];\n\n            if (winNameDomainRegexListener) {\n                winNameDomainRegexListeners.splice(winNameDomainRegexListeners.indexOf(winNameDomainRegexListener, 1));\n\n                if (!winNameDomainRegexListeners.length) {\n                    delete winNameDomainListeners[__DOMAIN_REGEX__];\n                }\n            }\n\n            if (!Object.keys(winNameDomainListeners).length) {\n                delete winNameListeners[name];\n            }\n\n            if (win && !Object.keys(winNameListeners).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, uniqueID } 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, ResponseMessage } from '../types';\nimport type { OnType, SendType } from '../../types';\n\nexport function handleRequest(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 sendAck() : ZalgoPromise<void> {\n        return ZalgoPromise.flush().then(() => {\n            if (message.fireAndForget || isWindowClosed(source)) {\n                return;\n            }\n\n            try {\n                return sendMessage(source, origin, {\n                    id:     uniqueID(),\n                    origin: getDomain(window),\n                    type:   MESSAGE_TYPE.ACK,\n                    hash:   message.hash,\n                    name:   message.name\n                }, { on, send });\n            } catch (err) {\n                throw new Error(`Send ack message failed for ${ logName } in ${ getDomain() }\\n\\n${ stringifyError(err) }`);\n            }\n        });\n    }\n\n\n    function sendResponse(ack : $Values<typeof MESSAGE_ACK>, data : ?Object, error : ?mixed) : ZalgoPromise<void> {\n        return ZalgoPromise.flush().then(() => {\n            if (message.fireAndForget || isWindowClosed(source)) {\n                return;\n            }\n\n            if (__DEBUG__) {\n                if (ack === MESSAGE_ACK.SUCCESS) {\n                    console.info('respond::res', logName, origin, '\\n\\n', data);  // eslint-disable-line no-console\n                } else if (ack === MESSAGE_ACK.ERROR) {\n                    console.error('respond::err', logName, origin, '\\n\\n', error); // eslint-disable-line no-console\n                }\n            }\n\n            try {\n                return sendMessage(source, origin, {\n                    id:     uniqueID(),\n                    origin: getDomain(window),\n                    type:   MESSAGE_TYPE.RESPONSE,\n                    hash:   message.hash,\n                    name:   message.name,\n                    ack,\n                    data,\n                    error\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\n    \n    return ZalgoPromise.all([\n        sendAck(),\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            const data = message.data;\n\n            return options.handler({ source, origin, data });\n\n        }).then(data => {\n            return sendResponse(MESSAGE_ACK.SUCCESS, data);\n\n        }, error => {\n            return sendResponse(MESSAGE_ACK.ERROR, null, 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\nexport function handleAck(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\nexport function handleResponse(source : CrossDomainWindowType, origin : string, message : ResponseMessage) : 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","/* @flow */\n\nimport { ZalgoPromise } from 'zalgo-promise/src';\nimport { isWindowClosed, type CrossDomainWindowType, getDomain, isSameTopWindow, PROTOCOL  } from 'cross-domain-utils/src';\nimport { addEventListener, noop } from 'belter/src';\n\nimport type { Message } from '../types';\nimport { MESSAGE_TYPE } from '../../conf';\nimport { markWindowKnown, needsGlobalMessagingForBrowser } from '../../lib';\nimport { deserializeMessage } from '../../serialize';\nimport { getGlobal, globalStore, getGlobalKey } from '../../global';\nimport type { OnType, SendType, MessageEvent, CancelableType } from '../../types';\n\nimport { handleRequest, handleResponse, handleAck } from './types';\n\nfunction deserializeMessages(message : string, source : CrossDomainWindowType, origin : string, { on, send } : {| on : OnType, send : SendType |}) : ?$ReadOnlyArray<Message> {\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    const parseMessages = parsedMessage[getGlobalKey()];\n\n    if (!Array.isArray(parseMessages)) {\n        return;\n    }\n\n    return parseMessages;\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        if (isWindowClosed(source)) {\n            return;\n        }\n\n        // $FlowFixMe\n        origin = getDomain(source);\n    }\n\n    const messages = deserializeMessages(data, source, origin, { on, send });\n\n    if (!messages) {\n        return;\n    }\n\n    markWindowKnown(source);\n\n    for (const message of messages) {\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        try {\n            if (message.type === MESSAGE_TYPE.REQUEST) {\n                handleRequest(source, origin, message, { on, send });\n            } else if (message.type === MESSAGE_TYPE.RESPONSE) {\n                handleResponse(source, origin, message);\n            } else if (message.type === MESSAGE_TYPE.ACK) {\n                handleAck(source, origin, message);\n            }\n        } catch (err) {\n            setTimeout(() => {\n                throw err;\n            }, 0);\n        }\n    }\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    ZalgoPromise.try(() => {\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}\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 } from '../drivers';\nimport { WILDCARD } from '../conf';\nimport type { ServerOptionsType, HandlerType, CancelableType } from '../types';\n\nconst getDefaultServerOptions = () : ServerOptionsType => {\n    // $FlowFixMe\n    return {};\n};\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    options = options || getDefaultServerOptions();\n    if (typeof options === 'function') {\n        handler = options;\n        options = getDefaultServerOptions();\n    }\n\n    if (!handler) {\n        throw new Error('Expected handler');\n    }\n\n    const winOrProxyWin = options.window;\n    const domain = options.domain || WILDCARD;\n\n    const successHandler = handler || options.handler;\n    const errorHandler = options.errorHandler || (err => {\n        throw err;\n    });\n\n    const requestListener = addRequestListener({ name, win: winOrProxyWin, domain }, {\n        handler:     successHandler,\n        handleError: errorHandler\n    });\n\n    return {\n        cancel() {\n            requestListener.cancel();\n        }\n    };\n}\n\ntype CancelableZalgoPromise<T> = ZalgoPromise<T> & {|\n    cancel : () => void\n|};\n\nexport function once(name : string, options? : ServerOptionsType | HandlerType, handler? : HandlerType) : CancelableZalgoPromise<{| source : mixed, origin : string, data : Object |}> {\n    \n    options = options || getDefaultServerOptions();\n    if (typeof options === 'function') {\n        handler = options;\n        options = getDefaultServerOptions();\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    // $FlowFixMe\n    promise.cancel = listener.cancel;\n\n    // $FlowFixMe\n    return promise;\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 { 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 { ProxyWindow } from '../serialize/window';\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(`Can not send ${ name }. Expected domain ${ JSON.stringify(domain) } to be a string, array, or regex`);\n        }\n    }\n\n    if (isWindowClosed(win)) {\n        throw new Error(`Can not send ${ name }. Target window is closed`);\n    }\n}\n\nfunction normalizeDomain(win : CrossDomainWindowType, targetDomain : DomainMatcher, actualDomain : ?string, { send } : {| send : SendType |}) : ZalgoPromise<string> {\n    return ZalgoPromise.try(() => {\n        if (typeof targetDomain === 'string') {\n            return 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}\n\nexport const send : SendType = (winOrProxyWin, name, data, options) => {\n    options = options || {};\n    const domainMatcher = 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    return ProxyWindow.toProxyWindow(winOrProxyWin, { send }).awaitWindow().then(win => {\n\n        // $FlowFixMe\n        return ZalgoPromise.try(() => {\n            validateOptions(name, win, domainMatcher);\n\n            if (isAncestor(window, win)) {\n                return awaitWindowHello(win, childTimeout);\n            }\n            \n        }).then(({ domain: actualDomain } = {}) => {\n\n            return normalizeDomain(win, domainMatcher, actualDomain, { send });\n        }).then(targetDomain => {\n            const 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            return sendMessage(win, domain, {\n                id:     uniqueID(),\n                origin: getDomain(window),\n                type:   MESSAGE_TYPE.REQUEST,\n                hash,\n                name,\n                data,\n                fireAndForget\n            }, { on, send }).then(() => {\n                return fireAndForget ? promise.resolve() : promise;\n            }, err => {\n                throw new Error(`Send request message failed for ${ logName } in ${ getDomain() }\\n\\n${ stringifyError(err) }`);\n            });\n        });\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';\n\n// $FlowFixMe\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\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 : number = __TEST__ ? 2000 : -1;\nexport const RESPONSE_CYCLE_TIME = 500;\n","/* @flow */\n\nimport type { CrossDomainWindowType, DomainMatcher } from 'cross-domain-utils/src';\n\nimport { initHello } from './lib';\nimport { listenForMessages, stopListenForMessages, receiveMessage, setupGlobalReceiveMessage, cancelResponseListeners } from './drivers';\nimport { getGlobal, deleteGlobal } from './global';\nimport { on, send } from './public';\nimport { setupBridge } from './bridge';\nimport { serializeMessage as internalSerializeMessage, deserializeMessage as internalDeserializeMessage, ProxyWindow } from './serialize';\n\nexport function serializeMessage<T>(destination : CrossDomainWindowType | ProxyWindow, domain : DomainMatcher, obj : T) : string {\n    return internalSerializeMessage(destination, domain, obj, { on, send });\n}\n\nexport function deserializeMessage<T : mixed>(source : CrossDomainWindowType | ProxyWindow, origin : string, message : string) : T {\n    return internalDeserializeMessage(source, origin, message, { on, send });\n}\n\nexport function createProxyWindow(win? : CrossDomainWindowType) : ProxyWindow {\n    return new ProxyWindow({ send, win });\n}\n\nexport function toProxyWindow(win : CrossDomainWindowType | ProxyWindow) : ProxyWindow {\n    return ProxyWindow.toProxyWindow(win, { send });\n}\n\nexport function setup() {\n    if (!getGlobal().initialized) {\n        getGlobal().initialized = true;\n    \n        setupGlobalReceiveMessage({ on, send });\n        listenForMessages({ on, send });\n    \n        if (__POST_ROBOT__.__IE_POPUP_SUPPORT__) {\n            setupBridge({ on, send, receiveMessage });\n        }\n\n        initHello({ on, send });\n    }\n}\n\nexport function destroy() {\n    cancelResponseListeners();\n    stopListenForMessages();\n    deleteGlobal();\n}\n","/* @flow */\n\nimport { type CrossDomainWindowType, isWindowClosed } from 'cross-domain-utils/src';\nimport { noop } from 'belter/src';\n\nimport { windowStore } from './global';\n\nexport function cleanUpWindow(win : CrossDomainWindowType) {\n    const requestPromises = windowStore('requestPromises');\n    for (const promise of requestPromises.get(win, [])) {\n        promise.reject(new Error(`Window ${ isWindowClosed(win) ? 'closed' : 'cleaned up' } before response`)).catch(noop);\n    }\n}\n","/* @flow */\n\nexport function isRegex(item : mixed) : boolean {\n    // $FlowFixMe method-unbinding\n    return Object.prototype.toString.call(item) === '[object RegExp]';\n}\n\n// eslint-disable-next-line no-unused-vars\nexport function noop(...args : $ReadOnlyArray<mixed>) {\n    // pass\n}\n","/* @flow */\n/* eslint max-lines: 0 */\n\nimport { isRegex, noop } from './util';\nimport type { CrossDomainWindowType, SameDomainWindowType, DomainMatcher } from './types';\nimport { PROTOCOL, WILDCARD } from './constants';\n\nconst IE_WIN_ACCESS_ERROR = 'Call was rejected by callee.\\r\\n';\n\nexport function getActualProtocol(win : SameDomainWindowType = window) : ?string {\n    return win.location.protocol;\n}\n\nexport function getProtocol(win : SameDomainWindowType = window) : ?string {\n    if (win.mockDomain) {\n        const protocol = win.mockDomain.split('//')[0];\n\n        if (protocol) {\n            return protocol;\n        }\n    }\n\n    return getActualProtocol(win);\n}\n\nexport function isFileProtocol(win : SameDomainWindowType = window) : boolean {\n    return getProtocol(win) === PROTOCOL.FILE;\n}\n\nexport function isAboutProtocol(win : SameDomainWindowType = window) : boolean {\n    return getProtocol(win) === PROTOCOL.ABOUT;\n}\n\nexport function isMockProtocol(win : SameDomainWindowType = window) : boolean {\n    return getProtocol(win) === PROTOCOL.MOCK;\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    const location = win.location;\n\n    if (!location) {\n        throw new Error(`Can not read window location`);\n    }\n\n    const protocol = getActualProtocol(win);\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        const parent = getParent(win);\n        if (parent && canReadFromWindow(parent)) {\n            // $FlowFixMe\n            return getActualDomain(parent);\n        }\n\n        return `${ PROTOCOL.ABOUT }//`;\n    }\n\n    const 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    const 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        const 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 (isMockProtocol(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        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) : $ReadOnlyArray<CrossDomainWindowType> {\n\n    const 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    const 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) : $ReadOnlyArray<CrossDomainWindowType> {\n\n    const 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) : $ReadOnlyArray<CrossDomainWindowType> {\n\n    const result = [];\n\n    for (const frame of getFrames(win)) {\n        result.push(frame);\n\n        for (const 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 (const 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    const opener = getNextOpener(win);\n\n    if (opener) {\n        return getUltimateTop(opener);\n    }\n\n    return top;\n}\n\nexport function getAllFramesInWindow(win : CrossDomainWindowType) : $ReadOnlyArray<CrossDomainWindowType> {\n    const top = getTop(win);\n\n    if (!top) {\n        throw new Error(`Can not determine top window`);\n    }\n\n    let result = [ ...getAllChildFrames(top), top ];\n\n    // Win may be in shadow dom\n    if (result.indexOf(win) === -1) {\n        result = [ ...result, win, ...getAllChildFrames(win) ];\n    }\n\n    return result;\n}\n\nexport function getAllWindows(win? : CrossDomainWindowType = window) : $ReadOnlyArray<CrossDomainWindowType> {\n    const frames = getAllFramesInWindow(win);\n    const 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    const doc = frame.ownerDocument;\n\n    if (doc && doc.documentElement && !doc.documentElement.contains(frame)) {\n        let parent = frame;\n\n        while (parent.parentNode && parent.parentNode !== parent) {\n            parent = parent.parentNode;\n        }\n\n        // $FlowFixMe\n        if (!parent.host || !doc.documentElement.contains(parent.host)) {\n            return true;\n        }\n    }\n\n    return false;\n}\n\nfunction safeIndexOf<T>(collection : $ReadOnlyArray<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\nconst iframeWindows = [];\nconst 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    const iframeIndex = safeIndexOf(iframeWindows, win);\n\n    if (iframeIndex !== -1) {\n        const 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    const winFrames = getFrames(win);\n\n    for (const 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    const frame = getFrameByName(win, name);\n\n    if (frame) {\n        return frame;\n    }\n\n    for (const childFrame of getFrames(win)) {\n        const namedFrame = findChildFrameByName(childFrame, name);\n\n        if (namedFrame) {\n            return namedFrame;\n        }\n    }\n}\n\nexport function findFrameByName(win : CrossDomainWindowType, name : string) : ?CrossDomainWindowType {\n    const frame = getFrameByName(win, name);\n\n    if (frame) {\n        return frame;\n    }\n\n    const top = getTop(win) || win;\n\n    return findChildFrameByName(top, name);\n}\n\nexport function isParent(win : CrossDomainWindowType, frame : CrossDomainWindowType) : boolean {\n\n    const frameParent = getParent(frame);\n\n    if (frameParent) {\n        return frameParent === win;\n    }\n\n    for (const 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    const opener = getOpener(win);\n\n    if (opener) {\n        return opener;\n    }\n\n    const parent = getParent(win);\n\n    if (parent) {\n        return parent;\n    }\n}\n\nexport function getAncestors(win : CrossDomainWindowType) : $ReadOnlyArray<CrossDomainWindowType> {\n\n    const 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    const 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 (const 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 (const item1 of collection1) {\n        for (const 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    const top1 = getTop(win1) || win1;\n    const 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    const allFrames1 = getAllFramesInWindow(win1);\n    const allFrames2 = getAllFramesInWindow(win2);\n\n    if (anyMatch(allFrames1, allFrames2)) {\n        return true;\n    }\n\n    const opener1 = getOpener(top1);\n    const 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    const 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        // $FlowFixMe method-unbinding\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    try {\n        if ('postMessage' in obj && 'self' in obj && 'location' in obj) {\n            return true;\n        }\n    } catch (err) {\n        // pass\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 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\nexport function closeWindow(win : CrossDomainWindowType) {\n    if (isIframe(win)) {\n        const frame = getFrameForWindow(win);\n        if (frame && frame.parentElement) {\n            frame.parentElement.removeChild(frame);\n            return;\n        }\n    }\n\n    try {\n        win.close();\n    } catch (err) {\n        // pass\n    }\n}\n","/* @flow */\n\nexport const PROTOCOL = {\n    MOCK:  ('mock:' : 'mock:'),\n    FILE:  ('file:' : 'file:'),\n    ABOUT: ('about:' : 'about:')\n};\n\nexport const WILDCARD = '*';\n\nexport const WINDOW_TYPE = {\n    IFRAME: ('iframe' : 'iframe'),\n    POPUP:  ('popup' : 'popup')\n};\n","/* @flow */\n\nimport { isSameDomain, type CrossDomainWindowType } from '@krakenjs/cross-domain-utils/src';\nimport { getCurrentScriptUID } from 'belter/src';\n\nexport function getGlobalKey() : string {\n    if (__ZOID__.__SCRIPT_NAMESPACE__) {\n        return `${ __ZOID__.__GLOBAL_KEY__ }_${ getCurrentScriptUID() }`;\n    } else {\n        return __ZOID__.__GLOBAL_KEY__;\n    }\n}\n\nexport function getGlobal<T>(win : CrossDomainWindowType) : T {\n    const globalKey = getGlobalKey();\n\n    if (!isSameDomain(win)) {\n        throw new Error(`Can not get global for window on different domain`);\n    }\n\n    if (!win[globalKey]) {\n        win[globalKey] = {};\n    }\n\n    return win[globalKey];\n}\n\nexport function tryGlobal<T, R>(win : CrossDomainWindowType, handler : (T) => R) : ?R {\n    try {\n        return handler(getGlobal(win));\n    } catch (err) {\n        // pass\n    }\n}\n\nexport function destroyGlobal() {\n    const globalKey = getGlobalKey();\n    delete window[globalKey];\n}\n","/* @flow */\n\nimport { ZalgoPromise } from 'zalgo-promise/src';\nimport { serializeMessage, deserializeMessage, toProxyWindow, type ProxyWindow } from 'post-robot/src';\nimport { uniqueID, base64encode, base64decode } from 'belter/src';\nimport type { CrossDomainWindowType, DomainMatcher } from '@krakenjs/cross-domain-utils/src';\n\nimport { getGlobal } from './global';\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                // $FlowFixMe[object-this-reference]\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\nexport function basicSerialize<T>(data : T) : string {\n    return base64encode(JSON.stringify(data));\n}\n\nexport function basicDeserialize<T>(serializedData : string) : T {\n    return JSON.parse(base64decode(serializedData));\n}\n\nexport const REFERENCE_TYPE = {\n    UID: ('uid' : 'uid'),\n    RAW: ('raw' : 'raw')\n};\n\nexport type UIDReferenceType = {| type : typeof REFERENCE_TYPE.UID, uid : string |};\nexport type RawReferenceType<T> = {| type : typeof REFERENCE_TYPE.RAW, val : T |};\n\nexport type ReferenceType<T> =\n    UIDReferenceType |\n    RawReferenceType<T>;\n\nexport function getUIDRefStore<T>(win : CrossDomainWindowType) : { [string] : T } {\n    const global = getGlobal(win);\n    global.references = global.references || {};\n    return global.references;\n}\n\nexport function getUIDRef<T>(val : T) : ReferenceType<T> {\n    const uid = uniqueID();\n    const references = getUIDRefStore(window);\n    references[uid] = val;\n    return { type: REFERENCE_TYPE.UID, uid };\n}\n\nexport function getRawRef<T>(val : T) : ReferenceType<T> {\n    return { type: REFERENCE_TYPE.RAW, val };\n}\n\nexport function getRefValue<T>(win : CrossDomainWindowType, ref : ReferenceType<T>) : T {\n    if (ref.type === REFERENCE_TYPE.RAW) {\n        return ref.val;\n    }\n\n    if (ref.type === REFERENCE_TYPE.UID) {\n        const references = getUIDRefStore(win);\n        return references[ref.uid];\n    }\n\n    throw new Error(`Unsupported ref type: ${ ref.type }`);\n}\n\nexport function cleanupRef<T>(win : CrossDomainWindowType, ref : ReferenceType<T>) {\n    if (ref.type === REFERENCE_TYPE.UID) {\n        const references = getUIDRefStore(win);\n        delete references[ref.uid];\n    }\n}\n\ntype Message<T, M> = {|\n    sender : {|\n        domain : string\n    |},\n    metaData : M,\n    reference : ReferenceType<T>\n|};\n\ntype CrossDomainSerializeOptions<T, M> = {|\n    data : T,\n    metaData : M,\n    sender : {|\n        domain : string\n    |},\n    receiver : {|\n        win : ProxyWindow | CrossDomainWindowType,\n        domain : DomainMatcher\n    |},\n    passByReference? : boolean,\n    basic? : boolean\n|};\n\ntype CrossDomainSerializedMessage = {|\n    serializedData : string,\n    cleanReference : () => void\n|};\n\nexport function crossDomainSerialize<T, M>({ data, metaData, sender, receiver, passByReference = false, basic = false } : CrossDomainSerializeOptions<T, M>) : CrossDomainSerializedMessage {\n    const proxyWin = toProxyWindow(receiver.win);\n    const serializedMessage = basic\n        ? JSON.stringify(data)\n        : serializeMessage(proxyWin, receiver.domain, data);\n\n    const reference = passByReference\n        ? getUIDRef(serializedMessage)\n        : getRawRef(serializedMessage);\n\n    const message : Message<string, M> = {\n        sender: {\n            domain: sender.domain\n        },\n        metaData,\n        reference\n    };\n\n    const cleanReference = () => {\n        cleanupRef(window, reference);\n    };\n\n    return {\n        serializedData: basicSerialize(message),\n        cleanReference\n    };\n}\n\ntype CrossDomainDeserializeOptions<M> = {|\n    data : string,\n    sender : {|\n        win : CrossDomainWindowType | ({| metaData : M |}) => CrossDomainWindowType,\n        domain? : string | ({| metaData : M |}) => string\n    |},\n    basic? : boolean\n|};\n\ntype CrossDomainDeserializedMessage<T, M> = {|\n    data : T,\n    metaData : M,\n    sender : {|\n        domain : string,\n        win : CrossDomainWindowType\n    |},\n    reference : ReferenceType<string>\n|};\n\nexport function crossDomainDeserialize<T, M>({ data, sender, basic = false } : CrossDomainDeserializeOptions<M>) : CrossDomainDeserializedMessage<T, M> {\n    const message : Message<string, M> = basicDeserialize(data);\n\n    const { reference, metaData } = message;\n\n    let win;\n    if (typeof sender.win === 'function') {\n        win = sender.win({ metaData });\n    } else {\n        win = sender.win;\n    }\n\n    let domain;\n    if (typeof sender.domain === 'function') {\n        domain = sender.domain({ metaData });\n    } else if (typeof sender.domain === 'string') {\n        domain = sender.domain;\n    } else {\n        domain = message.sender.domain;\n    }\n\n    const serializedData = getRefValue(win, reference);\n    const deserializedData = basic\n        ? JSON.parse(serializedData)\n        : deserializeMessage(win, domain, serializedData);\n    \n    return {\n        data:   deserializedData,\n        metaData,\n        sender: { win, domain },\n        reference\n    };\n}\n","/* @flow */\n\nimport { WINDOW_TYPE } from '@krakenjs/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' : 'string'),\n    OBJECT:   ('object' : 'object'),\n    FUNCTION: ('function' : 'function'),\n    BOOLEAN:  ('boolean' : 'boolean'),\n    NUMBER:   ('number' : 'number'),\n    ARRAY:    ('array' : 'array')\n};\n\nexport const WINDOW_REFERENCE = {\n    OPENER: ('opener' : 'opener'),\n    PARENT: ('parent' : 'parent'),\n    GLOBAL: ('global' : 'global'),\n    NAME:   ('name' : 'name')\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    DESTROY:  'zoid-destroy',\n    PROPS:    'zoid-props',\n    RESIZE:   'zoid-resize',\n    FOCUS:    'zoid-focus'\n};\n\nexport const METHOD = {\n    GET:  ('get' : 'get'),\n    POST: ('post' : 'post')\n};\n","/* @flow */\n\nimport { assertExists, memoize } from 'belter/src';\nimport { isSameDomain, getOpener, getNthParentFromTop, getAncestor, getAllFramesInWindow, getParent, isTop,\n    findFrameByName, getDomain, assertSameDomain, type CrossDomainWindowType, getDistanceFromTop } from '@krakenjs/cross-domain-utils/src';\n\nimport { ZOID, WINDOW_REFERENCE } from '../constants';\nimport type { InitialChildPayload, WindowRef } from '../parent';\n\nimport { crossDomainDeserialize, crossDomainSerialize, REFERENCE_TYPE, type ReferenceType } from './serialize';\nimport { tryGlobal } from './global';\n\nfunction getWindowByRef(windowRef : WindowRef) : CrossDomainWindowType {\n    if (windowRef.type === WINDOW_REFERENCE.OPENER) {\n        return assertExists('opener', getOpener(window));\n\n    } else if (windowRef.type === WINDOW_REFERENCE.PARENT && typeof windowRef.distance === 'number') {\n        return assertExists('parent', getNthParentFromTop(window, windowRef.distance));\n\n    } else if (windowRef.type === WINDOW_REFERENCE.GLOBAL && windowRef.uid && typeof windowRef.uid === 'string') {\n        const { uid } = windowRef;\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 win = tryGlobal(frame, global => global.windows && global.windows[uid]);\n\n                if (win) {\n                    return win;\n                }\n            }\n        }\n    } else if (windowRef.type === WINDOW_REFERENCE.NAME) {\n        const { name } = windowRef;\n        return assertExists('namedWindow', findFrameByName(assertExists('ancestor', getAncestor(window)), name));\n    }\n\n    throw new Error(`Unable to find ${ windowRef.type } parent component window`);\n}\n\nexport function buildChildWindowName({ name, serializedPayload } : {| name : string, serializedPayload : string |}) : string {\n    return `__${ ZOID }__${ name }__${ serializedPayload }__`;\n}\n\nfunction parseWindowName(windowName : string) : {| name : string, serializedInitialPayload : string |} {\n    if (!windowName) {\n        throw new Error(`No window name`);\n    }\n\n    const [ , zoidcomp, name, serializedInitialPayload ] = 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 (!serializedInitialPayload) {\n        throw new Error(`Expected serialized payload ref`);\n    }\n\n    return { name, serializedInitialPayload };\n}\n\nexport type InitialParentPayload<P, X> = {|\n    parent : {|\n        domain : string,\n        win : CrossDomainWindowType\n    |},\n    payload : InitialChildPayload<P, X>,\n    reference : ReferenceType<string>\n|};\n\nconst parseInitialParentPayload = memoize(<P, X>(windowName : string) : InitialParentPayload<P, X> => {\n    const { serializedInitialPayload } = parseWindowName(windowName);\n\n    const { data: payload, sender: parent, reference } = crossDomainDeserialize({\n        data:   serializedInitialPayload,\n        sender: {\n            win: ({ metaData: { windowRef } }) => getWindowByRef(windowRef)\n        }\n    });\n\n    return {\n        parent,\n        payload,\n        reference\n    };\n});\n\nexport function getInitialParentPayload<P, X>() : InitialParentPayload<P, X> {\n    return parseInitialParentPayload(window.name);\n}\n\nexport function isChildComponentWindow(name : string) : boolean {\n    try {\n        return parseWindowName(window.name).name === name;\n    } catch (err) {\n        // pass\n    }\n\n    return false;\n}\n\nexport function getWindowRef(targetWindow : CrossDomainWindowType, currentWindow? : CrossDomainWindowType = window) : ?WindowRef {\n    if (targetWindow === getParent(currentWindow)) {\n        return { type: WINDOW_REFERENCE.PARENT, distance: getDistanceFromTop(targetWindow) };\n    }\n\n    if (targetWindow === getOpener(currentWindow)) {\n        return { type: WINDOW_REFERENCE.OPENER };\n    }\n\n    if (isSameDomain(targetWindow) && !isTop(targetWindow)) {\n        const windowName = assertSameDomain(targetWindow).name;\n        if (windowName) {\n            return { type: WINDOW_REFERENCE.NAME, name: windowName };\n        }\n    }\n}\n\ntype UpdateChildWindowNameWithRefOptions = {|\n    componentName : string,\n    parentComponentWindow : CrossDomainWindowType\n|};\n\nexport function updateChildWindowNameWithRef({ componentName, parentComponentWindow } : UpdateChildWindowNameWithRefOptions) {\n    const { serializedInitialPayload } = parseWindowName(window.name);\n\n    const { data, sender, reference, metaData } = crossDomainDeserialize({\n        data:   serializedInitialPayload,\n        sender: {\n            win: parentComponentWindow\n        },\n        basic: true\n    });\n\n    if (reference.type === REFERENCE_TYPE.UID || metaData.windowRef.type === WINDOW_REFERENCE.GLOBAL) {\n        const windowRef = getWindowRef(parentComponentWindow);\n\n        const { serializedData: serializedPayload } = crossDomainSerialize({\n            data,\n            metaData: {\n                windowRef\n            },\n            sender: {\n                domain: sender.domain\n            },\n            receiver: {\n                win:    window,\n                domain: getDomain()\n            },\n            basic: true\n        });\n\n        window.name = buildChildWindowName({\n            name:              componentName,\n            serializedPayload\n        });\n    }\n}\n","/* @flow */\n\nimport { getDomain, isSameDomain, type CrossDomainWindowType } from '@krakenjs/cross-domain-utils/src';\n\nimport type { PropsDefinitionType, PropsType, ChildPropsType } from '../component/props';\n\nimport type { ChildHelpers } from './index';\n\n// $FlowFixMe\nexport function normalizeChildProp<P, T, X>(propsDef : PropsDefinitionType<P, X>, props : PropsType<P>, key : string, value : ?T, helpers : ChildHelpers<P, X>) : ?T  {\n    if (!propsDef.hasOwnProperty(key)) {\n        return value;\n    }\n\n    const prop = propsDef[key];\n\n    if (typeof prop.childDecorate === 'function') {\n        const { uid, tag, close, focus, onError, onProps, resize, getParent, getParentDomain, show, hide, export: xport, getSiblings } = helpers;\n        const decoratedValue = prop.childDecorate({ value, uid, tag, close, focus, onError, onProps, resize, getParent, getParentDomain, show, hide, export: xport, getSiblings });\n\n        // $FlowFixMe\n        return decoratedValue;\n    }\n\n    return value;\n}\n\n// eslint-disable-next-line max-params\nexport function normalizeChildProps<P, X>(parentComponentWindow : CrossDomainWindowType, propsDef : PropsDefinitionType<P, X>, props : PropsType<P>, origin : string, helpers : ChildHelpers<P, X>, isUpdate : boolean = false) : ChildPropsType<P, X> {\n\n    const result = {};\n\n    for (const key of Object.keys(props)) {\n        const prop = propsDef[key];\n\n        if (prop && prop.sameDomain && (origin !== getDomain(window) || !isSameDomain(parentComponentWindow))) {\n            continue;\n        }\n\n        // $FlowFixMe\n        const value = normalizeChildProp(propsDef, 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 Object.keys(propsDef)) {\n            if (!props.hasOwnProperty(key)) {\n                result[key] = normalizeChildProp(propsDef, props, key, undefined, helpers);\n            }\n        }\n    }\n\n    // $FlowFixMe\n    return result;\n}\n","/* @flow */\n/* eslint max-lines: 0 */\n\nimport { isSameDomain, matchDomain, getAllFramesInWindow, type CrossDomainWindowType,\n    onCloseWindow, assertSameDomain } from '@krakenjs/cross-domain-utils/src';\nimport { markWindowKnown, type CrossDomainFunctionType } from 'post-robot/src';\nimport { ZalgoPromise } from 'zalgo-promise/src';\nimport { extend, onResize, elementReady, noop } from 'belter/src';\n\nimport { getGlobal, tryGlobal, getInitialParentPayload, updateChildWindowNameWithRef } from '../lib';\nimport { CONTEXT } from '../constants';\nimport type { NormalizedComponentOptionsType, getSiblingsPropType } from '../component';\nimport type { PropsType, ChildPropsType } from '../component/props';\nimport type { StringMatcherType } from '../types';\n\nimport { normalizeChildProps } from './props';\n\nexport type ChildExportsType<P> = {|\n    updateProps : CrossDomainFunctionType<[ PropsType<P> ], void>,\n    close : CrossDomainFunctionType<[], void>\n|};\n\nexport type ChildHelpers<P, X> = {|\n    uid : string,\n    tag : string,\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) => {| cancel : () => void |},\n    getParent : () => CrossDomainWindowType,\n    getParentDomain : () => string,\n    show : () => ZalgoPromise<void>,\n    hide : () => ZalgoPromise<void>,\n    export : (X) => ZalgoPromise<void>,\n    getSiblings : getSiblingsPropType\n|};\n\nfunction checkParentDomain(allowedParentDomains : StringMatcherType, domain : string) {\n    if (!matchDomain(allowedParentDomains, domain)) {\n        throw new Error(`Can not be rendered by domain: ${ domain }`);\n    }\n}\n\nfunction focus() : ZalgoPromise<void> {\n    return ZalgoPromise.try(() => {\n        window.focus();\n    });\n}\n\nfunction destroy() : ZalgoPromise<void> {\n    return ZalgoPromise.try(() => {\n        window.close();\n    });\n}\n\nexport type ChildComponent<P, X> = {|\n    getProps : () => ChildPropsType<P, X>,\n    init : () => ZalgoPromise<void>\n|};\n\nexport function childComponent<P, X, C>(options : NormalizedComponentOptionsType<P, X, C>) : ChildComponent<P, X> {\n    const { tag, propsDef, autoResize, allowedParentDomains } = options;\n\n    const onPropHandlers = [];\n\n    const { parent, payload } = getInitialParentPayload();\n    const { win: parentComponentWindow, domain: parentDomain } = parent;\n\n    let props : ChildPropsType<P, X>;\n    const exportsPromise = new ZalgoPromise();\n\n    const { version, uid, exports: parentExports, context, props: initialProps } = payload;\n\n    if (version !== __ZOID__.__VERSION__) {\n        throw new Error(`Parent window has zoid version ${ version }, child window has version ${ __ZOID__.__VERSION__ }`);\n    }\n\n    const { show, hide, close, onError, checkClose, export: parentExport, resize: parentResize, init: parentInit } = parentExports;\n\n    const getParent = () => parentComponentWindow;\n    const getParentDomain = () => parentDomain;\n    \n    const onProps = (handler : Function) => {\n        onPropHandlers.push(handler);\n        return {\n            cancel: () => {\n                onPropHandlers.splice(onPropHandlers.indexOf(handler), 1);\n            }\n        };\n    };\n\n    const resize = ({ width, height } : {| width : ?number, height : ?number |}) : ZalgoPromise<void> => {\n        return parentResize.fireAndForget({ width, height });\n    };\n\n    const xport = (xports : X) : ZalgoPromise<void> => {\n        exportsPromise.resolve(xports);\n        return parentExport(xports);\n    };\n\n    const getSiblings = ({ anyParent } = {}) => {\n        const result = [];\n        const currentParent = props.parent;\n\n        if (typeof anyParent === 'undefined') {\n            anyParent = !currentParent;\n        }\n\n        if (!anyParent && !currentParent) {\n            throw new Error(`No parent found for ${ tag } child`);\n        }\n\n        for (const win of getAllFramesInWindow(window)) {\n            if (!isSameDomain(win)) {\n                continue;\n            }\n\n            const xprops : ChildPropsType<mixed, mixed> = assertSameDomain(win).xprops;\n\n            if (!xprops || getParent() !== xprops.getParent()) {\n                continue;\n            }\n\n            const winParent = xprops.parent;\n\n            if (!anyParent && currentParent) {\n                if (!winParent || winParent.uid !== currentParent.uid) {\n                    continue;\n                }\n            }\n\n            const xports = tryGlobal(win, global => global.exports);\n\n            result.push({\n                props:   xprops,\n                exports: xports\n            });\n        }\n\n        return result;\n    };\n\n    const getHelpers = () : ChildHelpers<P, X> => {\n        return {\n            tag, show, hide, close, focus, onError, resize, getSiblings,\n            onProps, getParent, getParentDomain, uid, export: xport\n        };\n    };\n\n    const watchForClose = () => {\n        window.addEventListener('beforeunload', () => {\n            checkClose.fireAndForget();\n        });\n\n        window.addEventListener('unload', () => {\n            checkClose.fireAndForget();\n        });\n\n        onCloseWindow(parentComponentWindow, () => {\n            destroy();\n        });\n    };\n\n    const setProps = (newProps : PropsType<P>, origin : string, isUpdate : boolean = false) => {\n        const helpers = getHelpers();\n        const normalizedProps = normalizeChildProps(parentComponentWindow, propsDef, newProps, origin, helpers, isUpdate);\n\n        if (props) {\n            extend(props, normalizedProps);\n        } else {\n            props = normalizedProps;\n        }\n\n        for (const handler of onPropHandlers) {\n            handler(props);\n        }\n    };\n    \n    const getAutoResize = () : ZalgoPromise<{| width : boolean, height : boolean, element : ?HTMLElement |}> => {\n        const { width = false, height = false, element: elementRef = 'body' } = autoResize;\n        return elementReady(elementRef).catch(noop).then(element => {\n            return { width, height, element };\n        });\n    };\n\n    const watchForResize = () : ?ZalgoPromise<void> => {\n        return getAutoResize().then(({ width, height, element }) => {\n            if (!element || (!width && !height) || context === CONTEXT.POPUP) {\n                return;\n            }\n\n            onResize(element, ({ width: newWidth, height: newHeight }) => {\n                resize({\n                    width:  width ? newWidth : undefined,\n                    height: height ? newHeight : undefined\n                });\n            }, { width, height });\n        });\n    };\n\n    const updateProps = (newProps : (PropsType<P>)) : ZalgoPromise<void> => {\n        return ZalgoPromise.try(() => setProps(newProps, parentDomain, true));\n    };\n\n    const init = () => {\n        return ZalgoPromise.try(() => {\n            if (isSameDomain(parentComponentWindow)) {\n                updateChildWindowNameWithRef({\n                    componentName: options.name,\n                    parentComponentWindow\n                });\n            }\n\n            getGlobal(window).exports = options.exports({\n                getExports: () => exportsPromise\n            });\n\n            checkParentDomain(allowedParentDomains, parentDomain);\n            markWindowKnown(parentComponentWindow);\n            watchForClose();\n\n            return parentInit({ updateProps, close: destroy });\n    \n        }).then(() => {\n            return watchForResize();\n    \n        }).catch(err => {\n            onError(err);\n        });\n    };\n\n    const getProps = () => {\n        if (props) {\n            return props;\n        } else {\n            setProps(initialProps, parentDomain);\n            return props;\n        }\n    };\n\n    return {\n        init,\n        getProps\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 '@krakenjs/cross-domain-utils/src';\nimport { ProxyWindow, toProxyWindow } from 'post-robot/src';\n\nimport type { CssDimensionsType } from '../types';\nimport { PROP_SERIALIZATION, PROP_TYPE } from '../constants';\n\nexport type EventHandlerType<T> = (T) => void | ZalgoPromise<void>;\nexport type Sibling = {|\n    props : mixed,\n    exports : mixed\n|};\n\nexport type timeoutPropType = number;\nexport type windowPropType = CrossDomainWindowType | ProxyWindow;\nexport type cspNoncePropType = string;\nexport type uidPropType = string;\nexport type tagPropType = string;\nexport type closePropType = () => ZalgoPromise<void>;\nexport type focusPropType = () => ZalgoPromise<void>;\nexport type showPropType = () => ZalgoPromise<void>;\nexport type exportPropType<X> = (X) => ZalgoPromise<void>;\nexport type getSiblingsPropType = (opts? : {| anyParent? : boolean |}) => $ReadOnlyArray<Sibling>;\nexport type hidePropType = () => ZalgoPromise<void>;\nexport type resizePropType = ({| width : ?number, height : ?number |}) => ZalgoPromise<void>;\nexport type getParentPropType = () => CrossDomainWindowType;\nexport type getParentDomainPropType = () => string;\n\nexport type onDisplayPropType = EventHandlerType<void>;\nexport type onRenderedPropType = EventHandlerType<void>;\nexport type onRenderPropType = EventHandlerType<void>;\nexport type onClosePropType = EventHandlerType<void>;\nexport type onDestroyPropType = EventHandlerType<void>;\nexport type onResizePropType = EventHandlerType<void>;\nexport type onFocusPropType = EventHandlerType<void>;\nexport type onErrorPropType = EventHandlerType<mixed>;\nexport type onPropsPropType<P> = ((PropsType<P>) => void) => {| cancel : () => void |}; // eslint-disable-line no-use-before-define\n\nexport type ParentPropType<P, X> = {|\n    uid : string,\n    // eslint-disable-next-line no-use-before-define\n    props : PropsType<P>,\n    export : exportPropType<X>\n|};\n\nexport type PropsInputType<P> = {|\n    parent? : ParentPropType<mixed, mixed>,\n    \n    timeout? : timeoutPropType,\n    window? : windowPropType,\n    cspNonce? : ?cspNoncePropType,\n\n    onDisplay? : onDisplayPropType,\n    onRendered? : onRenderedPropType,\n    onRender? : onRenderPropType,\n    onClose? : onClosePropType,\n    onDestroy? : onDestroyPropType,\n    onResize? : onResizePropType,\n    onFocus? : onFocusPropType,\n    onError? : onErrorPropType,\n    onProps? : onPropsPropType<P>,\n\n    ...P\n|};\n\nexport type PropsType<P> = {|\n    timeout? : timeoutPropType,\n    window? : ?windowPropType,\n    cspNonce? : ?cspNoncePropType,\n    dimensions : CssDimensionsType,\n\n    onDisplay : onDisplayPropType,\n    onRendered : onRenderedPropType,\n    onRender : onRenderPropType,\n    onClose : onClosePropType,\n    onDestroy : onDestroyPropType,\n    onResize : onResizePropType,\n    onFocus : onFocusPropType,\n    onError : onErrorPropType,\n    onProps : onPropsPropType<P>,\n    \n    ...P\n|};\n\ntype onErrorChildPropType = (mixed) => ZalgoPromise<void>;\n\nexport type ChildPropsType<P, X> = {|\n    ...PropsType<P>,\n\n    parent? : ParentPropType<mixed, mixed>,\n    uid : uidPropType,\n    tag : tagPropType,\n    close : closePropType,\n    focus : focusPropType,\n    show : showPropType,\n    hide : hidePropType,\n    export : exportPropType<X>,\n    getParent : getParentPropType,\n    getParentDomain : getParentDomainPropType,\n    resize : resizePropType,\n    onError : onErrorChildPropType,\n    onProps : onPropsPropType<P>,\n    getSiblings : getSiblingsPropType\n|};\n\nexport type PropDefinitionType<T, P, S : $Values<typeof PROP_TYPE>, X> = {|\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        container : HTMLElement | 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        container : HTMLElement | 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        container : HTMLElement | void,\n        event : EventEmitterType\n    |}) => T,\n    childDecorate? : ({|\n        value : ?T,\n        uid : uidPropType,\n        tag : tagPropType,\n        close : closePropType,\n        focus : focusPropType,\n        onError : onErrorPropType,\n        onProps : onPropsPropType<P>,\n        resize : resizePropType,\n        getParentDomain : getParentDomainPropType,\n        getParent : getParentPropType,\n        show : showPropType,\n        hide : hidePropType,\n        export : exportPropType<X>,\n        getSiblings : getSiblingsPropType\n    |}) => ?T,\n    required? : boolean,\n    queryParam? : boolean | string | ({| value : T |}) => (string | ZalgoPromise<string>),\n    bodyParam? : boolean | string | ({| value : T |}) => (string | ZalgoPromise<string>),\n    // eslint-disable-next-line no-undef\n    queryValue? : <R>({| value : T |}) => (ZalgoPromise<R> | R | string),\n    // eslint-disable-next-line no-undef\n    bodyValue? : <R>({| value : T |}) => (ZalgoPromise<R> | R | string),\n    sendToChild? : boolean,\n    allowDelegate? : boolean,\n    validate? : ({| value : T, props : PropsType<P> |}) => void,\n    sameDomain? : boolean,\n    serialization? : $Values<typeof PROP_SERIALIZATION>\n|};\n\nexport type BOOLEAN_DEFINITION_TYPE = typeof PROP_TYPE.BOOLEAN;\nexport type STRING_DEFINITION_TYPE = typeof PROP_TYPE.STRING;\nexport type NUMBER_DEFINITION_TYPE = typeof PROP_TYPE.NUMBER;\nexport type FUNCTION_DEFINITION_TYPE = typeof PROP_TYPE.FUNCTION;\nexport type ARRAY_DEFINITION_TYPE = typeof PROP_TYPE.ARRAY;\nexport type OBJECT_DEFINITION_TYPE = typeof PROP_TYPE.OBJECT;\n\nexport type DEFINITION_TYPE =\n        BOOLEAN_DEFINITION_TYPE | STRING_DEFINITION_TYPE | NUMBER_DEFINITION_TYPE |\n        FUNCTION_DEFINITION_TYPE | ARRAY_DEFINITION_TYPE | OBJECT_DEFINITION_TYPE;\n\n\nexport type BooleanPropDefinitionType<T : boolean, P, X> = PropDefinitionType<T, P, BOOLEAN_DEFINITION_TYPE, X>;\nexport type StringPropDefinitionType<T : string, P, X> = PropDefinitionType<T, P, STRING_DEFINITION_TYPE, X>;\nexport type NumberPropDefinitionType<T : number, P, X> = PropDefinitionType<T, P, NUMBER_DEFINITION_TYPE, X>;\nexport type FunctionPropDefinitionType<T : Function, P, X> = PropDefinitionType<T, P, FUNCTION_DEFINITION_TYPE, X>;\nexport type ArrayPropDefinitionType<T : Array<*> | $ReadOnlyArray<*>, P, X> = PropDefinitionType<T, P, ARRAY_DEFINITION_TYPE, X>; // eslint-disable-line flowtype/no-mutable-array\nexport type ObjectPropDefinitionType<T : Object, P, X> = PropDefinitionType<T, P, OBJECT_DEFINITION_TYPE, X>;\n\nexport type MixedPropDefinitionType<P, X> =\n    BooleanPropDefinitionType<*, P, X> |\n    StringPropDefinitionType<*, P, X> |\n    NumberPropDefinitionType<*, P, X> |\n    FunctionPropDefinitionType<*, P, X> |\n    ObjectPropDefinitionType<*, P, X> |\n    ArrayPropDefinitionType<*, P, X>;\n\nexport type UserPropsDefinitionType<P, X> = {|\n    [string] : MixedPropDefinitionType<P, X>\n|};\n\nexport type BuiltInPropsDefinitionType<P, X> = {|\n    timeout : NumberPropDefinitionType<timeoutPropType, P, X>,\n    window : ObjectPropDefinitionType<windowPropType, P, X>,\n    close : FunctionPropDefinitionType<closePropType, P, X>,\n    focus : FunctionPropDefinitionType<focusPropType, P, X>,\n    resize : FunctionPropDefinitionType<resizePropType, P, X>,\n    uid : StringPropDefinitionType<uidPropType, P, X>,\n    tag : StringPropDefinitionType<tagPropType, P, X>,\n    cspNonce : StringPropDefinitionType<cspNoncePropType, P, X>,\n    getParent : FunctionPropDefinitionType<getParentPropType, P, X>,\n    getParentDomain : FunctionPropDefinitionType<getParentDomainPropType, P, X>,\n    hide : FunctionPropDefinitionType<hidePropType, P, X>,\n    show : FunctionPropDefinitionType<showPropType, P, X>,\n    export : FunctionPropDefinitionType<exportPropType<X>, P, X>,\n    getSiblings : FunctionPropDefinitionType<getSiblingsPropType, P, X>,\n\n    onDisplay : FunctionPropDefinitionType<onDisplayPropType, P, X>,\n    onRendered : FunctionPropDefinitionType<onRenderedPropType, P, X>,\n    onRender : FunctionPropDefinitionType<onRenderPropType, P, X>,\n    onClose : FunctionPropDefinitionType<onClosePropType, P, X>,\n    onDestroy : FunctionPropDefinitionType<onDestroyPropType, P, X>,\n    onResize : FunctionPropDefinitionType<onClosePropType, P, X>,\n    onFocus : FunctionPropDefinitionType<onFocusPropType, P, X>,\n    onError : FunctionPropDefinitionType<onErrorPropType, P, X>,\n    onProps : FunctionPropDefinitionType<onPropsPropType<P>, P, X>\n|};\n\nexport type PropsDefinitionType<P, X> = {|\n    ...BuiltInPropsDefinitionType<P, X>,\n    [ string ] : MixedPropDefinitionType<P, X>\n|};\n\nconst defaultNoop = () => noop;\n// eslint-disable-next-line flowtype/require-exact-type\nconst decorateOnce = <F : Function>({ value } : { value : F }) : F => once(value);\n\nexport function getBuiltInProps<P, X>() : BuiltInPropsDefinitionType<P, X> {\n    return {\n        window: {\n            type:          PROP_TYPE.OBJECT,\n            sendToChild:   false,\n            required:      false,\n            allowDelegate: true,\n            validate:      ({ value }) => {\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 }) => {\n                return toProxyWindow(value);\n            }\n        },\n\n        timeout: {\n            type:        PROP_TYPE.NUMBER,\n            required:    false,\n            sendToChild: false\n        },\n\n        cspNonce: {\n            type:     PROP_TYPE.STRING,\n            required: false\n        },\n\n        onDisplay: {\n            type:          PROP_TYPE.FUNCTION,\n            required:      false,\n            sendToChild:   false,\n            allowDelegate: true,\n            default:       defaultNoop,\n            decorate:      decorateOnce\n        },\n\n        onRendered: {\n            type:        PROP_TYPE.FUNCTION,\n            required:    false,\n            sendToChild: false,\n            default:     defaultNoop,\n            decorate:    decorateOnce\n        },\n\n        onRender: {\n            type:        PROP_TYPE.FUNCTION,\n            required:    false,\n            sendToChild: false,\n            default:     defaultNoop,\n            decorate:    decorateOnce\n        },\n\n        onClose: {\n            type:          PROP_TYPE.FUNCTION,\n            required:      false,\n            sendToChild:   false,\n            allowDelegate: true,\n            default:       defaultNoop,\n            decorate:      decorateOnce\n        },\n\n        onDestroy: {\n            type:          PROP_TYPE.FUNCTION,\n            required:      false,\n            sendToChild:   false,\n            allowDelegate: true,\n            default:       defaultNoop,\n            decorate:      decorateOnce\n        },\n\n        onResize: {\n            type:          PROP_TYPE.FUNCTION,\n            required:      false,\n            sendToChild:   false,\n            allowDelegate: true,\n            default:       defaultNoop\n        },\n\n        onFocus: {\n            type:          PROP_TYPE.FUNCTION,\n            required:      false,\n            sendToChild:   false,\n            allowDelegate: true,\n            default:       defaultNoop\n        },\n\n        close: {\n            type:          PROP_TYPE.FUNCTION,\n            required:      false,\n            sendToChild:   false,\n            childDecorate: ({ close }) => close\n        },\n\n        focus: {\n            type:          PROP_TYPE.FUNCTION,\n            required:      false,\n            sendToChild:   false,\n            childDecorate: ({ focus }) => focus\n        },\n\n        resize: {\n            type:          PROP_TYPE.FUNCTION,\n            required:      false,\n            sendToChild:   false,\n            childDecorate: ({ resize }) => resize\n        },\n\n        uid: {\n            type:          PROP_TYPE.STRING,\n            required:      false,\n            sendToChild:   false,\n            childDecorate: ({ uid }) => uid\n        },\n\n        tag: {\n            type:          PROP_TYPE.STRING,\n            required:      false,\n            sendToChild:   false,\n            childDecorate: ({ tag }) => tag\n        },\n\n        getParent: {\n            type:          PROP_TYPE.FUNCTION,\n            required:      false,\n            sendToChild:   false,\n            childDecorate: ({ getParent }) => getParent\n        },\n\n        getParentDomain: {\n            type:          PROP_TYPE.FUNCTION,\n            required:      false,\n            sendToChild:   false,\n            childDecorate: ({ getParentDomain }) => getParentDomain\n        },\n\n        show: {\n            type:          PROP_TYPE.FUNCTION,\n            required:      false,\n            sendToChild:   false,\n            childDecorate: ({ show }) => show\n        },\n\n        hide: {\n            type:          PROP_TYPE.FUNCTION,\n            required:      false,\n            sendToChild:   false,\n            childDecorate: ({ hide }) => hide\n        },\n\n        export: {\n            type:          PROP_TYPE.FUNCTION,\n            required:      false,\n            sendToChild:   false,\n            childDecorate: ({ 'export': xport }) => xport\n        },\n\n        onError: {\n            type:          PROP_TYPE.FUNCTION,\n            required:      false,\n            sendToChild:   false,\n            childDecorate: ({ onError }) => onError\n        },\n\n        onProps: {\n            type:          PROP_TYPE.FUNCTION,\n            required:      false,\n            sendToChild:   false,\n            childDecorate: ({ onProps }) => onProps\n        },\n\n        getSiblings: {\n            type:          PROP_TYPE.FUNCTION,\n            required:      false,\n            sendToChild:   false,\n            childDecorate: ({ getSiblings }) => getSiblings\n        }\n    };\n}\n\ntype PropCallback<P, X, R> =\n    ((string, BooleanPropDefinitionType<boolean, P, X> | void, boolean) => R) &\n    ((string, StringPropDefinitionType<string, P, X> | void, string) => R) &\n    ((string, NumberPropDefinitionType<number, P, X> | void, number) => R) &\n    ((string, FunctionPropDefinitionType<Function, P, X> | void, Function) => R) &\n    ((string, ArrayPropDefinitionType<$ReadOnlyArray<*> | $ReadOnlyArray<*>, P, X>  | void, $ReadOnlyArray<*> | $ReadOnlyArray<*>) => R) &\n    ((string, ObjectPropDefinitionType<Object, P, X>  | void, Object) => R);\n\nexport function eachProp<P, X>(props : PropsType<P>, propsDef : PropsDefinitionType<P, X>, handler : PropCallback<P, X, void>) {\n    // $FlowFixMe[cannot-spread-indexer]\n    for (const key of Object.keys({ ...props, ...propsDef })) {\n        const propDef = propsDef[key];\n        const value = props[key];\n\n        // $FlowFixMe[incompatible-call]\n        handler(key, propDef, value);\n    }\n}\n\nexport function mapProps<P, X, T>(props : PropsType<P>, propsDef : PropsDefinitionType<P, X>, handler : PropCallback<P, X, T>) : $ReadOnlyArray<T> {\n    const results = [];\n\n    eachProp(props, propsDef, (key, propDef, value) => {\n        // $FlowFixMe[incompatible-call]\n        const result = handler(key, propDef, value);\n        results.push(result);\n    });\n    return results;\n}\n","/* @flow */\n\nimport { ZalgoPromise } from 'zalgo-promise/src';\nimport { dotify, isDefined, base64encode, noop } from 'belter/src';\n\nimport { eachProp, mapProps, type PropsInputType, type PropsType, type PropsDefinitionType } from '../component/props';\nimport { PROP_SERIALIZATION, METHOD, PROP_TYPE } from '../constants';\n\nimport type { ParentHelpers } from './index';\n\nexport function extendProps<P, X>(propsDef : PropsDefinitionType<P, X>, existingProps : PropsType<P>, inputProps : PropsInputType<P>, helpers : ParentHelpers<P>, container : HTMLElement | void) {\n    const { state, close, focus, event, onError } = helpers;\n\n    // $FlowFixMe\n    eachProp(inputProps, propsDef, (key, propDef, val) => {\n        let valueDetermined = false;\n        let value = val;\n\n        const getDerivedValue = () => {\n            if (!propDef) {\n                return value;\n            }\n\n            const alias = propDef.alias;\n            if (alias && !isDefined(val) && isDefined(inputProps[alias])) {\n                value = inputProps[alias];\n            }\n    \n            if (propDef.value) {\n                value = propDef.value({ props: existingProps, state, close, focus, event, onError, container });\n            }\n    \n            if (propDef.default && !isDefined(value) && !isDefined(inputProps[key])) {\n                value = propDef.default({ props: existingProps, state, close, focus, event, onError, container });\n            }\n\n            if (isDefined(value)) {\n                if (propDef.type === PROP_TYPE.ARRAY ? !Array.isArray(value) : (typeof value !== propDef.type)) {\n                    throw new TypeError(`Prop is not of type ${ propDef.type }: ${ key }`);\n                }\n            } else {\n                if (propDef.required !== false && !isDefined(inputProps[key])) {\n                    throw new Error(`Expected prop \"${ key }\" to be defined`);\n                }\n            }\n    \n            if (__DEBUG__ && isDefined(value) && propDef.validate) {\n                // $FlowFixMe\n                propDef.validate({ value, props: inputProps });\n            }\n\n            if (isDefined(value) && propDef.decorate) {\n                // $FlowFixMe\n                value = propDef.decorate({ value, props: existingProps, state, close, focus, event, onError, container });\n            }\n\n            return value;\n        };\n\n        const getter = () => {\n            if (valueDetermined) {\n                return value;\n            }\n\n            valueDetermined = true;\n            return getDerivedValue();\n        };\n\n        Object.defineProperty(existingProps, key, {\n            configurable: true,\n            enumerable:   true,\n            get:          getter\n        });\n    });\n\n    // $FlowFixMe\n    eachProp(existingProps, propsDef, noop);\n}\n\nexport function serializeProps<P, X>(propsDef : PropsDefinitionType<P, X>, props : (PropsType<P>), method : $Values<typeof METHOD>) : ZalgoPromise<{ [string] : string | boolean }> {\n\n    const params = {};\n\n    return ZalgoPromise.all(mapProps(props, propsDef, (key, propDef, value) => {\n        return ZalgoPromise.resolve().then(() => {\n\n            if (value === null || typeof value === 'undefined' || !propDef) {\n                return;\n            }\n\n            const getParam = {\n                [ METHOD.GET ]:  propDef.queryParam,\n                [ METHOD.POST ]: propDef.bodyParam\n            }[method];\n\n            const getValue = {\n                [ METHOD.GET ]:  propDef.queryValue,\n                [ METHOD.POST ]: propDef.bodyValue\n            }[method];\n            \n            if (!getParam) {\n                return;\n            }\n\n            return ZalgoPromise.hash({\n\n                finalParam: ZalgoPromise.try(() => {\n                    if (typeof getParam === 'function') {\n                        // $FlowFixMe[incompatible-call]\n                        return getParam({ value });\n                    } else if (typeof getParam === 'string') {\n                        return getParam;\n                    } else {\n                        return key;\n                    }\n                }),\n    \n                finalValue: ZalgoPromise.try(() => {\n                    if (typeof getValue === 'function' && isDefined(value)) {\n                        // $FlowFixMe[incompatible-call]\n                        // $FlowFixMe[incompatible-return]\n                        return getValue({ value });\n                    } else {\n                        // $FlowFixMe[incompatible-return]\n                        return value;\n                    }\n                })\n\n            }).then(({ finalParam, finalValue }) => {\n\n                let result;\n\n                if (typeof finalValue === 'boolean') {\n                    result = finalValue.toString();\n                } else if (typeof finalValue === 'string') {\n                    result = finalValue.toString();\n                } else if (typeof finalValue === 'object' && finalValue !== null) {\n\n                    if (propDef.serialization === PROP_SERIALIZATION.JSON) {\n                        result = JSON.stringify(finalValue);\n                    } else if (propDef.serialization === PROP_SERIALIZATION.BASE64) {\n                        result = base64encode(JSON.stringify(finalValue));\n                    } else if (propDef.serialization === PROP_SERIALIZATION.DOTIFY || !propDef.serialization) {\n                        result = dotify(finalValue, 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 finalValue === 'number') {\n                    result = finalValue.toString();\n                }\n\n                params[finalParam] = result;\n            });\n        });\n\n    })).then(() => {\n        return params;\n    });\n}\n","/* @flow */\n/* eslint max-lines: 0 */\n\nimport { send, bridge, ProxyWindow, toProxyWindow, type CrossDomainFunctionType, cleanUpWindow } from 'post-robot/src';\nimport { isSameDomain, matchDomain, getDomainFromUrl, isBlankDomain, getAncestor, getDomain, type CrossDomainWindowType,\n    getDistanceFromTop, normalizeMockUrl, assertSameDomain, closeWindow, onCloseWindow, isWindowClosed, isSameTopWindow,\n    type DomainMatcher } from '@krakenjs/cross-domain-utils/src';\nimport { ZalgoPromise } from 'zalgo-promise/src';\nimport { addEventListener, uniqueID, elementReady, writeElementToWindow, eventEmitter, type EventEmitterType,\n    noop, onResize, extendUrl, appendChild, cleanup,\n    once, stringifyError, destroyElement, getElementSafe, showElement, hideElement, iframe, memoize, isElementClosed,\n    awaitFrameWindow, popup, normalizeDimension, watchElementForClose, isShadowElement, insertShadowSlot, extend } from 'belter/src';\n\nimport { ZOID, POST_MESSAGE, CONTEXT, EVENT, METHOD,\n    WINDOW_REFERENCE, DEFAULT_DIMENSIONS } from '../constants';\nimport { getGlobal, getProxyObject, crossDomainSerialize, buildChildWindowName, type ProxyObject } from '../lib';\nimport type { PropsInputType, PropsType } from '../component/props';\nimport type { ChildExportsType } from '../child';\nimport type { CssDimensionsType, ContainerReferenceType } from '../types';\nimport type { NormalizedComponentOptionsType, AttributesType } from '../component';\n\nimport { serializeProps, extendProps } from './props';\n\nexport type RenderOptionsType<P> = {|\n    uid : string,\n    props : PropsType<P>,\n    tag : string,\n    context : $Values<typeof CONTEXT>,\n    close : (?string) => ZalgoPromise<void>,\n    focus : () => ZalgoPromise<void>,\n    doc : Document,\n    container? : HTMLElement,\n    dimensions : CssDimensionsType,\n    state : Object,\n    event : EventEmitterType,\n    frame : ?HTMLIFrameElement,\n    prerenderFrame : ?HTMLIFrameElement\n|};\n\nexport type ParentExportsType<P, X> = {|\n    init : (ChildExportsType<P>) => ZalgoPromise<void>,\n    close : () => ZalgoPromise<void>,\n    checkClose : CrossDomainFunctionType<[], boolean>,\n    resize : CrossDomainFunctionType<[{| width? : ?number, height? : ?number |}], void>,\n    onError : (mixed) => ZalgoPromise<void>,\n    show : () => ZalgoPromise<void>,\n    hide : () => ZalgoPromise<void>,\n    export : (X) => ZalgoPromise<void>\n|};\n\nexport type WindowRef =\n    {| type : typeof WINDOW_REFERENCE.OPENER |} |\n    {| type : typeof WINDOW_REFERENCE.PARENT, distance : number |} |\n    {| type : typeof WINDOW_REFERENCE.GLOBAL, uid : string |} |\n    {| type : typeof WINDOW_REFERENCE.NAME, name : string |};\n\nexport type InitialChildPayload<P, X> = {|\n    uid : string,\n    tag : string,\n    version : string,\n    context : $Values<typeof CONTEXT>,\n    childDomainMatch : DomainMatcher,\n    props : PropsType<P>,\n    exports : ParentExportsType<P, X>\n|};\n\nexport type InitialChildPayloadMetadata = {|\n    windowRef : WindowRef\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\nfunction getDefaultProps<P>() : PropsType<P> {\n    // $FlowFixMe\n    return {};\n}\n\ntype InternalState = {|\n    visible : boolean\n|};\n\ntype Rerender = () => ZalgoPromise<void>;\n\ntype RenderContainerOptions = {|\n    context : $Values<typeof CONTEXT>,\n    proxyFrame : ?ProxyObject<HTMLIFrameElement>,\n    proxyPrerenderFrame : ?ProxyObject<HTMLIFrameElement>,\n    rerender : Rerender\n|};\n\ntype ResolveInitPromise = () => ZalgoPromise<void>;\ntype RejectInitPromise = (mixed) => ZalgoPromise<void>;\ntype GetProxyContainer = (container : ContainerReferenceType) => ZalgoPromise<ProxyObject<HTMLElement>>;\ntype Show = () => ZalgoPromise<void>;\ntype Hide = () => ZalgoPromise<void>;\ntype Close = () => ZalgoPromise<void>;\ntype OnError = (mixed) => ZalgoPromise<void>;\ntype RenderContainer = (proxyContainer : ProxyObject<HTMLElement>, RenderContainerOptions) => ZalgoPromise<?ProxyObject<HTMLElement>>;\ntype SetProxyWin = (ProxyWindow) => ZalgoPromise<void>;\ntype GetProxyWindow = () => ZalgoPromise<ProxyWindow>;\ntype OpenFrame = (context : $Values<typeof CONTEXT>, {| windowName : string |}) => ZalgoPromise<?ProxyObject<HTMLIFrameElement>>;\ntype OpenPrerenderFrame = (context : $Values<typeof CONTEXT>) => ZalgoPromise<?ProxyObject<HTMLIFrameElement>>;\ntype Prerender = (proxyPrerenderWin : ProxyWindow, {| context : $Values<typeof CONTEXT>|}) => ZalgoPromise<void>;\ntype Open = (context : $Values<typeof CONTEXT>, {| proxyWin : ProxyWindow, proxyFrame : ?ProxyObject<HTMLIFrameElement>, windowName : string |}) => ZalgoPromise<ProxyWindow>;\ntype OpenPrerender = (context : $Values<typeof CONTEXT>, proxyWin : ProxyWindow, proxyPrerenderFrame : ?ProxyObject<HTMLIFrameElement>) => ZalgoPromise<ProxyWindow>;\ntype WatchForUnload = () => ZalgoPromise<void>;\ntype GetInternalState = () => ZalgoPromise<InternalState>;\ntype SetInternalState = (InternalState) => ZalgoPromise<InternalState>;\n\ntype ParentDelegateOverrides<P> = {|\n    props : PropsType<P>,\n    event : EventEmitterType,\n    close : Close,\n    onError : OnError,\n    getProxyContainer : GetProxyContainer,\n    show : Show,\n    hide : Hide,\n    renderContainer : RenderContainer,\n    getProxyWindow : GetProxyWindow,\n    setProxyWin : SetProxyWin,\n    openFrame : OpenFrame,\n    openPrerenderFrame : OpenPrerenderFrame,\n    prerender : Prerender,\n    open : Open,\n    openPrerender : OpenPrerender,\n    watchForUnload : WatchForUnload,\n    getInternalState : GetInternalState,\n    setInternalState : SetInternalState,\n    resolveInitPromise : ResolveInitPromise,\n    rejectInitPromise : RejectInitPromise\n|};\n\ntype DelegateOverrides = {|\n    getProxyContainer : GetProxyContainer,\n    show : Show,\n    hide : Hide,\n    renderContainer : RenderContainer,\n    getProxyWindow : GetProxyWindow,\n    setProxyWin : SetProxyWin,\n    openFrame : OpenFrame,\n    openPrerenderFrame : OpenPrerenderFrame,\n    prerender : Prerender,\n    open : Open,\n    openPrerender : OpenPrerender,\n    watchForUnload : WatchForUnload\n|};\n\ntype RenderOptions = {|\n    target : CrossDomainWindowType,\n    container : ContainerReferenceType,\n    context : $Values<typeof CONTEXT>,\n    rerender : Rerender\n|};\n\ntype ParentComponent<P, X> = {|\n    init : () => void,\n    render : (RenderOptions) => ZalgoPromise<void>,\n    getProps : () => PropsType<P>,\n    setProps : (newProps : PropsInputType<P>, isUpdate? : boolean) => void,\n    export : (X) => ZalgoPromise<void>,\n    destroy : (err? : mixed) => ZalgoPromise<void>,\n    getHelpers : () => ParentHelpers<P>,\n    getDelegateOverrides : () => ZalgoPromise<DelegateOverrides>,\n    getExports : () => X\n|};\n\nconst getDefaultOverrides = <P>() : ParentDelegateOverrides<P> => {\n    // $FlowFixMe\n    return {};\n};\n\ntype ParentOptions<P, X, C> = {|\n    uid : string,\n    options : NormalizedComponentOptionsType<P, X, C>,\n    overrides? : ParentDelegateOverrides<P>,\n    parentWin? : CrossDomainWindowType\n|};\n\nexport function parentComponent<P, X, C>({ uid, options, overrides = getDefaultOverrides(), parentWin = window } : ParentOptions<P, X, C>) : ParentComponent<P, X> {\n    const { propsDef, containerTemplate, prerenderTemplate, tag, name, attributes, dimensions, autoResize, url, domain: domainMatch, validate, exports: xports } = options;\n\n    const initPromise = new ZalgoPromise();\n    const handledErrors = [];\n    const clean = cleanup();\n    const state = {};\n    const inputProps = {};\n    let internalState = {\n        visible: true\n    };\n    const event = overrides.event ? overrides.event : eventEmitter();\n    const props : PropsType<P> = overrides.props ? overrides.props : getDefaultProps();\n\n    let currentProxyWin : ?ProxyWindow;\n    let currentProxyContainer : ?ProxyObject<HTMLElement>;\n    let childComponent : ?ChildExportsType<P>;\n    let currentChildDomain : ?string;\n    let currentContainer : HTMLElement | void;\n\n    const onErrorOverride : ?OnError = overrides.onError;\n    let getProxyContainerOverride : ?GetProxyContainer = overrides.getProxyContainer;\n    let showOverride : ?Show = overrides.show;\n    let hideOverride : ?Hide = overrides.hide;\n    const closeOverride : ?Close = overrides.close;\n    let renderContainerOverride : ?RenderContainer = overrides.renderContainer;\n    let getProxyWindowOverride : ?GetProxyWindow = overrides.getProxyWindow;\n    let setProxyWinOverride : ?SetProxyWin = overrides.setProxyWin;\n    let openFrameOverride : ?OpenFrame = overrides.openFrame;\n    let openPrerenderFrameOverride : ?OpenPrerenderFrame = overrides.openPrerenderFrame;\n    let prerenderOverride : ?Prerender = overrides.prerender;\n    let openOverride : ?Open = overrides.open;\n    let openPrerenderOverride : ?OpenPrerender = overrides.openPrerender;\n    let watchForUnloadOverride : ?WatchForUnload = overrides.watchForUnload;\n    const getInternalStateOverride : ?GetInternalState = overrides.getInternalState;\n    const setInternalStateOverride : ?SetInternalState = overrides.setInternalState;\n\n    const getDimensions = () : CssDimensionsType => {\n        if (typeof dimensions === 'function') {\n            return dimensions({ props });\n        }\n        return dimensions;\n    };\n\n    const resolveInitPromise = () => {\n        return ZalgoPromise.try(() => {\n            if (overrides.resolveInitPromise) {\n                return overrides.resolveInitPromise();\n            }\n\n            return initPromise.resolve();\n        });\n    };\n\n    const rejectInitPromise = (err : mixed) => {\n        return ZalgoPromise.try(() => {\n            if (overrides.rejectInitPromise) {\n                return overrides.rejectInitPromise(err);\n            }\n\n            return initPromise.reject(err);\n        });\n    };\n\n    const getPropsForChild = (initialChildDomain : string) : ZalgoPromise<PropsType<P>> => {\n        const result = {};\n\n        for (const key of Object.keys(props)) {\n            const prop = propsDef[key];\n\n            if (prop && prop.sendToChild === false) {\n                continue;\n            }\n\n            if (prop && prop.sameDomain && !matchDomain(initialChildDomain, getDomain(window))) {\n                continue;\n            }\n            \n            result[key] = props[key];\n        }\n\n        // $FlowFixMe\n        return ZalgoPromise.hash(result);\n    };\n\n    const setupEvents = () => {\n        event.on(EVENT.RENDER,   () => props.onRender());\n        event.on(EVENT.DISPLAY,  () => props.onDisplay());\n        event.on(EVENT.RENDERED, () => props.onRendered());\n        event.on(EVENT.CLOSE,    () => props.onClose());\n        event.on(EVENT.DESTROY,  () => props.onDestroy());\n        event.on(EVENT.RESIZE,   () => props.onResize());\n        event.on(EVENT.FOCUS,    () => props.onFocus());\n        event.on(EVENT.PROPS,    (newProps) => props.onProps(newProps));\n        event.on(EVENT.ERROR, err => {\n            if (props && props.onError) {\n                return props.onError(err);\n            } else {\n                return rejectInitPromise(err).then(() => {\n                    setTimeout(() => {\n                        throw err;\n                    }, 1);\n                });\n            }\n        });\n\n        clean.register(event.reset);\n    };\n\n    const getInternalState = () => {\n        return ZalgoPromise.try(() => {\n            if (getInternalStateOverride) {\n                return getInternalStateOverride();\n            }\n\n            return internalState;\n        });\n    };\n\n    const setInternalState = (newInternalState)  => {\n        return ZalgoPromise.try(() => {\n            if (setInternalStateOverride) {\n                return setInternalStateOverride(newInternalState);\n            }\n\n            internalState = { ...internalState, ...newInternalState };\n            return internalState;\n        });\n    };\n\n    const getProxyWindow = () : ZalgoPromise<ProxyWindow> => {\n        if (getProxyWindowOverride) {\n            return getProxyWindowOverride();\n        }\n\n        return ZalgoPromise.try(() => {\n            const windowProp = props.window;\n\n            if (windowProp) {\n                const proxyWin = toProxyWindow(windowProp);\n                clean.register(() => windowProp.close());\n                return proxyWin;\n            }\n\n            return new ProxyWindow({ send });\n        });\n    };\n\n    const setProxyWin = (proxyWin : ProxyWindow) : ZalgoPromise<void> => {\n        if (setProxyWinOverride) {\n            return setProxyWinOverride(proxyWin);\n        }\n\n        return ZalgoPromise.try(() => {\n            currentProxyWin = proxyWin;\n        });\n    };\n\n    const show = () : ZalgoPromise<void> => {\n        if (showOverride) {\n            return showOverride();\n        }\n\n        return ZalgoPromise.hash({\n            setState:    setInternalState({ visible: true }),\n            showElement: currentProxyContainer ? currentProxyContainer.get().then(showElement) : null\n        }).then(noop);\n    };\n\n    const hide = () : ZalgoPromise<void> => {\n        if (hideOverride) {\n            return hideOverride();\n        }\n\n        return ZalgoPromise.hash({\n            setState:    setInternalState({ visible: false }),\n            showElement: currentProxyContainer ? currentProxyContainer.get().then(hideElement) : null\n        }).then(noop);\n    };\n\n    const getUrl = () : string => {\n        if (typeof url === 'function') {\n            return url({ props });\n        }\n\n        return url;\n    };\n\n    const getAttributes = () : AttributesType => {\n        if (typeof attributes === 'function') {\n            return attributes({ props });\n        }\n\n        return attributes;\n    };\n\n    const buildQuery = () : ZalgoPromise<{| [string] : string | boolean |}> => {\n        return serializeProps(propsDef, props, METHOD.GET);\n    };\n\n    const buildBody = () : ZalgoPromise<{| [string] : string | boolean |}> => {\n        return serializeProps(propsDef, props, METHOD.POST);\n    };\n\n    const buildUrl = () : ZalgoPromise<string> => {\n        return buildQuery().then(query => {\n            return extendUrl(normalizeMockUrl(getUrl()), { query });\n        });\n    };\n\n    const getInitialChildDomain = () : string => {\n        return getDomainFromUrl(getUrl());\n    };\n\n    const getDomainMatcher = () : DomainMatcher => {\n        if (domainMatch) {\n            return domainMatch;\n        }\n\n        return getInitialChildDomain();\n    };\n\n    const openFrame = (context : $Values<typeof CONTEXT>, { windowName } : {| windowName : string |}) : ZalgoPromise<?ProxyObject<HTMLIFrameElement>> => {\n        if (openFrameOverride) {\n            return openFrameOverride(context, { windowName });\n        }\n        \n        return ZalgoPromise.try(() => {\n            if (context === CONTEXT.IFRAME && __ZOID__.__IFRAME_SUPPORT__) {\n\n                // $FlowFixMe\n                const attrs = {\n                    name:  windowName,\n                    title: name,\n                    ...getAttributes().iframe\n                };\n\n                return getProxyObject(iframe({ attributes: attrs }));\n            }\n        });\n    };\n\n    const openPrerenderFrame = (context : $Values<typeof CONTEXT>) : ZalgoPromise<?ProxyObject<HTMLIFrameElement>> => {\n        if (openPrerenderFrameOverride) {\n            return openPrerenderFrameOverride(context);\n        }\n\n        return ZalgoPromise.try(() => {\n            if (context === CONTEXT.IFRAME && __ZOID__.__IFRAME_SUPPORT__) {\n                // $FlowFixMe\n                const attrs = {\n                    name:  `__${ ZOID }_prerender_frame__${ name }_${ uniqueID() }__`,\n                    title: `prerender__${ name }`,\n                    ...getAttributes().iframe\n                };\n                return getProxyObject(iframe({\n                    attributes: attrs\n                }));\n            }\n        });\n    };\n    \n    const openPrerender = (context : $Values<typeof CONTEXT>, proxyWin : ProxyWindow, proxyPrerenderFrame : ?ProxyObject<HTMLIFrameElement>) : ZalgoPromise<ProxyWindow> => {\n        if (openPrerenderOverride) {\n            return openPrerenderOverride(context, proxyWin, proxyPrerenderFrame);\n        }\n        \n        return ZalgoPromise.try(() => {\n            if (context === CONTEXT.IFRAME && __ZOID__.__IFRAME_SUPPORT__) {\n                if (!proxyPrerenderFrame) {\n                    throw new Error(`Expected proxy frame to be passed`);\n                }\n                \n                return proxyPrerenderFrame.get().then(prerenderFrame => {\n                    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            } else if (context === CONTEXT.POPUP && __ZOID__.__POPUP_SUPPORT__) {\n                return proxyWin;\n            } else {\n                throw new Error(`No render context available for ${ context }`);\n            }\n        });\n    };\n\n    const focus = () : ZalgoPromise<void> => {\n        return ZalgoPromise.try(() => {\n            if (currentProxyWin) {\n                return ZalgoPromise.all([\n                    event.trigger(EVENT.FOCUS),\n                    currentProxyWin.focus()\n                ]).then(noop);\n            }\n        });\n    };\n\n    const getCurrentWindowReferenceUID = () : string => {\n        const global = getGlobal(window);\n        global.windows = global.windows || {};\n        global.windows[uid] = window;\n        clean.register(() => {\n            delete global.windows[uid];\n        });\n        return uid;\n    };\n\n    const getWindowRef = (target : CrossDomainWindowType, initialChildDomain : string, context : $Values<typeof CONTEXT>, proxyWin : ProxyWindow) : WindowRef => {\n        if (initialChildDomain === getDomain(window)) {\n            return { type: WINDOW_REFERENCE.GLOBAL, uid: getCurrentWindowReferenceUID() };\n        }\n\n        if (target !== window) {\n            throw new Error(`Can not construct cross-domain window reference for different target window`);\n        }\n\n        if (props.window) {\n            const actualComponentWindow = proxyWin.getWindow();\n            if (!actualComponentWindow) {\n                throw new Error(`Can not construct cross-domain window reference for lazy window prop`);\n            }\n\n            if (getAncestor(actualComponentWindow) !== window) {\n                throw new Error(`Can not construct cross-domain window reference for window prop with different ancestor`);\n            }\n        }\n\n        if (context === CONTEXT.POPUP) {\n            return { type: WINDOW_REFERENCE.OPENER };\n        } else if (context === CONTEXT.IFRAME) {\n            return { type: WINDOW_REFERENCE.PARENT, distance: getDistanceFromTop(window) };\n        }\n\n        throw new Error(`Can not construct window reference for child`);\n    };\n\n    const runTimeout = () : ZalgoPromise<void> => {\n        return ZalgoPromise.try(() => {\n            const timeout = props.timeout;\n\n            if (timeout) {\n                return initPromise.timeout(timeout, new Error(`Loading component timed out after ${ timeout } milliseconds`));\n            }\n        });\n    };\n\n    const initChild = (childDomain : string, childExports : ChildExportsType<P>) : ZalgoPromise<void> => {\n        return ZalgoPromise.try(() => {\n            currentChildDomain = childDomain;\n            childComponent = childExports;\n            resolveInitPromise();\n            clean.register(() => childExports.close.fireAndForget().catch(noop));\n        });\n    };\n\n    const resize = ({ width, height } : {| width? : ?number, height? : ?number |}) : ZalgoPromise<void> => {\n        return ZalgoPromise.try(() => {\n            event.trigger(EVENT.RESIZE, { width, height });\n        });\n    };\n\n    const destroy = (err : mixed) : ZalgoPromise<void> => {\n        // eslint-disable-next-line promise/no-promise-in-callback\n        return ZalgoPromise.try(() => {\n            return event.trigger(EVENT.DESTROY);\n        }).catch(noop).then(() => {\n            return clean.all(err);\n        }).then(() => {\n            initPromise.asyncReject(err || new Error('Component destroyed'));\n        });\n    };\n\n    const close = memoize((err? : mixed) : ZalgoPromise<void> => {\n        return ZalgoPromise.try(() => {\n\n            if (closeOverride) {\n                // $FlowFixMe\n                const source = closeOverride.__source__;\n\n                if (isWindowClosed(source)) {\n                    return;\n                }\n\n                return closeOverride();\n            }\n\n            return ZalgoPromise.try(() => {\n                return event.trigger(EVENT.CLOSE);\n            }).then(() => {\n                return destroy(err || new Error(`Component closed`));\n            });\n        });\n    });\n\n    const open = (context : $Values<typeof CONTEXT>, { proxyWin, proxyFrame, windowName } : {| proxyWin : ProxyWindow, proxyFrame : ?ProxyObject<HTMLIFrameElement>, windowName : string |}) : ZalgoPromise<ProxyWindow> => {\n        if (openOverride) {\n            return openOverride(context,  { proxyWin, proxyFrame, windowName });\n        }\n        \n        return ZalgoPromise.try(() => {\n            if (context === CONTEXT.IFRAME && __ZOID__.__IFRAME_SUPPORT__) {\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                        clean.register(() => destroyElement(frame));\n                        clean.register(() => cleanUpWindow(win));\n                        return win;\n                    });\n                });\n            } else if (context === CONTEXT.POPUP && __ZOID__.__POPUP_SUPPORT__) {\n                let { width = DEFAULT_DIMENSIONS.WIDTH, height = DEFAULT_DIMENSIONS.HEIGHT } = getDimensions();\n\n                width = normalizeDimension(width, window.outerWidth);\n                height = normalizeDimension(height, window.outerWidth);\n\n                // $FlowFixMe\n                const attrs = {\n                    name: windowName,\n                    width,\n                    height,\n                    ...getAttributes().popup\n                };\n    \n                const win = popup('', attrs);\n    \n                clean.register(() => closeWindow(win));\n                clean.register(() => cleanUpWindow(win));\n\n                return win;\n            } else {\n                throw new Error(`No render context available for ${ context }`);\n            }\n\n        }).then(win => {\n            proxyWin.setWindow(win, { send });\n            return proxyWin.setName(windowName).then(() => {\n                return proxyWin;\n            });\n        });\n    };\n\n    const watchForUnload = () => {\n        return ZalgoPromise.try(() => {\n            const unloadWindowListener = addEventListener(window, 'unload', once(() => {\n                destroy(new Error(`Window navigated away`));\n            }));\n    \n            const closeParentWindowListener = onCloseWindow(parentWin, destroy, 3000);\n            clean.register(closeParentWindowListener.cancel);\n            clean.register(unloadWindowListener.cancel);\n\n            if (watchForUnloadOverride) {\n                return watchForUnloadOverride();\n            }\n        });\n    };\n\n    const watchForClose = (proxyWin : ProxyWindow, context : $Values<typeof CONTEXT>) : ZalgoPromise<void> => {\n        let cancelled = false;\n\n        clean.register(() => {\n            cancelled = true;\n        });\n\n        return ZalgoPromise.delay(2000).then(() => {\n            return proxyWin.isClosed();\n        }).then(isClosed => {\n            if (!cancelled) {\n                if (isClosed) {\n                    return close(new Error(`Detected ${ context } close`));\n                } else {\n                    return watchForClose(proxyWin, context);\n                }\n            }\n        });\n    };\n\n    const checkWindowClose = (proxyWin : ProxyWindow) : ZalgoPromise<boolean> => {\n        let closed = false;\n        \n        return proxyWin.isClosed().then(isClosed => {\n            if (isClosed) {\n                closed = true;\n                return close(new Error(`Detected component window close`));\n            }\n\n            return ZalgoPromise.delay(200)\n                .then(() => proxyWin.isClosed())\n                .then(secondIsClosed => {\n                    if (secondIsClosed) {\n                        closed = true;\n                        return close(new Error(`Detected component window close`));\n                    }\n                });\n        }).then(() => {\n            return closed;\n        });\n    };\n\n    const onError = (err : mixed) : ZalgoPromise<void> => {\n        if (onErrorOverride) {\n            return onErrorOverride(err);\n        }\n\n        return ZalgoPromise.try(() => {\n            if (handledErrors.indexOf(err) !== -1) {\n                return;\n            }\n\n            handledErrors.push(err);\n            initPromise.asyncReject(err);\n\n            return event.trigger(EVENT.ERROR, err);\n        });\n    };\n\n    const exportsPromise : ZalgoPromise<X> = new ZalgoPromise();\n\n    const getExports = () : X => {\n        return xports({\n            getExports: () => exportsPromise\n        });\n    };\n\n    const xport = (actualExports : X) : ZalgoPromise<void> => {\n        return ZalgoPromise.try(() => {\n            exportsPromise.resolve(actualExports);\n        });\n    };\n\n    initChild.onError = onError;\n\n    const buildParentExports = (win : ProxyWindow) : ParentExportsType<P, X> => {\n        const checkClose = () => checkWindowClose(win);\n        function init(childExports : ChildExportsType<P>) : ZalgoPromise<void> {\n            return initChild(this.origin, childExports);\n        }\n        return { init, close, checkClose, resize, onError, show, hide, export: xport };\n    };\n\n    const buildInitialChildPayload = ({ proxyWin, initialChildDomain, childDomainMatch, context } : {| proxyWin : ProxyWindow, initialChildDomain : string, childDomainMatch : DomainMatcher, context : $Values<typeof CONTEXT>|} = {}) : ZalgoPromise<InitialChildPayload<P, X>> => {\n        return getPropsForChild(initialChildDomain).then(childProps => {\n            return {\n                uid,\n                context,\n                tag,\n                childDomainMatch,\n                version:      __ZOID__.__VERSION__,\n                props:        childProps,\n                exports:      buildParentExports(proxyWin)\n            };\n        });\n    };\n\n    const buildSerializedChildPayload = ({ proxyWin, initialChildDomain, childDomainMatch, target = window, context } : {| proxyWin : ProxyWindow, initialChildDomain : string, childDomainMatch : DomainMatcher, target : CrossDomainWindowType, context : $Values<typeof CONTEXT>|} = {}) : ZalgoPromise<string> => {\n        return buildInitialChildPayload({ proxyWin, initialChildDomain, childDomainMatch, context }).then(childPayload => {\n            const { serializedData, cleanReference } = crossDomainSerialize({\n                data:     childPayload,\n                metaData: {\n                    windowRef: getWindowRef(target, initialChildDomain, context, proxyWin)\n                },\n                sender: {\n                    domain: getDomain(window)\n                },\n                receiver: {\n                    win:    proxyWin,\n                    domain: childDomainMatch\n                },\n                passByReference: initialChildDomain === getDomain()\n            });\n\n            clean.register(cleanReference);\n            return serializedData;\n        });\n    };\n\n    const buildWindowName = ({ proxyWin, initialChildDomain, childDomainMatch, target, context } : {| proxyWin : ProxyWindow, initialChildDomain : string, childDomainMatch : DomainMatcher, target : CrossDomainWindowType, context : $Values<typeof CONTEXT>|}) : ZalgoPromise<string> => {\n        return buildSerializedChildPayload({ proxyWin, initialChildDomain, childDomainMatch, target, context }).then(serializedPayload => {\n            return buildChildWindowName({ name, serializedPayload });\n        });\n    };\n\n    const renderTemplate = (renderer : (RenderOptionsType<P>) => ?HTMLElement, { context, container, doc, frame, prerenderFrame } : {| context : $Values<typeof CONTEXT>, container? : HTMLElement, doc : Document, frame? : ?HTMLIFrameElement, prerenderFrame? : ?HTMLIFrameElement |}) : ?HTMLElement => {\n        \n        return renderer({\n            uid, container, context, doc, frame, prerenderFrame,\n            focus, close, state, props, tag, dimensions: getDimensions(), event\n        });\n    };\n\n    const prerender = (proxyPrerenderWin : ProxyWindow, { context } : {| context : $Values<typeof CONTEXT>|}) : ZalgoPromise<void> => {\n        if (prerenderOverride) {\n            return prerenderOverride(proxyPrerenderWin, { context });\n        }\n                                                                                                                                                                                                                                    \n        return ZalgoPromise.try(() => {\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 = renderTemplate(prerenderTemplate, { context, 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' } = autoResize;\n            element = getElementSafe(element, doc);\n            \n            if (element && (width || height)) {\n                const prerenderResizeListener = onResize(element, ({ width: newWidth, height: newHeight }) => {\n                    resize({\n                        width:  width ? newWidth : undefined,\n                        height: height ? newHeight : undefined\n                    });\n                }, { width, height, win: prerenderWindow });\n\n                event.on(EVENT.RENDERED, prerenderResizeListener.cancel);\n            }\n        });\n    };\n    const renderContainer : RenderContainer = (proxyContainer : ProxyObject<HTMLElement>, { proxyFrame, proxyPrerenderFrame, context, rerender } : RenderContainerOptions) : ZalgoPromise<?ProxyObject<HTMLElement>> => {\n\n        if (renderContainerOverride) {\n            return renderContainerOverride(proxyContainer, { proxyFrame, proxyPrerenderFrame, context, rerender });\n        }\n\n        return ZalgoPromise.hash({\n            container:      proxyContainer.get(),\n            // $FlowFixMe\n            frame:          proxyFrame ? proxyFrame.get() : null,\n            // $FlowFixMe\n            prerenderFrame: proxyPrerenderFrame ? proxyPrerenderFrame.get() : null,\n            internalState:  getInternalState()\n        }).then(({ container, frame, prerenderFrame, internalState: { visible } }) => {\n            const innerContainer = renderTemplate(containerTemplate, { context, container, frame, prerenderFrame, doc: document });\n            if (innerContainer) {\n                if (!visible) {\n                    hideElement(innerContainer);\n                }\n                appendChild(container, innerContainer);\n                const containerWatcher = watchElementForClose(innerContainer, () => {\n                    const removeError = new Error(`Detected container element removed from DOM`);\n                    return ZalgoPromise.delay(1).then(() => {\n                        if (isElementClosed(innerContainer)) {\n                            close(removeError);\n                        } else {\n                            clean.all(removeError);\n                            return rerender().then(resolveInitPromise, rejectInitPromise);\n                        }\n                    });\n                });\n                \n                clean.register(() => containerWatcher.cancel());\n                clean.register(() => destroyElement(innerContainer));\n                currentProxyContainer = getProxyObject(innerContainer);\n                return currentProxyContainer;\n            }\n        });\n    };\n\n    const getBridgeUrl = () : ?string => {\n        if (typeof options.bridgeUrl === 'function') {\n            return options.bridgeUrl({ props });\n        }\n\n        return options.bridgeUrl;\n    };\n\n    const openBridge = (proxyWin : ProxyWindow, initialChildDomain : 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: initialChildDomain }) || bridge.hasBridge(initialChildDomain, initialChildDomain)) {\n                    return;\n                }\n\n                const bridgeUrl = 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, initialChildDomain);\n                return bridge.openBridge(normalizeMockUrl(bridgeUrl), bridgeDomain);\n            });\n        }\n    };\n\n    const getHelpers = () : ParentHelpers<P> => {\n        return {\n            state, event, close, focus, resize,\n            // eslint-disable-next-line no-use-before-define\n            onError, updateProps, show, hide\n        };\n    };\n\n    const getProps = () => props;\n\n    const getDefaultPropsInput = () : PropsInputType<P> => {\n        // $FlowFixMe\n        return {};\n    };\n\n    const setProps = (newInputProps : PropsInputType<P> = getDefaultPropsInput()) => {\n        if (__DEBUG__ && validate) {\n            validate({ props: newInputProps });\n        }\n\n        const container = currentContainer;\n        const helpers = getHelpers();\n        extend(inputProps, newInputProps);\n\n        // $FlowFixMe\n        extendProps(propsDef, props, inputProps, helpers, container);\n    };\n\n    const updateProps = (newProps : PropsInputType<P>) : ZalgoPromise<void> => {\n        setProps(newProps);\n\n        return initPromise.then(() => {\n            const child = childComponent;\n            const proxyWin = currentProxyWin;\n            const childDomain = currentChildDomain;\n            \n            if (!child || !proxyWin || !childDomain) {\n                return;\n            }\n\n            return getPropsForChild(childDomain).then(childProps => {\n                return child.updateProps(childProps).catch(err => {\n                    return checkWindowClose(proxyWin).then(closed => {\n                        if (!closed) {\n                            throw err;\n                        }\n                    });\n                });\n            });\n        });\n    };\n\n    const getProxyContainer : GetProxyContainer = (container : ContainerReferenceType) : ZalgoPromise<ProxyObject<HTMLElement>> => {\n        if (getProxyContainerOverride) {\n            return getProxyContainerOverride(container);\n        }\n\n        return ZalgoPromise.try(() => {\n            return elementReady(container);\n        }).then(containerElement => {\n            if (isShadowElement(containerElement)) {\n                containerElement = insertShadowSlot(containerElement);\n            }\n\n            currentContainer = containerElement;\n            return getProxyObject(containerElement);\n        });\n    };\n\n    const delegate = (context : $Values<typeof CONTEXT>, target : CrossDomainWindowType) : ZalgoPromise<DelegateOverrides> => {\n        const delegateProps = {};\n        for (const propName of Object.keys(props)) {\n            const propDef = propsDef[propName];\n            if (propDef && propDef.allowDelegate) {\n                delegateProps[propName] = props[propName];\n            }\n        }\n\n        const childOverridesPromise = send(target, `${ POST_MESSAGE.DELEGATE }_${ name }`, {\n            uid,\n            overrides: {\n                props: delegateProps, event, close, onError, getInternalState,\n                setInternalState, resolveInitPromise, rejectInitPromise\n            }\n        }).then(({ data: { parent } }) => {\n            const parentComp : ParentComponent<P, X> = parent;\n\n            clean.register(err => {\n                if (!isWindowClosed(target)) {\n                    return parentComp.destroy(err);\n                }\n            });\n            return parentComp.getDelegateOverrides();\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        getProxyContainerOverride = (...args) => childOverridesPromise.then(childOverrides => childOverrides.getProxyContainer(...args));\n        renderContainerOverride = (...args) => childOverridesPromise.then(childOverrides => childOverrides.renderContainer(...args));\n        showOverride = (...args) => childOverridesPromise.then(childOverrides => childOverrides.show(...args));\n        hideOverride = (...args) => childOverridesPromise.then(childOverrides => childOverrides.hide(...args));\n        watchForUnloadOverride = (...args) => childOverridesPromise.then(childOverrides => childOverrides.watchForUnload(...args));\n\n        if (context === CONTEXT.IFRAME && __ZOID__.__IFRAME_SUPPORT__) {\n            getProxyWindowOverride = (...args) => childOverridesPromise.then(childOverrides => childOverrides.getProxyWindow(...args));\n            openFrameOverride = (...args) => childOverridesPromise.then(childOverrides => childOverrides.openFrame(...args));\n            openPrerenderFrameOverride = (...args) => childOverridesPromise.then(childOverrides => childOverrides.openPrerenderFrame(...args));\n            prerenderOverride = (...args) => childOverridesPromise.then(childOverrides => childOverrides.prerender(...args));\n            openOverride = (...args) => childOverridesPromise.then(childOverrides => childOverrides.open(...args));\n            openPrerenderOverride = (...args) => childOverridesPromise.then(childOverrides => childOverrides.openPrerender(...args));\n        } else if (context === CONTEXT.POPUP && __ZOID__.__POPUP_SUPPORT__) {\n            setProxyWinOverride = (...args) => childOverridesPromise.then(childOverrides => childOverrides.setProxyWin(...args));\n        }\n\n        return childOverridesPromise;\n    };\n\n    const getDelegateOverrides = () : ZalgoPromise<DelegateOverrides> => {\n        return ZalgoPromise.try(() => {\n            return {\n                getProxyContainer, show, hide, renderContainer, getProxyWindow, watchForUnload,\n                openFrame, openPrerenderFrame, prerender, open, openPrerender, setProxyWin\n            };\n        });\n    };\n\n    const checkAllowRender = (target : CrossDomainWindowType, childDomainMatch : DomainMatcher, container : ContainerReferenceType) => {\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(childDomainMatch, origin) && !isSameDomain(target)) {\n            throw new Error(`Can not render remotely to ${ childDomainMatch.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    const init = () => {\n        setupEvents();\n    };\n\n    const render = ({ target, container, context, rerender } : RenderOptions) : ZalgoPromise<void> => {\n        return ZalgoPromise.try(() => {\n            const initialChildDomain = getInitialChildDomain();\n            const childDomainMatch = getDomainMatcher();\n            \n            checkAllowRender(target, childDomainMatch, container);\n\n            const delegatePromise = ZalgoPromise.try(() => {\n                if (target !== window) {\n                    return delegate(context, target);\n                }\n            });\n\n            const windowProp = props.window;\n\n            const watchForUnloadPromise = watchForUnload();\n            \n            const buildBodyPromise = buildBody();\n            const onRenderPromise = event.trigger(EVENT.RENDER);\n\n            const getProxyContainerPromise = getProxyContainer(container);\n            const getProxyWindowPromise = getProxyWindow();\n\n            const finalSetPropsPromise = getProxyContainerPromise.then(() => {\n                return setProps();\n            });\n\n            const buildUrlPromise = finalSetPropsPromise.then(() => {\n                return buildUrl();\n            });\n\n            const buildWindowNamePromise = getProxyWindowPromise.then(proxyWin => {\n                return buildWindowName({ proxyWin, initialChildDomain, childDomainMatch, target, context });\n            });\n\n            const openFramePromise = buildWindowNamePromise.then(windowName => openFrame(context, { windowName }));\n            const openPrerenderFramePromise = openPrerenderFrame(context);\n\n            const renderContainerPromise = ZalgoPromise.hash({ proxyContainer: getProxyContainerPromise, proxyFrame: openFramePromise, proxyPrerenderFrame: openPrerenderFramePromise }).then(({ proxyContainer, proxyFrame, proxyPrerenderFrame }) => {\n                return renderContainer(proxyContainer, { context, proxyFrame, proxyPrerenderFrame, rerender });\n            }).then(proxyContainer => {\n                return proxyContainer;\n            });\n\n            const openPromise = ZalgoPromise.hash({ windowName: buildWindowNamePromise, proxyFrame: openFramePromise, proxyWin: getProxyWindowPromise }).then(({ windowName, proxyWin, proxyFrame }) => {\n                return windowProp\n                    ? proxyWin\n                    : open(context, { windowName, proxyWin, proxyFrame });\n            });\n\n            const openPrerenderPromise = ZalgoPromise.hash({ proxyWin: openPromise, proxyPrerenderFrame: openPrerenderFramePromise }).then(({ proxyWin, proxyPrerenderFrame }) => {\n                return openPrerender(context, proxyWin, proxyPrerenderFrame);\n            });\n\n            const setStatePromise = openPromise.then(proxyWin => {\n                currentProxyWin = proxyWin;\n                return setProxyWin(proxyWin);\n            });\n            \n            const prerenderPromise = ZalgoPromise.hash({ proxyPrerenderWin: openPrerenderPromise, state: setStatePromise }).then(({ proxyPrerenderWin }) => {\n                return prerender(proxyPrerenderWin, { context });\n            });\n\n            const setWindowNamePromise =  ZalgoPromise.hash({ proxyWin: openPromise, windowName: buildWindowNamePromise }).then(({ proxyWin, windowName }) => {\n                if (windowProp) {\n                    return proxyWin.setName(windowName);\n                }\n            });\n\n            const getMethodPromise = ZalgoPromise.hash({ body: buildBodyPromise }).then(({ body }) => {\n                if (options.method) {\n                    return options.method;\n                }\n\n                if (Object.keys(body).length) {\n                    return METHOD.POST;\n                }\n\n                return METHOD.GET;\n            });\n\n\n            const loadUrlPromise = ZalgoPromise.hash({ proxyWin: openPromise, windowUrl: buildUrlPromise, body: buildBodyPromise, method: getMethodPromise, windowName: setWindowNamePromise, prerender: prerenderPromise }).then(({ proxyWin, windowUrl, body, method }) => {\n                return proxyWin.setLocation(windowUrl, { method, body });\n            });\n\n            const watchForClosePromise = openPromise.then(proxyWin => {\n                watchForClose(proxyWin, context);\n            });\n\n            const onDisplayPromise = ZalgoPromise.hash({ container: renderContainerPromise, prerender: prerenderPromise }).then(() => {\n                return event.trigger(EVENT.DISPLAY);\n            });\n\n            const openBridgePromise = openPromise.then(proxyWin => {\n                return openBridge(proxyWin, initialChildDomain, context);\n            });\n\n            const runTimeoutPromise = loadUrlPromise.then(() => {\n                return runTimeout();\n            });\n\n            const onRenderedPromise = initPromise.then(() => {\n                return event.trigger(EVENT.RENDERED);\n            });\n\n            return ZalgoPromise.hash({\n                initPromise, buildUrlPromise, onRenderPromise, getProxyContainerPromise, openFramePromise, openPrerenderFramePromise, renderContainerPromise, openPromise,\n                openPrerenderPromise, setStatePromise, prerenderPromise, loadUrlPromise, buildWindowNamePromise, setWindowNamePromise, watchForClosePromise, onDisplayPromise,\n                openBridgePromise, runTimeoutPromise, onRenderedPromise, delegatePromise, watchForUnloadPromise, finalSetPropsPromise\n            });\n            \n        }).catch(err => {\n            return ZalgoPromise.all([\n                onError(err),\n                destroy(err)\n            ]).then(() => {\n                throw err;\n            }, () => {\n                throw err;\n            });\n        }).then(noop);\n    };\n\n    return {\n        init,\n        render,\n        destroy,\n        getProps,\n        setProps,\n        export: xport,\n        getHelpers,\n        getDelegateOverrides,\n        getExports\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/parent';\nimport { EVENT } from '../../constants';\n\nconst CLASS = {\n    VISIBLE:   'zoid-visible',\n    INVISIBLE: 'zoid-invisible'\n};\n\n\nexport function defaultContainerTemplate<P>({ uid, frame, prerenderFrame, doc, props, event, dimensions } : RenderOptionsType<P>) : ?HTMLElement {\n    const  { width, height } = dimensions;\n\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/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/* 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, getDomain, matchDomain, type CrossDomainWindowType, type DomainMatcher } from '@krakenjs/cross-domain-utils/src';\nimport { noop, isElement, cleanup, memoize, identity, extend, uniqueID } from 'belter/src';\n\nimport { childComponent, type ChildComponent } from '../child';\nimport { type RenderOptionsType, type ParentHelpers, parentComponent } from '../parent/parent';\nimport { ZOID, CONTEXT, POST_MESSAGE, WILDCARD, METHOD, PROP_TYPE } from '../constants';\nimport { react, angular, vue, vue3, angular2 } from '../drivers';\nimport { getGlobal, destroyGlobal, getInitialParentPayload, isChildComponentWindow } from '../lib';\nimport type { CssDimensionsType, StringMatcherType, ContainerReferenceType } from '../types';\n\nimport { validateOptions } from './validate';\nimport { defaultContainerTemplate, defaultPrerenderTemplate } from './templates';\nimport { getBuiltInProps, type UserPropsDefinitionType, type PropsDefinitionType, type PropsInputType,\n    type PropsType, type ParentPropType, type exportPropType, type DEFINITION_TYPE } from './props';\n\ntype LoggerPayload = { [string] : ?string | ?boolean };\n\n// eslint-disable-next-line flowtype/require-exact-type\ntype Logger = {\n    info : (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\ntype Attributes = {|\n    iframe? : { [string] : string },\n    popup? : { [string] : string }\n|};\n\nexport type ExportsConfigDefinition = {|\n    [string] : {|\n        type : DEFINITION_TYPE\n    |}\n|};\n\nexport type ExportsMapperDefinition<X> = ({|\n    getExports : () => ZalgoPromise<X>\n|}) => X;\n\nexport type ExportsDefinition<X> = ExportsConfigDefinition | ExportsMapperDefinition<X>;\n\nexport type ComponentOptionsType<P, X, C> = {|\n\n    tag : string,\n\n    url : string | ({| props : PropsType<P> |}) => string,\n    domain? : DomainMatcher,\n    bridgeUrl? : string,\n    method? : $Values<typeof METHOD>,\n\n    props? : UserPropsDefinitionType<P, X>,\n\n    dimensions? : CssDimensionsType | ({| props : PropsType<P> |}) => CssDimensionsType,\n    autoResize? : {| width? : boolean, height? : boolean, element? : string |},\n\n    allowedParentDomains? : StringMatcherType,\n\n    attributes? : Attributes | ({| props : PropsType<P> |}) => Attributes,\n\n    eligible? : ({| props : PropsInputType<P> |}) => {| eligible : boolean, reason? : string |},\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    children? : () => C,\n\n    exports? : ExportsDefinition<X>\n|};\n\nexport type AttributesType = {|\n    iframe? : { [string] : string },\n    popup? : { [string] : string }\n|};\n\ntype AutoResizeType = {|\n    width? : boolean,\n    height? : boolean,\n    element? : string\n|};\n\nexport type NormalizedComponentOptionsType<P, X, C> = {|\n    tag : string,\n    name : string,\n\n    url : string | ({| props : PropsType<P> |}) => string,\n    domain : ?DomainMatcher,\n    bridgeUrl : ?string,\n    method : ?$Values<typeof METHOD>,\n\n    propsDef : PropsDefinitionType<P, X>,\n    dimensions : CssDimensionsType | ({| props : PropsType<P> |}) => CssDimensionsType,\n    autoResize : AutoResizeType,\n\n    allowedParentDomains : StringMatcherType,\n\n    attributes : AttributesType | ({| props : PropsType<P> |}) => AttributesType,\n\n    eligible : ({| props : PropsInputType<P> |}) => {| eligible : boolean, reason? : string |},\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    logger : Logger,\n\n    children : () => C,\n\n    exports : ExportsMapperDefinition<X>\n|};\n\nexport type ZoidComponentInstance<P, X = void, C = void> = {|\n    ...ParentHelpers<P>,\n    ...X,\n    ...C,\n    isEligible : () => boolean,\n    clone : () => ZoidComponentInstance<P, X, C>,\n    render : (container? : ContainerReferenceType, context? : $Values<typeof CONTEXT>) => ZalgoPromise<void>,\n    renderTo : (target : CrossDomainWindowType, container? : ContainerReferenceType, context? : $Values<typeof CONTEXT>) => ZalgoPromise<void>\n|};\n\n// eslint-disable-next-line flowtype/require-exact-type\nexport type ZoidComponent<P, X = void, C = void> = {\n    (props? : PropsInputType<P> | void) : ZoidComponentInstance<P, X, C>,\n    // eslint-disable-next-line no-undef\n    driver : <T>(string, mixed) => T,\n    isChild : () => boolean,\n    xprops? : PropsType<P>,\n    canRenderTo : (CrossDomainWindowType) => ZalgoPromise<boolean>,\n    instances : $ReadOnlyArray<ZoidComponentInstance<P, X, C>>\n};\n\nconst getDefaultAttributes = () : AttributesType => {\n    // $FlowFixMe\n    return {};\n};\n\nconst getDefaultAutoResize = () : AutoResizeType => {\n    // $FlowFixMe\n    return {};\n};\n\nconst getDefaultExports = <X>() : () => X => {\n    // $FlowFixMe\n    return noop;\n};\n\nconst getDefaultDimensions = () : CssDimensionsType => {\n    // $FlowFixMe\n    return {};\n};\n\nfunction normalizeOptions<P, X, C>(options : ComponentOptionsType<P, X, C>) : NormalizedComponentOptionsType<P, X, C> {\n    const {\n        tag,\n        url,\n        domain,\n        bridgeUrl,\n        props = {},\n        dimensions = getDefaultDimensions(),\n        autoResize = getDefaultAutoResize(),\n        allowedParentDomains = WILDCARD,\n        attributes = getDefaultAttributes(),\n        defaultContext = CONTEXT.IFRAME,\n        containerTemplate = (__ZOID__.__DEFAULT_CONTAINER__ ? defaultContainerTemplate : null),\n        prerenderTemplate = (__ZOID__.__DEFAULT_PRERENDER__ ? defaultPrerenderTemplate : null),\n        validate,\n        eligible = () => ({ eligible: true }),\n        logger = { info: noop },\n        exports: xportsDefinition = getDefaultExports(),\n        method,\n        children = () : C => {\n            // $FlowFixMe\n            return {};\n        }\n    } = options;\n\n    const name = tag.replace(/-/g, '_');\n\n    // $FlowFixMe[incompatible-type]\n    // $FlowFixMe[cannot-spread-inexact]\n    const propsDef : PropsDefinitionType<P, X> = {\n        ...getBuiltInProps(),\n        ...props\n    };\n\n    if (!containerTemplate) {\n        throw new Error(`Container template required`);\n    }\n\n    const xports = typeof xportsDefinition === 'function'\n        ? xportsDefinition\n        : ({ getExports }) : X => {\n            const result = {};\n\n            for (const key of Object.keys(xportsDefinition)) {\n                const { type } = xportsDefinition[key];\n                const valuePromise = getExports().then(res => {\n                    // $FlowFixMe\n                    return res[key];\n                });\n\n                if (type === PROP_TYPE.FUNCTION) {\n                    result[key] = (...args) => valuePromise.then(value => value(...args));\n                } else {\n                    result[key] = valuePromise;\n                }\n            }\n\n            // $FlowFixMe\n            return result;\n        };\n\n    return {\n        name,\n        tag,\n        url,\n        domain,\n        bridgeUrl,\n        method,\n        propsDef,\n        dimensions,\n        autoResize,\n        allowedParentDomains,\n        attributes,\n        defaultContext,\n        containerTemplate,\n        prerenderTemplate,\n        validate,\n        logger,\n        eligible,\n        children,\n        exports:     xports\n    };\n}\n\nlet cleanInstances = cleanup();\nconst cleanZoid = cleanup();\n\nexport type Component<P, X, C> = {|\n    init : (props? : PropsInputType<P> | void) => ZoidComponentInstance<P, X, C>,\n    instances : $ReadOnlyArray<ZoidComponentInstance<P, X, C>>,\n    driver : (string, mixed) => mixed,\n    isChild : () => boolean,\n    canRenderTo : (CrossDomainWindowType) => ZalgoPromise<boolean>,\n    registerChild : () => ?ChildComponent<P, X>\n|};\n\nexport function component<P, X, C>(opts : ComponentOptionsType<P, X, C>) : Component<P, X, C> {\n    if (__DEBUG__) {\n        validateOptions(opts);\n    }\n\n    const options = normalizeOptions(opts);\n\n    const {\n        name,\n        tag,\n        defaultContext,\n        propsDef,\n        eligible,\n        children\n    } = options;\n\n    const global = getGlobal(window);\n    const driverCache = {};\n    const instances = [];\n\n    const isChild = () : boolean => {\n        if (isChildComponentWindow(name)) {\n            const { payload } = getInitialParentPayload();\n            if (payload.tag === tag && matchDomain(payload.childDomainMatch, getDomain())) {\n                return true;\n            }\n        }\n\n        return false;\n    };\n\n    const registerChild = memoize(() : ?ChildComponent<P, X> => {\n        if (isChild()) {\n            if (window.xprops) {\n                delete global.components[tag];\n                throw new Error(`Can not register ${ name } as child - child already registered`);\n            }\n\n            const child = childComponent(options);\n            child.init();\n            return child;\n        }\n    });\n\n    const listenForDelegate = () => {\n        const allowDelegateListener = on(`${ POST_MESSAGE.ALLOW_DELEGATE }_${ name }`, () => {\n            return true;\n        });\n\n        const delegateListener = on(`${ POST_MESSAGE.DELEGATE }_${ name }`, ({ source, data: { uid, overrides } }) => {\n            return {\n                parent: parentComponent({\n                    uid, options, overrides, parentWin: source\n                })\n            };\n        });\n\n        cleanZoid.register(allowDelegateListener.cancel);\n        cleanZoid.register(delegateListener.cancel);\n    };\n\n    const canRenderTo = (win : CrossDomainWindowType) : ZalgoPromise<boolean> => {\n        return send(win, `${ POST_MESSAGE.ALLOW_DELEGATE }_${ name }`).then(({ data }) => {\n            return data;\n        }).catch(() => {\n            return false;\n        });\n    };\n\n    const getDefaultContainer = (context : $Values<typeof CONTEXT>, container? : ContainerReferenceType) : ContainerReferenceType => {\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    const getDefaultContext = (props : PropsInputType<P>, context : ?$Values<typeof CONTEXT>) : 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 defaultContext;\n        });\n    };\n\n    const getDefaultInputProps = () : PropsInputType<P> => {\n        // $FlowFixMe\n        return {};\n    };\n\n    const init = (inputProps? : PropsInputType<P> | void) : ZoidComponentInstance<P, X, C> => {\n        // eslint-disable-next-line prefer-const\n        let instance;\n\n        const uid = `${ ZOID }-${ tag }-${ uniqueID() }`;\n        const props = inputProps || getDefaultInputProps();\n\n        const { eligible: eligibility, reason } = eligible({ props });\n        const isEligible = () => eligibility;\n\n        const onDestroy = props.onDestroy;\n        props.onDestroy = (...args) => {\n            if (instance && eligibility) {\n                instances.splice(instances.indexOf(instance), 1);\n            }\n\n            if (onDestroy) {\n                return onDestroy(...args);\n            }\n        };\n\n        const parent = parentComponent({\n            uid, options\n        });\n\n        parent.init();\n\n        if (eligibility) {\n            parent.setProps(props);\n        } else {\n            if (props.onDestroy) {\n                props.onDestroy();\n            }\n        }\n\n        cleanInstances.register(err => {\n            return parent.destroy(err || new Error(`zoid destroyed all components`));\n        });\n\n        const clone = ({ decorate = identity } = {}) => {\n            return init(decorate(props));\n        };\n\n        const getChildren = () : C => {\n            // $FlowFixMe\n            const childComponents : {| [string] : ZoidComponent<mixed> |} = children();\n            const result = {};\n\n            for (const childName of Object.keys(childComponents)) {\n                const Child : ZoidComponent<mixed> = childComponents[childName];\n\n                result[childName] = (childInputProps) => {\n                    const parentProps : PropsType<P> = parent.getProps();\n                    const parentExport : exportPropType<X> = parent.export;\n\n                    const childParent : ParentPropType<P, X> = {\n                        uid,\n                        props:  parentProps,\n                        export: parentExport\n                    };\n                    \n                    const childProps : PropsInputType<mixed> = {\n                        ...childInputProps,\n                        parent: childParent\n                    };\n\n                    return Child(childProps);\n                };\n            }\n\n            // $FlowFixMe\n            return result;\n        };\n\n        const render = (target, container, context) => {\n            return ZalgoPromise.try(() => {\n                if (!eligibility) {\n                    const err = new Error(reason || `${ name } component is not eligible`);\n\n                    return parent.destroy(err).then(() => {\n                        throw err;\n                    });\n                }\n\n                if (!isWindow(target)) {\n                    throw new Error(`Must pass window to renderTo`);\n                }\n\n                return getDefaultContext(props, context);\n\n            }).then(finalContext => {\n                container = getDefaultContainer(finalContext, container);\n\n                if (target !== window && typeof container !== 'string') {\n                    throw new Error(`Must pass string element when rendering to another window`);\n                }\n\n                return parent.render({\n                    target,\n                    container,\n                    context:    finalContext,\n                    rerender: () => {\n                        const newInstance = clone();\n                        extend(instance, newInstance);\n                        return newInstance.renderTo(target, container, context);\n                    }\n                });\n\n            }).catch(err => {\n                return parent.destroy(err).then(() => {\n                    throw err;\n                });\n            });\n        };\n\n        instance = {\n            ...parent.getExports(),\n            ...parent.getHelpers(),\n            ...getChildren(),\n            isEligible,\n            clone,\n            render:   (container, context) => render(window, container, context),\n            renderTo: (target, container, context) => render(target, container, context)\n        };\n\n        if (eligibility) {\n            instances.push(instance);\n        }\n\n        return instance;\n    };\n\n    const driver = (driverName : string, dep : mixed) : mixed => {\n        if (__ZOID__.__FRAMEWORK_SUPPORT__) {\n            const drivers = { react, angular, vue, vue3, angular2 };\n\n            if (!drivers[driverName]) {\n                throw new Error(`Could not find driver for framework: ${ driverName }`);\n            }\n\n            if (!driverCache[driverName]) {\n                driverCache[driverName] = drivers[driverName].register(tag, propsDef, init, dep);\n            }\n\n            return driverCache[driverName];\n        } else {\n            throw new Error(`Driver support not enabled`);\n        }\n    };\n\n    registerChild();\n    listenForDelegate();\n\n    global.components = global.components || {};\n    if (global.components[tag]) {\n        throw new Error(`Can not register multiple components with the same tag: ${ tag }`);\n    }\n    global.components[tag] = true;\n\n    return {\n        init,\n        instances,\n        driver,\n        isChild,\n        canRenderTo,\n        registerChild\n    };\n}\n\nexport type ComponentDriverType<P, L, D, X, C> = {|\n    register : (string, PropsDefinitionType<P, X>, (PropsInputType<P>) => ZoidComponentInstance<P, X, C>, L) => D\n|};\n\nexport type ZoidProps<P> = PropsType<P>;\n\n// eslint-disable-next-line no-undef\nexport type CreateZoidComponent = <P, X, C>(options : ComponentOptionsType<P, X, C>) => ZoidComponent<P, X, C>;\n\nexport const create : CreateZoidComponent = <P, X, C>(options : ComponentOptionsType<P, X, C>) : ZoidComponent<P, X, C> => {\n    setupPostRobot();\n\n    const comp = component(options);\n\n    const init = (props? : PropsInputType<P> | void) => comp.init(props);\n    init.driver = (name, dep) => comp.driver(name, dep);\n    init.isChild = () => comp.isChild();\n    init.canRenderTo = (win) => comp.canRenderTo(win);\n    init.instances = comp.instances;\n\n    const child = comp.registerChild();\n    if (child) {\n        window.xprops = init.xprops = child.getProps();\n    }\n\n    return init;\n};\n\nexport function destroyComponents(err? : mixed) : ZalgoPromise<void> {\n    if (bridge) {\n        bridge.destroyBridges();\n    }\n\n    const destroyPromise = cleanInstances.all(err);\n    cleanInstances = cleanup();\n    return destroyPromise;\n}\n\nexport const destroyAll = destroyComponents;\n\nexport function destroy(err? : mixed) : ZalgoPromise<void> {\n    destroyAll();\n    destroyGlobal();\n    destroyPostRobot();\n    return cleanZoid.all(err);\n}\n"],"sourceRoot":""}