{"version":3,"sources":["webpack://[name]/webpack/universalModuleDefinition","webpack://[name]/webpack/bootstrap","webpack://[name]/./node_modules/belter/src/util.js","webpack://[name]/./node_modules/zalgo-promise/src/utils.js","webpack://[name]/./node_modules/zalgo-promise/src/exceptions.js","webpack://[name]/./node_modules/zalgo-promise/src/flush.js","webpack://[name]/./node_modules/zalgo-promise/src/promise.js","webpack://[name]/./node_modules/cross-domain-utils/src/constants.js","webpack://[name]/./node_modules/cross-domain-utils/src/utils.js","webpack://[name]/./node_modules/cross-domain-safe-weakmap/src/util.js","webpack://[name]/./node_modules/cross-domain-safe-weakmap/src/weakmap.js","webpack://[name]/./node_modules/cross-domain-safe-weakmap/src/native.js","webpack://[name]/./node_modules/belter/src/screenHeights.js","webpack://[name]/./node_modules/belter/src/device.js","webpack://[name]/./node_modules/belter/src/constants.js","webpack://[name]/./node_modules/belter/src/dom.js","webpack://[name]/./src/component.js","webpack://[name]/./node_modules/zoid/dist/zoid.frame.js","webpack://[name]/./src/cta/preload.html","webpack://[name]/./src/assets/RA21-White.svg","webpack://[name]/./node_modules/process/browser.js","webpack://[name]/./src/index.js","webpack://[name]/./node_modules/bootstrap/dist/css/bootstrap.min.css?1dcf","webpack://[name]/./node_modules/style-loader/lib/addStyles.js","webpack://[name]/./node_modules/style-loader/lib/urls.js"],"names":["root","factory","exports","module","define","amd","this","webpackJsonpCallback","data","moduleId","chunkId","chunkIds","moreModules","executeModules","i","resolves","length","Object","prototype","hasOwnProperty","call","installedChunks","push","modules","parentJsonpFunction","shift","deferredModules","apply","checkDeferredModules","result","deferredModule","fulfilled","j","depId","splice","__webpack_require__","s","installedModules","4","l","m","c","d","name","getter","o","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","p","jsonpArray","oldJsonpFunction","slice","objectIDs","isElement","element","passed","window","Element","_typeof","nodeType","style","ownerDocument","_","getFunctionName","fn","__name__","displayName","setFunctionName","err","base64encode","str","btoa","encodeURIComponent","replace","p1","String","fromCharCode","parseInt","Buffer","from","toString","Error","uniqueID","chars","randomID","charAt","Math","floor","random","timeID","Date","toISOString","toLowerCase","concat","getGlobal","global","__GLOBAL__","serializeArgs","args","JSON","stringify","Array","subkey","val","obj","WeakMap","uid","set","getObjectID","getEmptyObject","memoizeGlobalIndex","memoizeGlobalIndexValidFrom","memoize","method","simpleCache","thisCache","options","arguments","undefined","_options$thisNamespac","thisNamespace","cacheTime","time","memoizeIndex","memoizedFunction","_len","_key","cache","cacheKey","getOrSet","_unused","cacheResult","now","reset","clear","promisify","promisifiedFunction","ZalgoPromise","inlineMemoize","logic","__inline_memoize_cache__","_toConsumableArray","noop","once","called","strHashStr","hash","total","charCodeAt","abs","item","extend","source","assign","values","safeInterval","timeout","loop","setTimeout","cancel","clearTimeout","capitalizeFirstLetter","string","toUpperCase","arrayFrom","tryCatch","error","removeFromArray","arr","index","indexOf","ExtendableError","_Error","_inherits","_super","message","_this6","_classCallCheck","constructor","captureStackTrace","_assertThisInitialized","stack","_createClass","_wrapNativeSuper","isPromise","Promise","Window","then","dispatchedErrors","possiblyUnhandledPromiseHandlers","flushPromise","activeCount","flushActive","promise","resolve","startActive","endActive","handler","_this","_defineProperty","resolved","rejected","errorHandled","handlers","isAsync","res","reject","__DEBUG__","asyncReject","promises","count","results","chain","firstPromise","secondPromise","prom","awaitPromises","_loop","all","items","map","onPossiblyUnhandledException","context","delay","Zalgo","dispatch","_this2","dispatchPossiblyUnhandledError","dispatching","_handlers$i","onSuccess","onError","promiseResult","onFinally","_this3","TypeError","PROTOCOL","IE_WIN_ACCESS_ERROR","getActualProtocol","win","location","protocol","getProtocol","mockDomain","split","isAboutProtocol","getParent","parent","canReadFromWindow","href","getActualDomain","host","getDomain","domain","isActuallySameDomain","desc","getOwnPropertyDescriptor","isMockProtocol","isSameDomain","assertSameDomain","isFrameWindowClosed","frame","contentWindow","parentNode","doc","documentElement","contains","safeIndexOf","collection","iframeWindows","iframeFrames","isWindowClosed","allowMock","closed","mockclosed","top","iframeIndex","linkFrameWindow","cleanIframes","isWindow","self","__cross_domain_utils_window_check__","CrossDomainSafeWeakMap","freeze","testWeakMap","testKey","hasNativeWeakMap","weakmap","keys","isSafeToReadWrite","entry","writable","_cleanupClosedWindows","has","sfvcScreens","device","textSizeHeights","textSizeHeightsNoTabs","zoomHeight","maybeSafari","getUserAgent","navigator","mockUserAgent","userAgent","isDevice","match","ATTRIBUTES","isDocumentReady","Boolean","document","body","readyState","isDocumentInteractive","interval","setInterval","clearInterval","destroyElement","removeChild","inferCurrentScript","getStackTrace","stackDetails","exec","scriptLocation","_step9","_iterator9","_createForOfIteratorHelper","getElementsByTagName","reverse","done","script","src","e","f","currentScript","getCurrentScript","currentUID","getAttribute","_script","dataset","stringToHash","hashedString","hashResult","setAttribute","zoid","require","preload_template","_set_default_props","opts","props","color","backgroundColor","dimensions","width","height","DiscoveryComponent","tag","url","process","defaultEnv","defaultLogLevel","autoResize","contexts","iframe","popup","containerTemplate","prerenderFrame","event","div","createElement","cspNonce","appendChild","createTextNode","classList","add","on","remove","prerenderTemplate","login_initiator_url","loginInitiatorURL","loginHandlerURL","discovery_request","discoveryRequest","discovery_request_url","_t","innerHTML","addEventListener","preventDefault","render","selector","__webpack_exports__","_setPrototypeOf","setPrototypeOf","__proto__","_inheritsLoose","subClass","superClass","_extends","target","utils_isPromise","_toString","dom_PopupOpenError","component_create","component_destroy","destroyComponents","destroyAll","PROP_TYPE","PROP_SERIALIZATION","CONTEXT","EVENT","promise_ZalgoPromise","_result","_error","_proto","_err","_result2","toPromise","lazy","_delay","flush","isRegex","WINDOW_TYPE","IFRAME","POPUP","utils_getParent","getOpener","opener","isAncestorParent","child","childParent","getFrames","frames","len","_i","_frame","getAllChildFrames","_i3","_getFrames2","_i5","_getAllChildFrames2","getTop","_i7","_getAllChildFrames4","getAllFramesInWindow","getFrameByName","winFrames","_i9","childFrame","getAncestor","anyMatch","collection1","collection2","_i17","item1","_i19","getDistanceFromTop","distance","isSameTopWindow","win1","win2","top1","top2","allFrames1","allFrames2","opener1","opener2","matchDomain","pattern","origin","isArray","some","subpattern","getDomainFromUrl","join","onCloseWindow","callback","maxtime","check","getFrameForWindow","frameElement","_i21","_document$querySelect2","querySelectorAll","closeWindow","parentElement","close","util_safeIndexOf","weakmap_CrossDomainSafeWeakMap","_getPrototypeOf","getPrototypeOf","_isNativeReflectConstruct","Reflect","construct","sham","Proxy","construct_construct","Parent","Class","a","instance","Function","wrapNativeSuper_wrapNativeSuper","_cache","Map","Wrapper","configurable","memoizePromise","memoizedPromiseFunction","_arguments","_len2","_key2","src_util_noop","stringifyError","level","newErr","identity","isDefined","util_isRegex","util_getOrSet","cleanup","cleanErr","tasks","cleaned","cleaner","register","task","assertExists","thing","util_ExtendableError","ReferenceError","getBody","urlEncode","parseQuery","queryString","params","_i2","_queryString$split2","pair","decodeURIComponent","extendQuery","originalQuery","filter","getElementSafe","id","querySelector","elementReady","el","awaitFrameLoadPromises","_ExtendableError","PopupOpenError","awaitFrameLoad","_promise","awaitFrameWindow","loadedFrame","dom_iframe","container","styleText","className","attributes","_i10","_Object$keys2","styleSheet","cssText","html","allowTransparency","border","class","isIE","hasAttribute","removeEventListener","showElement","setProperty","hideElement","isElementClosed","onResize","_temp","_ref2","_ref2$width","_ref2$height","_ref2$interval","_ref2$win","currentWidth","offsetWidth","currentHeight","offsetHeight","canceled","observer","getClientRects","newWidth","newHeight","ResizeObserver","observe","MutationObserver","childList","subtree","characterData","disconnect","isShadowElement","_i22","_Array$prototype$slic2","toPx","toCSS","test","global_getGlobal","globalKey","getObj","globalStore","defStore","store","storeKey","defVal","del","_SERIALIZER","WildCard","getWildcard","WINDOW_WILDCARD","windowStore","winStore","getStore","getInstanceID","resolveHelloPromise","_ref","helloPromises","existingPromise","newPromise","sayHello","_ref4","send","instanceID","_ref5","getWindowInstanceID","_ref6","_ref7","markWindowKnown","isSerializedType","__type__","determineType","serializeType","type","__val__","_DESERIALIZER","SERIALIZER","code","regex","date","toJSON","array","number","defaultSerializers","DESERIALIZER","RegExp","defaultDeserializers","cleanupProxyWindows","idToProxyWindow","_idToProxyWindow$keys2","shouldClean","getSerializedWindow","winPromise","_ref$id","windowNamePromise","windowTypePromise","getName","getType","focus","isClosed","setLocation","_opts$method","_ref3","_ref3$method","form","display","_i24","_Object$keys4","_body$key","input","submit","setName","sameDomain","window_ProxyWindow","ProxyWindow","serializedWindow","isProxyWindow","actualWindow","actualWindowPromise","getID","setWindow","isPopup","_this4","isPopupPromise","getNamePromise","reopenPromise","open","focusPromise","getWindow","awaitWindow","matchWindow","_this5","proxyInstanceID","knownWindowInstanceID","unwrap","serialize","toProxyWindow","deserialize","_ref8","_ref9","addMethod","methodStore","proxyWindowMethods","lookupMethod","function_serializeFunction","destination","meth","methodSource","arg","__id__","serializeMessage","_serialize","serializers","serializer","deserializeMessage","_deserialize","deserializers","parse","deserializer","cross_domain_zalgo_promise","serializedPromise","cross_domain_function","serializedFunction","getDeserializedFunction","crossDomainFunctionWrapper","_args","fireAndForget","__origin__","__source__","cross_domain_window","SEND_MESSAGE_STRATEGIES","send_sendMessage","domainBuffer","buffer","serializedMessage","__post_robot_10_0_44__","strategies","errors","strategyName","getResponseListener","deleteResponseListener","isResponseListenerErrored","getRequestListener","requestListeners","_i4","winQualifier","nameListeners","domainListeners","__domain_regex__","_i6","_domainListeners$__DO2","_domainListeners$__DO3","listener","handleRequest","logName","sendResponse","ack","pathname","handleError","handleAck","handleResponse","receive_receiveMessage","receivedMessages","messages","parsedMessage","parseMessages","on_on","requestListener","addRequestListener","listenersCollection","_i8","_win2","_listenersCollection","_i12","_domain2","_i14","existingListener","regexListeners","regexListener","strDomain","errorHandler","postrobot_post_message","postMessage","postrobot_global","foreignGlobal","receiveMessage","send_send","domainMatcher","responseTimeout","childTimeout","actualParent","_i15","_getFrames8","targetDomain","actualDomain","normalizedDomain","responseListener","reqPromises","totalAckTimeout","totalResTimeout","ackTimeout","resTimeout","cancelled","max","setup_toProxyWindow","lib_global_getGlobal","__zoid_9_0_86__","tryGlobal","getProxyObject","basicSerialize","getUIDRefStore","references","crossDomainSerialize","metaData","sender","receiver","_ref$passByReference","passByReference","_ref$basic","basic","proxyWin","reference","serializedData","cleanReference","ref","crossDomainDeserialize","_ref2$basic","atob","STRING","OBJECT","FUNCTION","BOOLEAN","NUMBER","ARRAY","DOTIFY","BASE64","RENDER","RENDERED","DISPLAY","ERROR","CLOSE","DESTROY","PROPS","RESIZE","FOCUS","buildChildWindowName","serializedPayload","parseWindowName","windowName","_windowName$split","zoidcomp","serializedInitialPayload","parseInitialParentPayload","_crossDomainDeseriali","windowRef","_ret","ancestor","_getAllFramesInWindow2","windows","v","findChildFrameByName","_i11","_getFrames4","namedFrame","payload","getInitialParentPayload","window_getWindowRef","targetWindow","currentWindow","normalizeChildProp","propsDef","helpers","prop","childDecorate","onProps","resize","getParentDomain","show","hide","export","getSiblings","child_focus","child_destroy","props_defaultNoop","props_decorateOnce","eachProp","serializeProps","propDef","_METHOD$GET$METHOD$PO","_METHOD$GET$METHOD$PO2","getParam","queryParam","post","bodyParam","getValue","queryValue","bodyValue","finalParam","finalValue","serialization","dotify","prefix","newobj","every","dotkey","parentComponent","triggered","emitter","currentProxyWin","currentProxyContainer","childComponent","currentChildDomain","currentContainer","_ref$overrides","overrides","_ref$parentWin","parentWin","domainMatch","xports","initPromise","handledErrors","clean","state","inputProps","internalState","visible","eventName","handlerList","trigger","_len3","_key3","triggerOnce","_len4","_key4","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","resolveInitPromise","rejectInitPromise","getPropsForChild","initialChildDomain","sendToChild","newInternalState","windowProp","_proxyWin","setState","getUrl","getAttributes","getInitialChildDomain","title","proxyPrerenderFrame","prerenderFrameWindow","getWindowRef","actualComponentWindow","initChild","childDomain","childExports","destroy","proxyFrame","_requestPromises$get2","unloadWindowListener","closeParentWindowListener","checkWindowClose","secondIsClosed","exportsPromise","xport","actualExports","renderTemplate","renderer","proxyPrerenderWin","prerenderWindow","tagName","_arrayFrom2","children","_arrayFrom4","_autoResize$width","_autoResize$height","_autoResize$element","prerenderResizeListener","_ref10","proxyContainer","_ref11","rerender","_ref12","innerContainer","containerWatcher","sacrificialFrame","sacrificialFrameWin","mutationObservers","_i18","elementClosed","mutationElement","mutationObserver","frameWin","removeError","getHelpers","updateProps","setProps","newInputProps","existingProps","valueDetermined","alias","required","decorate","newProps","childProps","containerElement","insertShadowSlot","shadowHost","shadowRoot","slotName","slot","slotProvider","init","onRender","onDisplay","onRendered","onClose","onDestroy","onFocus","_ref14","childDomainMatch","delegatePromise","delegateProps","propName","allowDelegate","childOverridesPromise","_ref13","parentComp","getDelegateOverrides","childOverrides","_len5","_key5","_len6","_key6","_len7","_key7","_len8","_key8","_len9","_key9","_len10","_key10","_len11","_key11","watchForUnloadPromise","buildBodyPromise","onRenderPromise","getProxyContainerPromise","getProxyWindowPromise","finalSetPropsPromise","buildUrlPromise","query","originalUrl","originalHash","_url$split","_originalUrl$split","hashString","buildWindowNamePromise","_temp2","_ref6$target","version","checkClose","childPayload","_crossDomainSerialize","openFramePromise","openPrerenderFramePromise","renderContainerPromise","_ref15","openPromise","_ref16","openPrerenderPromise","_ref17","setStatePromise","prerenderPromise","_ref18","setWindowNamePromise","_ref19","getMethodPromise","_ref20","loadUrlPromise","windowUrl","_ref21","watchForClosePromise","watchForClose","onDisplayPromise","openBridgePromise","runTimeoutPromise","onRenderedPromise","getProps","getExports","defaultContainerTemplate","cleanInstances","cleanZoid","initialized","sourceElement","originalEvent","comp","allowDelegateListener","delegateListener","bridgeUrl","_options$props","_options$dimensions","_options$autoResize","_options$allowedParen","allowedParentDomains","_options$attributes","_options$defaultConte","defaultContext","_options$containerTem","_options$prerenderTem","validate","_options$eligible","eligible","_options$logger","logger","info","_options$exports","xportsDefinition","_options$children","default","valuePromise","instances","isChild","_payload","registerChild","xprops","components","onPropHandlers","_getInitialParentPayl","parentComponentWindow","parentDomain","parentExports","initialProps","parentExport","parentResize","parentInit","anyParent","currentParent","winParent","isUpdate","normalizedProps","componentName","_crossDomainDeseriali2","_ref2$data","_eligible","eligibility","reason","clone","_ref4$decorate","_render","finalContext","newInstance","renderTo","childComponents","_loop2","childName","Child","childInputProps","parentProps","isEligible","driver","driverName","dep","canRenderTo","component","destroyPromise","responseListeners","_responseListeners$ke2","__t","__p","cachedSetTimeout","cachedClearTimeout","defaultSetTimout","defaultClearTimeout","runTimeout","fun","currentQueue","queue","draining","queueIndex","cleanUpNextTick","drainQueue","run","marker","runClearTimeout","Item","nextTick","browser","env","argv","versions","addListener","off","removeListener","removeAllListeners","emit","prependListener","prependOnceListener","listeners","binding","cwd","chdir","dir","umask","onload","content","transform","locals","memo","stylesInDom","isOldIE","getTarget","getElement","styleTarget","HTMLIFrameElement","contentDocument","head","singleton","singletonCounter","stylesInsertedAtTop","fixUrls","addStylesToDom","styles","domStyle","refs","parts","addStyle","listToStyles","list","newStyles","base","part","css","media","sourceMap","insertStyleElement","insertInto","lastStyleElementInsertedAtTop","insertAt","nextSibling","insertBefore","firstChild","before","removeStyleElement","idx","createStyleElement","attrs","nonce","getNonce","addAttrs","forEach","update","styleIndex","applyToSingletonTag","URL","createObjectURL","revokeObjectURL","Blob","link","rel","createLinkElement","updateLink","applyToTag","newObj","DEBUG","newList","mayRemove","textStore","replaceText","replacement","cssNode","childNodes","autoFixUrls","convertToAbsoluteUrls","unescape","blob","oldSrc","baseUrl","currentDir","fullMatch","origUrl","newUrl","unquotedOrigUrl","trim","$1"],"mappings":"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","file":"index.13dcb35bee733e3bcc46.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(\"index\", [], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"index\"] = factory();\n\telse\n\t\troot[\"index\"] = factory();\n})(this, function() {\nreturn "," \t// install a JSONP callback for chunk loading\n \tfunction webpackJsonpCallback(data) {\n \t\tvar chunkIds = data[0];\n \t\tvar moreModules = data[1];\n \t\tvar executeModules = data[2];\n\n \t\t// add \"moreModules\" to the modules object,\n \t\t// then flag all \"chunkIds\" as loaded and fire callback\n \t\tvar moduleId, chunkId, i = 0, resolves = [];\n \t\tfor(;i < chunkIds.length; i++) {\n \t\t\tchunkId = chunkIds[i];\n \t\t\tif(Object.prototype.hasOwnProperty.call(installedChunks, chunkId) && installedChunks[chunkId]) {\n \t\t\t\tresolves.push(installedChunks[chunkId][0]);\n \t\t\t}\n \t\t\tinstalledChunks[chunkId] = 0;\n \t\t}\n \t\tfor(moduleId in moreModules) {\n \t\t\tif(Object.prototype.hasOwnProperty.call(moreModules, moduleId)) {\n \t\t\t\tmodules[moduleId] = moreModules[moduleId];\n \t\t\t}\n \t\t}\n \t\tif(parentJsonpFunction) parentJsonpFunction(data);\n\n \t\twhile(resolves.length) {\n \t\t\tresolves.shift()();\n \t\t}\n\n \t\t// add entry modules from loaded chunk to deferred list\n \t\tdeferredModules.push.apply(deferredModules, executeModules || []);\n\n \t\t// run deferred modules when all chunks ready\n \t\treturn checkDeferredModules();\n \t};\n \tfunction checkDeferredModules() {\n \t\tvar result;\n \t\tfor(var i = 0; i < deferredModules.length; i++) {\n \t\t\tvar deferredModule = deferredModules[i];\n \t\t\tvar fulfilled = true;\n \t\t\tfor(var j = 1; j < deferredModule.length; j++) {\n \t\t\t\tvar depId = deferredModule[j];\n \t\t\t\tif(installedChunks[depId] !== 0) fulfilled = false;\n \t\t\t}\n \t\t\tif(fulfilled) {\n \t\t\t\tdeferredModules.splice(i--, 1);\n \t\t\t\tresult = __webpack_require__(__webpack_require__.s = deferredModule[0]);\n \t\t\t}\n \t\t}\n\n \t\treturn result;\n \t}\n\n \t// The module cache\n \tvar installedModules = {};\n\n \t// object to store loaded and loading chunks\n \t// undefined = chunk not loaded, null = chunk preloaded/prefetched\n \t// Promise = chunk loading, 0 = chunk loaded\n \tvar installedChunks = {\n \t\t4: 0\n \t};\n\n \tvar deferredModules = [];\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 \tvar jsonpArray = this[\"webpackJsonp_name_\"] = this[\"webpackJsonp_name_\"] || [];\n \tvar oldJsonpFunction = jsonpArray.push.bind(jsonpArray);\n \tjsonpArray.push = webpackJsonpCallback;\n \tjsonpArray = jsonpArray.slice();\n \tfor(var i = 0; i < jsonpArray.length; i++) webpackJsonpCallback(jsonpArray[i]);\n \tvar parentJsonpFunction = oldJsonpFunction;\n\n\n \t// add entry module to deferred list\n \tdeferredModules.push([37,0,1]);\n \t// run deferred modules when ready\n \treturn checkDeferredModules();\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 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 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","/* @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","/* @flow */\n\nexport const sfvcScreens = {\n    '926': {\n        device:          'iPhone 12/13 Pro Max',\n        textSizeHeights: [\n            752, 748, 744, 738\n        ],\n        textSizeHeightsNoTabs: [\n            860, 858, 856, 854\n        ],\n        zoomHeight: {\n            '1.15': [ 752, 747, 744, 738 ],\n            '1.25': [ 753, 748, 744, 738 ],\n            '1.5':  [ 752, 749, 744, 738 ],\n            '1.75': [ 753, 747, 744, 739 ],\n            '2':    [ 752, 748, 744 ],  // 738 removed as same in Safari\n            '2.5':  [ 753, 748 ],       // 745, 738 removed as same in Safari\n            '3':    [ 753, 744 ]        // 747, 738 removed as same in Safari\n        },\n        maybeSafari: {\n            '2':    [ 738 ],\n            '2.5':  [ 745, 738 ],\n            '3':    [ 747, 738 ]\n        }\n    },\n    '896': {\n        device:          'iPhone XS Max, iPhone 11 Pro Max, iPhone XR, iPhone 11',\n        textSizeHeights: [\n            721, 717, 713, 707\n        ],\n        textSizeHeightsNoTabs: [\n            829, 827, 825, 823\n        ],\n        zoomHeight: {\n            '1.15': [ 721, 716, 713, 707 ],\n            '1.25': [ 721, 718, 713, 708 ],\n            '1.5':  [ 722, 717, 713 ], // 707 removed as same in Safari\n            '1.75': [ 721, 718, 712, 707 ],\n            '2':    [ 722, 718, 714, 708 ],\n            '2.5':  [ 720, 718, 713, 708 ],\n            '3':    [ 720, 717, 708 ] // 714 removed as same in Safari\n        },\n        maybeSafari: {\n            '1.5':  [ 707 ],\n            '3':    [ 714 ]\n        }\n    },\n    '844': {\n        device:          'iPhone 12, iPhone 12 Pro',\n        textSizeHeights: [\n            670, 666, 662, 656\n        ],\n        textSizeHeightsNoTabs: [\n            778, 776, 774, 772\n        ],\n        zoomHeight: {\n            '1.15': [ 670, 666, 662 ], // 656 removed as same in Safari\n            '1.25': [ 670, 666, 663, 656 ],\n            '1.5':  [ 671, 666, 662 ], // 656 removed as same in Safari\n            '1.75': [ 670, 667, 662, 656 ],\n            '2':    [ 670, 666, 662 ], // 656 removed as same in Safari\n            '2.5':  [ 670, 663 ], // 665, 655 removed as same in Safari\n            '3':    [ 669, 666, 663, 657 ] // 663 removed as same in Safari\n        },\n        maybeSafari: {\n            '1.15': [ 656 ],\n            '1.5':  [ 656 ],\n            '2':    [ 656 ],\n            '2.5':  [ 665, 655 ],\n            '3':    [ 663 ]\n        }\n    },\n    '812': {\n        device:          'iPhone X, iPhone XS, iPhone 11 Pro, iPhone 12 Mini',\n        textSizeHeights: [\n            641, 637, 633, 627\n        ],\n        textSizeHeightsNoTabs: [\n            749, 747, 745, 743\n        ],\n        zoomHeight: {\n            '1.15': [ 641, 637, 633, 627 ],\n            '1.25': [ 641, 638, 633, 628 ],\n            '1.5':  [ 641, 638, 633, 627 ],\n            '1.75': [ 641, 637, 634 ], // 627 removed as same in Safari\n            '2':    [ 642, 638, 634, 628 ],\n            '2.5':  [ 640, 638, 633, 628 ],\n            '3':    [ 642, 633 ] // 636, 627 removed as same in Safari\n        },\n        maybeSafari: {\n            '1.75': [ 627 ],\n            '3':    [ 636, 627 ]\n        }\n    },\n    '736': {\n        device:          'iPhone 6 Plus, iPhone 6S Plus, iPhone 7 Plus, iPhone 8 Plus',\n        textSizeHeights: [\n            628, 624, 620, 614\n        ],\n        textSizeHeightsNoTabs: [\n            736, 734, 732, 730\n        ],\n        zoomHeight: {\n            '1.15': [ 628, 624, 620, 614 ],\n            '1.25': [ 628, 624, 620, 614 ],\n            '1.5':  [ 629, 624, 620 ], // 614\n            '1.75': [ 628, 625, 620, 614 ],\n            '2':    [ 628, 624, 620 ], // 614\n            '2.5':  [ 628, 625, 620, 615 ],\n            '3':    [ 627, 624, 615 ] // 621\n        },\n        maybeSafari: {\n            '1.5':  [ 614 ],\n            '2':    [ 614 ],\n            '3':    [ 621 ]\n        }\n    },\n    '667': {\n        device:          'iPhone 6, iPhone 6S, iPhone 7, iPhone 8,  iPhone SE2',\n        textSizeHeights: [\n            559, 555, 551, 545\n        ],\n        textSizeHeightsNoTabs: [\n            667, 665, 663, 661\n        ],\n        zoomHeight: {\n            '1.15': [ 559, 555, 551, 545 ],\n            '1.25': [ 559, 555, 551, 545 ],\n            '1.5':  [ 560, 555, 551 ], // 545\n            '1.75': [ 558, 555, 551 ], // 544\n            '2':    [ 560, 556, 552, 546 ],\n            '2.5':  [ 560, 555, 550 ], // 545\n            '3':    [ 558, 555, 546 ] // 552\n        },\n        maybeSafari: {\n            '1.5':  [ 545 ],\n            '1.75': [ 544 ],\n            '2.5':  [ 545 ],\n            '3':    [ 552 ]\n        }\n    }\n};\n","/* @flow */\nimport { sfvcScreens } from './screenHeights';\n\nexport function getUserAgent() : string {\n    return window.navigator.mockUserAgent || window.navigator.userAgent;\n}\n\nconst TABLET_PATTERN = /ip(a|ro)d|silk|xoom|playbook|tablet|kindle|Nexus 7|GT-P10|SC-01C|SHW-M180S|SM-T320|SGH-T849|SCH-I800|SHW-M180L|SPH-P100|SGH-I987|zt180|HTC( Flyer|_Flyer)|Sprint ATP51|ViewPad7|pandigital(sprnova|nova)|Ideos S7|Dell Streak 7|Advent Vega|A101IT|A70BHT|MID7015|Next2|nook|FOLIO|MB511.*RUTEM|Mac OS.*Silk/i;\n\nexport function isDevice(userAgent? : string = getUserAgent()) : boolean {\n    if (userAgent.match(/Android|webOS|iPhone|iPad|iPod|bada|Symbian|Palm|CriOS|BlackBerry|IEMobile|WindowsMobile|Opera Mini/i)) {\n        return true;\n    }\n\n    return false;\n}\n\nexport function isTablet(userAgent? : string = getUserAgent()) : boolean {\n    return TABLET_PATTERN.test(userAgent);\n}\n\nexport function isWebView() : boolean {\n    const userAgent = getUserAgent();\n    return (/(iPhone|iPod|iPad|Macintosh).*AppleWebKit(?!.*Safari)|.*WKWebView/i).test(userAgent) ||\n        (/\\bwv\\b/).test(userAgent) ||\n    (/Android.*Version\\/(\\d)\\.(\\d)/i).test(userAgent);\n}\n\nexport function isStandAlone() : boolean {\n    return (window.navigator.standalone === true || window.matchMedia('(display-mode: standalone)').matches);\n}\n\nexport function isFacebookWebView(ua? : string = getUserAgent()) : boolean {\n    return (/FBAN/).test(ua) || (/FBAV/).test(ua);\n}\n\nexport function isFirefox(ua? : string = getUserAgent()) : boolean {\n    return (/Firefox/i).test(ua);\n}\n\nexport function isFirefoxIOS(ua? : string = getUserAgent()) : boolean {\n    return (/FxiOS/i).test(ua);\n}\n\nexport function isEdgeIOS(ua? : string = getUserAgent()) : boolean {\n    return (/EdgiOS/i).test(ua);\n}\n\nexport function isOperaMini(ua? : string = getUserAgent()) : boolean {\n    return (/Opera Mini/i).test(ua);\n}\n\nexport function isAndroid(ua? : string = getUserAgent()) : boolean {\n    return (/Android/).test(ua);\n}\n\nexport function isIos(ua? : string = getUserAgent()) : boolean {\n    return (/iPhone|iPod|iPad/).test(ua);\n}\n\nexport function isIOS14(ua? : string = getUserAgent()) : boolean {\n    return (/iPhone.*OS.*(1)?(?:(1)[0-4]| [0-9])_/).test(ua);\n}\n\nexport function isGoogleSearchApp(ua? : string = getUserAgent()) : boolean {\n    return (/\\bGSA\\b/).test(ua);\n}\n\nexport function isQQBrowser(ua? : string = getUserAgent()) : boolean {\n    return (/QQBrowser/).test(ua);\n}\n\nexport function isIosWebview(ua? : string = getUserAgent()) : boolean {\n    if (isIos(ua)) {\n        if (isGoogleSearchApp(ua)) {\n            return true;\n        }\n        return (/.+AppleWebKit(?!.*Safari)|.*WKWebView/).test(ua);\n    }\n    return false;\n}\n\nexport function isSFVC(ua? : string = getUserAgent()) : boolean {\n    if (isIos(ua)) {\n        const height = window.innerHeight;\n        const scale = Math.round(window.screen.width / window.innerWidth * 100) / 100;\n        const computedHeight = Math.round(height * scale);\n\n        let device = null;\n        if (isIOS14(ua)) {\n            device = sfvcScreens[window.outerHeight];\n        } else {\n            if (scale !== 1) {\n                return true;\n            }\n\n            device = sfvcScreens[window.outerHeight];\n        }\n\n        if (!device) {\n            return true;\n        }\n\n        if (scale > 1 && device.zoomHeight && device.zoomHeight[scale]) {\n            return device.zoomHeight[scale].indexOf(computedHeight) !== -1;\n        } else {\n            return device.textSizeHeights.indexOf(computedHeight) !== -1 ||\n                   device.textSizeHeightsNoTabs.indexOf(computedHeight) !== -1;\n        }\n    }\n    return false;\n}\n\nexport function isSFVCorSafari(ua? : string = getUserAgent()) : boolean {\n    if (isIos(ua)) {\n        const sfvc = isSFVC(ua);\n\n        const device = isIOS14(ua)\n            ? sfvcScreens[window.outerHeight]\n            : null;\n\n        if (!device) {\n            return false;\n        }\n\n        const height = window.innerHeight;\n        const scale = Math.round(window.screen.width / window.innerWidth * 100) / 100;\n\n        const computedHeight = Math.round(height * scale);\n        const possibleSafariSizes = device.maybeSafari;\n\n        let maybeSafari = false;\n        if (scale > 1 &&\n            possibleSafariSizes[scale] &&\n            possibleSafariSizes[scale].indexOf(computedHeight) !== -1) {\n                \n            maybeSafari = true;\n        }\n\n        return sfvc || maybeSafari;\n    }\n    return false;\n}\n\nexport function isAndroidWebview(ua? : string = getUserAgent()) : boolean {\n    if (isAndroid(ua)) {\n        return (/Version\\/[\\d.]+/).test(ua) && !isOperaMini(ua);\n    }\n    return false;\n}\n\nexport function isIE() : boolean {\n\n    if (window.document.documentMode) {\n        return true;\n    }\n\n    return Boolean(\n        window.navigator &&\n        window.navigator.userAgent &&\n        (/Edge|MSIE|rv:11/i).test(window.navigator.userAgent)\n    );\n}\n\nexport function isIECompHeader() : boolean {\n    const mHttp = window.document.querySelector('meta[http-equiv=\"X-UA-Compatible\"]');\n    const mContent = window.document.querySelector('meta[content=\"IE=edge\"]');\n    if (mHttp && mContent) {\n        return true;\n    }\n    return false;\n}\n\nexport function isElectron() : boolean {\n    if (typeof process !== 'undefined' && process.versions && process.versions.electron) {\n        return true;\n    }\n    return false;\n}\n\nexport function isIEIntranet() : boolean {\n\n    // This status check only works for older versions of IE with document.documentMode set\n\n    if (window.document.documentMode) {\n        try {\n            const status = window.status;\n\n            window.status = 'testIntranetMode';\n\n            if (window.status === 'testIntranetMode') {\n                window.status = status;\n\n                return true;\n            }\n\n            return false;\n\n        } catch (err) {\n\n            return false;\n        }\n    }\n\n    return false;\n}\n\nexport function isMacOsCna() : boolean {\n    const userAgent = getUserAgent();\n    return (/Macintosh.*AppleWebKit(?!.*Safari)/i).test(userAgent);\n}\n\nexport function supportsPopups(ua? : string = getUserAgent()) : boolean {\n    return !(isIosWebview(ua) || isAndroidWebview(ua) || isOperaMini(ua) ||\n        isFirefoxIOS(ua) || isEdgeIOS(ua) || isFacebookWebView(ua) || isQQBrowser(ua) || isElectron() || isMacOsCna() || isStandAlone());\n}\n\nexport function isChrome(ua? : string = getUserAgent()) : boolean {\n    return (/Chrome|Chromium|CriOS/).test(ua) && !(/SamsungBrowser|Silk|EdgA/).test(ua);\n}\n\nexport function isSafari(ua? : string = getUserAgent()) : boolean {\n    return (/Safari/).test(ua) && !isChrome(ua) && !(/Silk|FxiOS|EdgiOS/).test(ua);\n}\n\nexport function isApplePaySupported() : boolean {\n    try {\n        if (window.ApplePaySession && window.ApplePaySession.supportsVersion(3) && window.ApplePaySession.canMakePayments()) {\n            return true;\n        }\n    } catch (e) {\n        return false;\n    }\n\n    return false;\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/* 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","import {ds_response_url} from \"@theidentityselector/thiss-ds\";\n\nconst zoid = require('zoid/dist/zoid.frame');\nconst preload_template = require('!ejs-loader!./cta/preload.html');\nimport {toCSS, destroyElement} from 'belter/src';\n\n/**\n * The stub for the (zoid) DiscoveryComponent\n */\n\nfunction _set_default_props(opts) {\n    if (opts.props.color === undefined) {\n        opts.props.color = \"#0079ff\";\n    }\n    if (opts.props.backgroundColor === undefined) {\n        opts.props.backgroundColor = \"#FFFFFF\";\n    }\n    if (opts.dimensions.width === undefined) {\n        opts.dimensions.width = '350px';\n    }\n    if (opts.dimensions.height === undefined) {\n        opts.dimensions.height = '80px';\n    }\n    opts.props.dimensions = opts.dimensions;\n}\n\nfunction prerenderTemplate(opts) {\n\n    let login_initiator_url = opts.props.loginInitiatorURL || opts.props.loginHandlerURL;\n    let discovery_request = opts.props.discoveryRequest;\n\n    if (!discovery_request)\n        discovery_request = login_initiator_url;\n\n\n    if (typeof discovery_request !== 'function') {\n        let discovery_request_url = discovery_request;\n        discovery_request = function () {\n            window.top.location.href = discovery_request_url;\n        };\n    }\n\n    _set_default_props(opts);\n    const _t = opts.doc.createElement(\"html\");\n    _t.innerHTML = preload_template(opts.props);\n    _t.addEventListener('click', function(event) {\n        event.preventDefault();\n        discovery_request();\n    });\n    return _t;\n}\n\nfunction containerTemplate(opts) {\n    _set_default_props(opts);\n\n    let uid = opts.uid;\n    let doc = opts.doc;\n    let props = opts.props;\n    let height = opts.dimensions.height;\n    let width = opts.dimensions.width;\n    let frame = opts.frame;\n    let prerenderFrame = opts.prerenderFrame;\n    let event = opts.event;\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        #${ 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        #${ uid } > iframe.invisible {\n            opacity: 0;\n        }\n        #${ uid } > iframe.visible {\n            opacity: 1;\n    }\n    `));\n\n    div.appendChild(frame);\n    div.appendChild(prerenderFrame);\n    div.appendChild(style);\n\n    prerenderFrame.classList.add('visible');\n    frame.classList.add('invisible');\n\n    event.on('zoid-rendered', () => {\n        prerenderFrame.classList.remove('visible');\n        prerenderFrame.classList.add('invisible');\n\n        frame.classList.remove('invisible');\n        frame.classList.add('visible');\n\n        setTimeout(() => {\n            destroyElement(prerenderFrame);\n        }, 1);\n    });\n\n    /*\n    event.on('zoid-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\n    return div;\n}\n\nexport const DiscoveryComponent = zoid.create({\n\n    // The html tag used to render my component\n    tag: 'thiss-cta',\n\n    url: process.env.COMPONENT_URL,\n\n    defaultEnv: 'thiss',\n\n    // default dimensions for the component\n    dimensions: {\n    \twidth: '350px',\n    \theight: '80px'\n    },\n    \n    // defines the log level in the JavaScript console\n    defaultLogLevel: process.env.LOGLEVEL,\n    \n    // defines if the container should be resized\n    autoResize: {\n        width: false,\n        height: false\n    },\n    \n    contexts: {\n        iframe: true,\n        popup: false\n    },\n\n    backgroundColor: '#FFFFFF',\n    color: '#0079ff',\n\n    containerTemplate: containerTemplate,\n    prerenderTemplate: prerenderTemplate\n});\n\nDiscoveryComponent.render = function(props, selector) {\n  return DiscoveryComponent(props).render(selector);\n};","!function(root, factory) {\n    \"object\" == typeof exports && \"object\" == typeof module ? module.exports = factory() : \"function\" == typeof define && define.amd ? define(\"zoid\", [], factory) : \"object\" == typeof exports ? exports.zoid = factory() : root.zoid = factory();\n}(\"undefined\" != typeof self ? self : this, (function() {\n    return function(modules) {\n        var installedModules = {};\n        function __webpack_require__(moduleId) {\n            if (installedModules[moduleId]) return installedModules[moduleId].exports;\n            var module = installedModules[moduleId] = {\n                i: moduleId,\n                l: !1,\n                exports: {}\n            };\n            modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n            module.l = !0;\n            return module.exports;\n        }\n        __webpack_require__.m = modules;\n        __webpack_require__.c = installedModules;\n        __webpack_require__.d = function(exports, name, getter) {\n            __webpack_require__.o(exports, name) || Object.defineProperty(exports, name, {\n                enumerable: !0,\n                get: getter\n            });\n        };\n        __webpack_require__.r = function(exports) {\n            \"undefined\" != typeof Symbol && Symbol.toStringTag && Object.defineProperty(exports, Symbol.toStringTag, {\n                value: \"Module\"\n            });\n            Object.defineProperty(exports, \"__esModule\", {\n                value: !0\n            });\n        };\n        __webpack_require__.t = function(value, mode) {\n            1 & mode && (value = __webpack_require__(value));\n            if (8 & mode) return value;\n            if (4 & mode && \"object\" == typeof value && value && value.__esModule) return value;\n            var ns = Object.create(null);\n            __webpack_require__.r(ns);\n            Object.defineProperty(ns, \"default\", {\n                enumerable: !0,\n                value: value\n            });\n            if (2 & mode && \"string\" != typeof value) for (var key in value) __webpack_require__.d(ns, key, function(key) {\n                return value[key];\n            }.bind(null, key));\n            return ns;\n        };\n        __webpack_require__.n = function(module) {\n            var getter = module && module.__esModule ? function() {\n                return module.default;\n            } : function() {\n                return module;\n            };\n            __webpack_require__.d(getter, \"a\", getter);\n            return getter;\n        };\n        __webpack_require__.o = function(object, property) {\n            return {}.hasOwnProperty.call(object, property);\n        };\n        __webpack_require__.p = \"\";\n        return __webpack_require__(__webpack_require__.s = 0);\n    }([ function(module, __webpack_exports__, __webpack_require__) {\n        \"use strict\";\n        __webpack_require__.r(__webpack_exports__);\n        __webpack_require__.d(__webpack_exports__, \"PopupOpenError\", (function() {\n            return dom_PopupOpenError;\n        }));\n        __webpack_require__.d(__webpack_exports__, \"create\", (function() {\n            return component_create;\n        }));\n        __webpack_require__.d(__webpack_exports__, \"destroy\", (function() {\n            return component_destroy;\n        }));\n        __webpack_require__.d(__webpack_exports__, \"destroyComponents\", (function() {\n            return destroyComponents;\n        }));\n        __webpack_require__.d(__webpack_exports__, \"destroyAll\", (function() {\n            return destroyAll;\n        }));\n        __webpack_require__.d(__webpack_exports__, \"PROP_TYPE\", (function() {\n            return PROP_TYPE;\n        }));\n        __webpack_require__.d(__webpack_exports__, \"PROP_SERIALIZATION\", (function() {\n            return PROP_SERIALIZATION;\n        }));\n        __webpack_require__.d(__webpack_exports__, \"CONTEXT\", (function() {\n            return CONTEXT;\n        }));\n        __webpack_require__.d(__webpack_exports__, \"EVENT\", (function() {\n            return EVENT;\n        }));\n        function _setPrototypeOf(o, p) {\n            return (_setPrototypeOf = Object.setPrototypeOf || function(o, p) {\n                o.__proto__ = p;\n                return o;\n            })(o, p);\n        }\n        function _inheritsLoose(subClass, superClass) {\n            subClass.prototype = Object.create(superClass.prototype);\n            subClass.prototype.constructor = subClass;\n            _setPrototypeOf(subClass, superClass);\n        }\n        function _extends() {\n            return (_extends = Object.assign || function(target) {\n                for (var i = 1; i < arguments.length; i++) {\n                    var source = arguments[i];\n                    for (var key in source) ({}).hasOwnProperty.call(source, key) && (target[key] = source[key]);\n                }\n                return target;\n            }).apply(this, arguments);\n        }\n        function utils_isPromise(item) {\n            try {\n                if (!item) return !1;\n                if (\"undefined\" != typeof Promise && item instanceof Promise) return !0;\n                if (\"undefined\" != typeof window && \"function\" == typeof window.Window && item instanceof window.Window) return !1;\n                if (\"undefined\" != typeof window && \"function\" == typeof window.constructor && item instanceof window.constructor) return !1;\n                var _toString = {}.toString;\n                if (_toString) {\n                    var name = _toString.call(item);\n                    if (\"[object Window]\" === name || \"[object global]\" === name || \"[object DOMWindow]\" === name) return !1;\n                }\n                if (\"function\" == typeof item.then) return !0;\n            } catch (err) {\n                return !1;\n            }\n            return !1;\n        }\n        var dispatchedErrors = [];\n        var possiblyUnhandledPromiseHandlers = [];\n        var activeCount = 0;\n        var flushPromise;\n        function flushActive() {\n            if (!activeCount && flushPromise) {\n                var promise = flushPromise;\n                flushPromise = null;\n                promise.resolve();\n            }\n        }\n        function startActive() {\n            activeCount += 1;\n        }\n        function endActive() {\n            activeCount -= 1;\n            flushActive();\n        }\n        var promise_ZalgoPromise = function() {\n            function ZalgoPromise(handler) {\n                var _this = this;\n                this.resolved = void 0;\n                this.rejected = void 0;\n                this.errorHandled = void 0;\n                this.value = void 0;\n                this.error = void 0;\n                this.handlers = void 0;\n                this.dispatching = void 0;\n                this.stack = void 0;\n                this.resolved = !1;\n                this.rejected = !1;\n                this.errorHandled = !1;\n                this.handlers = [];\n                if (handler) {\n                    var _result;\n                    var _error;\n                    var resolved = !1;\n                    var rejected = !1;\n                    var isAsync = !1;\n                    startActive();\n                    try {\n                        handler((function(res) {\n                            if (isAsync) _this.resolve(res); else {\n                                resolved = !0;\n                                _result = res;\n                            }\n                        }), (function(err) {\n                            if (isAsync) _this.reject(err); else {\n                                rejected = !0;\n                                _error = err;\n                            }\n                        }));\n                    } catch (err) {\n                        endActive();\n                        this.reject(err);\n                        return;\n                    }\n                    endActive();\n                    isAsync = !0;\n                    resolved ? this.resolve(_result) : rejected && this.reject(_error);\n                }\n            }\n            var _proto = ZalgoPromise.prototype;\n            _proto.resolve = function(result) {\n                if (this.resolved || this.rejected) return this;\n                if (utils_isPromise(result)) throw new Error(\"Can not resolve promise with another promise\");\n                this.resolved = !0;\n                this.value = result;\n                this.dispatch();\n                return this;\n            };\n            _proto.reject = function(error) {\n                var _this2 = this;\n                if (this.resolved || this.rejected) return this;\n                if (utils_isPromise(error)) throw new Error(\"Can not reject promise with another promise\");\n                if (!error) {\n                    var _err = error && \"function\" == typeof error.toString ? error.toString() : {}.toString.call(error);\n                    error = new Error(\"Expected reject to be called with Error, got \" + _err);\n                }\n                this.rejected = !0;\n                this.error = error;\n                this.errorHandled || setTimeout((function() {\n                    _this2.errorHandled || function(err, promise) {\n                        if (-1 === dispatchedErrors.indexOf(err)) {\n                            dispatchedErrors.push(err);\n                            setTimeout((function() {\n                                throw err;\n                            }), 1);\n                            for (var j = 0; j < possiblyUnhandledPromiseHandlers.length; j++) possiblyUnhandledPromiseHandlers[j](err, promise);\n                        }\n                    }(error, _this2);\n                }), 1);\n                this.dispatch();\n                return this;\n            };\n            _proto.asyncReject = function(error) {\n                this.errorHandled = !0;\n                this.reject(error);\n                return this;\n            };\n            _proto.dispatch = function() {\n                var resolved = this.resolved, rejected = this.rejected, handlers = this.handlers;\n                if (!this.dispatching && (resolved || rejected)) {\n                    this.dispatching = !0;\n                    startActive();\n                    var chain = function(firstPromise, secondPromise) {\n                        return firstPromise.then((function(res) {\n                            secondPromise.resolve(res);\n                        }), (function(err) {\n                            secondPromise.reject(err);\n                        }));\n                    };\n                    for (var i = 0; i < handlers.length; i++) {\n                        var _handlers$i = handlers[i], onSuccess = _handlers$i.onSuccess, onError = _handlers$i.onError, promise = _handlers$i.promise;\n                        var _result2 = void 0;\n                        if (resolved) try {\n                            _result2 = onSuccess ? onSuccess(this.value) : this.value;\n                        } catch (err) {\n                            promise.reject(err);\n                            continue;\n                        } else if (rejected) {\n                            if (!onError) {\n                                promise.reject(this.error);\n                                continue;\n                            }\n                            try {\n                                _result2 = onError(this.error);\n                            } catch (err) {\n                                promise.reject(err);\n                                continue;\n                            }\n                        }\n                        if (_result2 instanceof ZalgoPromise && (_result2.resolved || _result2.rejected)) {\n                            var promiseResult = _result2;\n                            promiseResult.resolved ? promise.resolve(promiseResult.value) : promise.reject(promiseResult.error);\n                            promiseResult.errorHandled = !0;\n                        } else utils_isPromise(_result2) ? _result2 instanceof ZalgoPromise && (_result2.resolved || _result2.rejected) ? _result2.resolved ? promise.resolve(_result2.value) : promise.reject(_result2.error) : chain(_result2, promise) : promise.resolve(_result2);\n                    }\n                    handlers.length = 0;\n                    this.dispatching = !1;\n                    endActive();\n                }\n            };\n            _proto.then = function(onSuccess, onError) {\n                if (onSuccess && \"function\" != typeof onSuccess && !onSuccess.call) throw new Error(\"Promise.then expected a function for success handler\");\n                if (onError && \"function\" != typeof onError && !onError.call) throw new Error(\"Promise.then expected a function for error handler\");\n                var promise = new ZalgoPromise;\n                this.handlers.push({\n                    promise: promise,\n                    onSuccess: onSuccess,\n                    onError: onError\n                });\n                this.errorHandled = !0;\n                this.dispatch();\n                return promise;\n            };\n            _proto.catch = function(onError) {\n                return this.then(void 0, onError);\n            };\n            _proto.finally = function(onFinally) {\n                if (onFinally && \"function\" != typeof onFinally && !onFinally.call) throw new Error(\"Promise.finally expected a function\");\n                return this.then((function(result) {\n                    return ZalgoPromise.try(onFinally).then((function() {\n                        return result;\n                    }));\n                }), (function(err) {\n                    return ZalgoPromise.try(onFinally).then((function() {\n                        throw err;\n                    }));\n                }));\n            };\n            _proto.timeout = function(time, err) {\n                var _this3 = this;\n                if (this.resolved || this.rejected) return this;\n                var timeout = setTimeout((function() {\n                    _this3.resolved || _this3.rejected || _this3.reject(err || new Error(\"Promise timed out after \" + time + \"ms\"));\n                }), time);\n                return this.then((function(result) {\n                    clearTimeout(timeout);\n                    return result;\n                }));\n            };\n            _proto.toPromise = function() {\n                if (\"undefined\" == typeof Promise) throw new TypeError(\"Could not find Promise\");\n                return Promise.resolve(this);\n            };\n            _proto.lazy = function() {\n                this.errorHandled = !0;\n                return this;\n            };\n            ZalgoPromise.resolve = function(value) {\n                return value instanceof ZalgoPromise ? value : utils_isPromise(value) ? new ZalgoPromise((function(resolve, reject) {\n                    return value.then(resolve, reject);\n                })) : (new ZalgoPromise).resolve(value);\n            };\n            ZalgoPromise.reject = function(error) {\n                return (new ZalgoPromise).reject(error);\n            };\n            ZalgoPromise.asyncReject = function(error) {\n                return (new ZalgoPromise).asyncReject(error);\n            };\n            ZalgoPromise.all = function(promises) {\n                var promise = new ZalgoPromise;\n                var count = promises.length;\n                var results = [].slice();\n                if (!count) {\n                    promise.resolve(results);\n                    return promise;\n                }\n                var chain = function(i, firstPromise, secondPromise) {\n                    return firstPromise.then((function(res) {\n                        results[i] = res;\n                        0 == (count -= 1) && promise.resolve(results);\n                    }), (function(err) {\n                        secondPromise.reject(err);\n                    }));\n                };\n                for (var i = 0; i < promises.length; i++) {\n                    var prom = promises[i];\n                    if (prom instanceof ZalgoPromise) {\n                        if (prom.resolved) {\n                            results[i] = prom.value;\n                            count -= 1;\n                            continue;\n                        }\n                    } else if (!utils_isPromise(prom)) {\n                        results[i] = prom;\n                        count -= 1;\n                        continue;\n                    }\n                    chain(i, ZalgoPromise.resolve(prom), promise);\n                }\n                0 === count && promise.resolve(results);\n                return promise;\n            };\n            ZalgoPromise.hash = function(promises) {\n                var result = {};\n                var awaitPromises = [];\n                var _loop = function(key) {\n                    if (promises.hasOwnProperty(key)) {\n                        var value = promises[key];\n                        utils_isPromise(value) ? awaitPromises.push(value.then((function(res) {\n                            result[key] = res;\n                        }))) : result[key] = value;\n                    }\n                };\n                for (var key in promises) _loop(key);\n                return ZalgoPromise.all(awaitPromises).then((function() {\n                    return result;\n                }));\n            };\n            ZalgoPromise.map = function(items, method) {\n                return ZalgoPromise.all(items.map(method));\n            };\n            ZalgoPromise.onPossiblyUnhandledException = function(handler) {\n                return function(handler) {\n                    possiblyUnhandledPromiseHandlers.push(handler);\n                    return {\n                        cancel: function() {\n                            possiblyUnhandledPromiseHandlers.splice(possiblyUnhandledPromiseHandlers.indexOf(handler), 1);\n                        }\n                    };\n                }(handler);\n            };\n            ZalgoPromise.try = function(method, context, args) {\n                if (method && \"function\" != typeof method && !method.call) throw new Error(\"Promise.try expected a function\");\n                var result;\n                startActive();\n                try {\n                    result = method.apply(context, args || []);\n                } catch (err) {\n                    endActive();\n                    return ZalgoPromise.reject(err);\n                }\n                endActive();\n                return ZalgoPromise.resolve(result);\n            };\n            ZalgoPromise.delay = function(_delay) {\n                return new ZalgoPromise((function(resolve) {\n                    setTimeout(resolve, _delay);\n                }));\n            };\n            ZalgoPromise.isPromise = function(value) {\n                return !!(value && value instanceof ZalgoPromise) || utils_isPromise(value);\n            };\n            ZalgoPromise.flush = function() {\n                return function(Zalgo) {\n                    var promise = flushPromise = flushPromise || new Zalgo;\n                    flushActive();\n                    return promise;\n                }(ZalgoPromise);\n            };\n            return ZalgoPromise;\n        }();\n        function isRegex(item) {\n            return \"[object RegExp]\" === {}.toString.call(item);\n        }\n        var WINDOW_TYPE = {\n            IFRAME: \"iframe\",\n            POPUP: \"popup\"\n        };\n        var IE_WIN_ACCESS_ERROR = \"Call was rejected by callee.\\r\\n\";\n        function getActualProtocol(win) {\n            void 0 === win && (win = window);\n            return win.location.protocol;\n        }\n        function getProtocol(win) {\n            void 0 === win && (win = window);\n            if (win.mockDomain) {\n                var protocol = win.mockDomain.split(\"//\")[0];\n                if (protocol) return protocol;\n            }\n            return getActualProtocol(win);\n        }\n        function isAboutProtocol(win) {\n            void 0 === win && (win = window);\n            return \"about:\" === getProtocol(win);\n        }\n        function utils_getParent(win) {\n            void 0 === win && (win = window);\n            if (win) try {\n                if (win.parent && win.parent !== win) return win.parent;\n            } catch (err) {}\n        }\n        function getOpener(win) {\n            void 0 === win && (win = window);\n            if (win && !utils_getParent(win)) try {\n                return win.opener;\n            } catch (err) {}\n        }\n        function canReadFromWindow(win) {\n            try {\n                return !0;\n            } catch (err) {}\n            return !1;\n        }\n        function getActualDomain(win) {\n            void 0 === win && (win = window);\n            var location = win.location;\n            if (!location) throw new Error(\"Can not read window location\");\n            var protocol = getActualProtocol(win);\n            if (!protocol) throw new Error(\"Can not read window protocol\");\n            if (\"file:\" === protocol) return \"file://\";\n            if (\"about:\" === protocol) {\n                var parent = utils_getParent(win);\n                return parent && canReadFromWindow() ? getActualDomain(parent) : \"about://\";\n            }\n            var host = location.host;\n            if (!host) throw new Error(\"Can not read window host\");\n            return protocol + \"//\" + host;\n        }\n        function getDomain(win) {\n            void 0 === win && (win = window);\n            var domain = getActualDomain(win);\n            return domain && win.mockDomain && 0 === win.mockDomain.indexOf(\"mock:\") ? win.mockDomain : domain;\n        }\n        function isSameDomain(win) {\n            if (!function(win) {\n                try {\n                    if (win === window) return !0;\n                } catch (err) {}\n                try {\n                    var desc = Object.getOwnPropertyDescriptor(win, \"location\");\n                    if (desc && !1 === desc.enumerable) return !1;\n                } catch (err) {}\n                try {\n                    if (isAboutProtocol(win) && canReadFromWindow()) return !0;\n                } catch (err) {}\n                try {\n                    if (function(win) {\n                        void 0 === win && (win = window);\n                        return \"mock:\" === getProtocol(win);\n                    }(win) && canReadFromWindow()) return !0;\n                } catch (err) {}\n                try {\n                    if (getActualDomain(win) === getActualDomain(window)) return !0;\n                } catch (err) {}\n                return !1;\n            }(win)) return !1;\n            try {\n                if (win === window) return !0;\n                if (isAboutProtocol(win) && canReadFromWindow()) return !0;\n                if (getDomain(window) === getDomain(win)) return !0;\n            } catch (err) {}\n            return !1;\n        }\n        function assertSameDomain(win) {\n            if (!isSameDomain(win)) throw new Error(\"Expected window to be same domain\");\n            return win;\n        }\n        function isAncestorParent(parent, child) {\n            if (!parent || !child) return !1;\n            var childParent = utils_getParent(child);\n            return childParent ? childParent === parent : -1 !== function(win) {\n                var result = [];\n                try {\n                    for (;win.parent !== win; ) {\n                        result.push(win.parent);\n                        win = win.parent;\n                    }\n                } catch (err) {}\n                return result;\n            }(child).indexOf(parent);\n        }\n        function getFrames(win) {\n            var result = [];\n            var frames;\n            try {\n                frames = win.frames;\n            } catch (err) {\n                frames = win;\n            }\n            var len;\n            try {\n                len = frames.length;\n            } catch (err) {}\n            if (0 === len) return result;\n            if (len) {\n                for (var i = 0; i < len; i++) {\n                    var frame = void 0;\n                    try {\n                        frame = frames[i];\n                    } catch (err) {\n                        continue;\n                    }\n                    result.push(frame);\n                }\n                return result;\n            }\n            for (var _i = 0; _i < 100; _i++) {\n                var _frame = void 0;\n                try {\n                    _frame = frames[_i];\n                } catch (err) {\n                    return result;\n                }\n                if (!_frame) return result;\n                result.push(_frame);\n            }\n            return result;\n        }\n        function getAllChildFrames(win) {\n            var result = [];\n            for (var _i3 = 0, _getFrames2 = getFrames(win); _i3 < _getFrames2.length; _i3++) {\n                var frame = _getFrames2[_i3];\n                result.push(frame);\n                for (var _i5 = 0, _getAllChildFrames2 = getAllChildFrames(frame); _i5 < _getAllChildFrames2.length; _i5++) result.push(_getAllChildFrames2[_i5]);\n            }\n            return result;\n        }\n        function getTop(win) {\n            void 0 === win && (win = window);\n            try {\n                if (win.top) return win.top;\n            } catch (err) {}\n            if (utils_getParent(win) === win) return win;\n            try {\n                if (isAncestorParent(window, win) && window.top) return window.top;\n            } catch (err) {}\n            try {\n                if (isAncestorParent(win, window) && window.top) return window.top;\n            } catch (err) {}\n            for (var _i7 = 0, _getAllChildFrames4 = getAllChildFrames(win); _i7 < _getAllChildFrames4.length; _i7++) {\n                var frame = _getAllChildFrames4[_i7];\n                try {\n                    if (frame.top) return frame.top;\n                } catch (err) {}\n                if (utils_getParent(frame) === frame) return frame;\n            }\n        }\n        function getAllFramesInWindow(win) {\n            var top = getTop(win);\n            if (!top) throw new Error(\"Can not determine top window\");\n            var result = [].concat(getAllChildFrames(top), [ top ]);\n            -1 === result.indexOf(win) && (result = [].concat(result, [ win ], getAllChildFrames(win)));\n            return result;\n        }\n        var iframeWindows = [];\n        var iframeFrames = [];\n        function isWindowClosed(win, allowMock) {\n            void 0 === allowMock && (allowMock = !0);\n            try {\n                if (win === window) return !1;\n            } catch (err) {\n                return !0;\n            }\n            try {\n                if (!win) return !0;\n            } catch (err) {\n                return !0;\n            }\n            try {\n                if (win.closed) return !0;\n            } catch (err) {\n                return !err || err.message !== IE_WIN_ACCESS_ERROR;\n            }\n            if (allowMock && isSameDomain(win)) try {\n                if (win.mockclosed) return !0;\n            } catch (err) {}\n            try {\n                if (!win.parent || !win.top) return !0;\n            } catch (err) {}\n            var iframeIndex = function(collection, item) {\n                for (var i = 0; i < collection.length; i++) try {\n                    if (collection[i] === item) return i;\n                } catch (err) {}\n                return -1;\n            }(iframeWindows, win);\n            if (-1 !== iframeIndex) {\n                var frame = iframeFrames[iframeIndex];\n                if (frame && function(frame) {\n                    if (!frame.contentWindow) return !0;\n                    if (!frame.parentNode) return !0;\n                    var doc = frame.ownerDocument;\n                    if (doc && doc.documentElement && !doc.documentElement.contains(frame)) {\n                        var parent = frame;\n                        for (;parent.parentNode && parent.parentNode !== parent; ) parent = parent.parentNode;\n                        if (!parent.host || !doc.documentElement.contains(parent.host)) return !0;\n                    }\n                    return !1;\n                }(frame)) return !0;\n            }\n            return !1;\n        }\n        function getFrameByName(win, name) {\n            var winFrames = getFrames(win);\n            for (var _i9 = 0; _i9 < winFrames.length; _i9++) {\n                var childFrame = winFrames[_i9];\n                try {\n                    if (isSameDomain(childFrame) && childFrame.name === name && -1 !== winFrames.indexOf(childFrame)) return childFrame;\n                } catch (err) {}\n            }\n            try {\n                if (-1 !== winFrames.indexOf(win.frames[name])) return win.frames[name];\n            } catch (err) {}\n            try {\n                if (-1 !== winFrames.indexOf(win[name])) return win[name];\n            } catch (err) {}\n        }\n        function getAncestor(win) {\n            void 0 === win && (win = window);\n            return getOpener(win = win || window) || utils_getParent(win) || void 0;\n        }\n        function anyMatch(collection1, collection2) {\n            for (var _i17 = 0; _i17 < collection1.length; _i17++) {\n                var item1 = collection1[_i17];\n                for (var _i19 = 0; _i19 < collection2.length; _i19++) if (item1 === collection2[_i19]) return !0;\n            }\n            return !1;\n        }\n        function getDistanceFromTop(win) {\n            void 0 === win && (win = window);\n            var distance = 0;\n            var parent = win;\n            for (;parent; ) (parent = utils_getParent(parent)) && (distance += 1);\n            return distance;\n        }\n        function isSameTopWindow(win1, win2) {\n            var top1 = getTop(win1) || win1;\n            var top2 = getTop(win2) || win2;\n            try {\n                if (top1 && top2) return top1 === top2;\n            } catch (err) {}\n            var allFrames1 = getAllFramesInWindow(win1);\n            var allFrames2 = getAllFramesInWindow(win2);\n            if (anyMatch(allFrames1, allFrames2)) return !0;\n            var opener1 = getOpener(top1);\n            var opener2 = getOpener(top2);\n            return opener1 && anyMatch(getAllFramesInWindow(opener1), allFrames2) || opener2 && anyMatch(getAllFramesInWindow(opener2), allFrames1), \n            !1;\n        }\n        function matchDomain(pattern, origin) {\n            if (\"string\" == typeof pattern) {\n                if (\"string\" == typeof origin) return \"*\" === pattern || origin === pattern;\n                if (isRegex(origin)) return !1;\n                if (Array.isArray(origin)) return !1;\n            }\n            return isRegex(pattern) ? isRegex(origin) ? pattern.toString() === origin.toString() : !Array.isArray(origin) && Boolean(origin.match(pattern)) : !!Array.isArray(pattern) && (Array.isArray(origin) ? JSON.stringify(pattern) === JSON.stringify(origin) : !isRegex(origin) && pattern.some((function(subpattern) {\n                return matchDomain(subpattern, origin);\n            })));\n        }\n        function getDomainFromUrl(url) {\n            return url.match(/^(https?|mock|file):\\/\\//) ? url.split(\"/\").slice(0, 3).join(\"/\") : getDomain();\n        }\n        function onCloseWindow(win, callback, delay, maxtime) {\n            void 0 === delay && (delay = 1e3);\n            void 0 === maxtime && (maxtime = 1 / 0);\n            var timeout;\n            !function check() {\n                if (isWindowClosed(win)) {\n                    timeout && clearTimeout(timeout);\n                    return callback();\n                }\n                if (maxtime <= 0) clearTimeout(timeout); else {\n                    maxtime -= delay;\n                    timeout = setTimeout(check, delay);\n                }\n            }();\n            return {\n                cancel: function() {\n                    timeout && clearTimeout(timeout);\n                }\n            };\n        }\n        function isWindow(obj) {\n            try {\n                if (obj === window) return !0;\n            } catch (err) {\n                if (err && err.message === IE_WIN_ACCESS_ERROR) return !0;\n            }\n            try {\n                if (\"[object Window]\" === {}.toString.call(obj)) return !0;\n            } catch (err) {\n                if (err && err.message === IE_WIN_ACCESS_ERROR) return !0;\n            }\n            try {\n                if (window.Window && obj instanceof window.Window) return !0;\n            } catch (err) {\n                if (err && err.message === IE_WIN_ACCESS_ERROR) return !0;\n            }\n            try {\n                if (obj && obj.self === obj) return !0;\n            } catch (err) {\n                if (err && err.message === IE_WIN_ACCESS_ERROR) return !0;\n            }\n            try {\n                if (obj && obj.parent === obj) return !0;\n            } catch (err) {\n                if (err && err.message === IE_WIN_ACCESS_ERROR) return !0;\n            }\n            try {\n                if (obj && obj.top === obj) return !0;\n            } catch (err) {\n                if (err && err.message === IE_WIN_ACCESS_ERROR) return !0;\n            }\n            try {\n                if (obj && \"__unlikely_value__\" === obj.__cross_domain_utils_window_check__) return !1;\n            } catch (err) {\n                return !0;\n            }\n            try {\n                if (\"postMessage\" in obj && \"self\" in obj && \"location\" in obj) return !0;\n            } catch (err) {}\n            return !1;\n        }\n        function getFrameForWindow(win) {\n            if (isSameDomain(win)) return assertSameDomain(win).frameElement;\n            for (var _i21 = 0, _document$querySelect2 = document.querySelectorAll(\"iframe\"); _i21 < _document$querySelect2.length; _i21++) {\n                var frame = _document$querySelect2[_i21];\n                if (frame && frame.contentWindow && frame.contentWindow === win) return frame;\n            }\n        }\n        function closeWindow(win) {\n            if (function(win) {\n                void 0 === win && (win = window);\n                return Boolean(utils_getParent(win));\n            }(win)) {\n                var frame = getFrameForWindow(win);\n                if (frame && frame.parentElement) {\n                    frame.parentElement.removeChild(frame);\n                    return;\n                }\n            }\n            try {\n                win.close();\n            } catch (err) {}\n        }\n        function util_safeIndexOf(collection, item) {\n            for (var i = 0; i < collection.length; i++) try {\n                if (collection[i] === item) return i;\n            } catch (err) {}\n            return -1;\n        }\n        var weakmap_CrossDomainSafeWeakMap = function() {\n            function CrossDomainSafeWeakMap() {\n                this.name = void 0;\n                this.weakmap = void 0;\n                this.keys = void 0;\n                this.values = void 0;\n                this.name = \"__weakmap_\" + (1e9 * Math.random() >>> 0) + \"__\";\n                if (function() {\n                    if (\"undefined\" == typeof WeakMap) return !1;\n                    if (void 0 === Object.freeze) return !1;\n                    try {\n                        var testWeakMap = new WeakMap;\n                        var testKey = {};\n                        Object.freeze(testKey);\n                        testWeakMap.set(testKey, \"__testvalue__\");\n                        return \"__testvalue__\" === testWeakMap.get(testKey);\n                    } catch (err) {\n                        return !1;\n                    }\n                }()) try {\n                    this.weakmap = new WeakMap;\n                } catch (err) {}\n                this.keys = [];\n                this.values = [];\n            }\n            var _proto = CrossDomainSafeWeakMap.prototype;\n            _proto._cleanupClosedWindows = function() {\n                var weakmap = this.weakmap;\n                var keys = this.keys;\n                for (var i = 0; i < keys.length; i++) {\n                    var value = keys[i];\n                    if (isWindow(value) && isWindowClosed(value)) {\n                        if (weakmap) try {\n                            weakmap.delete(value);\n                        } catch (err) {}\n                        keys.splice(i, 1);\n                        this.values.splice(i, 1);\n                        i -= 1;\n                    }\n                }\n            };\n            _proto.isSafeToReadWrite = function(key) {\n                return !isWindow(key);\n            };\n            _proto.set = function(key, value) {\n                if (!key) throw new Error(\"WeakMap expected key\");\n                var weakmap = this.weakmap;\n                if (weakmap) try {\n                    weakmap.set(key, value);\n                } catch (err) {\n                    delete this.weakmap;\n                }\n                if (this.isSafeToReadWrite(key)) try {\n                    var name = this.name;\n                    var entry = key[name];\n                    entry && entry[0] === key ? entry[1] = value : Object.defineProperty(key, name, {\n                        value: [ key, value ],\n                        writable: !0\n                    });\n                    return;\n                } catch (err) {}\n                this._cleanupClosedWindows();\n                var keys = this.keys;\n                var values = this.values;\n                var index = util_safeIndexOf(keys, key);\n                if (-1 === index) {\n                    keys.push(key);\n                    values.push(value);\n                } else values[index] = value;\n            };\n            _proto.get = function(key) {\n                if (!key) throw new Error(\"WeakMap expected key\");\n                var weakmap = this.weakmap;\n                if (weakmap) try {\n                    if (weakmap.has(key)) return weakmap.get(key);\n                } catch (err) {\n                    delete this.weakmap;\n                }\n                if (this.isSafeToReadWrite(key)) try {\n                    var entry = key[this.name];\n                    return entry && entry[0] === key ? entry[1] : void 0;\n                } catch (err) {}\n                this._cleanupClosedWindows();\n                var index = util_safeIndexOf(this.keys, key);\n                if (-1 !== index) return this.values[index];\n            };\n            _proto.delete = function(key) {\n                if (!key) throw new Error(\"WeakMap expected key\");\n                var weakmap = this.weakmap;\n                if (weakmap) try {\n                    weakmap.delete(key);\n                } catch (err) {\n                    delete this.weakmap;\n                }\n                if (this.isSafeToReadWrite(key)) try {\n                    var entry = key[this.name];\n                    entry && entry[0] === key && (entry[0] = entry[1] = void 0);\n                } catch (err) {}\n                this._cleanupClosedWindows();\n                var keys = this.keys;\n                var index = util_safeIndexOf(keys, key);\n                if (-1 !== index) {\n                    keys.splice(index, 1);\n                    this.values.splice(index, 1);\n                }\n            };\n            _proto.has = function(key) {\n                if (!key) throw new Error(\"WeakMap expected key\");\n                var weakmap = this.weakmap;\n                if (weakmap) try {\n                    if (weakmap.has(key)) return !0;\n                } catch (err) {\n                    delete this.weakmap;\n                }\n                if (this.isSafeToReadWrite(key)) try {\n                    var entry = key[this.name];\n                    return !(!entry || entry[0] !== key);\n                } catch (err) {}\n                this._cleanupClosedWindows();\n                return -1 !== util_safeIndexOf(this.keys, key);\n            };\n            _proto.getOrSet = function(key, getter) {\n                if (this.has(key)) return this.get(key);\n                var value = getter();\n                this.set(key, value);\n                return value;\n            };\n            return CrossDomainSafeWeakMap;\n        }();\n        function _getPrototypeOf(o) {\n            return (_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function(o) {\n                return o.__proto__ || Object.getPrototypeOf(o);\n            })(o);\n        }\n        function _isNativeReflectConstruct() {\n            if (\"undefined\" == typeof Reflect || !Reflect.construct) return !1;\n            if (Reflect.construct.sham) return !1;\n            if (\"function\" == typeof Proxy) return !0;\n            try {\n                Date.prototype.toString.call(Reflect.construct(Date, [], (function() {})));\n                return !0;\n            } catch (e) {\n                return !1;\n            }\n        }\n        function construct_construct(Parent, args, Class) {\n            return (construct_construct = _isNativeReflectConstruct() ? Reflect.construct : function(Parent, args, Class) {\n                var a = [ null ];\n                a.push.apply(a, args);\n                var instance = new (Function.bind.apply(Parent, a));\n                Class && _setPrototypeOf(instance, Class.prototype);\n                return instance;\n            }).apply(null, arguments);\n        }\n        function wrapNativeSuper_wrapNativeSuper(Class) {\n            var _cache = \"function\" == typeof Map ? new Map : void 0;\n            return (wrapNativeSuper_wrapNativeSuper = function(Class) {\n                if (null === Class || !(fn = Class, -1 !== Function.toString.call(fn).indexOf(\"[native code]\"))) return Class;\n                var fn;\n                if (\"function\" != typeof Class) throw new TypeError(\"Super expression must either be null or a function\");\n                if (void 0 !== _cache) {\n                    if (_cache.has(Class)) return _cache.get(Class);\n                    _cache.set(Class, Wrapper);\n                }\n                function Wrapper() {\n                    return construct_construct(Class, arguments, _getPrototypeOf(this).constructor);\n                }\n                Wrapper.prototype = Object.create(Class.prototype, {\n                    constructor: {\n                        value: Wrapper,\n                        enumerable: !1,\n                        writable: !0,\n                        configurable: !0\n                    }\n                });\n                return _setPrototypeOf(Wrapper, Class);\n            })(Class);\n        }\n        function getFunctionName(fn) {\n            return fn.name || fn.__name__ || fn.displayName || \"anonymous\";\n        }\n        function setFunctionName(fn, name) {\n            try {\n                delete fn.name;\n                fn.name = name;\n            } catch (err) {}\n            fn.__name__ = fn.displayName = name;\n            return fn;\n        }\n        function base64encode(str) {\n            if (\"function\" == typeof btoa) return btoa(encodeURIComponent(str).replace(/%([0-9A-F]{2})/g, (function(m, p1) {\n                return String.fromCharCode(parseInt(p1, 16));\n            }))).replace(/[=]/g, \"\");\n            if (\"undefined\" != typeof Buffer) return Buffer.from(str, \"utf8\").toString(\"base64\").replace(/[=]/g, \"\");\n            throw new Error(\"Can not find window.btoa or Buffer\");\n        }\n        function uniqueID() {\n            var chars = \"0123456789abcdef\";\n            return \"uid_\" + \"xxxxxxxxxx\".replace(/./g, (function() {\n                return chars.charAt(Math.floor(Math.random() * chars.length));\n            })) + \"_\" + base64encode((new Date).toISOString().slice(11, 19).replace(\"T\", \".\")).replace(/[^a-zA-Z0-9]/g, \"\").toLowerCase();\n        }\n        var objectIDs;\n        function serializeArgs(args) {\n            try {\n                return JSON.stringify([].slice.call(args), (function(subkey, val) {\n                    return \"function\" == typeof val ? \"memoize[\" + function(obj) {\n                        objectIDs = objectIDs || new weakmap_CrossDomainSafeWeakMap;\n                        if (null == obj || \"object\" != typeof obj && \"function\" != typeof obj) throw new Error(\"Invalid object\");\n                        var uid = objectIDs.get(obj);\n                        if (!uid) {\n                            uid = typeof obj + \":\" + uniqueID();\n                            objectIDs.set(obj, uid);\n                        }\n                        return uid;\n                    }(val) + \"]\" : val;\n                }));\n            } catch (err) {\n                throw new Error(\"Arguments not serializable -- can not be used to memoize\");\n            }\n        }\n        function getEmptyObject() {\n            return {};\n        }\n        var memoizeGlobalIndex = 0;\n        var memoizeGlobalIndexValidFrom = 0;\n        function memoize(method, options) {\n            void 0 === options && (options = {});\n            var _options$thisNamespac = options.thisNamespace, thisNamespace = void 0 !== _options$thisNamespac && _options$thisNamespac, cacheTime = options.time;\n            var simpleCache;\n            var thisCache;\n            var memoizeIndex = memoizeGlobalIndex;\n            memoizeGlobalIndex += 1;\n            var memoizedFunction = function() {\n                for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) args[_key] = arguments[_key];\n                if (memoizeIndex < memoizeGlobalIndexValidFrom) {\n                    simpleCache = null;\n                    thisCache = null;\n                    memoizeIndex = memoizeGlobalIndex;\n                    memoizeGlobalIndex += 1;\n                }\n                var cache;\n                cache = thisNamespace ? (thisCache = thisCache || new weakmap_CrossDomainSafeWeakMap).getOrSet(this, getEmptyObject) : simpleCache = simpleCache || {};\n                var cacheKey = serializeArgs(args);\n                var cacheResult = cache[cacheKey];\n                if (cacheResult && cacheTime && Date.now() - cacheResult.time < cacheTime) {\n                    delete cache[cacheKey];\n                    cacheResult = null;\n                }\n                if (cacheResult) return cacheResult.value;\n                var time = Date.now();\n                var value = method.apply(this, arguments);\n                cache[cacheKey] = {\n                    time: time,\n                    value: value\n                };\n                return value;\n            };\n            memoizedFunction.reset = function() {\n                simpleCache = null;\n                thisCache = null;\n            };\n            return setFunctionName(memoizedFunction, (options.name || getFunctionName(method)) + \"::memoized\");\n        }\n        memoize.clear = function() {\n            memoizeGlobalIndexValidFrom = memoizeGlobalIndex;\n        };\n        function memoizePromise(method) {\n            var cache = {};\n            function memoizedPromiseFunction() {\n                var _arguments = arguments, _this = this;\n                for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) args[_key2] = arguments[_key2];\n                var key = serializeArgs(args);\n                if (cache.hasOwnProperty(key)) return cache[key];\n                cache[key] = promise_ZalgoPromise.try((function() {\n                    return method.apply(_this, _arguments);\n                })).finally((function() {\n                    delete cache[key];\n                }));\n                return cache[key];\n            }\n            memoizedPromiseFunction.reset = function() {\n                cache = {};\n            };\n            return setFunctionName(memoizedPromiseFunction, getFunctionName(method) + \"::promiseMemoized\");\n        }\n        function src_util_noop() {}\n        function once(method) {\n            var called = !1;\n            return setFunctionName((function() {\n                if (!called) {\n                    called = !0;\n                    return method.apply(this, arguments);\n                }\n            }), getFunctionName(method) + \"::once\");\n        }\n        function stringifyError(err, level) {\n            void 0 === level && (level = 1);\n            if (level >= 3) return \"stringifyError stack overflow\";\n            try {\n                if (!err) return \"<unknown error: \" + {}.toString.call(err) + \">\";\n                if (\"string\" == typeof err) return err;\n                if (err instanceof Error) {\n                    var stack = err && err.stack;\n                    var message = err && err.message;\n                    if (stack && message) return -1 !== stack.indexOf(message) ? stack : message + \"\\n\" + stack;\n                    if (stack) return stack;\n                    if (message) return message;\n                }\n                return err && err.toString && \"function\" == typeof err.toString ? err.toString() : {}.toString.call(err);\n            } catch (newErr) {\n                return \"Error while stringifying error: \" + stringifyError(newErr, level + 1);\n            }\n        }\n        function stringify(item) {\n            return \"string\" == typeof item ? item : item && item.toString && \"function\" == typeof item.toString ? item.toString() : {}.toString.call(item);\n        }\n        function extend(obj, source) {\n            if (!source) return obj;\n            if (Object.assign) return Object.assign(obj, source);\n            for (var key in source) source.hasOwnProperty(key) && (obj[key] = source[key]);\n            return obj;\n        }\n        memoize((function(obj) {\n            if (Object.values) return Object.values(obj);\n            var result = [];\n            for (var key in obj) obj.hasOwnProperty(key) && result.push(obj[key]);\n            return result;\n        }));\n        function identity(item) {\n            return item;\n        }\n        function safeInterval(method, time) {\n            var timeout;\n            !function loop() {\n                timeout = setTimeout((function() {\n                    method();\n                    loop();\n                }), time);\n            }();\n            return {\n                cancel: function() {\n                    clearTimeout(timeout);\n                }\n            };\n        }\n        function arrayFrom(item) {\n            return [].slice.call(item);\n        }\n        function isDefined(value) {\n            return null != value;\n        }\n        function util_isRegex(item) {\n            return \"[object RegExp]\" === {}.toString.call(item);\n        }\n        function util_getOrSet(obj, key, getter) {\n            if (obj.hasOwnProperty(key)) return obj[key];\n            var val = getter();\n            obj[key] = val;\n            return val;\n        }\n        function cleanup(obj) {\n            var tasks = [];\n            var cleaned = !1;\n            var cleanErr;\n            var cleaner = {\n                set: function(name, item) {\n                    if (!cleaned) {\n                        obj[name] = item;\n                        cleaner.register((function() {\n                            delete obj[name];\n                        }));\n                    }\n                    return item;\n                },\n                register: function(method) {\n                    var task = once((function() {\n                        return method(cleanErr);\n                    }));\n                    cleaned ? method(cleanErr) : tasks.push(task);\n                    return {\n                        cancel: function() {\n                            var index = tasks.indexOf(task);\n                            -1 !== index && tasks.splice(index, 1);\n                        }\n                    };\n                },\n                all: function(err) {\n                    cleanErr = err;\n                    var results = [];\n                    cleaned = !0;\n                    for (;tasks.length; ) {\n                        var task = tasks.shift();\n                        results.push(task());\n                    }\n                    return promise_ZalgoPromise.all(results).then(src_util_noop);\n                }\n            };\n            return cleaner;\n        }\n        function assertExists(name, thing) {\n            if (null == thing) throw new Error(\"Expected \" + name + \" to be present\");\n            return thing;\n        }\n        var util_ExtendableError = function(_Error) {\n            _inheritsLoose(ExtendableError, _Error);\n            function ExtendableError(message) {\n                var _this6;\n                (_this6 = _Error.call(this, message) || this).name = _this6.constructor.name;\n                \"function\" == typeof Error.captureStackTrace ? Error.captureStackTrace(function(self) {\n                    if (void 0 === self) throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n                    return self;\n                }(_this6), _this6.constructor) : _this6.stack = new Error(message).stack;\n                return _this6;\n            }\n            return ExtendableError;\n        }(wrapNativeSuper_wrapNativeSuper(Error));\n        function getBody() {\n            var body = document.body;\n            if (!body) throw new Error(\"Body element not found\");\n            return body;\n        }\n        function isDocumentReady() {\n            return Boolean(document.body) && \"complete\" === document.readyState;\n        }\n        function isDocumentInteractive() {\n            return Boolean(document.body) && \"interactive\" === document.readyState;\n        }\n        function urlEncode(str) {\n            return encodeURIComponent(str);\n        }\n        memoize((function() {\n            return new promise_ZalgoPromise((function(resolve) {\n                if (isDocumentReady() || isDocumentInteractive()) return resolve();\n                var interval = setInterval((function() {\n                    if (isDocumentReady() || isDocumentInteractive()) {\n                        clearInterval(interval);\n                        return resolve();\n                    }\n                }), 10);\n            }));\n        }));\n        function parseQuery(queryString) {\n            return function(method, logic, args) {\n                void 0 === args && (args = []);\n                var cache = method.__inline_memoize_cache__ = method.__inline_memoize_cache__ || {};\n                var key = serializeArgs(args);\n                return cache.hasOwnProperty(key) ? cache[key] : cache[key] = function() {\n                    var params = {};\n                    if (!queryString) return params;\n                    if (-1 === queryString.indexOf(\"=\")) return params;\n                    for (var _i2 = 0, _queryString$split2 = queryString.split(\"&\"); _i2 < _queryString$split2.length; _i2++) {\n                        var pair = _queryString$split2[_i2];\n                        (pair = pair.split(\"=\"))[0] && pair[1] && (params[decodeURIComponent(pair[0])] = decodeURIComponent(pair[1]));\n                    }\n                    return params;\n                }.apply(void 0, args);\n            }(parseQuery, 0, [ queryString ]);\n        }\n        function extendQuery(originalQuery, props) {\n            void 0 === props && (props = {});\n            return props && Object.keys(props).length ? function(obj) {\n                void 0 === obj && (obj = {});\n                return Object.keys(obj).filter((function(key) {\n                    return \"string\" == typeof obj[key] || \"boolean\" == typeof obj[key];\n                })).map((function(key) {\n                    var val = obj[key];\n                    if (\"string\" != typeof val && \"boolean\" != typeof val) throw new TypeError(\"Invalid type for query\");\n                    return urlEncode(key) + \"=\" + urlEncode(val.toString());\n                })).join(\"&\");\n            }(_extends({}, parseQuery(originalQuery), props)) : originalQuery;\n        }\n        function appendChild(container, child) {\n            container.appendChild(child);\n        }\n        function isElement(element) {\n            return element instanceof window.Element || null !== element && \"object\" == typeof element && 1 === element.nodeType && \"object\" == typeof element.style && \"object\" == typeof element.ownerDocument;\n        }\n        function getElementSafe(id, doc) {\n            void 0 === doc && (doc = document);\n            return isElement(id) ? id : \"string\" == typeof id ? doc.querySelector(id) : void 0;\n        }\n        function elementReady(id) {\n            return new promise_ZalgoPromise((function(resolve, reject) {\n                var name = stringify(id);\n                var el = getElementSafe(id);\n                if (el) return resolve(el);\n                if (isDocumentReady()) return reject(new Error(\"Document is ready and element \" + name + \" does not exist\"));\n                var interval = setInterval((function() {\n                    if (el = getElementSafe(id)) {\n                        resolve(el);\n                        clearInterval(interval);\n                    } else 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        var dom_PopupOpenError = function(_ExtendableError) {\n            _inheritsLoose(PopupOpenError, _ExtendableError);\n            function PopupOpenError() {\n                return _ExtendableError.apply(this, arguments) || this;\n            }\n            return PopupOpenError;\n        }(util_ExtendableError);\n        var awaitFrameLoadPromises;\n        function awaitFrameLoad(frame) {\n            if ((awaitFrameLoadPromises = awaitFrameLoadPromises || new weakmap_CrossDomainSafeWeakMap).has(frame)) {\n                var _promise = awaitFrameLoadPromises.get(frame);\n                if (_promise) return _promise;\n            }\n            var promise = new promise_ZalgoPromise((function(resolve, reject) {\n                frame.addEventListener(\"load\", (function() {\n                    !function(frame) {\n                        !function() {\n                            for (var i = 0; i < iframeWindows.length; i++) {\n                                var closed = !1;\n                                try {\n                                    closed = iframeWindows[i].closed;\n                                } catch (err) {}\n                                if (closed) {\n                                    iframeFrames.splice(i, 1);\n                                    iframeWindows.splice(i, 1);\n                                }\n                            }\n                        }();\n                        if (frame && frame.contentWindow) try {\n                            iframeWindows.push(frame.contentWindow);\n                            iframeFrames.push(frame);\n                        } catch (err) {}\n                    }(frame);\n                    resolve(frame);\n                }));\n                frame.addEventListener(\"error\", (function(err) {\n                    frame.contentWindow ? resolve(frame) : reject(err);\n                }));\n            }));\n            awaitFrameLoadPromises.set(frame, promise);\n            return promise;\n        }\n        function awaitFrameWindow(frame) {\n            return awaitFrameLoad(frame).then((function(loadedFrame) {\n                if (!loadedFrame.contentWindow) throw new Error(\"Could not find window in iframe\");\n                return loadedFrame.contentWindow;\n            }));\n        }\n        function dom_iframe(options, container) {\n            void 0 === options && (options = {});\n            var style = options.style || {};\n            var frame = function(tag, options, container) {\n                void 0 === tag && (tag = \"div\");\n                void 0 === options && (options = {});\n                tag = tag.toLowerCase();\n                var element = document.createElement(tag);\n                options.style && extend(element.style, options.style);\n                options.class && (element.className = options.class.join(\" \"));\n                options.id && element.setAttribute(\"id\", options.id);\n                if (options.attributes) for (var _i10 = 0, _Object$keys2 = Object.keys(options.attributes); _i10 < _Object$keys2.length; _i10++) {\n                    var key = _Object$keys2[_i10];\n                    element.setAttribute(key, options.attributes[key]);\n                }\n                options.styleSheet && function(el, styleText, doc) {\n                    void 0 === doc && (doc = window.document);\n                    el.styleSheet ? el.styleSheet.cssText = styleText : el.appendChild(doc.createTextNode(styleText));\n                }(element, options.styleSheet);\n                if (options.html) {\n                    if (\"iframe\" === tag) throw new Error(\"Iframe html can not be written unless container provided and iframe in DOM\");\n                    element.innerHTML = options.html;\n                }\n                return element;\n            }(\"iframe\", {\n                attributes: _extends({\n                    allowTransparency: \"true\"\n                }, options.attributes || {}),\n                style: _extends({\n                    backgroundColor: \"transparent\",\n                    border: \"none\"\n                }, style),\n                html: options.html,\n                class: options.class\n            });\n            var isIE = window.navigator.userAgent.match(/MSIE|Edge/i);\n            frame.hasAttribute(\"id\") || frame.setAttribute(\"id\", uniqueID());\n            awaitFrameLoad(frame);\n            container && function(id, doc) {\n                void 0 === doc && (doc = document);\n                var element = getElementSafe(id, doc);\n                if (element) return element;\n                throw new Error(\"Can not find element: \" + stringify(id));\n            }(container).appendChild(frame);\n            (options.url || isIE) && frame.setAttribute(\"src\", options.url || \"about:blank\");\n            return frame;\n        }\n        function addEventListener(obj, event, handler) {\n            obj.addEventListener(event, handler);\n            return {\n                cancel: function() {\n                    obj.removeEventListener(event, handler);\n                }\n            };\n        }\n        function showElement(element) {\n            element.style.setProperty(\"display\", \"\");\n        }\n        function hideElement(element) {\n            element.style.setProperty(\"display\", \"none\", \"important\");\n        }\n        function destroyElement(element) {\n            element && element.parentNode && element.parentNode.removeChild(element);\n        }\n        function isElementClosed(el) {\n            return !(el && el.parentNode && el.ownerDocument && el.ownerDocument.documentElement && el.ownerDocument.documentElement.contains(el));\n        }\n        function onResize(el, handler, _temp) {\n            var _ref2 = void 0 === _temp ? {} : _temp, _ref2$width = _ref2.width, width = void 0 === _ref2$width || _ref2$width, _ref2$height = _ref2.height, height = void 0 === _ref2$height || _ref2$height, _ref2$interval = _ref2.interval, interval = void 0 === _ref2$interval ? 100 : _ref2$interval, _ref2$win = _ref2.win, win = void 0 === _ref2$win ? window : _ref2$win;\n            var currentWidth = el.offsetWidth;\n            var currentHeight = el.offsetHeight;\n            var canceled = !1;\n            handler({\n                width: currentWidth,\n                height: currentHeight\n            });\n            var check = function() {\n                if (!canceled && function(el) {\n                    return Boolean(el.offsetWidth || el.offsetHeight || el.getClientRects().length);\n                }(el)) {\n                    var newWidth = el.offsetWidth;\n                    var newHeight = el.offsetHeight;\n                    (width && newWidth !== currentWidth || height && newHeight !== currentHeight) && handler({\n                        width: newWidth,\n                        height: newHeight\n                    });\n                    currentWidth = newWidth;\n                    currentHeight = newHeight;\n                }\n            };\n            var observer;\n            var timeout;\n            win.addEventListener(\"resize\", check);\n            if (void 0 !== win.ResizeObserver) {\n                (observer = new win.ResizeObserver(check)).observe(el);\n                timeout = safeInterval(check, 10 * interval);\n            } else if (void 0 !== win.MutationObserver) {\n                (observer = new win.MutationObserver(check)).observe(el, {\n                    attributes: !0,\n                    childList: !0,\n                    subtree: !0,\n                    characterData: !1\n                });\n                timeout = safeInterval(check, 10 * interval);\n            } else timeout = safeInterval(check, interval);\n            return {\n                cancel: function() {\n                    canceled = !0;\n                    observer.disconnect();\n                    window.removeEventListener(\"resize\", check);\n                    timeout.cancel();\n                }\n            };\n        }\n        function isShadowElement(element) {\n            for (;element.parentNode; ) element = element.parentNode;\n            return \"[object ShadowRoot]\" === element.toString();\n        }\n        var currentScript = \"undefined\" != typeof document ? document.currentScript : null;\n        var getCurrentScript = memoize((function() {\n            if (currentScript) return currentScript;\n            if (currentScript = function() {\n                try {\n                    var stack = function() {\n                        try {\n                            throw new Error(\"_\");\n                        } catch (err) {\n                            return err.stack || \"\";\n                        }\n                    }();\n                    var stackDetails = /.*at [^(]*\\((.*):(.+):(.+)\\)$/gi.exec(stack);\n                    var scriptLocation = stackDetails && stackDetails[1];\n                    if (!scriptLocation) return;\n                    for (var _i22 = 0, _Array$prototype$slic2 = [].slice.call(document.getElementsByTagName(\"script\")).reverse(); _i22 < _Array$prototype$slic2.length; _i22++) {\n                        var script = _Array$prototype$slic2[_i22];\n                        if (script.src && script.src === scriptLocation) return script;\n                    }\n                } catch (err) {}\n            }()) return currentScript;\n            throw new Error(\"Can not determine current script\");\n        }));\n        var currentUID = uniqueID();\n        memoize((function() {\n            var script;\n            try {\n                script = getCurrentScript();\n            } catch (err) {\n                return currentUID;\n            }\n            var uid = script.getAttribute(\"data-uid\");\n            if (uid && \"string\" == typeof uid) return uid;\n            if ((uid = script.getAttribute(\"data-uid-auto\")) && \"string\" == typeof uid) return uid;\n            if (script.src) {\n                var hashedString = function(str) {\n                    var hash = \"\";\n                    for (var i = 0; i < str.length; i++) {\n                        var total = str[i].charCodeAt(0) * i;\n                        str[i + 1] && (total += str[i + 1].charCodeAt(0) * (i - 1));\n                        hash += String.fromCharCode(97 + Math.abs(total) % 26);\n                    }\n                    return hash;\n                }(JSON.stringify({\n                    src: script.src,\n                    dataset: script.dataset\n                }));\n                uid = \"uid_\" + hashedString.slice(hashedString.length - 30);\n            } else uid = uniqueID();\n            script.setAttribute(\"data-uid-auto\", uid);\n            return uid;\n        }));\n        function toPx(val) {\n            return function(val) {\n                if (\"number\" == typeof val) return val;\n                var match = val.match(/^([0-9]+)(px|%)$/);\n                if (!match) throw new Error(\"Could not match css value from \" + val);\n                return parseInt(match[1], 10);\n            }(val) + \"px\";\n        }\n        function toCSS(val) {\n            return \"number\" == typeof val ? toPx(val) : \"string\" == typeof (str = val) && /^[0-9]+%$/.test(str) ? val : toPx(val);\n            var str;\n        }\n        function global_getGlobal(win) {\n            void 0 === win && (win = window);\n            var globalKey = \"__post_robot_10_0_44__\";\n            return win !== window ? win[globalKey] : win[globalKey] = win[globalKey] || {};\n        }\n        var getObj = function() {\n            return {};\n        };\n        function globalStore(key, defStore) {\n            void 0 === key && (key = \"store\");\n            void 0 === defStore && (defStore = getObj);\n            return util_getOrSet(global_getGlobal(), key, (function() {\n                var store = defStore();\n                return {\n                    has: function(storeKey) {\n                        return store.hasOwnProperty(storeKey);\n                    },\n                    get: function(storeKey, defVal) {\n                        return store.hasOwnProperty(storeKey) ? store[storeKey] : defVal;\n                    },\n                    set: function(storeKey, val) {\n                        store[storeKey] = val;\n                        return val;\n                    },\n                    del: function(storeKey) {\n                        delete store[storeKey];\n                    },\n                    getOrSet: function(storeKey, getter) {\n                        return util_getOrSet(store, storeKey, getter);\n                    },\n                    reset: function() {\n                        store = defStore();\n                    },\n                    keys: function() {\n                        return Object.keys(store);\n                    }\n                };\n            }));\n        }\n        var WildCard = function() {};\n        function getWildcard() {\n            var global = global_getGlobal();\n            global.WINDOW_WILDCARD = global.WINDOW_WILDCARD || new WildCard;\n            return global.WINDOW_WILDCARD;\n        }\n        function windowStore(key, defStore) {\n            void 0 === key && (key = \"store\");\n            void 0 === defStore && (defStore = getObj);\n            return globalStore(\"windowStore\").getOrSet(key, (function() {\n                var winStore = new weakmap_CrossDomainSafeWeakMap;\n                var getStore = function(win) {\n                    return winStore.getOrSet(win, defStore);\n                };\n                return {\n                    has: function(win) {\n                        return getStore(win).hasOwnProperty(key);\n                    },\n                    get: function(win, defVal) {\n                        var store = getStore(win);\n                        return store.hasOwnProperty(key) ? store[key] : defVal;\n                    },\n                    set: function(win, val) {\n                        getStore(win)[key] = val;\n                        return val;\n                    },\n                    del: function(win) {\n                        delete getStore(win)[key];\n                    },\n                    getOrSet: function(win, getter) {\n                        return util_getOrSet(getStore(win), key, getter);\n                    }\n                };\n            }));\n        }\n        function getInstanceID() {\n            return globalStore(\"instance\").getOrSet(\"instanceID\", uniqueID);\n        }\n        function resolveHelloPromise(win, _ref) {\n            var domain = _ref.domain;\n            var helloPromises = windowStore(\"helloPromises\");\n            var existingPromise = helloPromises.get(win);\n            existingPromise && existingPromise.resolve({\n                domain: domain\n            });\n            var newPromise = promise_ZalgoPromise.resolve({\n                domain: domain\n            });\n            helloPromises.set(win, newPromise);\n            return newPromise;\n        }\n        function sayHello(win, _ref4) {\n            return (0, _ref4.send)(win, \"postrobot_hello\", {\n                instanceID: getInstanceID()\n            }, {\n                domain: \"*\",\n                timeout: -1\n            }).then((function(_ref5) {\n                var origin = _ref5.origin, instanceID = _ref5.data.instanceID;\n                resolveHelloPromise(win, {\n                    domain: origin\n                });\n                return {\n                    win: win,\n                    domain: origin,\n                    instanceID: instanceID\n                };\n            }));\n        }\n        function getWindowInstanceID(win, _ref6) {\n            var send = _ref6.send;\n            return windowStore(\"windowInstanceIDPromises\").getOrSet(win, (function() {\n                return sayHello(win, {\n                    send: send\n                }).then((function(_ref7) {\n                    return _ref7.instanceID;\n                }));\n            }));\n        }\n        function markWindowKnown(win) {\n            windowStore(\"knownWindows\").set(win, !0);\n        }\n        function isSerializedType(item) {\n            return \"object\" == typeof item && null !== item && \"string\" == typeof item.__type__;\n        }\n        function determineType(val) {\n            return void 0 === val ? \"undefined\" : null === val ? \"null\" : Array.isArray(val) ? \"array\" : \"function\" == typeof val ? \"function\" : \"object\" == typeof val ? val instanceof Error ? \"error\" : \"function\" == typeof val.then ? \"promise\" : \"[object RegExp]\" === {}.toString.call(val) ? \"regex\" : \"[object Date]\" === {}.toString.call(val) ? \"date\" : \"object\" : \"string\" == typeof val ? \"string\" : \"number\" == typeof val ? \"number\" : \"boolean\" == typeof val ? \"boolean\" : void 0;\n        }\n        function serializeType(type, val) {\n            return {\n                __type__: type,\n                __val__: val\n            };\n        }\n        var _SERIALIZER;\n        var SERIALIZER = ((_SERIALIZER = {}).function = function() {}, _SERIALIZER.error = function(_ref) {\n            return serializeType(\"error\", {\n                message: _ref.message,\n                stack: _ref.stack,\n                code: _ref.code,\n                data: _ref.data\n            });\n        }, _SERIALIZER.promise = function() {}, _SERIALIZER.regex = function(val) {\n            return serializeType(\"regex\", val.source);\n        }, _SERIALIZER.date = function(val) {\n            return serializeType(\"date\", val.toJSON());\n        }, _SERIALIZER.array = function(val) {\n            return val;\n        }, _SERIALIZER.object = function(val) {\n            return val;\n        }, _SERIALIZER.string = function(val) {\n            return val;\n        }, _SERIALIZER.number = function(val) {\n            return val;\n        }, _SERIALIZER.boolean = function(val) {\n            return val;\n        }, _SERIALIZER.null = function(val) {\n            return val;\n        }, _SERIALIZER[void 0] = function(val) {\n            return serializeType(\"undefined\", val);\n        }, _SERIALIZER);\n        var defaultSerializers = {};\n        var _DESERIALIZER;\n        var DESERIALIZER = ((_DESERIALIZER = {}).function = function() {\n            throw new Error(\"Function serialization is not implemented; nothing to deserialize\");\n        }, _DESERIALIZER.error = function(_ref2) {\n            var stack = _ref2.stack, code = _ref2.code, data = _ref2.data;\n            var error = new Error(_ref2.message);\n            error.code = code;\n            data && (error.data = data);\n            error.stack = stack + \"\\n\\n\" + error.stack;\n            return error;\n        }, _DESERIALIZER.promise = function() {\n            throw new Error(\"Promise serialization is not implemented; nothing to deserialize\");\n        }, _DESERIALIZER.regex = function(val) {\n            return new RegExp(val);\n        }, _DESERIALIZER.date = function(val) {\n            return new Date(val);\n        }, _DESERIALIZER.array = function(val) {\n            return val;\n        }, _DESERIALIZER.object = function(val) {\n            return val;\n        }, _DESERIALIZER.string = function(val) {\n            return val;\n        }, _DESERIALIZER.number = function(val) {\n            return val;\n        }, _DESERIALIZER.boolean = function(val) {\n            return val;\n        }, _DESERIALIZER.null = function(val) {\n            return val;\n        }, _DESERIALIZER[void 0] = function() {}, _DESERIALIZER);\n        var defaultDeserializers = {};\n        new promise_ZalgoPromise((function(resolve) {\n            if (window.document && window.document.body) return resolve(window.document.body);\n            var interval = setInterval((function() {\n                if (window.document && window.document.body) {\n                    clearInterval(interval);\n                    return resolve(window.document.body);\n                }\n            }), 10);\n        }));\n        function cleanupProxyWindows() {\n            var idToProxyWindow = globalStore(\"idToProxyWindow\");\n            for (var _i2 = 0, _idToProxyWindow$keys2 = idToProxyWindow.keys(); _i2 < _idToProxyWindow$keys2.length; _i2++) {\n                var id = _idToProxyWindow$keys2[_i2];\n                idToProxyWindow.get(id).shouldClean() && idToProxyWindow.del(id);\n            }\n        }\n        function getSerializedWindow(winPromise, _ref) {\n            var send = _ref.send, _ref$id = _ref.id, id = void 0 === _ref$id ? uniqueID() : _ref$id;\n            var windowNamePromise = winPromise.then((function(win) {\n                if (isSameDomain(win)) return assertSameDomain(win).name;\n            }));\n            var windowTypePromise = winPromise.then((function(window) {\n                if (isWindowClosed(window)) throw new Error(\"Window is closed, can not determine type\");\n                return getOpener(window) ? WINDOW_TYPE.POPUP : WINDOW_TYPE.IFRAME;\n            }));\n            windowNamePromise.catch(src_util_noop);\n            windowTypePromise.catch(src_util_noop);\n            var getName = function() {\n                return winPromise.then((function(win) {\n                    if (!isWindowClosed(win)) return isSameDomain(win) ? assertSameDomain(win).name : windowNamePromise;\n                }));\n            };\n            return {\n                id: id,\n                getType: function() {\n                    return windowTypePromise;\n                },\n                getInstanceID: memoizePromise((function() {\n                    return winPromise.then((function(win) {\n                        return getWindowInstanceID(win, {\n                            send: send\n                        });\n                    }));\n                })),\n                close: function() {\n                    return winPromise.then(closeWindow);\n                },\n                getName: getName,\n                focus: function() {\n                    return winPromise.then((function(win) {\n                        win.focus();\n                    }));\n                },\n                isClosed: function() {\n                    return winPromise.then((function(win) {\n                        return isWindowClosed(win);\n                    }));\n                },\n                setLocation: function(href, opts) {\n                    void 0 === opts && (opts = {});\n                    return winPromise.then((function(win) {\n                        var domain = window.location.protocol + \"//\" + window.location.host;\n                        var _opts$method = opts.method, method = void 0 === _opts$method ? \"get\" : _opts$method, body = opts.body;\n                        if (0 === href.indexOf(\"/\")) href = \"\" + domain + href; else if (!href.match(/^https?:\\/\\//) && 0 !== href.indexOf(domain)) throw new Error(\"Expected url to be http or https url, or absolute path, got \" + JSON.stringify(href));\n                        if (\"post\" === method) return getName().then((function(name) {\n                            if (!name) throw new Error(\"Can not post to window without target name\");\n                            !function(_ref3) {\n                                var url = _ref3.url, target = _ref3.target, body = _ref3.body, _ref3$method = _ref3.method, method = void 0 === _ref3$method ? \"post\" : _ref3$method;\n                                var 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                                if (body) for (var _i24 = 0, _Object$keys4 = Object.keys(body); _i24 < _Object$keys4.length; _i24++) {\n                                    var _body$key;\n                                    var key = _Object$keys4[_i24];\n                                    var input = document.createElement(\"input\");\n                                    input.setAttribute(\"name\", key);\n                                    input.setAttribute(\"value\", null == (_body$key = body[key]) ? void 0 : _body$key.toString());\n                                    form.appendChild(input);\n                                }\n                                getBody().appendChild(form);\n                                form.submit();\n                                getBody().removeChild(form);\n                            }({\n                                url: href,\n                                target: name,\n                                method: method,\n                                body: body\n                            });\n                        }));\n                        if (\"get\" !== method) throw new Error(\"Unsupported method: \" + method);\n                        if (isSameDomain(win)) try {\n                            if (win.location && \"function\" == typeof win.location.replace) {\n                                win.location.replace(href);\n                                return;\n                            }\n                        } catch (err) {}\n                        win.location = href;\n                    }));\n                },\n                setName: function(name) {\n                    return winPromise.then((function(win) {\n                        var sameDomain = isSameDomain(win);\n                        var frame = getFrameForWindow(win);\n                        if (!sameDomain) throw new Error(\"Can not set name for cross-domain window: \" + name);\n                        assertSameDomain(win).name = name;\n                        frame && frame.setAttribute(\"name\", name);\n                        windowNamePromise = promise_ZalgoPromise.resolve(name);\n                    }));\n                }\n            };\n        }\n        var window_ProxyWindow = function() {\n            function ProxyWindow(_ref2) {\n                var send = _ref2.send, win = _ref2.win, serializedWindow = _ref2.serializedWindow;\n                this.id = void 0;\n                this.isProxyWindow = !0;\n                this.serializedWindow = void 0;\n                this.actualWindow = void 0;\n                this.actualWindowPromise = void 0;\n                this.send = void 0;\n                this.name = void 0;\n                this.actualWindowPromise = new promise_ZalgoPromise;\n                this.serializedWindow = serializedWindow || getSerializedWindow(this.actualWindowPromise, {\n                    send: send\n                });\n                globalStore(\"idToProxyWindow\").set(this.getID(), this);\n                win && this.setWindow(win, {\n                    send: send\n                });\n            }\n            var _proto = ProxyWindow.prototype;\n            _proto.getID = function() {\n                return this.serializedWindow.id;\n            };\n            _proto.getType = function() {\n                return this.serializedWindow.getType();\n            };\n            _proto.isPopup = function() {\n                return this.getType().then((function(type) {\n                    return type === WINDOW_TYPE.POPUP;\n                }));\n            };\n            _proto.setLocation = function(href, opts) {\n                var _this = this;\n                return this.serializedWindow.setLocation(href, opts).then((function() {\n                    return _this;\n                }));\n            };\n            _proto.getName = function() {\n                return this.serializedWindow.getName();\n            };\n            _proto.setName = function(name) {\n                var _this2 = this;\n                return this.serializedWindow.setName(name).then((function() {\n                    return _this2;\n                }));\n            };\n            _proto.close = function() {\n                var _this3 = this;\n                return this.serializedWindow.close().then((function() {\n                    return _this3;\n                }));\n            };\n            _proto.focus = function() {\n                var _this4 = this;\n                var isPopupPromise = this.isPopup();\n                var getNamePromise = this.getName();\n                var reopenPromise = promise_ZalgoPromise.hash({\n                    isPopup: isPopupPromise,\n                    name: getNamePromise\n                }).then((function(_ref3) {\n                    var name = _ref3.name;\n                    _ref3.isPopup && name && window.open(\"\", name);\n                }));\n                var focusPromise = this.serializedWindow.focus();\n                return promise_ZalgoPromise.all([ reopenPromise, focusPromise ]).then((function() {\n                    return _this4;\n                }));\n            };\n            _proto.isClosed = function() {\n                return this.serializedWindow.isClosed();\n            };\n            _proto.getWindow = function() {\n                return this.actualWindow;\n            };\n            _proto.setWindow = function(win, _ref4) {\n                var send = _ref4.send;\n                this.actualWindow = win;\n                this.actualWindowPromise.resolve(this.actualWindow);\n                this.serializedWindow = getSerializedWindow(this.actualWindowPromise, {\n                    send: send,\n                    id: this.getID()\n                });\n                windowStore(\"winToProxyWindow\").set(win, this);\n            };\n            _proto.awaitWindow = function() {\n                return this.actualWindowPromise;\n            };\n            _proto.matchWindow = function(win, _ref5) {\n                var _this5 = this;\n                var send = _ref5.send;\n                return promise_ZalgoPromise.try((function() {\n                    return _this5.actualWindow ? win === _this5.actualWindow : promise_ZalgoPromise.hash({\n                        proxyInstanceID: _this5.getInstanceID(),\n                        knownWindowInstanceID: getWindowInstanceID(win, {\n                            send: send\n                        })\n                    }).then((function(_ref6) {\n                        var match = _ref6.proxyInstanceID === _ref6.knownWindowInstanceID;\n                        match && _this5.setWindow(win, {\n                            send: send\n                        });\n                        return match;\n                    }));\n                }));\n            };\n            _proto.unwrap = function() {\n                return this.actualWindow || this;\n            };\n            _proto.getInstanceID = function() {\n                return this.serializedWindow.getInstanceID();\n            };\n            _proto.shouldClean = function() {\n                return Boolean(this.actualWindow && isWindowClosed(this.actualWindow));\n            };\n            _proto.serialize = function() {\n                return this.serializedWindow;\n            };\n            ProxyWindow.unwrap = function(win) {\n                return ProxyWindow.isProxyWindow(win) ? win.unwrap() : win;\n            };\n            ProxyWindow.serialize = function(win, _ref7) {\n                var send = _ref7.send;\n                cleanupProxyWindows();\n                return ProxyWindow.toProxyWindow(win, {\n                    send: send\n                }).serialize();\n            };\n            ProxyWindow.deserialize = function(serializedWindow, _ref8) {\n                var send = _ref8.send;\n                cleanupProxyWindows();\n                return globalStore(\"idToProxyWindow\").get(serializedWindow.id) || new ProxyWindow({\n                    serializedWindow: serializedWindow,\n                    send: send\n                });\n            };\n            ProxyWindow.isProxyWindow = function(obj) {\n                return Boolean(obj && !isWindow(obj) && obj.isProxyWindow);\n            };\n            ProxyWindow.toProxyWindow = function(win, _ref9) {\n                var send = _ref9.send;\n                cleanupProxyWindows();\n                if (ProxyWindow.isProxyWindow(win)) return win;\n                var actualWindow = win;\n                return windowStore(\"winToProxyWindow\").get(actualWindow) || new ProxyWindow({\n                    win: actualWindow,\n                    send: send\n                });\n            };\n            return ProxyWindow;\n        }();\n        function addMethod(id, val, name, source, domain) {\n            var methodStore = windowStore(\"methodStore\");\n            var proxyWindowMethods = globalStore(\"proxyWindowMethods\");\n            if (window_ProxyWindow.isProxyWindow(source)) proxyWindowMethods.set(id, {\n                val: val,\n                name: name,\n                domain: domain,\n                source: source\n            }); else {\n                proxyWindowMethods.del(id);\n                methodStore.getOrSet(source, (function() {\n                    return {};\n                }))[id] = {\n                    domain: domain,\n                    name: name,\n                    val: val,\n                    source: source\n                };\n            }\n        }\n        function lookupMethod(source, id) {\n            var methodStore = windowStore(\"methodStore\");\n            var proxyWindowMethods = globalStore(\"proxyWindowMethods\");\n            return methodStore.getOrSet(source, (function() {\n                return {};\n            }))[id] || proxyWindowMethods.get(id);\n        }\n        function function_serializeFunction(destination, domain, val, key, _ref3) {\n            on = (_ref = {\n                on: _ref3.on,\n                send: _ref3.send\n            }).on, send = _ref.send, globalStore(\"builtinListeners\").getOrSet(\"functionCalls\", (function() {\n                return on(\"postrobot_method\", {\n                    domain: \"*\"\n                }, (function(_ref2) {\n                    var source = _ref2.source, origin = _ref2.origin, data = _ref2.data;\n                    var id = data.id, name = data.name;\n                    var meth = lookupMethod(source, id);\n                    if (!meth) throw new Error(\"Could not find method '\" + name + \"' with id: \" + data.id + \" in \" + getDomain(window));\n                    var methodSource = meth.source, domain = meth.domain, val = meth.val;\n                    return promise_ZalgoPromise.try((function() {\n                        if (!matchDomain(domain, origin)) throw new Error(\"Method '\" + data.name + \"' domain \" + JSON.stringify(util_isRegex(meth.domain) ? meth.domain.source : meth.domain) + \" does not match origin \" + origin + \" in \" + getDomain(window));\n                        if (window_ProxyWindow.isProxyWindow(methodSource)) return methodSource.matchWindow(source, {\n                            send: send\n                        }).then((function(match) {\n                            if (!match) throw new Error(\"Method call '\" + data.name + \"' failed - proxy window does not match source in \" + getDomain(window));\n                        }));\n                    })).then((function() {\n                        return val.apply({\n                            source: source,\n                            origin: origin\n                        }, data.args);\n                    }), (function(err) {\n                        return promise_ZalgoPromise.try((function() {\n                            if (val.onError) return val.onError(err);\n                        })).then((function() {\n                            err.stack && (err.stack = \"Remote call to \" + name + \"(\" + function(args) {\n                                void 0 === args && (args = []);\n                                return arrayFrom(args).map((function(arg) {\n                                    return \"string\" == typeof arg ? \"'\" + arg + \"'\" : void 0 === arg ? \"undefined\" : null === arg ? \"null\" : \"boolean\" == typeof arg ? arg.toString() : Array.isArray(arg) ? \"[ ... ]\" : \"object\" == typeof arg ? \"{ ... }\" : \"function\" == typeof arg ? \"() => { ... }\" : \"<\" + typeof arg + \">\";\n                                })).join(\", \");\n                            }(data.args) + \") failed\\n\\n\" + err.stack);\n                            throw err;\n                        }));\n                    })).then((function(result) {\n                        return {\n                            result: result,\n                            id: id,\n                            name: name\n                        };\n                    }));\n                }));\n            }));\n            var _ref, on, send;\n            var id = val.__id__ || uniqueID();\n            destination = window_ProxyWindow.unwrap(destination);\n            var name = val.__name__ || val.name || key;\n            \"string\" == typeof name && \"function\" == typeof name.indexOf && 0 === name.indexOf(\"anonymous::\") && (name = name.replace(\"anonymous::\", key + \"::\"));\n            if (window_ProxyWindow.isProxyWindow(destination)) {\n                addMethod(id, val, name, destination, domain);\n                destination.awaitWindow().then((function(win) {\n                    addMethod(id, val, name, win, domain);\n                }));\n            } else addMethod(id, val, name, destination, domain);\n            return serializeType(\"cross_domain_function\", {\n                id: id,\n                name: name\n            });\n        }\n        function serializeMessage(destination, domain, obj, _ref) {\n            var _serialize;\n            var on = _ref.on, send = _ref.send;\n            return function(obj, serializers) {\n                void 0 === serializers && (serializers = defaultSerializers);\n                var result = JSON.stringify(obj, (function(key) {\n                    var val = this[key];\n                    if (isSerializedType(this)) return val;\n                    var type = determineType(val);\n                    if (!type) return val;\n                    var serializer = serializers[type] || SERIALIZER[type];\n                    return serializer ? serializer(val, key) : val;\n                }));\n                return void 0 === result ? \"undefined\" : result;\n            }(obj, ((_serialize = {}).promise = function(val, key) {\n                return function(destination, domain, val, key, _ref) {\n                    return serializeType(\"cross_domain_zalgo_promise\", {\n                        then: function_serializeFunction(destination, domain, (function(resolve, reject) {\n                            return val.then(resolve, reject);\n                        }), key, {\n                            on: _ref.on,\n                            send: _ref.send\n                        })\n                    });\n                }(destination, domain, val, key, {\n                    on: on,\n                    send: send\n                });\n            }, _serialize.function = function(val, key) {\n                return function_serializeFunction(destination, domain, val, key, {\n                    on: on,\n                    send: send\n                });\n            }, _serialize.object = function(val) {\n                return isWindow(val) || window_ProxyWindow.isProxyWindow(val) ? serializeType(\"cross_domain_window\", window_ProxyWindow.serialize(val, {\n                    send: send\n                })) : val;\n            }, _serialize));\n        }\n        function deserializeMessage(source, origin, message, _ref2) {\n            var _deserialize;\n            var send = _ref2.send;\n            return function(str, deserializers) {\n                void 0 === deserializers && (deserializers = defaultDeserializers);\n                if (\"undefined\" !== str) return JSON.parse(str, (function(key, val) {\n                    if (isSerializedType(this)) return val;\n                    var type;\n                    var value;\n                    if (isSerializedType(val)) {\n                        type = val.__type__;\n                        value = val.__val__;\n                    } else {\n                        type = determineType(val);\n                        value = val;\n                    }\n                    if (!type) return value;\n                    var deserializer = deserializers[type] || DESERIALIZER[type];\n                    return deserializer ? deserializer(value, key) : value;\n                }));\n            }(message, ((_deserialize = {}).cross_domain_zalgo_promise = function(serializedPromise) {\n                return function(source, origin, _ref2) {\n                    return new promise_ZalgoPromise(_ref2.then);\n                }(0, 0, serializedPromise);\n            }, _deserialize.cross_domain_function = function(serializedFunction) {\n                return function(source, origin, _ref4, _ref5) {\n                    var id = _ref4.id, name = _ref4.name;\n                    var send = _ref5.send;\n                    var getDeserializedFunction = function(opts) {\n                        void 0 === opts && (opts = {});\n                        function crossDomainFunctionWrapper() {\n                            var _arguments = arguments;\n                            return window_ProxyWindow.toProxyWindow(source, {\n                                send: send\n                            }).awaitWindow().then((function(win) {\n                                var meth = lookupMethod(win, id);\n                                if (meth && meth.val !== crossDomainFunctionWrapper) return meth.val.apply({\n                                    source: window,\n                                    origin: getDomain()\n                                }, _arguments);\n                                var _args = [].slice.call(_arguments);\n                                return opts.fireAndForget ? send(win, \"postrobot_method\", {\n                                    id: id,\n                                    name: name,\n                                    args: _args\n                                }, {\n                                    domain: origin,\n                                    fireAndForget: !0\n                                }) : send(win, \"postrobot_method\", {\n                                    id: id,\n                                    name: name,\n                                    args: _args\n                                }, {\n                                    domain: origin,\n                                    fireAndForget: !1\n                                }).then((function(res) {\n                                    return res.data.result;\n                                }));\n                            })).catch((function(err) {\n                                throw err;\n                            }));\n                        }\n                        crossDomainFunctionWrapper.__name__ = name;\n                        crossDomainFunctionWrapper.__origin__ = origin;\n                        crossDomainFunctionWrapper.__source__ = source;\n                        crossDomainFunctionWrapper.__id__ = id;\n                        crossDomainFunctionWrapper.origin = origin;\n                        return crossDomainFunctionWrapper;\n                    };\n                    var crossDomainFunctionWrapper = getDeserializedFunction();\n                    crossDomainFunctionWrapper.fireAndForget = getDeserializedFunction({\n                        fireAndForget: !0\n                    });\n                    return crossDomainFunctionWrapper;\n                }(source, origin, serializedFunction, {\n                    send: send\n                });\n            }, _deserialize.cross_domain_window = function(serializedWindow) {\n                return window_ProxyWindow.deserialize(serializedWindow, {\n                    send: send\n                });\n            }, _deserialize));\n        }\n        var SEND_MESSAGE_STRATEGIES = {};\n        SEND_MESSAGE_STRATEGIES.postrobot_post_message = function(win, serializedMessage, domain) {\n            0 === domain.indexOf(\"file:\") && (domain = \"*\");\n            win.postMessage(serializedMessage, domain);\n        };\n        SEND_MESSAGE_STRATEGIES.postrobot_global = function(win, serializedMessage) {\n            if (!function(win) {\n                return (win = win || window).navigator.mockUserAgent || win.navigator.userAgent;\n            }(window).match(/MSIE|rv:11|trident|edge\\/12|edge\\/13/i)) throw new Error(\"Global messaging not needed for browser\");\n            if (!isSameDomain(win)) throw new Error(\"Post message through global disabled between different domain windows\");\n            if (!1 !== isSameTopWindow(window, win)) throw new Error(\"Can only use global to communicate between two different windows, not between frames\");\n            var foreignGlobal = global_getGlobal(win);\n            if (!foreignGlobal) throw new Error(\"Can not find postRobot global on foreign window\");\n            foreignGlobal.receiveMessage({\n                source: window,\n                origin: getDomain(),\n                data: serializedMessage\n            });\n        };\n        function send_sendMessage(win, domain, message, _ref2) {\n            var on = _ref2.on, send = _ref2.send;\n            return promise_ZalgoPromise.try((function() {\n                var domainBuffer = windowStore().getOrSet(win, (function() {\n                    return {};\n                }));\n                domainBuffer.buffer = domainBuffer.buffer || [];\n                domainBuffer.buffer.push(message);\n                domainBuffer.flush = domainBuffer.flush || promise_ZalgoPromise.flush().then((function() {\n                    if (isWindowClosed(win)) throw new Error(\"Window is closed\");\n                    var serializedMessage = serializeMessage(win, domain, ((_ref = {}).__post_robot_10_0_44__ = domainBuffer.buffer || [], \n                    _ref), {\n                        on: on,\n                        send: send\n                    });\n                    var _ref;\n                    delete domainBuffer.buffer;\n                    var strategies = Object.keys(SEND_MESSAGE_STRATEGIES);\n                    var errors = [];\n                    for (var _i2 = 0; _i2 < strategies.length; _i2++) {\n                        var strategyName = strategies[_i2];\n                        try {\n                            SEND_MESSAGE_STRATEGIES[strategyName](win, serializedMessage, domain);\n                        } catch (err) {\n                            errors.push(err);\n                        }\n                    }\n                    if (errors.length === strategies.length) throw new Error(\"All post-robot messaging strategies failed:\\n\\n\" + errors.map((function(err, i) {\n                        return i + \". \" + stringifyError(err);\n                    })).join(\"\\n\\n\"));\n                }));\n                return domainBuffer.flush.then((function() {\n                    delete domainBuffer.flush;\n                }));\n            })).then(src_util_noop);\n        }\n        function getResponseListener(hash) {\n            return globalStore(\"responseListeners\").get(hash);\n        }\n        function deleteResponseListener(hash) {\n            globalStore(\"responseListeners\").del(hash);\n        }\n        function isResponseListenerErrored(hash) {\n            return globalStore(\"erroredResponseListeners\").has(hash);\n        }\n        function getRequestListener(_ref) {\n            var name = _ref.name, win = _ref.win, domain = _ref.domain;\n            var requestListeners = windowStore(\"requestListeners\");\n            \"*\" === win && (win = null);\n            \"*\" === domain && (domain = null);\n            if (!name) throw new Error(\"Name required to get request listener\");\n            for (var _i4 = 0, _ref3 = [ win, getWildcard() ]; _i4 < _ref3.length; _i4++) {\n                var winQualifier = _ref3[_i4];\n                if (winQualifier) {\n                    var nameListeners = requestListeners.get(winQualifier);\n                    if (nameListeners) {\n                        var domainListeners = nameListeners[name];\n                        if (domainListeners) {\n                            if (domain && \"string\" == typeof domain) {\n                                if (domainListeners[domain]) return domainListeners[domain];\n                                if (domainListeners.__domain_regex__) for (var _i6 = 0, _domainListeners$__DO2 = domainListeners.__domain_regex__; _i6 < _domainListeners$__DO2.length; _i6++) {\n                                    var _domainListeners$__DO3 = _domainListeners$__DO2[_i6], listener = _domainListeners$__DO3.listener;\n                                    if (matchDomain(_domainListeners$__DO3.regex, domain)) return listener;\n                                }\n                            }\n                            if (domainListeners[\"*\"]) return domainListeners[\"*\"];\n                        }\n                    }\n                }\n            }\n        }\n        function handleRequest(source, origin, message, _ref) {\n            var on = _ref.on, send = _ref.send;\n            var options = getRequestListener({\n                name: message.name,\n                win: source,\n                domain: origin\n            });\n            var logName = \"postrobot_method\" === message.name && message.data && \"string\" == typeof message.data.name ? message.data.name + \"()\" : message.name;\n            function sendResponse(ack, data, error) {\n                return promise_ZalgoPromise.flush().then((function() {\n                    if (!message.fireAndForget && !isWindowClosed(source)) try {\n                        return send_sendMessage(source, origin, {\n                            id: uniqueID(),\n                            origin: getDomain(window),\n                            type: \"postrobot_message_response\",\n                            hash: message.hash,\n                            name: message.name,\n                            ack: ack,\n                            data: data,\n                            error: error\n                        }, {\n                            on: on,\n                            send: send\n                        });\n                    } catch (err) {\n                        throw new Error(\"Send response message failed for \" + logName + \" in \" + getDomain() + \"\\n\\n\" + stringifyError(err));\n                    }\n                }));\n            }\n            return promise_ZalgoPromise.all([ promise_ZalgoPromise.flush().then((function() {\n                if (!message.fireAndForget && !isWindowClosed(source)) try {\n                    return send_sendMessage(source, origin, {\n                        id: uniqueID(),\n                        origin: getDomain(window),\n                        type: \"postrobot_message_ack\",\n                        hash: message.hash,\n                        name: message.name\n                    }, {\n                        on: on,\n                        send: send\n                    });\n                } catch (err) {\n                    throw new Error(\"Send ack message failed for \" + logName + \" in \" + getDomain() + \"\\n\\n\" + stringifyError(err));\n                }\n            })), promise_ZalgoPromise.try((function() {\n                if (!options) throw new Error(\"No handler found for post message: \" + message.name + \" from \" + origin + \" in \" + window.location.protocol + \"//\" + window.location.host + window.location.pathname);\n                if (!matchDomain(options.domain, origin)) throw new Error(\"Request origin \" + origin + \" does not match domain \" + options.domain.toString());\n                return options.handler({\n                    source: source,\n                    origin: origin,\n                    data: message.data\n                });\n            })).then((function(data) {\n                return sendResponse(\"success\", data);\n            }), (function(error) {\n                return sendResponse(\"error\", null, error);\n            })) ]).then(src_util_noop).catch((function(err) {\n                if (options && options.handleError) return options.handleError(err);\n                throw err;\n            }));\n        }\n        function handleAck(source, origin, message) {\n            if (!isResponseListenerErrored(message.hash)) {\n                var options = getResponseListener(message.hash);\n                if (!options) 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                try {\n                    if (!matchDomain(options.domain, origin)) throw new Error(\"Ack origin \" + origin + \" does not match domain \" + options.domain.toString());\n                    if (source !== options.win) throw new Error(\"Ack source does not match registered window\");\n                } catch (err) {\n                    options.promise.reject(err);\n                }\n                options.ack = !0;\n            }\n        }\n        function handleResponse(source, origin, message) {\n            if (!isResponseListenerErrored(message.hash)) {\n                var options = getResponseListener(message.hash);\n                if (!options) 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                if (!matchDomain(options.domain, origin)) throw new Error(\"Response origin \" + origin + \" does not match domain \" + (pattern = options.domain, \n                Array.isArray(pattern) ? \"(\" + pattern.join(\" | \") + \")\" : isRegex(pattern) ? \"RegExp(\" + pattern.toString() + \")\" : pattern.toString()));\n                var pattern;\n                if (source !== options.win) throw new Error(\"Response source does not match registered window\");\n                deleteResponseListener(message.hash);\n                \"error\" === message.ack ? options.promise.reject(message.error) : \"success\" === message.ack && options.promise.resolve({\n                    source: source,\n                    origin: origin,\n                    data: message.data\n                });\n            }\n        }\n        function receive_receiveMessage(event, _ref2) {\n            var on = _ref2.on, send = _ref2.send;\n            var receivedMessages = globalStore(\"receivedMessages\");\n            try {\n                if (!window || window.closed || !event.source) return;\n            } catch (err) {\n                return;\n            }\n            var source = event.source, origin = event.origin;\n            var messages = function(message, source, origin, _ref) {\n                var on = _ref.on, send = _ref.send;\n                var parsedMessage;\n                try {\n                    parsedMessage = deserializeMessage(source, origin, message, {\n                        on: on,\n                        send: send\n                    });\n                } catch (err) {\n                    return;\n                }\n                if (parsedMessage && \"object\" == typeof parsedMessage && null !== parsedMessage) {\n                    var parseMessages = parsedMessage.__post_robot_10_0_44__;\n                    if (Array.isArray(parseMessages)) return parseMessages;\n                }\n            }(event.data, source, origin, {\n                on: on,\n                send: send\n            });\n            if (messages) {\n                markWindowKnown(source);\n                for (var _i2 = 0; _i2 < messages.length; _i2++) {\n                    var message = messages[_i2];\n                    if (receivedMessages.has(message.id)) return;\n                    receivedMessages.set(message.id, !0);\n                    if (isWindowClosed(source) && !message.fireAndForget) return;\n                    0 === message.origin.indexOf(\"file:\") && (origin = \"file://\");\n                    try {\n                        \"postrobot_message_request\" === message.type ? handleRequest(source, origin, message, {\n                            on: on,\n                            send: send\n                        }) : \"postrobot_message_response\" === message.type ? handleResponse(source, origin, message) : \"postrobot_message_ack\" === message.type && handleAck(source, origin, message);\n                    } catch (err) {\n                        setTimeout((function() {\n                            throw err;\n                        }), 0);\n                    }\n                }\n            }\n        }\n        function on_on(name, options, handler) {\n            if (!name) throw new Error(\"Expected name\");\n            if (\"function\" == typeof (options = options || {})) {\n                handler = options;\n                options = {};\n            }\n            if (!handler) throw new Error(\"Expected handler\");\n            (options = options || {}).name = name;\n            options.handler = handler || options.handler;\n            var win = options.window;\n            var domain = options.domain;\n            var requestListener = function addRequestListener(_ref4, listener) {\n                var name = _ref4.name, win = _ref4.win, domain = _ref4.domain;\n                var requestListeners = windowStore(\"requestListeners\");\n                if (!name || \"string\" != typeof name) throw new Error(\"Name required to add request listener\");\n                if (Array.isArray(win)) {\n                    var listenersCollection = [];\n                    for (var _i8 = 0, _win2 = win; _i8 < _win2.length; _i8++) listenersCollection.push(addRequestListener({\n                        name: name,\n                        domain: domain,\n                        win: _win2[_i8]\n                    }, listener));\n                    return {\n                        cancel: function() {\n                            for (var _i10 = 0; _i10 < listenersCollection.length; _i10++) listenersCollection[_i10].cancel();\n                        }\n                    };\n                }\n                if (Array.isArray(domain)) {\n                    var _listenersCollection = [];\n                    for (var _i12 = 0, _domain2 = domain; _i12 < _domain2.length; _i12++) _listenersCollection.push(addRequestListener({\n                        name: name,\n                        win: win,\n                        domain: _domain2[_i12]\n                    }, listener));\n                    return {\n                        cancel: function() {\n                            for (var _i14 = 0; _i14 < _listenersCollection.length; _i14++) _listenersCollection[_i14].cancel();\n                        }\n                    };\n                }\n                var existingListener = getRequestListener({\n                    name: name,\n                    win: win,\n                    domain: domain\n                });\n                win && \"*\" !== win || (win = getWildcard());\n                domain = domain || \"*\";\n                if (existingListener) throw win && domain ? new Error(\"Request listener already exists for \" + name + \" on domain \" + domain.toString() + \" for \" + (win === getWildcard() ? \"wildcard\" : \"specified\") + \" window\") : win ? new Error(\"Request listener already exists for \" + name + \" for \" + (win === getWildcard() ? \"wildcard\" : \"specified\") + \" window\") : domain ? new Error(\"Request listener already exists for \" + name + \" on domain \" + domain.toString()) : new Error(\"Request listener already exists for \" + name);\n                var nameListeners = requestListeners.getOrSet(win, (function() {\n                    return {};\n                }));\n                var domainListeners = util_getOrSet(nameListeners, name, (function() {\n                    return {};\n                }));\n                var strDomain = domain.toString();\n                var regexListeners;\n                var regexListener;\n                util_isRegex(domain) ? (regexListeners = util_getOrSet(domainListeners, \"__domain_regex__\", (function() {\n                    return [];\n                }))).push(regexListener = {\n                    regex: domain,\n                    listener: listener\n                }) : domainListeners[strDomain] = listener;\n                return {\n                    cancel: function() {\n                        delete domainListeners[strDomain];\n                        if (regexListener) {\n                            regexListeners.splice(regexListeners.indexOf(regexListener, 1));\n                            regexListeners.length || delete domainListeners.__domain_regex__;\n                        }\n                        Object.keys(domainListeners).length || delete nameListeners[name];\n                        win && !Object.keys(nameListeners).length && requestListeners.del(win);\n                    }\n                };\n            }({\n                name: name,\n                win: win,\n                domain: domain\n            }, {\n                handler: options.handler,\n                handleError: options.errorHandler || function(err) {\n                    throw err;\n                },\n                window: win,\n                domain: domain || \"*\",\n                name: name\n            });\n            return {\n                cancel: function() {\n                    requestListener.cancel();\n                }\n            };\n        }\n        var send_send = function send(win, name, data, options) {\n            var domainMatcher = (options = options || {}).domain || \"*\";\n            var responseTimeout = options.timeout || -1;\n            var childTimeout = options.timeout || 5e3;\n            var fireAndForget = options.fireAndForget || !1;\n            return promise_ZalgoPromise.try((function() {\n                !function(name, win, domain) {\n                    if (!name) throw new Error(\"Expected name\");\n                    if (domain && \"string\" != typeof domain && !Array.isArray(domain) && !util_isRegex(domain)) throw new TypeError(\"Can not send \" + name + \". Expected domain \" + JSON.stringify(domain) + \" to be a string, array, or regex\");\n                    if (isWindowClosed(win)) throw new Error(\"Can not send \" + name + \". Target window is closed\");\n                }(name, win, domainMatcher);\n                if (function(parent, child) {\n                    var actualParent = getAncestor(child);\n                    if (actualParent) return actualParent === parent;\n                    if (child === parent) return !1;\n                    if (getTop(child) === child) return !1;\n                    for (var _i15 = 0, _getFrames8 = getFrames(parent); _i15 < _getFrames8.length; _i15++) if (_getFrames8[_i15] === child) return !0;\n                    return !1;\n                }(window, win)) return function(win, timeout, name) {\n                    void 0 === timeout && (timeout = 5e3);\n                    void 0 === name && (name = \"Window\");\n                    var promise = function(win) {\n                        return windowStore(\"helloPromises\").getOrSet(win, (function() {\n                            return new promise_ZalgoPromise;\n                        }));\n                    }(win);\n                    -1 !== timeout && (promise = promise.timeout(timeout, new Error(name + \" did not load after \" + timeout + \"ms\")));\n                    return promise;\n                }(win, childTimeout);\n            })).then((function(_temp) {\n                return function(win, targetDomain, actualDomain, _ref) {\n                    var send = _ref.send;\n                    return promise_ZalgoPromise.try((function() {\n                        return \"string\" == typeof targetDomain ? targetDomain : promise_ZalgoPromise.try((function() {\n                            return actualDomain || sayHello(win, {\n                                send: send\n                            }).then((function(_ref2) {\n                                return _ref2.domain;\n                            }));\n                        })).then((function(normalizedDomain) {\n                            if (!matchDomain(targetDomain, targetDomain)) throw new Error(\"Domain \" + stringify(targetDomain) + \" does not match \" + stringify(targetDomain));\n                            return normalizedDomain;\n                        }));\n                    }));\n                }(win, domainMatcher, (void 0 === _temp ? {} : _temp).domain, {\n                    send: send\n                });\n            })).then((function(targetDomain) {\n                var domain = targetDomain;\n                var logName = \"postrobot_method\" === name && data && \"string\" == typeof data.name ? data.name + \"()\" : name;\n                var promise = new promise_ZalgoPromise;\n                var hash = name + \"_\" + uniqueID();\n                if (!fireAndForget) {\n                    var responseListener = {\n                        name: name,\n                        win: win,\n                        domain: domain,\n                        promise: promise\n                    };\n                    !function(hash, listener) {\n                        globalStore(\"responseListeners\").set(hash, listener);\n                    }(hash, responseListener);\n                    var reqPromises = windowStore(\"requestPromises\").getOrSet(win, (function() {\n                        return [];\n                    }));\n                    reqPromises.push(promise);\n                    promise.catch((function() {\n                        !function(hash) {\n                            globalStore(\"erroredResponseListeners\").set(hash, !0);\n                        }(hash);\n                        deleteResponseListener(hash);\n                    }));\n                    var totalAckTimeout = function(win) {\n                        return windowStore(\"knownWindows\").get(win, !1);\n                    }(win) ? 1e4 : 2e3;\n                    var totalResTimeout = responseTimeout;\n                    var ackTimeout = totalAckTimeout;\n                    var resTimeout = totalResTimeout;\n                    var interval = safeInterval((function() {\n                        if (isWindowClosed(win)) return promise.reject(new Error(\"Window closed for \" + name + \" before \" + (responseListener.ack ? \"response\" : \"ack\")));\n                        if (responseListener.cancelled) return promise.reject(new Error(\"Response listener was cancelled for \" + name));\n                        ackTimeout = Math.max(ackTimeout - 500, 0);\n                        -1 !== resTimeout && (resTimeout = Math.max(resTimeout - 500, 0));\n                        return responseListener.ack || 0 !== ackTimeout ? 0 === resTimeout ? promise.reject(new Error(\"No response for postMessage \" + logName + \" in \" + getDomain() + \" in \" + totalResTimeout + \"ms\")) : void 0 : promise.reject(new Error(\"No ack for postMessage \" + logName + \" in \" + getDomain() + \" in \" + totalAckTimeout + \"ms\"));\n                    }), 500);\n                    promise.finally((function() {\n                        interval.cancel();\n                        reqPromises.splice(reqPromises.indexOf(promise, 1));\n                    })).catch(src_util_noop);\n                }\n                return send_sendMessage(win, domain, {\n                    id: uniqueID(),\n                    origin: getDomain(window),\n                    type: \"postrobot_message_request\",\n                    hash: hash,\n                    name: name,\n                    data: data,\n                    fireAndForget: fireAndForget\n                }, {\n                    on: on_on,\n                    send: send\n                }).then((function() {\n                    return fireAndForget ? promise.resolve() : promise;\n                }), (function(err) {\n                    throw new Error(\"Send request message failed for \" + logName + \" in \" + getDomain() + \"\\n\\n\" + stringifyError(err));\n                }));\n            }));\n        };\n        function setup_toProxyWindow(win) {\n            return window_ProxyWindow.toProxyWindow(win, {\n                send: send_send\n            });\n        }\n        function lib_global_getGlobal(win) {\n            if (!isSameDomain(win)) throw new Error(\"Can not get global for window on different domain\");\n            win.__zoid_9_0_86__ || (win.__zoid_9_0_86__ = {});\n            return win.__zoid_9_0_86__;\n        }\n        function tryGlobal(win, handler) {\n            try {\n                return handler(lib_global_getGlobal(win));\n            } catch (err) {}\n        }\n        function getProxyObject(obj) {\n            return {\n                get: function() {\n                    var _this = this;\n                    return promise_ZalgoPromise.try((function() {\n                        if (_this.source && _this.source !== window) throw new Error(\"Can not call get on proxy object from a remote window\");\n                        return obj;\n                    }));\n                }\n            };\n        }\n        function basicSerialize(data) {\n            return base64encode(JSON.stringify(data));\n        }\n        function getUIDRefStore(win) {\n            var global = lib_global_getGlobal(win);\n            global.references = global.references || {};\n            return global.references;\n        }\n        function crossDomainSerialize(_ref) {\n            var data = _ref.data, metaData = _ref.metaData, sender = _ref.sender, receiver = _ref.receiver, _ref$passByReference = _ref.passByReference, passByReference = void 0 !== _ref$passByReference && _ref$passByReference, _ref$basic = _ref.basic, basic = void 0 !== _ref$basic && _ref$basic;\n            var proxyWin = setup_toProxyWindow(receiver.win);\n            var serializedMessage = basic ? JSON.stringify(data) : serializeMessage(proxyWin, receiver.domain, data, {\n                on: on_on,\n                send: send_send\n            });\n            var reference = passByReference ? function(val) {\n                var uid = uniqueID();\n                getUIDRefStore(window)[uid] = val;\n                return {\n                    type: \"uid\",\n                    uid: uid\n                };\n            }(serializedMessage) : {\n                type: \"raw\",\n                val: serializedMessage\n            };\n            return {\n                serializedData: basicSerialize({\n                    sender: {\n                        domain: sender.domain\n                    },\n                    metaData: metaData,\n                    reference: reference\n                }),\n                cleanReference: function() {\n                    win = window, \"uid\" === (ref = reference).type && delete getUIDRefStore(win)[ref.uid];\n                    var win, ref;\n                }\n            };\n        }\n        function crossDomainDeserialize(_ref2) {\n            var sender = _ref2.sender, _ref2$basic = _ref2.basic, basic = void 0 !== _ref2$basic && _ref2$basic;\n            var message = function(serializedData) {\n                return JSON.parse(function(str) {\n                    if (\"function\" == typeof atob) return decodeURIComponent([].map.call(atob(str), (function(c) {\n                        return \"%\" + (\"00\" + c.charCodeAt(0).toString(16)).slice(-2);\n                    })).join(\"\"));\n                    if (\"undefined\" != typeof Buffer) return Buffer.from(str, \"base64\").toString(\"utf8\");\n                    throw new Error(\"Can not find window.atob or Buffer\");\n                }(serializedData));\n            }(_ref2.data);\n            var reference = message.reference, metaData = message.metaData;\n            var win;\n            win = \"function\" == typeof sender.win ? sender.win({\n                metaData: metaData\n            }) : sender.win;\n            var domain;\n            domain = \"function\" == typeof sender.domain ? sender.domain({\n                metaData: metaData\n            }) : \"string\" == typeof sender.domain ? sender.domain : message.sender.domain;\n            var serializedData = function(win, ref) {\n                if (\"raw\" === ref.type) return ref.val;\n                if (\"uid\" === ref.type) return getUIDRefStore(win)[ref.uid];\n                throw new Error(\"Unsupported ref type: \" + ref.type);\n            }(win, reference);\n            return {\n                data: basic ? JSON.parse(serializedData) : function(source, origin, message) {\n                    return deserializeMessage(source, origin, message, {\n                        on: on_on,\n                        send: send_send\n                    });\n                }(win, domain, serializedData),\n                metaData: metaData,\n                sender: {\n                    win: win,\n                    domain: domain\n                },\n                reference: reference\n            };\n        }\n        var PROP_TYPE = {\n            STRING: \"string\",\n            OBJECT: \"object\",\n            FUNCTION: \"function\",\n            BOOLEAN: \"boolean\",\n            NUMBER: \"number\",\n            ARRAY: \"array\"\n        };\n        var PROP_SERIALIZATION = {\n            JSON: \"json\",\n            DOTIFY: \"dotify\",\n            BASE64: \"base64\"\n        };\n        var CONTEXT = WINDOW_TYPE;\n        var 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        function buildChildWindowName(_ref) {\n            return \"__zoid__\" + _ref.name + \"__\" + _ref.serializedPayload + \"__\";\n        }\n        function parseWindowName(windowName) {\n            if (!windowName) throw new Error(\"No window name\");\n            var _windowName$split = windowName.split(\"__\"), zoidcomp = _windowName$split[1], name = _windowName$split[2], serializedInitialPayload = _windowName$split[3];\n            if (\"zoid\" !== zoidcomp) throw new Error(\"Window not rendered by zoid - got \" + zoidcomp);\n            if (!name) throw new Error(\"Expected component name\");\n            if (!serializedInitialPayload) throw new Error(\"Expected serialized payload ref\");\n            return {\n                name: name,\n                serializedInitialPayload: serializedInitialPayload\n            };\n        }\n        var parseInitialParentPayload = memoize((function(windowName) {\n            var _crossDomainDeseriali = crossDomainDeserialize({\n                data: parseWindowName(windowName).serializedInitialPayload,\n                sender: {\n                    win: function(_ref2) {\n                        return function(windowRef) {\n                            if (\"opener\" === windowRef.type) return assertExists(\"opener\", getOpener(window));\n                            if (\"parent\" === windowRef.type && \"number\" == typeof windowRef.distance) return assertExists(\"parent\", function(win, n) {\n                                void 0 === n && (n = 1);\n                                return function(win, n) {\n                                    void 0 === n && (n = 1);\n                                    var parent = win;\n                                    for (var i = 0; i < n; i++) {\n                                        if (!parent) return;\n                                        parent = utils_getParent(parent);\n                                    }\n                                    return parent;\n                                }(win, getDistanceFromTop(win) - n);\n                            }(window, windowRef.distance));\n                            if (\"global\" === windowRef.type && windowRef.uid && \"string\" == typeof windowRef.uid) {\n                                var _ret = function() {\n                                    var uid = windowRef.uid;\n                                    var ancestor = getAncestor(window);\n                                    if (!ancestor) throw new Error(\"Can not find ancestor window\");\n                                    for (var _i2 = 0, _getAllFramesInWindow2 = getAllFramesInWindow(ancestor); _i2 < _getAllFramesInWindow2.length; _i2++) {\n                                        var frame = _getAllFramesInWindow2[_i2];\n                                        if (isSameDomain(frame)) {\n                                            var win = tryGlobal(frame, (function(global) {\n                                                return global.windows && global.windows[uid];\n                                            }));\n                                            if (win) return {\n                                                v: win\n                                            };\n                                        }\n                                    }\n                                }();\n                                if (\"object\" == typeof _ret) return _ret.v;\n                            } else if (\"name\" === windowRef.type) {\n                                var name = windowRef.name;\n                                return assertExists(\"namedWindow\", function(win, name) {\n                                    return getFrameByName(win, name) || function findChildFrameByName(win, name) {\n                                        var frame = getFrameByName(win, name);\n                                        if (frame) return frame;\n                                        for (var _i11 = 0, _getFrames4 = getFrames(win); _i11 < _getFrames4.length; _i11++) {\n                                            var namedFrame = findChildFrameByName(_getFrames4[_i11], name);\n                                            if (namedFrame) return namedFrame;\n                                        }\n                                    }(getTop(win) || win, name);\n                                }(assertExists(\"ancestor\", getAncestor(window)), name));\n                            }\n                            throw new Error(\"Unable to find \" + windowRef.type + \" parent component window\");\n                        }(_ref2.metaData.windowRef);\n                    }\n                }\n            });\n            return {\n                parent: _crossDomainDeseriali.sender,\n                payload: _crossDomainDeseriali.data,\n                reference: _crossDomainDeseriali.reference\n            };\n        }));\n        function getInitialParentPayload() {\n            return parseInitialParentPayload(window.name);\n        }\n        function window_getWindowRef(targetWindow, currentWindow) {\n            void 0 === currentWindow && (currentWindow = window);\n            if (targetWindow === utils_getParent(currentWindow)) return {\n                type: \"parent\",\n                distance: getDistanceFromTop(targetWindow)\n            };\n            if (targetWindow === getOpener(currentWindow)) return {\n                type: \"opener\"\n            };\n            if (isSameDomain(targetWindow) && !(win = targetWindow, win === getTop(win))) {\n                var windowName = assertSameDomain(targetWindow).name;\n                if (windowName) return {\n                    type: \"name\",\n                    name: windowName\n                };\n            }\n            var win;\n        }\n        function normalizeChildProp(propsDef, props, key, value, helpers) {\n            if (!propsDef.hasOwnProperty(key)) return value;\n            var prop = propsDef[key];\n            return \"function\" == typeof prop.childDecorate ? prop.childDecorate({\n                value: value,\n                uid: helpers.uid,\n                tag: helpers.tag,\n                close: helpers.close,\n                focus: helpers.focus,\n                onError: helpers.onError,\n                onProps: helpers.onProps,\n                resize: helpers.resize,\n                getParent: helpers.getParent,\n                getParentDomain: helpers.getParentDomain,\n                show: helpers.show,\n                hide: helpers.hide,\n                export: helpers.export,\n                getSiblings: helpers.getSiblings\n            }) : value;\n        }\n        function child_focus() {\n            return promise_ZalgoPromise.try((function() {\n                window.focus();\n            }));\n        }\n        function child_destroy() {\n            return promise_ZalgoPromise.try((function() {\n                window.close();\n            }));\n        }\n        var props_defaultNoop = function() {\n            return src_util_noop;\n        };\n        var props_decorateOnce = function(_ref) {\n            return once(_ref.value);\n        };\n        function eachProp(props, propsDef, handler) {\n            for (var _i2 = 0, _Object$keys2 = Object.keys(_extends({}, props, propsDef)); _i2 < _Object$keys2.length; _i2++) {\n                var key = _Object$keys2[_i2];\n                handler(key, propsDef[key], props[key]);\n            }\n        }\n        function serializeProps(propsDef, props, method) {\n            var params = {};\n            return promise_ZalgoPromise.all(function(props, propsDef, handler) {\n                var results = [];\n                eachProp(props, propsDef, (function(key, propDef, value) {\n                    var result = function(key, propDef, value) {\n                        return promise_ZalgoPromise.resolve().then((function() {\n                            var _METHOD$GET$METHOD$PO, _METHOD$GET$METHOD$PO2;\n                            if (null != value && propDef) {\n                                var getParam = (_METHOD$GET$METHOD$PO = {}, _METHOD$GET$METHOD$PO.get = propDef.queryParam, \n                                _METHOD$GET$METHOD$PO.post = propDef.bodyParam, _METHOD$GET$METHOD$PO)[method];\n                                var getValue = (_METHOD$GET$METHOD$PO2 = {}, _METHOD$GET$METHOD$PO2.get = propDef.queryValue, \n                                _METHOD$GET$METHOD$PO2.post = propDef.bodyValue, _METHOD$GET$METHOD$PO2)[method];\n                                if (getParam) return promise_ZalgoPromise.hash({\n                                    finalParam: promise_ZalgoPromise.try((function() {\n                                        return \"function\" == typeof getParam ? getParam({\n                                            value: value\n                                        }) : \"string\" == typeof getParam ? getParam : key;\n                                    })),\n                                    finalValue: promise_ZalgoPromise.try((function() {\n                                        return \"function\" == typeof getValue && isDefined(value) ? getValue({\n                                            value: value\n                                        }) : value;\n                                    }))\n                                }).then((function(_ref) {\n                                    var finalParam = _ref.finalParam, finalValue = _ref.finalValue;\n                                    var result;\n                                    if (\"boolean\" == typeof finalValue) result = finalValue.toString(); else if (\"string\" == typeof finalValue) result = finalValue.toString(); else if (\"object\" == typeof finalValue && null !== finalValue) {\n                                        if (propDef.serialization === PROP_SERIALIZATION.JSON) result = JSON.stringify(finalValue); else if (propDef.serialization === PROP_SERIALIZATION.BASE64) result = base64encode(JSON.stringify(finalValue)); else if (propDef.serialization === PROP_SERIALIZATION.DOTIFY || !propDef.serialization) {\n                                            result = function dotify(obj, prefix, newobj) {\n                                                void 0 === prefix && (prefix = \"\");\n                                                void 0 === newobj && (newobj = {});\n                                                prefix = prefix ? prefix + \".\" : prefix;\n                                                for (var key in obj) obj.hasOwnProperty(key) && null != obj[key] && \"function\" != typeof obj[key] && (obj[key] && Array.isArray(obj[key]) && obj[key].length && obj[key].every((function(val) {\n                                                    return \"object\" != typeof val;\n                                                })) ? newobj[\"\" + prefix + key + \"[]\"] = obj[key].join(\",\") : obj[key] && \"object\" == typeof obj[key] ? newobj = dotify(obj[key], \"\" + prefix + key, newobj) : newobj[\"\" + prefix + key] = obj[key].toString());\n                                                return newobj;\n                                            }(finalValue, key);\n                                            for (var _i2 = 0, _Object$keys2 = Object.keys(result); _i2 < _Object$keys2.length; _i2++) {\n                                                var dotkey = _Object$keys2[_i2];\n                                                params[dotkey] = result[dotkey];\n                                            }\n                                            return;\n                                        }\n                                    } else \"number\" == typeof finalValue && (result = finalValue.toString());\n                                    params[finalParam] = result;\n                                }));\n                            }\n                        }));\n                    }(key, propDef, value);\n                    results.push(result);\n                }));\n                return results;\n            }(props, propsDef)).then((function() {\n                return params;\n            }));\n        }\n        function parentComponent(_ref) {\n            var uid = _ref.uid, options = _ref.options, _ref$overrides = _ref.overrides, overrides = void 0 === _ref$overrides ? {} : _ref$overrides, _ref$parentWin = _ref.parentWin, parentWin = void 0 === _ref$parentWin ? window : _ref$parentWin;\n            var propsDef = options.propsDef, containerTemplate = options.containerTemplate, prerenderTemplate = options.prerenderTemplate, tag = options.tag, name = options.name, attributes = options.attributes, dimensions = options.dimensions, autoResize = options.autoResize, url = options.url, domainMatch = options.domain, xports = options.exports;\n            var initPromise = new promise_ZalgoPromise;\n            var handledErrors = [];\n            var clean = cleanup();\n            var state = {};\n            var inputProps = {};\n            var internalState = {\n                visible: !0\n            };\n            var event = overrides.event ? overrides.event : (triggered = {}, handlers = {}, \n            emitter = {\n                on: function(eventName, handler) {\n                    var handlerList = handlers[eventName] = handlers[eventName] || [];\n                    handlerList.push(handler);\n                    var cancelled = !1;\n                    return {\n                        cancel: function() {\n                            if (!cancelled) {\n                                cancelled = !0;\n                                handlerList.splice(handlerList.indexOf(handler), 1);\n                            }\n                        }\n                    };\n                },\n                once: function(eventName, handler) {\n                    var listener = emitter.on(eventName, (function() {\n                        listener.cancel();\n                        handler();\n                    }));\n                    return listener;\n                },\n                trigger: function(eventName) {\n                    for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) args[_key3 - 1] = arguments[_key3];\n                    var handlerList = handlers[eventName];\n                    var promises = [];\n                    if (handlerList) {\n                        var _loop = function(_i2) {\n                            var handler = handlerList[_i2];\n                            promises.push(promise_ZalgoPromise.try((function() {\n                                return handler.apply(void 0, args);\n                            })));\n                        };\n                        for (var _i2 = 0; _i2 < handlerList.length; _i2++) _loop(_i2);\n                    }\n                    return promise_ZalgoPromise.all(promises).then(src_util_noop);\n                },\n                triggerOnce: function(eventName) {\n                    if (triggered[eventName]) return promise_ZalgoPromise.resolve();\n                    triggered[eventName] = !0;\n                    for (var _len4 = arguments.length, args = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) args[_key4 - 1] = arguments[_key4];\n                    return emitter.trigger.apply(emitter, [ eventName ].concat(args));\n                },\n                reset: function() {\n                    handlers = {};\n                }\n            });\n            var triggered, handlers, emitter;\n            var props = overrides.props ? overrides.props : {};\n            var currentProxyWin;\n            var currentProxyContainer;\n            var childComponent;\n            var currentChildDomain;\n            var currentContainer;\n            var onErrorOverride = overrides.onError;\n            var getProxyContainerOverride = overrides.getProxyContainer;\n            var showOverride = overrides.show;\n            var hideOverride = overrides.hide;\n            var closeOverride = overrides.close;\n            var renderContainerOverride = overrides.renderContainer;\n            var getProxyWindowOverride = overrides.getProxyWindow;\n            var setProxyWinOverride = overrides.setProxyWin;\n            var openFrameOverride = overrides.openFrame;\n            var openPrerenderFrameOverride = overrides.openPrerenderFrame;\n            var prerenderOverride = overrides.prerender;\n            var openOverride = overrides.open;\n            var openPrerenderOverride = overrides.openPrerender;\n            var watchForUnloadOverride = overrides.watchForUnload;\n            var getInternalStateOverride = overrides.getInternalState;\n            var setInternalStateOverride = overrides.setInternalState;\n            var resolveInitPromise = function() {\n                return promise_ZalgoPromise.try((function() {\n                    return overrides.resolveInitPromise ? overrides.resolveInitPromise() : initPromise.resolve();\n                }));\n            };\n            var rejectInitPromise = function(err) {\n                return promise_ZalgoPromise.try((function() {\n                    return overrides.rejectInitPromise ? overrides.rejectInitPromise(err) : initPromise.reject(err);\n                }));\n            };\n            var getPropsForChild = function(initialChildDomain) {\n                var result = {};\n                for (var _i2 = 0, _Object$keys2 = Object.keys(props); _i2 < _Object$keys2.length; _i2++) {\n                    var key = _Object$keys2[_i2];\n                    var prop = propsDef[key];\n                    prop && !1 === prop.sendToChild || prop && prop.sameDomain && !matchDomain(initialChildDomain, getDomain(window)) || (result[key] = props[key]);\n                }\n                return promise_ZalgoPromise.hash(result);\n            };\n            var getInternalState = function() {\n                return promise_ZalgoPromise.try((function() {\n                    return getInternalStateOverride ? getInternalStateOverride() : internalState;\n                }));\n            };\n            var setInternalState = function(newInternalState) {\n                return promise_ZalgoPromise.try((function() {\n                    return setInternalStateOverride ? setInternalStateOverride(newInternalState) : internalState = _extends({}, internalState, newInternalState);\n                }));\n            };\n            var getProxyWindow = function() {\n                return getProxyWindowOverride ? getProxyWindowOverride() : promise_ZalgoPromise.try((function() {\n                    var windowProp = props.window;\n                    if (windowProp) {\n                        var _proxyWin = setup_toProxyWindow(windowProp);\n                        clean.register((function() {\n                            return windowProp.close();\n                        }));\n                        return _proxyWin;\n                    }\n                    return new window_ProxyWindow({\n                        send: send_send\n                    });\n                }));\n            };\n            var setProxyWin = function(proxyWin) {\n                return setProxyWinOverride ? setProxyWinOverride(proxyWin) : promise_ZalgoPromise.try((function() {\n                    currentProxyWin = proxyWin;\n                }));\n            };\n            var show = function() {\n                return showOverride ? showOverride() : promise_ZalgoPromise.hash({\n                    setState: setInternalState({\n                        visible: !0\n                    }),\n                    showElement: currentProxyContainer ? currentProxyContainer.get().then(showElement) : null\n                }).then(src_util_noop);\n            };\n            var hide = function() {\n                return hideOverride ? hideOverride() : promise_ZalgoPromise.hash({\n                    setState: setInternalState({\n                        visible: !1\n                    }),\n                    showElement: currentProxyContainer ? currentProxyContainer.get().then(hideElement) : null\n                }).then(src_util_noop);\n            };\n            var getUrl = function() {\n                return \"function\" == typeof url ? url({\n                    props: props\n                }) : url;\n            };\n            var getAttributes = function() {\n                return \"function\" == typeof attributes ? attributes({\n                    props: props\n                }) : attributes;\n            };\n            var getInitialChildDomain = function() {\n                return getDomainFromUrl(getUrl());\n            };\n            var openFrame = function(context, _ref2) {\n                var windowName = _ref2.windowName;\n                return openFrameOverride ? openFrameOverride(context, {\n                    windowName: windowName\n                }) : promise_ZalgoPromise.try((function() {\n                    if (context === CONTEXT.IFRAME) return getProxyObject(dom_iframe({\n                        attributes: _extends({\n                            name: windowName,\n                            title: name\n                        }, getAttributes().iframe)\n                    }));\n                }));\n            };\n            var openPrerenderFrame = function(context) {\n                return openPrerenderFrameOverride ? openPrerenderFrameOverride(context) : promise_ZalgoPromise.try((function() {\n                    if (context === CONTEXT.IFRAME) return getProxyObject(dom_iframe({\n                        attributes: _extends({\n                            name: \"__zoid_prerender_frame__\" + name + \"_\" + uniqueID() + \"__\",\n                            title: \"prerender__\" + name\n                        }, getAttributes().iframe)\n                    }));\n                }));\n            };\n            var openPrerender = function(context, proxyWin, proxyPrerenderFrame) {\n                return openPrerenderOverride ? openPrerenderOverride(context, proxyWin, proxyPrerenderFrame) : promise_ZalgoPromise.try((function() {\n                    if (context === CONTEXT.IFRAME) {\n                        if (!proxyPrerenderFrame) throw new Error(\"Expected proxy frame to be passed\");\n                        return proxyPrerenderFrame.get().then((function(prerenderFrame) {\n                            clean.register((function() {\n                                return destroyElement(prerenderFrame);\n                            }));\n                            return awaitFrameWindow(prerenderFrame).then((function(prerenderFrameWindow) {\n                                return assertSameDomain(prerenderFrameWindow);\n                            })).then((function(win) {\n                                return setup_toProxyWindow(win);\n                            }));\n                        }));\n                    }\n                    throw new Error(\"No render context available for \" + context);\n                }));\n            };\n            var focus = function() {\n                return promise_ZalgoPromise.try((function() {\n                    if (currentProxyWin) return promise_ZalgoPromise.all([ event.trigger(EVENT.FOCUS), currentProxyWin.focus() ]).then(src_util_noop);\n                }));\n            };\n            var getCurrentWindowReferenceUID = function() {\n                var global = lib_global_getGlobal(window);\n                global.windows = global.windows || {};\n                global.windows[uid] = window;\n                clean.register((function() {\n                    delete global.windows[uid];\n                }));\n                return uid;\n            };\n            var getWindowRef = function(target, initialChildDomain, context, proxyWin) {\n                if (initialChildDomain === getDomain(window)) return {\n                    type: \"global\",\n                    uid: getCurrentWindowReferenceUID()\n                };\n                if (target !== window) throw new Error(\"Can not construct cross-domain window reference for different target window\");\n                if (props.window) {\n                    var actualComponentWindow = proxyWin.getWindow();\n                    if (!actualComponentWindow) throw new Error(\"Can not construct cross-domain window reference for lazy window prop\");\n                    if (getAncestor(actualComponentWindow) !== window) throw new Error(\"Can not construct cross-domain window reference for window prop with different ancestor\");\n                }\n                if (context === CONTEXT.POPUP) return {\n                    type: \"opener\"\n                };\n                if (context === CONTEXT.IFRAME) return {\n                    type: \"parent\",\n                    distance: getDistanceFromTop(window)\n                };\n                throw new Error(\"Can not construct window reference for child\");\n            };\n            var initChild = function(childDomain, childExports) {\n                return promise_ZalgoPromise.try((function() {\n                    currentChildDomain = childDomain;\n                    childComponent = childExports;\n                    resolveInitPromise();\n                    clean.register((function() {\n                        return childExports.close.fireAndForget().catch(src_util_noop);\n                    }));\n                }));\n            };\n            var resize = function(_ref3) {\n                var width = _ref3.width, height = _ref3.height;\n                return promise_ZalgoPromise.try((function() {\n                    event.trigger(EVENT.RESIZE, {\n                        width: width,\n                        height: height\n                    });\n                }));\n            };\n            var destroy = function(err) {\n                return promise_ZalgoPromise.try((function() {\n                    return event.trigger(EVENT.DESTROY);\n                })).catch(src_util_noop).then((function() {\n                    return clean.all(err);\n                })).then((function() {\n                    initPromise.asyncReject(err || new Error(\"Component destroyed\"));\n                }));\n            };\n            var close = memoize((function(err) {\n                return promise_ZalgoPromise.try((function() {\n                    if (closeOverride) {\n                        if (isWindowClosed(closeOverride.__source__)) return;\n                        return closeOverride();\n                    }\n                    return promise_ZalgoPromise.try((function() {\n                        return event.trigger(EVENT.CLOSE);\n                    })).then((function() {\n                        return destroy(err || new Error(\"Component closed\"));\n                    }));\n                }));\n            }));\n            var open = function(context, _ref4) {\n                var proxyWin = _ref4.proxyWin, proxyFrame = _ref4.proxyFrame, windowName = _ref4.windowName;\n                return openOverride ? openOverride(context, {\n                    proxyWin: proxyWin,\n                    proxyFrame: proxyFrame,\n                    windowName: windowName\n                }) : promise_ZalgoPromise.try((function() {\n                    if (context === CONTEXT.IFRAME) {\n                        if (!proxyFrame) throw new Error(\"Expected proxy frame to be passed\");\n                        return proxyFrame.get().then((function(frame) {\n                            return awaitFrameWindow(frame).then((function(win) {\n                                clean.register((function() {\n                                    return destroyElement(frame);\n                                }));\n                                clean.register((function() {\n                                    return function(win) {\n                                        for (var _i2 = 0, _requestPromises$get2 = windowStore(\"requestPromises\").get(win, []); _i2 < _requestPromises$get2.length; _i2++) _requestPromises$get2[_i2].reject(new Error(\"Window \" + (isWindowClosed(win) ? \"closed\" : \"cleaned up\") + \" before response\")).catch(src_util_noop);\n                                    }(win);\n                                }));\n                                return win;\n                            }));\n                        }));\n                    }\n                    throw new Error(\"No render context available for \" + context);\n                })).then((function(win) {\n                    proxyWin.setWindow(win, {\n                        send: send_send\n                    });\n                    return proxyWin.setName(windowName).then((function() {\n                        return proxyWin;\n                    }));\n                }));\n            };\n            var watchForUnload = function() {\n                return promise_ZalgoPromise.try((function() {\n                    var unloadWindowListener = addEventListener(window, \"unload\", once((function() {\n                        destroy(new Error(\"Window navigated away\"));\n                    })));\n                    var closeParentWindowListener = onCloseWindow(parentWin, destroy, 3e3);\n                    clean.register(closeParentWindowListener.cancel);\n                    clean.register(unloadWindowListener.cancel);\n                    if (watchForUnloadOverride) return watchForUnloadOverride();\n                }));\n            };\n            var checkWindowClose = function(proxyWin) {\n                var closed = !1;\n                return proxyWin.isClosed().then((function(isClosed) {\n                    if (isClosed) {\n                        closed = !0;\n                        return close(new Error(\"Detected component window close\"));\n                    }\n                    return promise_ZalgoPromise.delay(200).then((function() {\n                        return proxyWin.isClosed();\n                    })).then((function(secondIsClosed) {\n                        if (secondIsClosed) {\n                            closed = !0;\n                            return close(new Error(\"Detected component window close\"));\n                        }\n                    }));\n                })).then((function() {\n                    return closed;\n                }));\n            };\n            var onError = function(err) {\n                return onErrorOverride ? onErrorOverride(err) : promise_ZalgoPromise.try((function() {\n                    if (-1 === handledErrors.indexOf(err)) {\n                        handledErrors.push(err);\n                        initPromise.asyncReject(err);\n                        return event.trigger(EVENT.ERROR, err);\n                    }\n                }));\n            };\n            var exportsPromise = new promise_ZalgoPromise;\n            var xport = function(actualExports) {\n                return promise_ZalgoPromise.try((function() {\n                    exportsPromise.resolve(actualExports);\n                }));\n            };\n            initChild.onError = onError;\n            var renderTemplate = function(renderer, _ref8) {\n                return renderer({\n                    uid: uid,\n                    container: _ref8.container,\n                    context: _ref8.context,\n                    doc: _ref8.doc,\n                    frame: _ref8.frame,\n                    prerenderFrame: _ref8.prerenderFrame,\n                    focus: focus,\n                    close: close,\n                    state: state,\n                    props: props,\n                    tag: tag,\n                    dimensions: \"function\" == typeof dimensions ? dimensions({\n                        props: props\n                    }) : dimensions,\n                    event: event\n                });\n            };\n            var prerender = function(proxyPrerenderWin, _ref9) {\n                var context = _ref9.context;\n                return prerenderOverride ? prerenderOverride(proxyPrerenderWin, {\n                    context: context\n                }) : promise_ZalgoPromise.try((function() {\n                    if (prerenderTemplate) {\n                        var prerenderWindow = proxyPrerenderWin.getWindow();\n                        if (prerenderWindow && isSameDomain(prerenderWindow) && function(win) {\n                            try {\n                                if (!win.location.href) return !0;\n                                if (\"about:blank\" === win.location.href) return !0;\n                            } catch (err) {}\n                            return !1;\n                        }(prerenderWindow)) {\n                            var doc = (prerenderWindow = assertSameDomain(prerenderWindow)).document;\n                            var el = renderTemplate(prerenderTemplate, {\n                                context: context,\n                                doc: doc\n                            });\n                            if (el) {\n                                if (el.ownerDocument !== doc) throw new Error(\"Expected prerender template to have been created with document from child window\");\n                                !function(win, el) {\n                                    var tag = el.tagName.toLowerCase();\n                                    if (\"html\" !== tag) throw new Error(\"Expected element to be html, got \" + tag);\n                                    var documentElement = win.document.documentElement;\n                                    for (var _i6 = 0, _arrayFrom2 = arrayFrom(documentElement.children); _i6 < _arrayFrom2.length; _i6++) documentElement.removeChild(_arrayFrom2[_i6]);\n                                    for (var _i8 = 0, _arrayFrom4 = arrayFrom(el.children); _i8 < _arrayFrom4.length; _i8++) documentElement.appendChild(_arrayFrom4[_i8]);\n                                }(prerenderWindow, el);\n                                var _autoResize$width = autoResize.width, width = void 0 !== _autoResize$width && _autoResize$width, _autoResize$height = autoResize.height, height = void 0 !== _autoResize$height && _autoResize$height, _autoResize$element = autoResize.element, element = void 0 === _autoResize$element ? \"body\" : _autoResize$element;\n                                if ((element = getElementSafe(element, doc)) && (width || height)) {\n                                    var prerenderResizeListener = onResize(element, (function(_ref10) {\n                                        resize({\n                                            width: width ? _ref10.width : void 0,\n                                            height: height ? _ref10.height : void 0\n                                        });\n                                    }), {\n                                        width: width,\n                                        height: height,\n                                        win: prerenderWindow\n                                    });\n                                    event.on(EVENT.RENDERED, prerenderResizeListener.cancel);\n                                }\n                            }\n                        }\n                    }\n                }));\n            };\n            var renderContainer = function(proxyContainer, _ref11) {\n                var proxyFrame = _ref11.proxyFrame, proxyPrerenderFrame = _ref11.proxyPrerenderFrame, context = _ref11.context, rerender = _ref11.rerender;\n                return renderContainerOverride ? renderContainerOverride(proxyContainer, {\n                    proxyFrame: proxyFrame,\n                    proxyPrerenderFrame: proxyPrerenderFrame,\n                    context: context,\n                    rerender: rerender\n                }) : promise_ZalgoPromise.hash({\n                    container: proxyContainer.get(),\n                    frame: proxyFrame ? proxyFrame.get() : null,\n                    prerenderFrame: proxyPrerenderFrame ? proxyPrerenderFrame.get() : null,\n                    internalState: getInternalState()\n                }).then((function(_ref12) {\n                    var container = _ref12.container, visible = _ref12.internalState.visible;\n                    var innerContainer = renderTemplate(containerTemplate, {\n                        context: context,\n                        container: container,\n                        frame: _ref12.frame,\n                        prerenderFrame: _ref12.prerenderFrame,\n                        doc: document\n                    });\n                    if (innerContainer) {\n                        visible || hideElement(innerContainer);\n                        appendChild(container, innerContainer);\n                        var containerWatcher = function(element, handler) {\n                            handler = once(handler);\n                            var cancelled = !1;\n                            var mutationObservers = [];\n                            var interval;\n                            var sacrificialFrame;\n                            var sacrificialFrameWin;\n                            var cancel = function() {\n                                cancelled = !0;\n                                for (var _i18 = 0; _i18 < mutationObservers.length; _i18++) mutationObservers[_i18].disconnect();\n                                interval && interval.cancel();\n                                sacrificialFrameWin && sacrificialFrameWin.removeEventListener(\"unload\", elementClosed);\n                                sacrificialFrame && destroyElement(sacrificialFrame);\n                            };\n                            var elementClosed = function() {\n                                if (!cancelled) {\n                                    handler();\n                                    cancel();\n                                }\n                            };\n                            if (isElementClosed(element)) {\n                                elementClosed();\n                                return {\n                                    cancel: cancel\n                                };\n                            }\n                            if (window.MutationObserver) {\n                                var mutationElement = element.parentElement;\n                                for (;mutationElement; ) {\n                                    var mutationObserver = new window.MutationObserver((function() {\n                                        isElementClosed(element) && elementClosed();\n                                    }));\n                                    mutationObserver.observe(mutationElement, {\n                                        childList: !0\n                                    });\n                                    mutationObservers.push(mutationObserver);\n                                    mutationElement = mutationElement.parentElement;\n                                }\n                            }\n                            (sacrificialFrame = document.createElement(\"iframe\")).setAttribute(\"name\", \"__detect_close_\" + uniqueID() + \"__\");\n                            sacrificialFrame.style.display = \"none\";\n                            awaitFrameWindow(sacrificialFrame).then((function(frameWin) {\n                                (sacrificialFrameWin = assertSameDomain(frameWin)).addEventListener(\"unload\", elementClosed);\n                            }));\n                            element.appendChild(sacrificialFrame);\n                            interval = safeInterval((function() {\n                                isElementClosed(element) && elementClosed();\n                            }), 1e3);\n                            return {\n                                cancel: cancel\n                            };\n                        }(innerContainer, (function() {\n                            var removeError = new Error(\"Detected container element removed from DOM\");\n                            return promise_ZalgoPromise.delay(1).then((function() {\n                                if (!isElementClosed(innerContainer)) {\n                                    clean.all(removeError);\n                                    return rerender().then(resolveInitPromise, rejectInitPromise);\n                                }\n                                close(removeError);\n                            }));\n                        }));\n                        clean.register((function() {\n                            return containerWatcher.cancel();\n                        }));\n                        clean.register((function() {\n                            return destroyElement(innerContainer);\n                        }));\n                        return currentProxyContainer = getProxyObject(innerContainer);\n                    }\n                }));\n            };\n            var getHelpers = function() {\n                return {\n                    state: state,\n                    event: event,\n                    close: close,\n                    focus: focus,\n                    resize: resize,\n                    onError: onError,\n                    updateProps: updateProps,\n                    show: show,\n                    hide: hide\n                };\n            };\n            var setProps = function(newInputProps) {\n                void 0 === newInputProps && (newInputProps = {});\n                var container = currentContainer;\n                var helpers = getHelpers();\n                extend(inputProps, newInputProps);\n                !function(propsDef, existingProps, inputProps, helpers, container) {\n                    var state = helpers.state, close = helpers.close, focus = helpers.focus, event = helpers.event, onError = helpers.onError;\n                    eachProp(inputProps, propsDef, (function(key, propDef, val) {\n                        var valueDetermined = !1;\n                        var value = val;\n                        Object.defineProperty(existingProps, key, {\n                            configurable: !0,\n                            enumerable: !0,\n                            get: function() {\n                                if (valueDetermined) return value;\n                                valueDetermined = !0;\n                                return function() {\n                                    if (!propDef) return value;\n                                    var alias = propDef.alias;\n                                    alias && !isDefined(val) && isDefined(inputProps[alias]) && (value = inputProps[alias]);\n                                    propDef.value && (value = propDef.value({\n                                        props: existingProps,\n                                        state: state,\n                                        close: close,\n                                        focus: focus,\n                                        event: event,\n                                        onError: onError,\n                                        container: container\n                                    }));\n                                    !propDef.default || isDefined(value) || isDefined(inputProps[key]) || (value = propDef.default({\n                                        props: existingProps,\n                                        state: state,\n                                        close: close,\n                                        focus: focus,\n                                        event: event,\n                                        onError: onError,\n                                        container: container\n                                    }));\n                                    if (isDefined(value)) {\n                                        if (propDef.type === PROP_TYPE.ARRAY ? !Array.isArray(value) : typeof value !== propDef.type) throw new TypeError(\"Prop is not of type \" + propDef.type + \": \" + key);\n                                    } else if (!1 !== propDef.required && !isDefined(inputProps[key])) throw new Error('Expected prop \"' + key + '\" to be defined');\n                                    isDefined(value) && propDef.decorate && (value = propDef.decorate({\n                                        value: value,\n                                        props: existingProps,\n                                        state: state,\n                                        close: close,\n                                        focus: focus,\n                                        event: event,\n                                        onError: onError,\n                                        container: container\n                                    }));\n                                    return value;\n                                }();\n                            }\n                        });\n                    }));\n                    eachProp(existingProps, propsDef, src_util_noop);\n                }(propsDef, props, inputProps, helpers, container);\n            };\n            var updateProps = function(newProps) {\n                setProps(newProps);\n                return initPromise.then((function() {\n                    var child = childComponent;\n                    var proxyWin = currentProxyWin;\n                    if (child && proxyWin && currentChildDomain) return getPropsForChild(currentChildDomain).then((function(childProps) {\n                        return child.updateProps(childProps).catch((function(err) {\n                            return checkWindowClose(proxyWin).then((function(closed) {\n                                if (!closed) throw err;\n                            }));\n                        }));\n                    }));\n                }));\n            };\n            var getProxyContainer = function(container) {\n                return getProxyContainerOverride ? getProxyContainerOverride(container) : promise_ZalgoPromise.try((function() {\n                    return elementReady(container);\n                })).then((function(containerElement) {\n                    isShadowElement(containerElement) && (containerElement = function insertShadowSlot(element) {\n                        var shadowHost = function(element) {\n                            var shadowRoot = function(element) {\n                                for (;element.parentNode; ) element = element.parentNode;\n                                if (isShadowElement(element)) return element;\n                            }(element);\n                            if (shadowRoot && shadowRoot.host) return shadowRoot.host;\n                        }(element);\n                        if (!shadowHost) throw new Error(\"Element is not in shadow dom\");\n                        var slotName = \"shadow-slot-\" + uniqueID();\n                        var slot = document.createElement(\"slot\");\n                        slot.setAttribute(\"name\", slotName);\n                        element.appendChild(slot);\n                        var slotProvider = document.createElement(\"div\");\n                        slotProvider.setAttribute(\"slot\", slotName);\n                        shadowHost.appendChild(slotProvider);\n                        return isShadowElement(shadowHost) ? insertShadowSlot(slotProvider) : slotProvider;\n                    }(containerElement));\n                    currentContainer = containerElement;\n                    return getProxyObject(containerElement);\n                }));\n            };\n            return {\n                init: function() {\n                    !function() {\n                        event.on(EVENT.RENDER, (function() {\n                            return props.onRender();\n                        }));\n                        event.on(EVENT.DISPLAY, (function() {\n                            return props.onDisplay();\n                        }));\n                        event.on(EVENT.RENDERED, (function() {\n                            return props.onRendered();\n                        }));\n                        event.on(EVENT.CLOSE, (function() {\n                            return props.onClose();\n                        }));\n                        event.on(EVENT.DESTROY, (function() {\n                            return props.onDestroy();\n                        }));\n                        event.on(EVENT.RESIZE, (function() {\n                            return props.onResize();\n                        }));\n                        event.on(EVENT.FOCUS, (function() {\n                            return props.onFocus();\n                        }));\n                        event.on(EVENT.PROPS, (function(newProps) {\n                            return props.onProps(newProps);\n                        }));\n                        event.on(EVENT.ERROR, (function(err) {\n                            return props && props.onError ? props.onError(err) : rejectInitPromise(err).then((function() {\n                                setTimeout((function() {\n                                    throw err;\n                                }), 1);\n                            }));\n                        }));\n                        clean.register(event.reset);\n                    }();\n                },\n                render: function(_ref14) {\n                    var target = _ref14.target, container = _ref14.container, context = _ref14.context, rerender = _ref14.rerender;\n                    return promise_ZalgoPromise.try((function() {\n                        var initialChildDomain = getInitialChildDomain();\n                        var childDomainMatch = domainMatch || getInitialChildDomain();\n                        !function(target, childDomainMatch, container) {\n                            if (target !== window) {\n                                if (!isSameTopWindow(window, target)) throw new Error(\"Can only renderTo an adjacent frame\");\n                                var origin = getDomain();\n                                if (!matchDomain(childDomainMatch, origin) && !isSameDomain(target)) throw new Error(\"Can not render remotely to \" + childDomainMatch.toString() + \" - can only render to \" + origin);\n                                if (container && \"string\" != typeof container) throw new Error(\"Container passed to renderTo must be a string selector, got \" + typeof container + \" }\");\n                            }\n                        }(target, childDomainMatch, container);\n                        var delegatePromise = promise_ZalgoPromise.try((function() {\n                            if (target !== window) return function(context, target) {\n                                var delegateProps = {};\n                                for (var _i4 = 0, _Object$keys4 = Object.keys(props); _i4 < _Object$keys4.length; _i4++) {\n                                    var propName = _Object$keys4[_i4];\n                                    var propDef = propsDef[propName];\n                                    propDef && propDef.allowDelegate && (delegateProps[propName] = props[propName]);\n                                }\n                                var childOverridesPromise = send_send(target, \"zoid_delegate_\" + name, {\n                                    uid: uid,\n                                    overrides: {\n                                        props: delegateProps,\n                                        event: event,\n                                        close: close,\n                                        onError: onError,\n                                        getInternalState: getInternalState,\n                                        setInternalState: setInternalState,\n                                        resolveInitPromise: resolveInitPromise,\n                                        rejectInitPromise: rejectInitPromise\n                                    }\n                                }).then((function(_ref13) {\n                                    var parentComp = _ref13.data.parent;\n                                    clean.register((function(err) {\n                                        if (!isWindowClosed(target)) return parentComp.destroy(err);\n                                    }));\n                                    return parentComp.getDelegateOverrides();\n                                })).catch((function(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                                getProxyContainerOverride = function() {\n                                    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) args[_key] = arguments[_key];\n                                    return childOverridesPromise.then((function(childOverrides) {\n                                        return childOverrides.getProxyContainer.apply(childOverrides, args);\n                                    }));\n                                };\n                                renderContainerOverride = function() {\n                                    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) args[_key2] = arguments[_key2];\n                                    return childOverridesPromise.then((function(childOverrides) {\n                                        return childOverrides.renderContainer.apply(childOverrides, args);\n                                    }));\n                                };\n                                showOverride = function() {\n                                    for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) args[_key3] = arguments[_key3];\n                                    return childOverridesPromise.then((function(childOverrides) {\n                                        return childOverrides.show.apply(childOverrides, args);\n                                    }));\n                                };\n                                hideOverride = function() {\n                                    for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) args[_key4] = arguments[_key4];\n                                    return childOverridesPromise.then((function(childOverrides) {\n                                        return childOverrides.hide.apply(childOverrides, args);\n                                    }));\n                                };\n                                watchForUnloadOverride = function() {\n                                    for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) args[_key5] = arguments[_key5];\n                                    return childOverridesPromise.then((function(childOverrides) {\n                                        return childOverrides.watchForUnload.apply(childOverrides, args);\n                                    }));\n                                };\n                                if (context === CONTEXT.IFRAME) {\n                                    getProxyWindowOverride = function() {\n                                        for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) args[_key6] = arguments[_key6];\n                                        return childOverridesPromise.then((function(childOverrides) {\n                                            return childOverrides.getProxyWindow.apply(childOverrides, args);\n                                        }));\n                                    };\n                                    openFrameOverride = function() {\n                                        for (var _len7 = arguments.length, args = new Array(_len7), _key7 = 0; _key7 < _len7; _key7++) args[_key7] = arguments[_key7];\n                                        return childOverridesPromise.then((function(childOverrides) {\n                                            return childOverrides.openFrame.apply(childOverrides, args);\n                                        }));\n                                    };\n                                    openPrerenderFrameOverride = function() {\n                                        for (var _len8 = arguments.length, args = new Array(_len8), _key8 = 0; _key8 < _len8; _key8++) args[_key8] = arguments[_key8];\n                                        return childOverridesPromise.then((function(childOverrides) {\n                                            return childOverrides.openPrerenderFrame.apply(childOverrides, args);\n                                        }));\n                                    };\n                                    prerenderOverride = function() {\n                                        for (var _len9 = arguments.length, args = new Array(_len9), _key9 = 0; _key9 < _len9; _key9++) args[_key9] = arguments[_key9];\n                                        return childOverridesPromise.then((function(childOverrides) {\n                                            return childOverrides.prerender.apply(childOverrides, args);\n                                        }));\n                                    };\n                                    openOverride = function() {\n                                        for (var _len10 = arguments.length, args = new Array(_len10), _key10 = 0; _key10 < _len10; _key10++) args[_key10] = arguments[_key10];\n                                        return childOverridesPromise.then((function(childOverrides) {\n                                            return childOverrides.open.apply(childOverrides, args);\n                                        }));\n                                    };\n                                    openPrerenderOverride = function() {\n                                        for (var _len11 = arguments.length, args = new Array(_len11), _key11 = 0; _key11 < _len11; _key11++) args[_key11] = arguments[_key11];\n                                        return childOverridesPromise.then((function(childOverrides) {\n                                            return childOverrides.openPrerender.apply(childOverrides, args);\n                                        }));\n                                    };\n                                }\n                                return childOverridesPromise;\n                            }(context, target);\n                        }));\n                        var windowProp = props.window;\n                        var watchForUnloadPromise = watchForUnload();\n                        var buildBodyPromise = serializeProps(propsDef, props, \"post\");\n                        var onRenderPromise = event.trigger(EVENT.RENDER);\n                        var getProxyContainerPromise = getProxyContainer(container);\n                        var getProxyWindowPromise = getProxyWindow();\n                        var finalSetPropsPromise = getProxyContainerPromise.then((function() {\n                            return setProps();\n                        }));\n                        var buildUrlPromise = finalSetPropsPromise.then((function() {\n                            return serializeProps(propsDef, props, \"get\").then((function(query) {\n                                return function(url, options) {\n                                    var query = options.query || {};\n                                    var hash = options.hash || {};\n                                    var originalUrl;\n                                    var originalHash;\n                                    var _url$split = url.split(\"#\");\n                                    originalHash = _url$split[1];\n                                    var _originalUrl$split = (originalUrl = _url$split[0]).split(\"?\");\n                                    originalUrl = _originalUrl$split[0];\n                                    var queryString = extendQuery(_originalUrl$split[1], query);\n                                    var hashString = extendQuery(originalHash, hash);\n                                    queryString && (originalUrl = originalUrl + \"?\" + queryString);\n                                    hashString && (originalUrl = originalUrl + \"#\" + hashString);\n                                    return originalUrl;\n                                }(function(url) {\n                                    if (!(domain = getDomainFromUrl(url), 0 === domain.indexOf(\"mock:\"))) return url;\n                                    var domain;\n                                    throw new Error(\"Mock urls not supported out of test mode\");\n                                }(getUrl()), {\n                                    query: query\n                                });\n                            }));\n                        }));\n                        var buildWindowNamePromise = getProxyWindowPromise.then((function(proxyWin) {\n                            return function(_temp2) {\n                                var _ref6 = void 0 === _temp2 ? {} : _temp2, proxyWin = _ref6.proxyWin, initialChildDomain = _ref6.initialChildDomain, childDomainMatch = _ref6.childDomainMatch, _ref6$target = _ref6.target, target = void 0 === _ref6$target ? window : _ref6$target, context = _ref6.context;\n                                return function(_temp) {\n                                    var _ref5 = void 0 === _temp ? {} : _temp, proxyWin = _ref5.proxyWin, childDomainMatch = _ref5.childDomainMatch, context = _ref5.context;\n                                    return getPropsForChild(_ref5.initialChildDomain).then((function(childProps) {\n                                        return {\n                                            uid: uid,\n                                            context: context,\n                                            tag: tag,\n                                            childDomainMatch: childDomainMatch,\n                                            version: \"9_0_86\",\n                                            props: childProps,\n                                            exports: (win = proxyWin, {\n                                                init: function(childExports) {\n                                                    return initChild(this.origin, childExports);\n                                                },\n                                                close: close,\n                                                checkClose: function() {\n                                                    return checkWindowClose(win);\n                                                },\n                                                resize: resize,\n                                                onError: onError,\n                                                show: show,\n                                                hide: hide,\n                                                export: xport\n                                            })\n                                        };\n                                        var win;\n                                    }));\n                                }({\n                                    proxyWin: proxyWin,\n                                    initialChildDomain: initialChildDomain,\n                                    childDomainMatch: childDomainMatch,\n                                    context: context\n                                }).then((function(childPayload) {\n                                    var _crossDomainSerialize = 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                                    }), serializedData = _crossDomainSerialize.serializedData;\n                                    clean.register(_crossDomainSerialize.cleanReference);\n                                    return serializedData;\n                                }));\n                            }({\n                                proxyWin: (_ref7 = {\n                                    proxyWin: proxyWin,\n                                    initialChildDomain: initialChildDomain,\n                                    childDomainMatch: childDomainMatch,\n                                    target: target,\n                                    context: context\n                                }).proxyWin,\n                                initialChildDomain: _ref7.initialChildDomain,\n                                childDomainMatch: _ref7.childDomainMatch,\n                                target: _ref7.target,\n                                context: _ref7.context\n                            }).then((function(serializedPayload) {\n                                return buildChildWindowName({\n                                    name: name,\n                                    serializedPayload: serializedPayload\n                                });\n                            }));\n                            var _ref7;\n                        }));\n                        var openFramePromise = buildWindowNamePromise.then((function(windowName) {\n                            return openFrame(context, {\n                                windowName: windowName\n                            });\n                        }));\n                        var openPrerenderFramePromise = openPrerenderFrame(context);\n                        var renderContainerPromise = promise_ZalgoPromise.hash({\n                            proxyContainer: getProxyContainerPromise,\n                            proxyFrame: openFramePromise,\n                            proxyPrerenderFrame: openPrerenderFramePromise\n                        }).then((function(_ref15) {\n                            return renderContainer(_ref15.proxyContainer, {\n                                context: context,\n                                proxyFrame: _ref15.proxyFrame,\n                                proxyPrerenderFrame: _ref15.proxyPrerenderFrame,\n                                rerender: rerender\n                            });\n                        })).then((function(proxyContainer) {\n                            return proxyContainer;\n                        }));\n                        var openPromise = promise_ZalgoPromise.hash({\n                            windowName: buildWindowNamePromise,\n                            proxyFrame: openFramePromise,\n                            proxyWin: getProxyWindowPromise\n                        }).then((function(_ref16) {\n                            var proxyWin = _ref16.proxyWin;\n                            return windowProp ? proxyWin : open(context, {\n                                windowName: _ref16.windowName,\n                                proxyWin: proxyWin,\n                                proxyFrame: _ref16.proxyFrame\n                            });\n                        }));\n                        var openPrerenderPromise = promise_ZalgoPromise.hash({\n                            proxyWin: openPromise,\n                            proxyPrerenderFrame: openPrerenderFramePromise\n                        }).then((function(_ref17) {\n                            return openPrerender(context, _ref17.proxyWin, _ref17.proxyPrerenderFrame);\n                        }));\n                        var setStatePromise = openPromise.then((function(proxyWin) {\n                            currentProxyWin = proxyWin;\n                            return setProxyWin(proxyWin);\n                        }));\n                        var prerenderPromise = promise_ZalgoPromise.hash({\n                            proxyPrerenderWin: openPrerenderPromise,\n                            state: setStatePromise\n                        }).then((function(_ref18) {\n                            return prerender(_ref18.proxyPrerenderWin, {\n                                context: context\n                            });\n                        }));\n                        var setWindowNamePromise = promise_ZalgoPromise.hash({\n                            proxyWin: openPromise,\n                            windowName: buildWindowNamePromise\n                        }).then((function(_ref19) {\n                            if (windowProp) return _ref19.proxyWin.setName(_ref19.windowName);\n                        }));\n                        var getMethodPromise = promise_ZalgoPromise.hash({\n                            body: buildBodyPromise\n                        }).then((function(_ref20) {\n                            return options.method ? options.method : Object.keys(_ref20.body).length ? \"post\" : \"get\";\n                        }));\n                        var loadUrlPromise = promise_ZalgoPromise.hash({\n                            proxyWin: openPromise,\n                            windowUrl: buildUrlPromise,\n                            body: buildBodyPromise,\n                            method: getMethodPromise,\n                            windowName: setWindowNamePromise,\n                            prerender: prerenderPromise\n                        }).then((function(_ref21) {\n                            return _ref21.proxyWin.setLocation(_ref21.windowUrl, {\n                                method: _ref21.method,\n                                body: _ref21.body\n                            });\n                        }));\n                        var watchForClosePromise = openPromise.then((function(proxyWin) {\n                            !function watchForClose(proxyWin, context) {\n                                var cancelled = !1;\n                                clean.register((function() {\n                                    cancelled = !0;\n                                }));\n                                return promise_ZalgoPromise.delay(2e3).then((function() {\n                                    return proxyWin.isClosed();\n                                })).then((function(isClosed) {\n                                    if (!cancelled) return isClosed ? close(new Error(\"Detected \" + context + \" close\")) : watchForClose(proxyWin, context);\n                                }));\n                            }(proxyWin, context);\n                        }));\n                        var onDisplayPromise = promise_ZalgoPromise.hash({\n                            container: renderContainerPromise,\n                            prerender: prerenderPromise\n                        }).then((function() {\n                            return event.trigger(EVENT.DISPLAY);\n                        }));\n                        var openBridgePromise = openPromise.then((function(proxyWin) {}));\n                        var runTimeoutPromise = loadUrlPromise.then((function() {\n                            return promise_ZalgoPromise.try((function() {\n                                var timeout = props.timeout;\n                                if (timeout) return initPromise.timeout(timeout, new Error(\"Loading component timed out after \" + timeout + \" milliseconds\"));\n                            }));\n                        }));\n                        var onRenderedPromise = initPromise.then((function() {\n                            return event.trigger(EVENT.RENDERED);\n                        }));\n                        return promise_ZalgoPromise.hash({\n                            initPromise: initPromise,\n                            buildUrlPromise: buildUrlPromise,\n                            onRenderPromise: onRenderPromise,\n                            getProxyContainerPromise: getProxyContainerPromise,\n                            openFramePromise: openFramePromise,\n                            openPrerenderFramePromise: openPrerenderFramePromise,\n                            renderContainerPromise: renderContainerPromise,\n                            openPromise: openPromise,\n                            openPrerenderPromise: openPrerenderPromise,\n                            setStatePromise: setStatePromise,\n                            prerenderPromise: prerenderPromise,\n                            loadUrlPromise: loadUrlPromise,\n                            buildWindowNamePromise: buildWindowNamePromise,\n                            setWindowNamePromise: setWindowNamePromise,\n                            watchForClosePromise: watchForClosePromise,\n                            onDisplayPromise: onDisplayPromise,\n                            openBridgePromise: openBridgePromise,\n                            runTimeoutPromise: runTimeoutPromise,\n                            onRenderedPromise: onRenderedPromise,\n                            delegatePromise: delegatePromise,\n                            watchForUnloadPromise: watchForUnloadPromise,\n                            finalSetPropsPromise: finalSetPropsPromise\n                        });\n                    })).catch((function(err) {\n                        return promise_ZalgoPromise.all([ onError(err), destroy(err) ]).then((function() {\n                            throw err;\n                        }), (function() {\n                            throw err;\n                        }));\n                    })).then(src_util_noop);\n                },\n                destroy: destroy,\n                getProps: function() {\n                    return props;\n                },\n                setProps: setProps,\n                export: xport,\n                getHelpers: getHelpers,\n                getDelegateOverrides: function() {\n                    return promise_ZalgoPromise.try((function() {\n                        return {\n                            getProxyContainer: getProxyContainer,\n                            show: show,\n                            hide: hide,\n                            renderContainer: renderContainer,\n                            getProxyWindow: getProxyWindow,\n                            watchForUnload: watchForUnload,\n                            openFrame: openFrame,\n                            openPrerenderFrame: openPrerenderFrame,\n                            prerender: prerender,\n                            open: open,\n                            openPrerender: openPrerender,\n                            setProxyWin: setProxyWin\n                        };\n                    }));\n                },\n                getExports: function() {\n                    return xports({\n                        getExports: function() {\n                            return exportsPromise;\n                        }\n                    });\n                }\n            };\n        }\n        function defaultContainerTemplate(_ref) {\n            var uid = _ref.uid, frame = _ref.frame, prerenderFrame = _ref.prerenderFrame, doc = _ref.doc, props = _ref.props, event = _ref.event, dimensions = _ref.dimensions;\n            var width = dimensions.width, height = dimensions.height;\n            if (frame && prerenderFrame) {\n                var div = doc.createElement(\"div\");\n                div.setAttribute(\"id\", uid);\n                var style = doc.createElement(\"style\");\n                props.cspNonce && style.setAttribute(\"nonce\", props.cspNonce);\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.zoid-invisible {\\n                opacity: 0;\\n            }\\n\\n            #\" + uid + \" > iframe.zoid-visible {\\n                opacity: 1;\\n        }\\n        \"));\n                div.appendChild(frame);\n                div.appendChild(prerenderFrame);\n                div.appendChild(style);\n                prerenderFrame.classList.add(\"zoid-visible\");\n                frame.classList.add(\"zoid-invisible\");\n                event.on(EVENT.RENDERED, (function() {\n                    prerenderFrame.classList.remove(\"zoid-visible\");\n                    prerenderFrame.classList.add(\"zoid-invisible\");\n                    frame.classList.remove(\"zoid-invisible\");\n                    frame.classList.add(\"zoid-visible\");\n                    setTimeout((function() {\n                        destroyElement(prerenderFrame);\n                    }), 1);\n                }));\n                event.on(EVENT.RESIZE, (function(_ref2) {\n                    var newWidth = _ref2.width, newHeight = _ref2.height;\n                    \"number\" == typeof newWidth && (div.style.width = toCSS(newWidth));\n                    \"number\" == typeof newHeight && (div.style.height = toCSS(newHeight));\n                }));\n                return div;\n            }\n        }\n        var cleanInstances = cleanup();\n        var cleanZoid = cleanup();\n        function component(opts) {\n            var options = function(options) {\n                var tag = options.tag, url = options.url, domain = options.domain, bridgeUrl = options.bridgeUrl, _options$props = options.props, props = void 0 === _options$props ? {} : _options$props, _options$dimensions = options.dimensions, dimensions = void 0 === _options$dimensions ? {} : _options$dimensions, _options$autoResize = options.autoResize, autoResize = void 0 === _options$autoResize ? {} : _options$autoResize, _options$allowedParen = options.allowedParentDomains, allowedParentDomains = void 0 === _options$allowedParen ? \"*\" : _options$allowedParen, _options$attributes = options.attributes, attributes = void 0 === _options$attributes ? {} : _options$attributes, _options$defaultConte = options.defaultContext, defaultContext = void 0 === _options$defaultConte ? CONTEXT.IFRAME : _options$defaultConte, _options$containerTem = options.containerTemplate, containerTemplate = void 0 === _options$containerTem ? defaultContainerTemplate : _options$containerTem, _options$prerenderTem = options.prerenderTemplate, prerenderTemplate = void 0 === _options$prerenderTem ? null : _options$prerenderTem, validate = options.validate, _options$eligible = options.eligible, eligible = void 0 === _options$eligible ? function() {\n                    return {\n                        eligible: !0\n                    };\n                } : _options$eligible, _options$logger = options.logger, logger = void 0 === _options$logger ? {\n                    info: src_util_noop\n                } : _options$logger, _options$exports = options.exports, xportsDefinition = void 0 === _options$exports ? src_util_noop : _options$exports, method = options.method, _options$children = options.children, children = void 0 === _options$children ? function() {\n                    return {};\n                } : _options$children;\n                var name = tag.replace(/-/g, \"_\");\n                var propsDef = _extends({}, {\n                    window: {\n                        type: PROP_TYPE.OBJECT,\n                        sendToChild: !1,\n                        required: !1,\n                        allowDelegate: !0,\n                        validate: function(_ref2) {\n                            var value = _ref2.value;\n                            if (!isWindow(value) && !window_ProxyWindow.isProxyWindow(value)) throw new Error(\"Expected Window or ProxyWindow\");\n                            if (isWindow(value)) {\n                                if (isWindowClosed(value)) throw new Error(\"Window is closed\");\n                                if (!isSameDomain(value)) throw new Error(\"Window is not same domain\");\n                            }\n                        },\n                        decorate: function(_ref3) {\n                            return setup_toProxyWindow(_ref3.value);\n                        }\n                    },\n                    timeout: {\n                        type: PROP_TYPE.NUMBER,\n                        required: !1,\n                        sendToChild: !1\n                    },\n                    cspNonce: {\n                        type: PROP_TYPE.STRING,\n                        required: !1\n                    },\n                    onDisplay: {\n                        type: PROP_TYPE.FUNCTION,\n                        required: !1,\n                        sendToChild: !1,\n                        allowDelegate: !0,\n                        default: props_defaultNoop,\n                        decorate: props_decorateOnce\n                    },\n                    onRendered: {\n                        type: PROP_TYPE.FUNCTION,\n                        required: !1,\n                        sendToChild: !1,\n                        default: props_defaultNoop,\n                        decorate: props_decorateOnce\n                    },\n                    onRender: {\n                        type: PROP_TYPE.FUNCTION,\n                        required: !1,\n                        sendToChild: !1,\n                        default: props_defaultNoop,\n                        decorate: props_decorateOnce\n                    },\n                    onClose: {\n                        type: PROP_TYPE.FUNCTION,\n                        required: !1,\n                        sendToChild: !1,\n                        allowDelegate: !0,\n                        default: props_defaultNoop,\n                        decorate: props_decorateOnce\n                    },\n                    onDestroy: {\n                        type: PROP_TYPE.FUNCTION,\n                        required: !1,\n                        sendToChild: !1,\n                        allowDelegate: !0,\n                        default: props_defaultNoop,\n                        decorate: props_decorateOnce\n                    },\n                    onResize: {\n                        type: PROP_TYPE.FUNCTION,\n                        required: !1,\n                        sendToChild: !1,\n                        allowDelegate: !0,\n                        default: props_defaultNoop\n                    },\n                    onFocus: {\n                        type: PROP_TYPE.FUNCTION,\n                        required: !1,\n                        sendToChild: !1,\n                        allowDelegate: !0,\n                        default: props_defaultNoop\n                    },\n                    close: {\n                        type: PROP_TYPE.FUNCTION,\n                        required: !1,\n                        sendToChild: !1,\n                        childDecorate: function(_ref4) {\n                            return _ref4.close;\n                        }\n                    },\n                    focus: {\n                        type: PROP_TYPE.FUNCTION,\n                        required: !1,\n                        sendToChild: !1,\n                        childDecorate: function(_ref5) {\n                            return _ref5.focus;\n                        }\n                    },\n                    resize: {\n                        type: PROP_TYPE.FUNCTION,\n                        required: !1,\n                        sendToChild: !1,\n                        childDecorate: function(_ref6) {\n                            return _ref6.resize;\n                        }\n                    },\n                    uid: {\n                        type: PROP_TYPE.STRING,\n                        required: !1,\n                        sendToChild: !1,\n                        childDecorate: function(_ref7) {\n                            return _ref7.uid;\n                        }\n                    },\n                    tag: {\n                        type: PROP_TYPE.STRING,\n                        required: !1,\n                        sendToChild: !1,\n                        childDecorate: function(_ref8) {\n                            return _ref8.tag;\n                        }\n                    },\n                    getParent: {\n                        type: PROP_TYPE.FUNCTION,\n                        required: !1,\n                        sendToChild: !1,\n                        childDecorate: function(_ref9) {\n                            return _ref9.getParent;\n                        }\n                    },\n                    getParentDomain: {\n                        type: PROP_TYPE.FUNCTION,\n                        required: !1,\n                        sendToChild: !1,\n                        childDecorate: function(_ref10) {\n                            return _ref10.getParentDomain;\n                        }\n                    },\n                    show: {\n                        type: PROP_TYPE.FUNCTION,\n                        required: !1,\n                        sendToChild: !1,\n                        childDecorate: function(_ref11) {\n                            return _ref11.show;\n                        }\n                    },\n                    hide: {\n                        type: PROP_TYPE.FUNCTION,\n                        required: !1,\n                        sendToChild: !1,\n                        childDecorate: function(_ref12) {\n                            return _ref12.hide;\n                        }\n                    },\n                    export: {\n                        type: PROP_TYPE.FUNCTION,\n                        required: !1,\n                        sendToChild: !1,\n                        childDecorate: function(_ref13) {\n                            return _ref13.export;\n                        }\n                    },\n                    onError: {\n                        type: PROP_TYPE.FUNCTION,\n                        required: !1,\n                        sendToChild: !1,\n                        childDecorate: function(_ref14) {\n                            return _ref14.onError;\n                        }\n                    },\n                    onProps: {\n                        type: PROP_TYPE.FUNCTION,\n                        required: !1,\n                        sendToChild: !1,\n                        childDecorate: function(_ref15) {\n                            return _ref15.onProps;\n                        }\n                    },\n                    getSiblings: {\n                        type: PROP_TYPE.FUNCTION,\n                        required: !1,\n                        sendToChild: !1,\n                        childDecorate: function(_ref16) {\n                            return _ref16.getSiblings;\n                        }\n                    }\n                }, props);\n                if (!containerTemplate) throw new Error(\"Container template required\");\n                return {\n                    name: name,\n                    tag: tag,\n                    url: url,\n                    domain: domain,\n                    bridgeUrl: bridgeUrl,\n                    method: method,\n                    propsDef: propsDef,\n                    dimensions: dimensions,\n                    autoResize: autoResize,\n                    allowedParentDomains: allowedParentDomains,\n                    attributes: attributes,\n                    defaultContext: defaultContext,\n                    containerTemplate: containerTemplate,\n                    prerenderTemplate: prerenderTemplate,\n                    validate: validate,\n                    logger: logger,\n                    eligible: eligible,\n                    children: children,\n                    exports: \"function\" == typeof xportsDefinition ? xportsDefinition : function(_ref) {\n                        var getExports = _ref.getExports;\n                        var result = {};\n                        var _loop = function(_i2, _Object$keys2) {\n                            var key = _Object$keys2[_i2];\n                            var type = xportsDefinition[key].type;\n                            var valuePromise = getExports().then((function(res) {\n                                return res[key];\n                            }));\n                            result[key] = type === PROP_TYPE.FUNCTION ? function() {\n                                for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) args[_key] = arguments[_key];\n                                return valuePromise.then((function(value) {\n                                    return value.apply(void 0, args);\n                                }));\n                            } : valuePromise;\n                        };\n                        for (var _i2 = 0, _Object$keys2 = Object.keys(xportsDefinition); _i2 < _Object$keys2.length; _i2++) _loop(_i2, _Object$keys2);\n                        return result;\n                    }\n                };\n            }(opts);\n            var name = options.name, tag = options.tag, defaultContext = options.defaultContext, eligible = options.eligible, children = options.children;\n            var global = lib_global_getGlobal(window);\n            var instances = [];\n            var isChild = function() {\n                if (function(name) {\n                    try {\n                        return parseWindowName(window.name).name === name;\n                    } catch (err) {}\n                    return !1;\n                }(name)) {\n                    var _payload = getInitialParentPayload().payload;\n                    if (_payload.tag === tag && matchDomain(_payload.childDomainMatch, getDomain())) return !0;\n                }\n                return !1;\n            };\n            var registerChild = memoize((function() {\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                    var child = function(options) {\n                        var tag = options.tag, propsDef = options.propsDef, autoResize = options.autoResize, allowedParentDomains = options.allowedParentDomains;\n                        var onPropHandlers = [];\n                        var _getInitialParentPayl = getInitialParentPayload(), parent = _getInitialParentPayl.parent, payload = _getInitialParentPayl.payload;\n                        var parentComponentWindow = parent.win, parentDomain = parent.domain;\n                        var props;\n                        var exportsPromise = new promise_ZalgoPromise;\n                        var version = payload.version, uid = payload.uid, parentExports = payload.exports, context = payload.context, initialProps = payload.props;\n                        if (\"9_0_86\" !== version) throw new Error(\"Parent window has zoid version \" + version + \", child window has version 9_0_86\");\n                        var show = parentExports.show, hide = parentExports.hide, close = parentExports.close, onError = parentExports.onError, checkClose = parentExports.checkClose, parentExport = parentExports.export, parentResize = parentExports.resize, parentInit = parentExports.init;\n                        var getParent = function() {\n                            return parentComponentWindow;\n                        };\n                        var getParentDomain = function() {\n                            return parentDomain;\n                        };\n                        var onProps = function(handler) {\n                            onPropHandlers.push(handler);\n                            return {\n                                cancel: function() {\n                                    onPropHandlers.splice(onPropHandlers.indexOf(handler), 1);\n                                }\n                            };\n                        };\n                        var resize = function(_ref) {\n                            return parentResize.fireAndForget({\n                                width: _ref.width,\n                                height: _ref.height\n                            });\n                        };\n                        var xport = function(xports) {\n                            exportsPromise.resolve(xports);\n                            return parentExport(xports);\n                        };\n                        var getSiblings = function(_temp) {\n                            var anyParent = (void 0 === _temp ? {} : _temp).anyParent;\n                            var result = [];\n                            var currentParent = props.parent;\n                            void 0 === anyParent && (anyParent = !currentParent);\n                            if (!anyParent && !currentParent) throw new Error(\"No parent found for \" + tag + \" child\");\n                            for (var _i2 = 0, _getAllFramesInWindow2 = getAllFramesInWindow(window); _i2 < _getAllFramesInWindow2.length; _i2++) {\n                                var win = _getAllFramesInWindow2[_i2];\n                                if (isSameDomain(win)) {\n                                    var xprops = assertSameDomain(win).xprops;\n                                    if (xprops && getParent() === xprops.getParent()) {\n                                        var winParent = xprops.parent;\n                                        if (anyParent || !currentParent || winParent && winParent.uid === currentParent.uid) {\n                                            var xports = tryGlobal(win, (function(global) {\n                                                return global.exports;\n                                            }));\n                                            result.push({\n                                                props: xprops,\n                                                exports: xports\n                                            });\n                                        }\n                                    }\n                                }\n                            }\n                            return result;\n                        };\n                        var setProps = function(newProps, origin, isUpdate) {\n                            void 0 === isUpdate && (isUpdate = !1);\n                            var normalizedProps = function(parentComponentWindow, propsDef, props, origin, helpers, isUpdate) {\n                                void 0 === isUpdate && (isUpdate = !1);\n                                var result = {};\n                                for (var _i2 = 0, _Object$keys2 = Object.keys(props); _i2 < _Object$keys2.length; _i2++) {\n                                    var key = _Object$keys2[_i2];\n                                    var prop = propsDef[key];\n                                    if (!prop || !prop.sameDomain || origin === getDomain(window) && isSameDomain(parentComponentWindow)) {\n                                        var value = normalizeChildProp(propsDef, 0, key, props[key], helpers);\n                                        result[key] = value;\n                                        prop && prop.alias && !result[prop.alias] && (result[prop.alias] = value);\n                                    }\n                                }\n                                if (!isUpdate) for (var _i4 = 0, _Object$keys4 = Object.keys(propsDef); _i4 < _Object$keys4.length; _i4++) {\n                                    var _key = _Object$keys4[_i4];\n                                    props.hasOwnProperty(_key) || (result[_key] = normalizeChildProp(propsDef, 0, _key, void 0, helpers));\n                                }\n                                return result;\n                            }(parentComponentWindow, propsDef, newProps, origin, {\n                                tag: tag,\n                                show: show,\n                                hide: hide,\n                                close: close,\n                                focus: child_focus,\n                                onError: onError,\n                                resize: resize,\n                                getSiblings: getSiblings,\n                                onProps: onProps,\n                                getParent: getParent,\n                                getParentDomain: getParentDomain,\n                                uid: uid,\n                                export: xport\n                            }, isUpdate);\n                            props ? extend(props, normalizedProps) : props = normalizedProps;\n                            for (var _i4 = 0; _i4 < onPropHandlers.length; _i4++) (0, onPropHandlers[_i4])(props);\n                        };\n                        var updateProps = function(newProps) {\n                            return promise_ZalgoPromise.try((function() {\n                                return setProps(newProps, parentDomain, !0);\n                            }));\n                        };\n                        return {\n                            init: function() {\n                                return promise_ZalgoPromise.try((function() {\n                                    isSameDomain(parentComponentWindow) && function(_ref3) {\n                                        var componentName = _ref3.componentName, parentComponentWindow = _ref3.parentComponentWindow;\n                                        var _crossDomainDeseriali2 = crossDomainDeserialize({\n                                            data: parseWindowName(window.name).serializedInitialPayload,\n                                            sender: {\n                                                win: parentComponentWindow\n                                            },\n                                            basic: !0\n                                        }), sender = _crossDomainDeseriali2.sender;\n                                        if (\"uid\" === _crossDomainDeseriali2.reference.type || \"global\" === _crossDomainDeseriali2.metaData.windowRef.type) {\n                                            var _crossDomainSerialize = crossDomainSerialize({\n                                                data: _crossDomainDeseriali2.data,\n                                                metaData: {\n                                                    windowRef: window_getWindowRef(parentComponentWindow)\n                                                },\n                                                sender: {\n                                                    domain: sender.domain\n                                                },\n                                                receiver: {\n                                                    win: window,\n                                                    domain: getDomain()\n                                                },\n                                                basic: !0\n                                            });\n                                            window.name = buildChildWindowName({\n                                                name: componentName,\n                                                serializedPayload: _crossDomainSerialize.serializedData\n                                            });\n                                        }\n                                    }({\n                                        componentName: options.name,\n                                        parentComponentWindow: parentComponentWindow\n                                    });\n                                    lib_global_getGlobal(window).exports = options.exports({\n                                        getExports: function() {\n                                            return exportsPromise;\n                                        }\n                                    });\n                                    !function(allowedParentDomains, domain) {\n                                        if (!matchDomain(allowedParentDomains, domain)) throw new Error(\"Can not be rendered by domain: \" + domain);\n                                    }(allowedParentDomains, parentDomain);\n                                    markWindowKnown(parentComponentWindow);\n                                    !function() {\n                                        window.addEventListener(\"beforeunload\", (function() {\n                                            checkClose.fireAndForget();\n                                        }));\n                                        window.addEventListener(\"unload\", (function() {\n                                            checkClose.fireAndForget();\n                                        }));\n                                        onCloseWindow(parentComponentWindow, (function() {\n                                            child_destroy();\n                                        }));\n                                    }();\n                                    return parentInit({\n                                        updateProps: updateProps,\n                                        close: child_destroy\n                                    });\n                                })).then((function() {\n                                    return (_autoResize$width = autoResize.width, width = void 0 !== _autoResize$width && _autoResize$width, \n                                    _autoResize$height = autoResize.height, height = void 0 !== _autoResize$height && _autoResize$height, \n                                    _autoResize$element = autoResize.element, elementReady(void 0 === _autoResize$element ? \"body\" : _autoResize$element).catch(src_util_noop).then((function(element) {\n                                        return {\n                                            width: width,\n                                            height: height,\n                                            element: element\n                                        };\n                                    }))).then((function(_ref3) {\n                                        var width = _ref3.width, height = _ref3.height, element = _ref3.element;\n                                        element && (width || height) && context !== CONTEXT.POPUP && onResize(element, (function(_ref4) {\n                                            resize({\n                                                width: width ? _ref4.width : void 0,\n                                                height: height ? _ref4.height : void 0\n                                            });\n                                        }), {\n                                            width: width,\n                                            height: height\n                                        });\n                                    }));\n                                    var _autoResize$width, width, _autoResize$height, height, _autoResize$element;\n                                })).catch((function(err) {\n                                    onError(err);\n                                }));\n                            },\n                            getProps: function() {\n                                if (props) return props;\n                                setProps(initialProps, parentDomain);\n                                return props;\n                            }\n                        };\n                    }(options);\n                    child.init();\n                    return child;\n                }\n            }));\n            registerChild();\n            !function() {\n                var allowDelegateListener = on_on(\"zoid_allow_delegate_\" + name, (function() {\n                    return !0;\n                }));\n                var delegateListener = on_on(\"zoid_delegate_\" + name, (function(_ref2) {\n                    var _ref2$data = _ref2.data;\n                    return {\n                        parent: parentComponent({\n                            uid: _ref2$data.uid,\n                            options: options,\n                            overrides: _ref2$data.overrides,\n                            parentWin: _ref2.source\n                        })\n                    };\n                }));\n                cleanZoid.register(allowDelegateListener.cancel);\n                cleanZoid.register(delegateListener.cancel);\n            }();\n            global.components = global.components || {};\n            if (global.components[tag]) throw new Error(\"Can not register multiple components with the same tag: \" + tag);\n            global.components[tag] = !0;\n            return {\n                init: function init(inputProps) {\n                    var instance;\n                    var uid = \"zoid-\" + tag + \"-\" + uniqueID();\n                    var props = inputProps || {};\n                    var _eligible = eligible({\n                        props: props\n                    }), eligibility = _eligible.eligible, reason = _eligible.reason;\n                    var onDestroy = props.onDestroy;\n                    props.onDestroy = function() {\n                        instance && eligibility && instances.splice(instances.indexOf(instance), 1);\n                        if (onDestroy) return onDestroy.apply(void 0, arguments);\n                    };\n                    var parent = parentComponent({\n                        uid: uid,\n                        options: options\n                    });\n                    parent.init();\n                    eligibility ? parent.setProps(props) : props.onDestroy && props.onDestroy();\n                    cleanInstances.register((function(err) {\n                        return parent.destroy(err || new Error(\"zoid destroyed all components\"));\n                    }));\n                    var clone = function(_temp) {\n                        var _ref4$decorate = (void 0 === _temp ? {} : _temp).decorate;\n                        return init((void 0 === _ref4$decorate ? identity : _ref4$decorate)(props));\n                    };\n                    var _render = function(target, container, context) {\n                        return promise_ZalgoPromise.try((function() {\n                            if (!eligibility) {\n                                var err = new Error(reason || name + \" component is not eligible\");\n                                return parent.destroy(err).then((function() {\n                                    throw err;\n                                }));\n                            }\n                            if (!isWindow(target)) throw new Error(\"Must pass window to renderTo\");\n                            return function(props, context) {\n                                return promise_ZalgoPromise.try((function() {\n                                    if (props.window) return setup_toProxyWindow(props.window).getType();\n                                    if (context) {\n                                        if (context !== CONTEXT.IFRAME && context !== CONTEXT.POPUP) throw new Error(\"Unrecognized context: \" + context);\n                                        return context;\n                                    }\n                                    return defaultContext;\n                                }));\n                            }(props, context);\n                        })).then((function(finalContext) {\n                            container = function(context, container) {\n                                if (container) {\n                                    if (\"string\" != typeof container && !isElement(container)) throw new TypeError(\"Expected string or element selector to be passed\");\n                                    return container;\n                                }\n                                if (context === CONTEXT.POPUP) return \"body\";\n                                throw new Error(\"Expected element to be passed to render iframe\");\n                            }(finalContext, container);\n                            if (target !== window && \"string\" != typeof container) throw new Error(\"Must pass string element when rendering to another window\");\n                            return parent.render({\n                                target: target,\n                                container: container,\n                                context: finalContext,\n                                rerender: function() {\n                                    var newInstance = clone();\n                                    extend(instance, newInstance);\n                                    return newInstance.renderTo(target, container, context);\n                                }\n                            });\n                        })).catch((function(err) {\n                            return parent.destroy(err).then((function() {\n                                throw err;\n                            }));\n                        }));\n                    };\n                    instance = _extends({}, parent.getExports(), parent.getHelpers(), function() {\n                        var childComponents = children();\n                        var result = {};\n                        var _loop2 = function(_i4, _Object$keys4) {\n                            var childName = _Object$keys4[_i4];\n                            var Child = childComponents[childName];\n                            result[childName] = function(childInputProps) {\n                                var parentProps = parent.getProps();\n                                var childProps = _extends({}, childInputProps, {\n                                    parent: {\n                                        uid: uid,\n                                        props: parentProps,\n                                        export: parent.export\n                                    }\n                                });\n                                return Child(childProps);\n                            };\n                        };\n                        for (var _i4 = 0, _Object$keys4 = Object.keys(childComponents); _i4 < _Object$keys4.length; _i4++) _loop2(_i4, _Object$keys4);\n                        return result;\n                    }(), {\n                        isEligible: function() {\n                            return eligibility;\n                        },\n                        clone: clone,\n                        render: function(container, context) {\n                            return _render(window, container, context);\n                        },\n                        renderTo: function(target, container, context) {\n                            return _render(target, container, context);\n                        }\n                    });\n                    eligibility && instances.push(instance);\n                    return instance;\n                },\n                instances: instances,\n                driver: function(driverName, dep) {\n                    throw new Error(\"Driver support not enabled\");\n                },\n                isChild: isChild,\n                canRenderTo: function(win) {\n                    return send_send(win, \"zoid_allow_delegate_\" + name).then((function(_ref3) {\n                        return _ref3.data;\n                    })).catch((function() {\n                        return !1;\n                    }));\n                },\n                registerChild: registerChild\n            };\n        }\n        var component_create = function(options) {\n            !function() {\n                if (!global_getGlobal().initialized) {\n                    global_getGlobal().initialized = !0;\n                    on = (_ref3 = {\n                        on: on_on,\n                        send: send_send\n                    }).on, send = _ref3.send, (global = global_getGlobal()).receiveMessage = global.receiveMessage || function(message) {\n                        return receive_receiveMessage(message, {\n                            on: on,\n                            send: send\n                        });\n                    };\n                    !function(_ref5) {\n                        var on = _ref5.on, send = _ref5.send;\n                        globalStore().getOrSet(\"postMessageListener\", (function() {\n                            return addEventListener(window, \"message\", (function(event) {\n                                !function(event, _ref4) {\n                                    var on = _ref4.on, send = _ref4.send;\n                                    promise_ZalgoPromise.try((function() {\n                                        var source = event.source || event.sourceElement;\n                                        var origin = event.origin || event.originalEvent && event.originalEvent.origin;\n                                        var data = event.data;\n                                        \"null\" === origin && (origin = \"file://\");\n                                        if (source) {\n                                            if (!origin) throw new Error(\"Post message did not have origin domain\");\n                                            receive_receiveMessage({\n                                                source: source,\n                                                origin: origin,\n                                                data: data\n                                            }, {\n                                                on: on,\n                                                send: send\n                                            });\n                                        }\n                                    }));\n                                }(event, {\n                                    on: on,\n                                    send: send\n                                });\n                            }));\n                        }));\n                    }({\n                        on: on_on,\n                        send: send_send\n                    });\n                    !function(_ref8) {\n                        var on = _ref8.on, send = _ref8.send;\n                        globalStore(\"builtinListeners\").getOrSet(\"helloListener\", (function() {\n                            var listener = on(\"postrobot_hello\", {\n                                domain: \"*\"\n                            }, (function(_ref3) {\n                                resolveHelloPromise(_ref3.source, {\n                                    domain: _ref3.origin\n                                });\n                                return {\n                                    instanceID: getInstanceID()\n                                };\n                            }));\n                            var parent = getAncestor();\n                            parent && sayHello(parent, {\n                                send: send\n                            }).catch((function(err) {}));\n                            return listener;\n                        }));\n                    }({\n                        on: on_on,\n                        send: send_send\n                    });\n                }\n                var _ref3, on, send, global;\n            }();\n            var comp = component(options);\n            var init = function(props) {\n                return comp.init(props);\n            };\n            init.driver = function(name, dep) {\n                return comp.driver(name, dep);\n            };\n            init.isChild = function() {\n                return comp.isChild();\n            };\n            init.canRenderTo = function(win) {\n                return comp.canRenderTo(win);\n            };\n            init.instances = comp.instances;\n            var child = comp.registerChild();\n            child && (window.xprops = init.xprops = child.getProps());\n            return init;\n        };\n        function destroyComponents(err) {\n            var destroyPromise = cleanInstances.all(err);\n            cleanInstances = cleanup();\n            return destroyPromise;\n        }\n        var destroyAll = destroyComponents;\n        function component_destroy(err) {\n            destroyAll();\n            delete window.__zoid_9_0_86__;\n            !function() {\n                !function() {\n                    var responseListeners = globalStore(\"responseListeners\");\n                    for (var _i2 = 0, _responseListeners$ke2 = responseListeners.keys(); _i2 < _responseListeners$ke2.length; _i2++) {\n                        var hash = _responseListeners$ke2[_i2];\n                        var listener = responseListeners.get(hash);\n                        listener && (listener.cancelled = !0);\n                        responseListeners.del(hash);\n                    }\n                }();\n                (listener = globalStore().get(\"postMessageListener\")) && listener.cancel();\n                var listener;\n                delete window.__post_robot_10_0_44__;\n            }();\n            return cleanZoid.all(err);\n        }\n    } ]);\n}));","module.exports = function(obj) {\nobj || (obj = {});\nvar __t, __p = '';\nwith (obj) {\n__p += '<!DOCTYPE html>\\n<html lang=\"en\">\\n<head>\\n    <meta charset=\"UTF-8\">\\n    <style>\\n        :root {\\n          --white: #ffffff;\\n          --warm-grey: #767676;\\n          --primary-blue: ' +\n((__t = ( color )) == null ? '' : __t) +\n';\\n        }\\n        body {\\n            box-sizing: border-box;\\n            padding: 0;\\n            margin: 0;\\n            /* -webkit-transform:translate3d(0,0,0); */\\n        }\\n        .ra21CTALoadingContainer {\\n            float: top;\\n            z-index: -999;\\n            position: relative;\\n        }\\n        .ra21CTAMain {\\n            align: top;\\n            float: bottom;\\n            font-family: \\'Helvetica\\', sans-serif;\\n            font-size: 12px;\\n            font-weight: normal;\\n            font-style: normal;\\n            font-stretch: normal;\\n            line-height: 1.67;\\n            letter-spacing: normal;\\n            text-align: center;\\n            background-color: var(--primary-blue);\\n            border-radius: 5px;\\n        }\\n\\n        .ra21-button {\\n          background-color: var(--primary-blue);\\n          border-radius: 5px;\\n          color: var(--warm-grey);\\n          cursor: pointer;\\n          display: flex;\\n          margin-bottom: 5px;\\n          padding: 9px;\\n          text-decoration: none;\\n        }\\n\\n        .ra21-button-logo-wrap {\\n            text-align: center;\\n            max-width: 50px;\\n            border-right: 1px solid #FFFFFF;\\n            padding: 5px 12px 5px 7px;\\n        }\\n\\n        .ra21-button-logo {\\n          width: 30px;\\n          vertical-align: middle;\\n        }\\n\\n        .ra21-button-text {\\n          padding-left: 10px;\\n          text-align: center;\\n          width: 85%;\\n          color: var(--white);\\n        }\\n\\n        .ra21-button-text-primary {\\n          font-family: \\'Helvetica\\', sans-serif;\\n          font-size: 14px;\\n          font-weight: 700;\\n          font-style: normal;\\n          font-stretch: normal;\\n          line-height: 1.4;\\n          letter-spacing: normal;\\n        }\\n\\n        .ra21-button-text-secondary {\\n          /* Zep */\\n          font-family: \\'Helvetica\\', sans-serif;\\n          font-size: 13px;\\n          font-weight: normal;\\n          font-style: normal;\\n          font-stretch: normal;\\n          line-height: 1.4;\\n          letter-spacing: normal;\\n        }\\n\\n        .ra21-access-text {\\n          cursor: pointer;\\n          text-align: center;\\n\\n          /* Zep */\\n          font-family: \\'Helvetica\\', sans-serif;\\n          font-size: 13px;\\n          font-weight: normal;\\n          font-style: normal;\\n          font-stretch: normal;\\n          line-height: 1.46;\\n          letter-spacing: normal;\\n          color: var(--primary-blue);\\n        }\\n        .align-items-center {\\n            -ms-flex-align: center!important;\\n            align-items: center!important;\\n        }\\n        .justify-content-center {\\n            -ms-flex-pack: center!important;\\n            justify-content: center!important;\\n        }\\n        .d-flex { display: flex!important; }\\n        .ra21-choose-another {\\n            /* height: 20px;\\n            min-height: 20px; */\\n        }\\n        a, a:hover { text-decoration: none; }\\n\\n    </style>\\n</head>\\n<body>\\n    <a id=\"fallbacklink\" href=\"#\"><div class=\"ra21CTALoadingContainer\">\\n        <div class=\"ra21CTAMain ra21-button\">\\n            <div class=\"ra21-button-logo-wrap\">\\n                <img class=\"ra21-button-logo\" src=\"' +\n((__t = ( require('../assets/RA21-White.svg') )) == null ? '' : __t) +\n'\">\\n            </div>\\n            <div class=\"d-flex justify-content-center align-items-center ra21-button-text\">\\n                <div class=\"ra21-button-text-primary\">Access through your institution</div>\\n            </div>\\n        </div>\\n        <div class=\"ra21-choose-another\"></div>\\n    </div></a>\\n</body>\\n</html>';\n\n}\nreturn __p\n}","module.exports = \"data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0idXRmLTgiPz4KPCEtLSBHZW5lcmF0b3I6IEFkb2JlIElsbHVzdHJhdG9yIDIzLjAuMiwgU1ZHIEV4cG9ydCBQbHVnLUluIC4gU1ZHIFZlcnNpb246IDYuMDAgQnVpbGQgMCkgIC0tPgo8c3ZnIHZlcnNpb249IjEuMSIgaWQ9IkxheWVyXzEiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyIgeG1sbnM6eGxpbms9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGxpbmsiIHg9IjBweCIgeT0iMHB4IgoJIHZpZXdCb3g9IjAgMCAyNTMuODggMjUzLjk5IiBzdHlsZT0iZW5hYmxlLWJhY2tncm91bmQ6bmV3IDAgMCAyNTMuODggMjUzLjk5OyIgeG1sOnNwYWNlPSJwcmVzZXJ2ZSI+CjxzdHlsZSB0eXBlPSJ0ZXh0L2NzcyI+Cgkuc3Qwe2ZpbGw6I0ZGRkZGRjt9Cjwvc3R5bGU+CjxnPgoJPHBhdGggY2xhc3M9InN0MCIgZD0iTTM3LjU4LDk3Ljc2aDE3OC43M2M1LjcsMCwxMC42OC0zLjU2LDEyLjQ2LTguOWMxLjQyLTUuMzQtMC4zNi0xMS4wNC00Ljk5LTE0LjI0bC04OS4zNy02NC4wOQoJCWMtNC42My0zLjItMTAuNjgtMy4yLTE0Ljk1LDBMMzAuMTEsNzQuNjFjLTMuMiwyLjQ5LTUuMzQsNi4wNS01LjM0LDEwLjMzQzI0Ljc3LDkyLjA2LDMwLjQ2LDk3Ljc2LDM3LjU4LDk3Ljc2eiBNMTI2Ljk1LDM2Ljg3CgkJbDQ5LjQ5LDM1LjI1SDc3LjQ2TDEyNi45NSwzNi44N3oiLz4KCTxwb2x5Z29uIGNsYXNzPSJzdDAiIHBvaW50cz0iMTA5LjQ1LDE4NS40IDEwOS44NSwxMjcuODIgODAuMjUsMTEzLjU1IDgwLjI1LDE5OS42NyAJIi8+Cgk8cG9seWdvbiBjbGFzcz0ic3QwIiBwb2ludHM9IjE3NC4xOSwxOTkuMjYgMTc0LjE5LDExNC4zNyAxNDQuOTksMTI4LjY0IDE0NC45OSwxODYuMjEgCSIvPgoJPHBhdGggY2xhc3M9InN0MCIgZD0iTTI0Mi4wNywyMjYuNDJjLTAuMDEsMC0wLjAzLDAtMC4wNCwwaC0xMC43NXYtMTAuNzRjMC0zLjcxLTMuMDEtNi43Mi02LjcyLTYuNzJsLTEwLjEsMHYtODYuMjEKCQljMC04LjItNi43MS0xNC45LTE0LjktMTQuOWMtOC4yLDAtMTQuOSw2LjcxLTE0LjksMTQuOXY4Ni4yMWwtMTE1LjQyLTAuMDJ2LTg2LjE5YzAtOC4yLTYuNzEtMTQuOS0xNC45LTE0LjkKCQljLTguMiwwLTE0LjksNi43MS0xNC45LDE0Ljl2ODYuMThsLTEwLjA4LDBjLTMuNzEsMC02LjcyLDMuMDEtNi43Miw2LjcydjEwLjc0SDExLjg2Yy0zLjcxLDAtNi43MiwzLjAxLTYuNzIsNi43MnYxMS42OGgyNDMuNjIKCQl2LTExLjYzQzI0OC43NywyMjkuNDUsMjQ1Ljc4LDIyNi40MywyNDIuMDcsMjI2LjQyeiIvPgo8L2c+Cjwvc3ZnPgo=\"","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","\nimport {DiscoveryComponent} from \"./component\"; /* webpackPrefetch: true */\nimport 'bootstrap/dist/css/bootstrap.min.css';\n\nwindow.onload = function() {\n    DiscoveryComponent({\n       loginHandlerURL: process.env.BASE_URL+'ds/?target=https://google.com&return=/&entityID=https://ra21.mnt.se/shibboleth',\n       backgroundColor: '#e9ecef'\n    }).render('#login');\n};\n","\nvar content = require(\"!!../../../mini-css-extract-plugin/dist/loader.js!../../../css-loader/index.js!./bootstrap.min.css\");\n\nif(typeof content === 'string') content = [[module.id, content, '']];\n\nvar transform;\nvar insertInto;\n\n\n\nvar options = {\"hmr\":true}\n\noptions.transform = transform\noptions.insertInto = undefined;\n\nvar update = require(\"!../../../style-loader/lib/addStyles.js\")(content, options);\n\nif(content.locals) module.exports = content.locals;\n\nif(module.hot) {\n\tmodule.hot.accept(\"!!../../../mini-css-extract-plugin/dist/loader.js!../../../css-loader/index.js!./bootstrap.min.css\", function() {\n\t\tvar newContent = require(\"!!../../../mini-css-extract-plugin/dist/loader.js!../../../css-loader/index.js!./bootstrap.min.css\");\n\n\t\tif(typeof newContent === 'string') newContent = [[module.id, newContent, '']];\n\n\t\tvar locals = (function(a, b) {\n\t\t\tvar key, idx = 0;\n\n\t\t\tfor(key in a) {\n\t\t\t\tif(!b || a[key] !== b[key]) return false;\n\t\t\t\tidx++;\n\t\t\t}\n\n\t\t\tfor(key in b) idx--;\n\n\t\t\treturn idx === 0;\n\t\t}(content.locals, newContent.locals));\n\n\t\tif(!locals) throw new Error('Aborting CSS HMR due to changed css-modules locals.');\n\n\t\tupdate(newContent);\n\t});\n\n\tmodule.hot.dispose(function() { update(); });\n}","/*\n\tMIT License http://www.opensource.org/licenses/mit-license.php\n\tAuthor Tobias Koppers @sokra\n*/\n\nvar stylesInDom = {};\n\nvar\tmemoize = function (fn) {\n\tvar memo;\n\n\treturn function () {\n\t\tif (typeof memo === \"undefined\") memo = fn.apply(this, arguments);\n\t\treturn memo;\n\t};\n};\n\nvar isOldIE = memoize(function () {\n\t// Test for IE <= 9 as proposed by Browserhacks\n\t// @see http://browserhacks.com/#hack-e71d8692f65334173fee715c222cb805\n\t// Tests for existence of standard globals is to allow style-loader\n\t// to operate correctly into non-standard environments\n\t// @see https://github.com/webpack-contrib/style-loader/issues/177\n\treturn window && document && document.all && !window.atob;\n});\n\nvar getTarget = function (target, parent) {\n  if (parent){\n    return parent.querySelector(target);\n  }\n  return document.querySelector(target);\n};\n\nvar getElement = (function (fn) {\n\tvar memo = {};\n\n\treturn function(target, parent) {\n                // If passing function in options, then use it for resolve \"head\" element.\n                // Useful for Shadow Root style i.e\n                // {\n                //   insertInto: function () { return document.querySelector(\"#foo\").shadowRoot }\n                // }\n                if (typeof target === 'function') {\n                        return target();\n                }\n                if (typeof memo[target] === \"undefined\") {\n\t\t\tvar styleTarget = getTarget.call(this, target, parent);\n\t\t\t// Special case to return head of iframe instead of iframe itself\n\t\t\tif (window.HTMLIFrameElement && styleTarget instanceof window.HTMLIFrameElement) {\n\t\t\t\ttry {\n\t\t\t\t\t// This will throw an exception if access to iframe is blocked\n\t\t\t\t\t// due to cross-origin restrictions\n\t\t\t\t\tstyleTarget = styleTarget.contentDocument.head;\n\t\t\t\t} catch(e) {\n\t\t\t\t\tstyleTarget = null;\n\t\t\t\t}\n\t\t\t}\n\t\t\tmemo[target] = styleTarget;\n\t\t}\n\t\treturn memo[target]\n\t};\n})();\n\nvar singleton = null;\nvar\tsingletonCounter = 0;\nvar\tstylesInsertedAtTop = [];\n\nvar\tfixUrls = require(\"./urls\");\n\nmodule.exports = function(list, options) {\n\tif (typeof DEBUG !== \"undefined\" && DEBUG) {\n\t\tif (typeof document !== \"object\") throw new Error(\"The style-loader cannot be used in a non-browser environment\");\n\t}\n\n\toptions = options || {};\n\n\toptions.attrs = typeof options.attrs === \"object\" ? options.attrs : {};\n\n\t// Force single-tag solution on IE6-9, which has a hard limit on the # of <style>\n\t// tags it will allow on a page\n\tif (!options.singleton && typeof options.singleton !== \"boolean\") options.singleton = isOldIE();\n\n\t// By default, add <style> tags to the <head> element\n        if (!options.insertInto) options.insertInto = \"head\";\n\n\t// By default, add <style> tags to the bottom of the target\n\tif (!options.insertAt) options.insertAt = \"bottom\";\n\n\tvar styles = listToStyles(list, options);\n\n\taddStylesToDom(styles, options);\n\n\treturn function update (newList) {\n\t\tvar mayRemove = [];\n\n\t\tfor (var i = 0; i < styles.length; i++) {\n\t\t\tvar item = styles[i];\n\t\t\tvar domStyle = stylesInDom[item.id];\n\n\t\t\tdomStyle.refs--;\n\t\t\tmayRemove.push(domStyle);\n\t\t}\n\n\t\tif(newList) {\n\t\t\tvar newStyles = listToStyles(newList, options);\n\t\t\taddStylesToDom(newStyles, options);\n\t\t}\n\n\t\tfor (var i = 0; i < mayRemove.length; i++) {\n\t\t\tvar domStyle = mayRemove[i];\n\n\t\t\tif(domStyle.refs === 0) {\n\t\t\t\tfor (var j = 0; j < domStyle.parts.length; j++) domStyle.parts[j]();\n\n\t\t\t\tdelete stylesInDom[domStyle.id];\n\t\t\t}\n\t\t}\n\t};\n};\n\nfunction addStylesToDom (styles, options) {\n\tfor (var i = 0; i < styles.length; i++) {\n\t\tvar item = styles[i];\n\t\tvar domStyle = stylesInDom[item.id];\n\n\t\tif(domStyle) {\n\t\t\tdomStyle.refs++;\n\n\t\t\tfor(var j = 0; j < domStyle.parts.length; j++) {\n\t\t\t\tdomStyle.parts[j](item.parts[j]);\n\t\t\t}\n\n\t\t\tfor(; j < item.parts.length; j++) {\n\t\t\t\tdomStyle.parts.push(addStyle(item.parts[j], options));\n\t\t\t}\n\t\t} else {\n\t\t\tvar parts = [];\n\n\t\t\tfor(var j = 0; j < item.parts.length; j++) {\n\t\t\t\tparts.push(addStyle(item.parts[j], options));\n\t\t\t}\n\n\t\t\tstylesInDom[item.id] = {id: item.id, refs: 1, parts: parts};\n\t\t}\n\t}\n}\n\nfunction listToStyles (list, options) {\n\tvar styles = [];\n\tvar newStyles = {};\n\n\tfor (var i = 0; i < list.length; i++) {\n\t\tvar item = list[i];\n\t\tvar id = options.base ? item[0] + options.base : item[0];\n\t\tvar css = item[1];\n\t\tvar media = item[2];\n\t\tvar sourceMap = item[3];\n\t\tvar part = {css: css, media: media, sourceMap: sourceMap};\n\n\t\tif(!newStyles[id]) styles.push(newStyles[id] = {id: id, parts: [part]});\n\t\telse newStyles[id].parts.push(part);\n\t}\n\n\treturn styles;\n}\n\nfunction insertStyleElement (options, style) {\n\tvar target = getElement(options.insertInto)\n\n\tif (!target) {\n\t\tthrow new Error(\"Couldn't find a style target. This probably means that the value for the 'insertInto' parameter is invalid.\");\n\t}\n\n\tvar lastStyleElementInsertedAtTop = stylesInsertedAtTop[stylesInsertedAtTop.length - 1];\n\n\tif (options.insertAt === \"top\") {\n\t\tif (!lastStyleElementInsertedAtTop) {\n\t\t\ttarget.insertBefore(style, target.firstChild);\n\t\t} else if (lastStyleElementInsertedAtTop.nextSibling) {\n\t\t\ttarget.insertBefore(style, lastStyleElementInsertedAtTop.nextSibling);\n\t\t} else {\n\t\t\ttarget.appendChild(style);\n\t\t}\n\t\tstylesInsertedAtTop.push(style);\n\t} else if (options.insertAt === \"bottom\") {\n\t\ttarget.appendChild(style);\n\t} else if (typeof options.insertAt === \"object\" && options.insertAt.before) {\n\t\tvar nextSibling = getElement(options.insertAt.before, target);\n\t\ttarget.insertBefore(style, nextSibling);\n\t} else {\n\t\tthrow new Error(\"[Style Loader]\\n\\n Invalid value for parameter 'insertAt' ('options.insertAt') found.\\n Must be 'top', 'bottom', or Object.\\n (https://github.com/webpack-contrib/style-loader#insertat)\\n\");\n\t}\n}\n\nfunction removeStyleElement (style) {\n\tif (style.parentNode === null) return false;\n\tstyle.parentNode.removeChild(style);\n\n\tvar idx = stylesInsertedAtTop.indexOf(style);\n\tif(idx >= 0) {\n\t\tstylesInsertedAtTop.splice(idx, 1);\n\t}\n}\n\nfunction createStyleElement (options) {\n\tvar style = document.createElement(\"style\");\n\n\tif(options.attrs.type === undefined) {\n\t\toptions.attrs.type = \"text/css\";\n\t}\n\n\tif(options.attrs.nonce === undefined) {\n\t\tvar nonce = getNonce();\n\t\tif (nonce) {\n\t\t\toptions.attrs.nonce = nonce;\n\t\t}\n\t}\n\n\taddAttrs(style, options.attrs);\n\tinsertStyleElement(options, style);\n\n\treturn style;\n}\n\nfunction createLinkElement (options) {\n\tvar link = document.createElement(\"link\");\n\n\tif(options.attrs.type === undefined) {\n\t\toptions.attrs.type = \"text/css\";\n\t}\n\toptions.attrs.rel = \"stylesheet\";\n\n\taddAttrs(link, options.attrs);\n\tinsertStyleElement(options, link);\n\n\treturn link;\n}\n\nfunction addAttrs (el, attrs) {\n\tObject.keys(attrs).forEach(function (key) {\n\t\tel.setAttribute(key, attrs[key]);\n\t});\n}\n\nfunction getNonce() {\n\tif (typeof __webpack_nonce__ === 'undefined') {\n\t\treturn null;\n\t}\n\n\treturn __webpack_nonce__;\n}\n\nfunction addStyle (obj, options) {\n\tvar style, update, remove, result;\n\n\t// If a transform function was defined, run it on the css\n\tif (options.transform && obj.css) {\n\t    result = typeof options.transform === 'function'\n\t\t ? options.transform(obj.css) \n\t\t : options.transform.default(obj.css);\n\n\t    if (result) {\n\t    \t// If transform returns a value, use that instead of the original css.\n\t    \t// This allows running runtime transformations on the css.\n\t    \tobj.css = result;\n\t    } else {\n\t    \t// If the transform function returns a falsy value, don't add this css.\n\t    \t// This allows conditional loading of css\n\t    \treturn function() {\n\t    \t\t// noop\n\t    \t};\n\t    }\n\t}\n\n\tif (options.singleton) {\n\t\tvar styleIndex = singletonCounter++;\n\n\t\tstyle = singleton || (singleton = createStyleElement(options));\n\n\t\tupdate = applyToSingletonTag.bind(null, style, styleIndex, false);\n\t\tremove = applyToSingletonTag.bind(null, style, styleIndex, true);\n\n\t} else if (\n\t\tobj.sourceMap &&\n\t\ttypeof URL === \"function\" &&\n\t\ttypeof URL.createObjectURL === \"function\" &&\n\t\ttypeof URL.revokeObjectURL === \"function\" &&\n\t\ttypeof Blob === \"function\" &&\n\t\ttypeof btoa === \"function\"\n\t) {\n\t\tstyle = createLinkElement(options);\n\t\tupdate = updateLink.bind(null, style, options);\n\t\tremove = function () {\n\t\t\tremoveStyleElement(style);\n\n\t\t\tif(style.href) URL.revokeObjectURL(style.href);\n\t\t};\n\t} else {\n\t\tstyle = createStyleElement(options);\n\t\tupdate = applyToTag.bind(null, style);\n\t\tremove = function () {\n\t\t\tremoveStyleElement(style);\n\t\t};\n\t}\n\n\tupdate(obj);\n\n\treturn function updateStyle (newObj) {\n\t\tif (newObj) {\n\t\t\tif (\n\t\t\t\tnewObj.css === obj.css &&\n\t\t\t\tnewObj.media === obj.media &&\n\t\t\t\tnewObj.sourceMap === obj.sourceMap\n\t\t\t) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tupdate(obj = newObj);\n\t\t} else {\n\t\t\tremove();\n\t\t}\n\t};\n}\n\nvar replaceText = (function () {\n\tvar textStore = [];\n\n\treturn function (index, replacement) {\n\t\ttextStore[index] = replacement;\n\n\t\treturn textStore.filter(Boolean).join('\\n');\n\t};\n})();\n\nfunction applyToSingletonTag (style, index, remove, obj) {\n\tvar css = remove ? \"\" : obj.css;\n\n\tif (style.styleSheet) {\n\t\tstyle.styleSheet.cssText = replaceText(index, css);\n\t} else {\n\t\tvar cssNode = document.createTextNode(css);\n\t\tvar childNodes = style.childNodes;\n\n\t\tif (childNodes[index]) style.removeChild(childNodes[index]);\n\n\t\tif (childNodes.length) {\n\t\t\tstyle.insertBefore(cssNode, childNodes[index]);\n\t\t} else {\n\t\t\tstyle.appendChild(cssNode);\n\t\t}\n\t}\n}\n\nfunction applyToTag (style, obj) {\n\tvar css = obj.css;\n\tvar media = obj.media;\n\n\tif(media) {\n\t\tstyle.setAttribute(\"media\", media)\n\t}\n\n\tif(style.styleSheet) {\n\t\tstyle.styleSheet.cssText = css;\n\t} else {\n\t\twhile(style.firstChild) {\n\t\t\tstyle.removeChild(style.firstChild);\n\t\t}\n\n\t\tstyle.appendChild(document.createTextNode(css));\n\t}\n}\n\nfunction updateLink (link, options, obj) {\n\tvar css = obj.css;\n\tvar sourceMap = obj.sourceMap;\n\n\t/*\n\t\tIf convertToAbsoluteUrls isn't defined, but sourcemaps are enabled\n\t\tand there is no publicPath defined then lets turn convertToAbsoluteUrls\n\t\ton by default.  Otherwise default to the convertToAbsoluteUrls option\n\t\tdirectly\n\t*/\n\tvar autoFixUrls = options.convertToAbsoluteUrls === undefined && sourceMap;\n\n\tif (options.convertToAbsoluteUrls || autoFixUrls) {\n\t\tcss = fixUrls(css);\n\t}\n\n\tif (sourceMap) {\n\t\t// http://stackoverflow.com/a/26603875\n\t\tcss += \"\\n/*# sourceMappingURL=data:application/json;base64,\" + btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))) + \" */\";\n\t}\n\n\tvar blob = new Blob([css], { type: \"text/css\" });\n\n\tvar oldSrc = link.href;\n\n\tlink.href = URL.createObjectURL(blob);\n\n\tif(oldSrc) URL.revokeObjectURL(oldSrc);\n}\n","\n/**\n * When source maps are enabled, `style-loader` uses a link element with a data-uri to\n * embed the css on the page. This breaks all relative urls because now they are relative to a\n * bundle instead of the current page.\n *\n * One solution is to only use full urls, but that may be impossible.\n *\n * Instead, this function \"fixes\" the relative urls to be absolute according to the current page location.\n *\n * A rudimentary test suite is located at `test/fixUrls.js` and can be run via the `npm test` command.\n *\n */\n\nmodule.exports = function (css) {\n  // get current location\n  var location = typeof window !== \"undefined\" && window.location;\n\n  if (!location) {\n    throw new Error(\"fixUrls requires window.location\");\n  }\n\n\t// blank or null?\n\tif (!css || typeof css !== \"string\") {\n\t  return css;\n  }\n\n  var baseUrl = location.protocol + \"//\" + location.host;\n  var currentDir = baseUrl + location.pathname.replace(/\\/[^\\/]*$/, \"/\");\n\n\t// convert each url(...)\n\t/*\n\tThis regular expression is just a way to recursively match brackets within\n\ta string.\n\n\t /url\\s*\\(  = Match on the word \"url\" with any whitespace after it and then a parens\n\t   (  = Start a capturing group\n\t     (?:  = Start a non-capturing group\n\t         [^)(]  = Match anything that isn't a parentheses\n\t         |  = OR\n\t         \\(  = Match a start parentheses\n\t             (?:  = Start another non-capturing groups\n\t                 [^)(]+  = Match anything that isn't a parentheses\n\t                 |  = OR\n\t                 \\(  = Match a start parentheses\n\t                     [^)(]*  = Match anything that isn't a parentheses\n\t                 \\)  = Match a end parentheses\n\t             )  = End Group\n              *\\) = Match anything and then a close parens\n          )  = Close non-capturing group\n          *  = Match anything\n       )  = Close capturing group\n\t \\)  = Match a close parens\n\n\t /gi  = Get all matches, not the first.  Be case insensitive.\n\t */\n\tvar fixedCss = css.replace(/url\\s*\\(((?:[^)(]|\\((?:[^)(]+|\\([^)(]*\\))*\\))*)\\)/gi, function(fullMatch, origUrl) {\n\t\t// strip quotes (if they exist)\n\t\tvar unquotedOrigUrl = origUrl\n\t\t\t.trim()\n\t\t\t.replace(/^\"(.*)\"$/, function(o, $1){ return $1; })\n\t\t\t.replace(/^'(.*)'$/, function(o, $1){ return $1; });\n\n\t\t// already a full url? no change\n\t\tif (/^(#|data:|http:\\/\\/|https:\\/\\/|file:\\/\\/\\/|\\s*$)/i.test(unquotedOrigUrl)) {\n\t\t  return fullMatch;\n\t\t}\n\n\t\t// convert the url to a full url\n\t\tvar newUrl;\n\n\t\tif (unquotedOrigUrl.indexOf(\"//\") === 0) {\n\t\t  \t//TODO: should we add protocol?\n\t\t\tnewUrl = unquotedOrigUrl;\n\t\t} else if (unquotedOrigUrl.indexOf(\"/\") === 0) {\n\t\t\t// path should be relative to the base url\n\t\t\tnewUrl = baseUrl + unquotedOrigUrl; // already starts with '/'\n\t\t} else {\n\t\t\t// path should be relative to current directory\n\t\t\tnewUrl = currentDir + unquotedOrigUrl.replace(/^\\.\\//, \"\"); // Strip leading './'\n\t\t}\n\n\t\t// send back the fixed url(...)\n\t\treturn \"url(\" + JSON.stringify(newUrl) + \")\";\n\t});\n\n\t// send back the fixed css\n\treturn fixedCss;\n};\n"],"sourceRoot":""}