{"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","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","getGlobal","global","__GLOBAL__","serializeArgs","args","JSON","stringify","Array","subkey","val","obj","WeakMap","uid","set","getObjectID","getEmptyObject","memoizeGlobalIndex","memoizeGlobalIndexValidFrom","memoize","method","simpleCache","thisCache","options","thisNamespace","cacheTime","time","memoizeIndex","memoizedFunction","cache","cacheKey","getOrSet","arguments","cacheResult","now","reset","clear","promisify","promisifiedFunction","ZalgoPromise","inlineMemoize","logic","__inline_memoize_cache__","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","message","constructor","captureStackTrace","stack","isPromise","Promise","Window","then","dispatchedErrors","possiblyUnhandledPromiseHandlers","flushPromise","activeCount","flushActive","promise","resolve","startActive","endActive","handler","resolved","rejected","errorHandled","handlers","isAsync","res","reject","__DEBUG__","asyncReject","promises","count","results","chain","firstPromise","secondPromise","prom","awaitPromises","all","items","map","onPossiblyUnhandledException","context","delay","Zalgo","dispatch","dispatchPossiblyUnhandledError","dispatching","onSuccess","onError","promiseResult","undefined","onFinally","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","getElementsByTagName","reverse","script","src","currentScript","getCurrentScript","currentUID","getAttribute","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","_this","_result","_error","_proto","_this2","_err","_handlers$i","_result2","_this3","toPromise","lazy","_loop","_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","concat","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","e","construct_construct","Parent","Class","a","instance","Function","wrapNativeSuper_wrapNativeSuper","_cache","Map","Wrapper","configurable","_options$thisNamespac","_len","_key","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","_Error","_this6","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.0c088da65e7fb4f40a8c.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([31,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":""}