{"version":3,"sources":["webpack://Polecat/webpack/universalModuleDefinition","webpack://Polecat/webpack/bootstrap","webpack://Polecat/delegated ./node_modules/react/index.js from dll-reference vendor","webpack://Polecat/delegated ./node_modules/prop-types/index.js from dll-reference vendor","webpack://Polecat/delegated ./node_modules/react-intl/lib/index.es.js from dll-reference vendor","webpack://Polecat/delegated ./node_modules/lodash/lodash.js from dll-reference vendor","webpack://Polecat/external \"vendor\"","webpack://Polecat/./node_modules/fscreen/lib/index.js","webpack://Polecat/delegated ./node_modules/react-dom/index.js from dll-reference vendor","webpack://Polecat/delegated ./node_modules/history/esm/history.js from dll-reference vendor","webpack://Polecat/./src/lib/i18n/format-message.js","webpack://Polecat/delegated ./node_modules/intl-messageformat/lib/index.js from dll-reference vendor","webpack://Polecat/./src/lib/history-provider.js","webpack://Polecat/./src/lib/i18n/translation-key-wrapper.js","webpack://Polecat/./src/lib/i18n/configured-i18n-provider-component.js","webpack://Polecat/./src/lib/i18n/index.js","webpack://Polecat/./node_modules/core-js/stable/index.js","webpack://Polecat/delegated ./node_modules/core-js/es/index.js from dll-reference vendor","webpack://Polecat/delegated ./node_modules/core-js/web/index.js from dll-reference vendor","webpack://Polecat/delegated ./node_modules/core-js/internals/path.js from dll-reference vendor","webpack://Polecat/./node_modules/regenerator-runtime/runtime.js","webpack://Polecat/./src/lib/url/url.js","webpack://Polecat/./src/router.js","webpack://Polecat/delegated ./node_modules/classnames/index.js from dll-reference vendor","webpack://Polecat/delegated ./node_modules/intl/index.js from dll-reference vendor","webpack://Polecat/./outer-sharing-frame/fullscreen-button/fullscreen-button.scss","webpack://Polecat/./outer-sharing-frame/outer-frame-control-style.scss","webpack://Polecat/./outer-sharing-frame/fullscreen-button/fullscreen-button-component.js","webpack://Polecat/./outer-sharing-frame/fullscreen-button/index.js","webpack://Polecat/./outer-sharing-frame/outer-frame-control-component.js","webpack://Polecat/./outer-sharing-frame/index.js"],"names":["root","factory","exports","module","define","amd","window","installedModules","__webpack_require__","moduleId","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","vendor","fullscreenEnabled","fullscreenElement","requestFullscreen","exitFullscreen","fullscreenchange","fullscreenerror","webkit","moz","ms","document","keys","default","element","requestFullscreenFunction","addEventListener","type","handler","options","removeEventListener","Boolean","val","toLowerCase","formatMessage","values","content","Content","item","isUndefined","message","MessageFormat","format","HistoryProvider","history","this","props","children","Component","childContextTypes","PropTypes","propTypes","node","translationKeyWrapper","DecoratedComponent","WrappedComponent","data-t","id","string","isRequired","ConfiguredI18NProviderComponent","locale","messages","translations","FormattedMessage","IntlFormattedMessage","FormattedHTMLMessage","IntlFormattedHTMLMessage","displayName","runtime","undefined","Op","hasOwn","$Symbol","iteratorSymbol","iterator","asyncIteratorSymbol","asyncIterator","toStringTagSymbol","wrap","innerFn","outerFn","self","tryLocsList","protoGenerator","Generator","generator","context","Context","_invoke","state","GenStateSuspendedStart","method","arg","GenStateExecuting","Error","GenStateCompleted","doneResult","delegate","delegateResult","maybeInvokeDelegate","ContinueSentinel","sent","_sent","dispatchException","abrupt","record","tryCatch","done","GenStateSuspendedYield","makeInvokeMethod","fn","obj","err","GeneratorFunction","GeneratorFunctionPrototype","IteratorPrototype","getProto","getPrototypeOf","NativeIteratorPrototype","Gp","defineIteratorMethods","forEach","AsyncIterator","previousPromise","callInvokeWithMethodAndArg","Promise","resolve","reject","invoke","result","__await","then","unwrapped","error","TypeError","info","resultName","next","nextLoc","pushTryEntry","locs","entry","tryLoc","catchLoc","finallyLoc","afterLoc","tryEntries","push","resetTryEntry","completion","reset","iterable","iteratorMethod","isNaN","length","constructor","isGeneratorFunction","genFun","ctor","mark","setPrototypeOf","__proto__","awrap","async","iter","toString","reverse","pop","skipTempReset","prev","charAt","slice","stop","rootRecord","rval","exception","handle","loc","caught","hasCatch","hasFinally","finallyEntry","complete","finish","thrown","delegateYield","regeneratorRuntime","accidentalStrictMode","Function","splitQueryString","query","list","replace","split","reduce","acc","joinQueryParams","params","index","createBrowserHistory","navigate","path","router","goBack","getHistory","getQueryParams","search","location","getQueryParam","param","setQueryParam","pathname","queryParams","removeQueryParam","FullscreenButton","isPointerActive","isFullscreen","enableClickAnywhere","onEnterFullscreen","onExitFullscreen","icon","className","title","classNames","styles","button","idle","onClick","PureComponent","bool","func","OuterFrameControlComponent","idleTimer","bindAll","iframe","getIframe","fscreen","handleFullscreenChange","style","pointerEvents","handleClickAnywhere","handleMouseMove","onMessageReceived","setTimeout","setState","clearTimeout","e","stopPropagation","body","iframeWindow","contentWindow","postMessage","data","reload","getElementById","fullscreenButton","handleEnterFullscreen","handleExitFullscreen","OuterFrameControl","domHost","ReactDOM","render","unmountComponentAtNode"],"mappings":"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","file":"outersharingframe.ae2a02b620177bad0c25.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([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"Polecat\"] = factory();\n\telse\n\t\troot[\"Polecat\"] = factory();\n})(window, function() {\nreturn "," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 908);\n","module.exports = (__webpack_require__(28))(0);","module.exports = (__webpack_require__(28))(1);","module.exports = (__webpack_require__(28))(1327);","module.exports = (__webpack_require__(28))(1116);","module.exports = vendor;","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nvar key = {\n  fullscreenEnabled: 0,\n  fullscreenElement: 1,\n  requestFullscreen: 2,\n  exitFullscreen: 3,\n  fullscreenchange: 4,\n  fullscreenerror: 5\n};\n\nvar webkit = ['webkitFullscreenEnabled', 'webkitFullscreenElement', 'webkitRequestFullscreen', 'webkitExitFullscreen', 'webkitfullscreenchange', 'webkitfullscreenerror'];\n\nvar moz = ['mozFullScreenEnabled', 'mozFullScreenElement', 'mozRequestFullScreen', 'mozCancelFullScreen', 'mozfullscreenchange', 'mozfullscreenerror'];\n\nvar ms = ['msFullscreenEnabled', 'msFullscreenElement', 'msRequestFullscreen', 'msExitFullscreen', 'MSFullscreenChange', 'MSFullscreenError'];\n\n// so it doesn't throw if no window or document\nvar document = typeof window !== 'undefined' && typeof window.document !== 'undefined' ? window.document : {};\n\nvar vendor = 'fullscreenEnabled' in document && Object.keys(key) || webkit[0] in document && webkit || moz[0] in document && moz || ms[0] in document && ms || [];\n\nexports.default = {\n  requestFullscreen: function requestFullscreen(element) {\n    return element[vendor[key.requestFullscreen]]();\n  },\n  requestFullscreenFunction: function requestFullscreenFunction(element) {\n    return element[vendor[key.requestFullscreen]];\n  },\n  get exitFullscreen() {\n    return document[vendor[key.exitFullscreen]].bind(document);\n  },\n  addEventListener: function addEventListener(type, handler, options) {\n    return document.addEventListener(vendor[key[type]], handler, options);\n  },\n  removeEventListener: function removeEventListener(type, handler, options) {\n    return document.removeEventListener(vendor[key[type]], handler, options);\n  },\n  get fullscreenEnabled() {\n    return Boolean(document[vendor[key.fullscreenEnabled]]);\n  },\n  set fullscreenEnabled(val) {},\n  get fullscreenElement() {\n    return document[vendor[key.fullscreenElement]];\n  },\n  set fullscreenElement(val) {},\n  get onfullscreenchange() {\n    return document[('on' + vendor[key.fullscreenchange]).toLowerCase()];\n  },\n  set onfullscreenchange(handler) {\n    return document[('on' + vendor[key.fullscreenchange]).toLowerCase()] = handler;\n  },\n  get onfullscreenerror() {\n    return document[('on' + vendor[key.fullscreenerror]).toLowerCase()];\n  },\n  set onfullscreenerror(handler) {\n    return document[('on' + vendor[key.fullscreenerror]).toLowerCase()] = handler;\n  }\n};","module.exports = (__webpack_require__(28))(175);","module.exports = (__webpack_require__(28))(115);","import MessageFormat from 'intl-messageformat';\nimport { isUndefined } from 'lodash';\nimport Content from '../../../content/default.json';\n\nconst formatMessage = (key, values, content = Content) => {\n  const item = content[key];\n  if (isUndefined(item)) {\n    return key;\n  }\n\n  const message = new MessageFormat(item, 'en');\n  return message.format(values);\n};\n\nexport { formatMessage };\n","module.exports = (__webpack_require__(28))(1108);","import PropTypes from 'prop-types';\nimport { Component } from 'react';\nimport { history } from '../router';\n\nclass HistoryProvider extends Component {\n  getChildContext() {\n    return { history };\n  }\n\n  render() {\n    const { children } = this.props;\n    return children;\n  }\n}\n\nHistoryProvider.childContextTypes = {\n  history: PropTypes.object,\n};\n\nHistoryProvider.propTypes = { children: PropTypes.node };\n\nexport default HistoryProvider;\n","import PropTypes from 'prop-types';\nimport React from 'react';\n\n/*\n * Components can be wrapped with a translationKeyWrapper which\n * adds a span that shows the translation id in a data-t attribute.\n * That way people can easily look up translations in the content files.\n */\nfunction translationKeyWrapper(DecoratedComponent) {\n  const WrappedComponent = props => (\n    <span data-t={props.id}>\n      <DecoratedComponent {...props} />\n    </span>\n  );\n\n  WrappedComponent.propTypes = {\n    ...DecoratedComponent.propTypes,\n    id: PropTypes.string.isRequired,\n  };\n\n  return WrappedComponent;\n}\n\nexport default translationKeyWrapper;\n","import PropTypes from 'prop-types';\nimport React from 'react';\nimport { IntlProvider } from 'react-intl';\nimport translations from '../../../content/default.json';\n\n// Gives the child tree access to the translation dictionary\nconst ConfiguredI18NProviderComponent = ({ children }) => (\n  <IntlProvider locale=\"en\" messages={translations}>\n    {children}\n  </IntlProvider>\n);\n\nConfiguredI18NProviderComponent.propTypes = {\n  children: PropTypes.node,\n};\n\nexport default ConfiguredI18NProviderComponent;\n","import translationKeyWrapper from './translation-key-wrapper';\nimport {\n  FormattedMessage as IntlFormattedMessage,\n  FormattedHTMLMessage as IntlFormattedHTMLMessage,\n} from 'react-intl';\nimport { formatMessage } from './format-message';\nimport ConfiguredI18NProvider from './configured-i18n-provider-component';\n\nconst FormattedMessage = translationKeyWrapper(IntlFormattedMessage);\nconst FormattedHTMLMessage = translationKeyWrapper(IntlFormattedHTMLMessage);\n\nFormattedMessage.displayName = 'FormattedMessage';\nFormattedHTMLMessage.displayName = 'FormattedHTMLMessage';\n\n// formatMessage is exposed to gecko-js\nexport {\n  FormattedMessage as default,\n  FormattedHTMLMessage,\n  formatMessage,\n  ConfiguredI18NProvider,\n};\n","require('../es');\nrequire('../web');\n\nmodule.exports = require('../internals/path');\n","module.exports = (__webpack_require__(28))(738);","module.exports = (__webpack_require__(28))(1086);","module.exports = (__webpack_require__(28))(131);","/**\n * Copyright (c) 2014-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nvar runtime = (function (exports) {\n  \"use strict\";\n\n  var Op = Object.prototype;\n  var hasOwn = Op.hasOwnProperty;\n  var undefined; // More compressible than void 0.\n  var $Symbol = typeof Symbol === \"function\" ? Symbol : {};\n  var iteratorSymbol = $Symbol.iterator || \"@@iterator\";\n  var asyncIteratorSymbol = $Symbol.asyncIterator || \"@@asyncIterator\";\n  var toStringTagSymbol = $Symbol.toStringTag || \"@@toStringTag\";\n\n  function wrap(innerFn, outerFn, self, tryLocsList) {\n    // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.\n    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;\n    var generator = Object.create(protoGenerator.prototype);\n    var context = new Context(tryLocsList || []);\n\n    // The ._invoke method unifies the implementations of the .next,\n    // .throw, and .return methods.\n    generator._invoke = makeInvokeMethod(innerFn, self, context);\n\n    return generator;\n  }\n  exports.wrap = wrap;\n\n  // Try/catch helper to minimize deoptimizations. Returns a completion\n  // record like context.tryEntries[i].completion. This interface could\n  // have been (and was previously) designed to take a closure to be\n  // invoked without arguments, but in all the cases we care about we\n  // already have an existing method we want to call, so there's no need\n  // to create a new function object. We can even get away with assuming\n  // the method takes exactly one argument, since that happens to be true\n  // in every case, so we don't have to touch the arguments object. The\n  // only additional allocation required is the completion record, which\n  // has a stable shape and so hopefully should be cheap to allocate.\n  function tryCatch(fn, obj, arg) {\n    try {\n      return { type: \"normal\", arg: fn.call(obj, arg) };\n    } catch (err) {\n      return { type: \"throw\", arg: err };\n    }\n  }\n\n  var GenStateSuspendedStart = \"suspendedStart\";\n  var GenStateSuspendedYield = \"suspendedYield\";\n  var GenStateExecuting = \"executing\";\n  var GenStateCompleted = \"completed\";\n\n  // Returning this object from the innerFn has the same effect as\n  // breaking out of the dispatch switch statement.\n  var ContinueSentinel = {};\n\n  // Dummy constructor functions that we use as the .constructor and\n  // .constructor.prototype properties for functions that return Generator\n  // objects. For full spec compliance, you may wish to configure your\n  // minifier not to mangle the names of these two functions.\n  function Generator() {}\n  function GeneratorFunction() {}\n  function GeneratorFunctionPrototype() {}\n\n  // This is a polyfill for %IteratorPrototype% for environments that\n  // don't natively support it.\n  var IteratorPrototype = {};\n  IteratorPrototype[iteratorSymbol] = function () {\n    return this;\n  };\n\n  var getProto = Object.getPrototypeOf;\n  var NativeIteratorPrototype = getProto && getProto(getProto(values([])));\n  if (NativeIteratorPrototype &&\n      NativeIteratorPrototype !== Op &&\n      hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {\n    // This environment has a native %IteratorPrototype%; use it instead\n    // of the polyfill.\n    IteratorPrototype = NativeIteratorPrototype;\n  }\n\n  var Gp = GeneratorFunctionPrototype.prototype =\n    Generator.prototype = Object.create(IteratorPrototype);\n  GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;\n  GeneratorFunctionPrototype.constructor = GeneratorFunction;\n  GeneratorFunctionPrototype[toStringTagSymbol] =\n    GeneratorFunction.displayName = \"GeneratorFunction\";\n\n  // Helper for defining the .next, .throw, and .return methods of the\n  // Iterator interface in terms of a single ._invoke method.\n  function defineIteratorMethods(prototype) {\n    [\"next\", \"throw\", \"return\"].forEach(function(method) {\n      prototype[method] = function(arg) {\n        return this._invoke(method, arg);\n      };\n    });\n  }\n\n  exports.isGeneratorFunction = function(genFun) {\n    var ctor = typeof genFun === \"function\" && genFun.constructor;\n    return ctor\n      ? ctor === GeneratorFunction ||\n        // For the native GeneratorFunction constructor, the best we can\n        // do is to check its .name property.\n        (ctor.displayName || ctor.name) === \"GeneratorFunction\"\n      : false;\n  };\n\n  exports.mark = function(genFun) {\n    if (Object.setPrototypeOf) {\n      Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);\n    } else {\n      genFun.__proto__ = GeneratorFunctionPrototype;\n      if (!(toStringTagSymbol in genFun)) {\n        genFun[toStringTagSymbol] = \"GeneratorFunction\";\n      }\n    }\n    genFun.prototype = Object.create(Gp);\n    return genFun;\n  };\n\n  // Within the body of any async function, `await x` is transformed to\n  // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test\n  // `hasOwn.call(value, \"__await\")` to determine if the yielded value is\n  // meant to be awaited.\n  exports.awrap = function(arg) {\n    return { __await: arg };\n  };\n\n  function AsyncIterator(generator) {\n    function invoke(method, arg, resolve, reject) {\n      var record = tryCatch(generator[method], generator, arg);\n      if (record.type === \"throw\") {\n        reject(record.arg);\n      } else {\n        var result = record.arg;\n        var value = result.value;\n        if (value &&\n            typeof value === \"object\" &&\n            hasOwn.call(value, \"__await\")) {\n          return Promise.resolve(value.__await).then(function(value) {\n            invoke(\"next\", value, resolve, reject);\n          }, function(err) {\n            invoke(\"throw\", err, resolve, reject);\n          });\n        }\n\n        return Promise.resolve(value).then(function(unwrapped) {\n          // When a yielded Promise is resolved, its final value becomes\n          // the .value of the Promise<{value,done}> result for the\n          // current iteration.\n          result.value = unwrapped;\n          resolve(result);\n        }, function(error) {\n          // If a rejected Promise was yielded, throw the rejection back\n          // into the async generator function so it can be handled there.\n          return invoke(\"throw\", error, resolve, reject);\n        });\n      }\n    }\n\n    var previousPromise;\n\n    function enqueue(method, arg) {\n      function callInvokeWithMethodAndArg() {\n        return new Promise(function(resolve, reject) {\n          invoke(method, arg, resolve, reject);\n        });\n      }\n\n      return previousPromise =\n        // If enqueue has been called before, then we want to wait until\n        // all previous Promises have been resolved before calling invoke,\n        // so that results are always delivered in the correct order. If\n        // enqueue has not been called before, then it is important to\n        // call invoke immediately, without waiting on a callback to fire,\n        // so that the async generator function has the opportunity to do\n        // any necessary setup in a predictable way. This predictability\n        // is why the Promise constructor synchronously invokes its\n        // executor callback, and why async functions synchronously\n        // execute code before the first await. Since we implement simple\n        // async functions in terms of async generators, it is especially\n        // important to get this right, even though it requires care.\n        previousPromise ? previousPromise.then(\n          callInvokeWithMethodAndArg,\n          // Avoid propagating failures to Promises returned by later\n          // invocations of the iterator.\n          callInvokeWithMethodAndArg\n        ) : callInvokeWithMethodAndArg();\n    }\n\n    // Define the unified helper method that is used to implement .next,\n    // .throw, and .return (see defineIteratorMethods).\n    this._invoke = enqueue;\n  }\n\n  defineIteratorMethods(AsyncIterator.prototype);\n  AsyncIterator.prototype[asyncIteratorSymbol] = function () {\n    return this;\n  };\n  exports.AsyncIterator = AsyncIterator;\n\n  // Note that simple async functions are implemented on top of\n  // AsyncIterator objects; they just return a Promise for the value of\n  // the final result produced by the iterator.\n  exports.async = function(innerFn, outerFn, self, tryLocsList) {\n    var iter = new AsyncIterator(\n      wrap(innerFn, outerFn, self, tryLocsList)\n    );\n\n    return exports.isGeneratorFunction(outerFn)\n      ? iter // If outerFn is a generator, return the full iterator.\n      : iter.next().then(function(result) {\n          return result.done ? result.value : iter.next();\n        });\n  };\n\n  function makeInvokeMethod(innerFn, self, context) {\n    var state = GenStateSuspendedStart;\n\n    return function invoke(method, arg) {\n      if (state === GenStateExecuting) {\n        throw new Error(\"Generator is already running\");\n      }\n\n      if (state === GenStateCompleted) {\n        if (method === \"throw\") {\n          throw arg;\n        }\n\n        // Be forgiving, per 25.3.3.3.3 of the spec:\n        // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume\n        return doneResult();\n      }\n\n      context.method = method;\n      context.arg = arg;\n\n      while (true) {\n        var delegate = context.delegate;\n        if (delegate) {\n          var delegateResult = maybeInvokeDelegate(delegate, context);\n          if (delegateResult) {\n            if (delegateResult === ContinueSentinel) continue;\n            return delegateResult;\n          }\n        }\n\n        if (context.method === \"next\") {\n          // Setting context._sent for legacy support of Babel's\n          // function.sent implementation.\n          context.sent = context._sent = context.arg;\n\n        } else if (context.method === \"throw\") {\n          if (state === GenStateSuspendedStart) {\n            state = GenStateCompleted;\n            throw context.arg;\n          }\n\n          context.dispatchException(context.arg);\n\n        } else if (context.method === \"return\") {\n          context.abrupt(\"return\", context.arg);\n        }\n\n        state = GenStateExecuting;\n\n        var record = tryCatch(innerFn, self, context);\n        if (record.type === \"normal\") {\n          // If an exception is thrown from innerFn, we leave state ===\n          // GenStateExecuting and loop back for another invocation.\n          state = context.done\n            ? GenStateCompleted\n            : GenStateSuspendedYield;\n\n          if (record.arg === ContinueSentinel) {\n            continue;\n          }\n\n          return {\n            value: record.arg,\n            done: context.done\n          };\n\n        } else if (record.type === \"throw\") {\n          state = GenStateCompleted;\n          // Dispatch the exception by looping back around to the\n          // context.dispatchException(context.arg) call above.\n          context.method = \"throw\";\n          context.arg = record.arg;\n        }\n      }\n    };\n  }\n\n  // Call delegate.iterator[context.method](context.arg) and handle the\n  // result, either by returning a { value, done } result from the\n  // delegate iterator, or by modifying context.method and context.arg,\n  // setting context.delegate to null, and returning the ContinueSentinel.\n  function maybeInvokeDelegate(delegate, context) {\n    var method = delegate.iterator[context.method];\n    if (method === undefined) {\n      // A .throw or .return when the delegate iterator has no .throw\n      // method always terminates the yield* loop.\n      context.delegate = null;\n\n      if (context.method === \"throw\") {\n        // Note: [\"return\"] must be used for ES3 parsing compatibility.\n        if (delegate.iterator[\"return\"]) {\n          // If the delegate iterator has a return method, give it a\n          // chance to clean up.\n          context.method = \"return\";\n          context.arg = undefined;\n          maybeInvokeDelegate(delegate, context);\n\n          if (context.method === \"throw\") {\n            // If maybeInvokeDelegate(context) changed context.method from\n            // \"return\" to \"throw\", let that override the TypeError below.\n            return ContinueSentinel;\n          }\n        }\n\n        context.method = \"throw\";\n        context.arg = new TypeError(\n          \"The iterator does not provide a 'throw' method\");\n      }\n\n      return ContinueSentinel;\n    }\n\n    var record = tryCatch(method, delegate.iterator, context.arg);\n\n    if (record.type === \"throw\") {\n      context.method = \"throw\";\n      context.arg = record.arg;\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    var info = record.arg;\n\n    if (! info) {\n      context.method = \"throw\";\n      context.arg = new TypeError(\"iterator result is not an object\");\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    if (info.done) {\n      // Assign the result of the finished delegate to the temporary\n      // variable specified by delegate.resultName (see delegateYield).\n      context[delegate.resultName] = info.value;\n\n      // Resume execution at the desired location (see delegateYield).\n      context.next = delegate.nextLoc;\n\n      // If context.method was \"throw\" but the delegate handled the\n      // exception, let the outer generator proceed normally. If\n      // context.method was \"next\", forget context.arg since it has been\n      // \"consumed\" by the delegate iterator. If context.method was\n      // \"return\", allow the original .return call to continue in the\n      // outer generator.\n      if (context.method !== \"return\") {\n        context.method = \"next\";\n        context.arg = undefined;\n      }\n\n    } else {\n      // Re-yield the result returned by the delegate method.\n      return info;\n    }\n\n    // The delegate iterator is finished, so forget it and continue with\n    // the outer generator.\n    context.delegate = null;\n    return ContinueSentinel;\n  }\n\n  // Define Generator.prototype.{next,throw,return} in terms of the\n  // unified ._invoke helper method.\n  defineIteratorMethods(Gp);\n\n  Gp[toStringTagSymbol] = \"Generator\";\n\n  // A Generator should always return itself as the iterator object when the\n  // @@iterator function is called on it. Some browsers' implementations of the\n  // iterator prototype chain incorrectly implement this, causing the Generator\n  // object to not be returned from this call. This ensures that doesn't happen.\n  // See https://github.com/facebook/regenerator/issues/274 for more details.\n  Gp[iteratorSymbol] = function() {\n    return this;\n  };\n\n  Gp.toString = function() {\n    return \"[object Generator]\";\n  };\n\n  function pushTryEntry(locs) {\n    var entry = { tryLoc: locs[0] };\n\n    if (1 in locs) {\n      entry.catchLoc = locs[1];\n    }\n\n    if (2 in locs) {\n      entry.finallyLoc = locs[2];\n      entry.afterLoc = locs[3];\n    }\n\n    this.tryEntries.push(entry);\n  }\n\n  function resetTryEntry(entry) {\n    var record = entry.completion || {};\n    record.type = \"normal\";\n    delete record.arg;\n    entry.completion = record;\n  }\n\n  function Context(tryLocsList) {\n    // The root entry object (effectively a try statement without a catch\n    // or a finally block) gives us a place to store values thrown from\n    // locations where there is no enclosing try statement.\n    this.tryEntries = [{ tryLoc: \"root\" }];\n    tryLocsList.forEach(pushTryEntry, this);\n    this.reset(true);\n  }\n\n  exports.keys = function(object) {\n    var keys = [];\n    for (var key in object) {\n      keys.push(key);\n    }\n    keys.reverse();\n\n    // Rather than returning an object with a next method, we keep\n    // things simple and return the next function itself.\n    return function next() {\n      while (keys.length) {\n        var key = keys.pop();\n        if (key in object) {\n          next.value = key;\n          next.done = false;\n          return next;\n        }\n      }\n\n      // To avoid creating an additional object, we just hang the .value\n      // and .done properties off the next function object itself. This\n      // also ensures that the minifier will not anonymize the function.\n      next.done = true;\n      return next;\n    };\n  };\n\n  function values(iterable) {\n    if (iterable) {\n      var iteratorMethod = iterable[iteratorSymbol];\n      if (iteratorMethod) {\n        return iteratorMethod.call(iterable);\n      }\n\n      if (typeof iterable.next === \"function\") {\n        return iterable;\n      }\n\n      if (!isNaN(iterable.length)) {\n        var i = -1, next = function next() {\n          while (++i < iterable.length) {\n            if (hasOwn.call(iterable, i)) {\n              next.value = iterable[i];\n              next.done = false;\n              return next;\n            }\n          }\n\n          next.value = undefined;\n          next.done = true;\n\n          return next;\n        };\n\n        return next.next = next;\n      }\n    }\n\n    // Return an iterator with no values.\n    return { next: doneResult };\n  }\n  exports.values = values;\n\n  function doneResult() {\n    return { value: undefined, done: true };\n  }\n\n  Context.prototype = {\n    constructor: Context,\n\n    reset: function(skipTempReset) {\n      this.prev = 0;\n      this.next = 0;\n      // Resetting context._sent for legacy support of Babel's\n      // function.sent implementation.\n      this.sent = this._sent = undefined;\n      this.done = false;\n      this.delegate = null;\n\n      this.method = \"next\";\n      this.arg = undefined;\n\n      this.tryEntries.forEach(resetTryEntry);\n\n      if (!skipTempReset) {\n        for (var name in this) {\n          // Not sure about the optimal order of these conditions:\n          if (name.charAt(0) === \"t\" &&\n              hasOwn.call(this, name) &&\n              !isNaN(+name.slice(1))) {\n            this[name] = undefined;\n          }\n        }\n      }\n    },\n\n    stop: function() {\n      this.done = true;\n\n      var rootEntry = this.tryEntries[0];\n      var rootRecord = rootEntry.completion;\n      if (rootRecord.type === \"throw\") {\n        throw rootRecord.arg;\n      }\n\n      return this.rval;\n    },\n\n    dispatchException: function(exception) {\n      if (this.done) {\n        throw exception;\n      }\n\n      var context = this;\n      function handle(loc, caught) {\n        record.type = \"throw\";\n        record.arg = exception;\n        context.next = loc;\n\n        if (caught) {\n          // If the dispatched exception was caught by a catch block,\n          // then let that catch block handle the exception normally.\n          context.method = \"next\";\n          context.arg = undefined;\n        }\n\n        return !! caught;\n      }\n\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        var record = entry.completion;\n\n        if (entry.tryLoc === \"root\") {\n          // Exception thrown outside of any try block that could handle\n          // it, so set the completion value of the entire function to\n          // throw the exception.\n          return handle(\"end\");\n        }\n\n        if (entry.tryLoc <= this.prev) {\n          var hasCatch = hasOwn.call(entry, \"catchLoc\");\n          var hasFinally = hasOwn.call(entry, \"finallyLoc\");\n\n          if (hasCatch && hasFinally) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            } else if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else if (hasCatch) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            }\n\n          } else if (hasFinally) {\n            if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else {\n            throw new Error(\"try statement without catch or finally\");\n          }\n        }\n      }\n    },\n\n    abrupt: function(type, arg) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc <= this.prev &&\n            hasOwn.call(entry, \"finallyLoc\") &&\n            this.prev < entry.finallyLoc) {\n          var finallyEntry = entry;\n          break;\n        }\n      }\n\n      if (finallyEntry &&\n          (type === \"break\" ||\n           type === \"continue\") &&\n          finallyEntry.tryLoc <= arg &&\n          arg <= finallyEntry.finallyLoc) {\n        // Ignore the finally entry if control is not jumping to a\n        // location outside the try/catch block.\n        finallyEntry = null;\n      }\n\n      var record = finallyEntry ? finallyEntry.completion : {};\n      record.type = type;\n      record.arg = arg;\n\n      if (finallyEntry) {\n        this.method = \"next\";\n        this.next = finallyEntry.finallyLoc;\n        return ContinueSentinel;\n      }\n\n      return this.complete(record);\n    },\n\n    complete: function(record, afterLoc) {\n      if (record.type === \"throw\") {\n        throw record.arg;\n      }\n\n      if (record.type === \"break\" ||\n          record.type === \"continue\") {\n        this.next = record.arg;\n      } else if (record.type === \"return\") {\n        this.rval = this.arg = record.arg;\n        this.method = \"return\";\n        this.next = \"end\";\n      } else if (record.type === \"normal\" && afterLoc) {\n        this.next = afterLoc;\n      }\n\n      return ContinueSentinel;\n    },\n\n    finish: function(finallyLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.finallyLoc === finallyLoc) {\n          this.complete(entry.completion, entry.afterLoc);\n          resetTryEntry(entry);\n          return ContinueSentinel;\n        }\n      }\n    },\n\n    \"catch\": function(tryLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc === tryLoc) {\n          var record = entry.completion;\n          if (record.type === \"throw\") {\n            var thrown = record.arg;\n            resetTryEntry(entry);\n          }\n          return thrown;\n        }\n      }\n\n      // The context.catch method must only be called with a location\n      // argument that corresponds to a known catch block.\n      throw new Error(\"illegal catch attempt\");\n    },\n\n    delegateYield: function(iterable, resultName, nextLoc) {\n      this.delegate = {\n        iterator: values(iterable),\n        resultName: resultName,\n        nextLoc: nextLoc\n      };\n\n      if (this.method === \"next\") {\n        // Deliberately forget the last sent value so that we don't\n        // accidentally pass it on to the delegate.\n        this.arg = undefined;\n      }\n\n      return ContinueSentinel;\n    }\n  };\n\n  // Regardless of whether this script is executing as a CommonJS module\n  // or not, return the runtime object so that we can declare the variable\n  // regeneratorRuntime in the outer scope, which allows this module to be\n  // injected easily by `bin/regenerator --include-runtime script.js`.\n  return exports;\n\n}(\n  // If this script is executing as a CommonJS module, use module.exports\n  // as the regeneratorRuntime namespace. Otherwise create a new empty\n  // object. Either way, the resulting object will be used to initialize\n  // the regeneratorRuntime variable at the top of this file.\n  typeof module === \"object\" ? module.exports : {}\n));\n\ntry {\n  regeneratorRuntime = runtime;\n} catch (accidentalStrictMode) {\n  // This module should not be running in strict mode, so the above\n  // assignment should always work unless something is misconfigured. Just\n  // in case runtime.js accidentally runs in strict mode, we can escape\n  // strict mode using a global Function call. This could conceivably fail\n  // if a Content Security Policy forbids using Function, but in that case\n  // the proper solution is to fix the accidental strict mode problem. If\n  // you've misconfigured your bundler to force strict mode and applied a\n  // CSP to forbid Function, and you're not willing to fix either of those\n  // problems, please detail your unique predicament in a GitHub issue.\n  Function(\"r\", \"regeneratorRuntime = r\")(runtime);\n}\n","export const splitQueryString = (query = '') => {\n  if (query.length === 0) {\n    return {};\n  }\n\n  const list = query.replace(/^\\?/, '').split('&');\n\n  return list.reduce((acc, item) => {\n    const [key, value] = item.split('=');\n\n    return { ...acc, [key]: value };\n  }, {});\n};\n\nexport const joinQueryParams = (params = '') => {\n  return Object.keys(params).reduce((acc, key, index) => {\n    return index === 0\n      ? `?${key}=${params[key]}`\n      : `${acc}&${key}=${params[key]}`;\n  }, '');\n};\n","import { createBrowserHistory } from 'history';\nimport { splitQueryString, joinQueryParams } from './lib/url';\n\nconst history = createBrowserHistory();\n\n/**\n * navigate\n *\n * Navigate using client side routing\n *\n * @param {string} path\n */\nconst navigate = path => {\n  history.push(path);\n};\n\n/**\n * getQueryParams\n *\n * Returns values in the query string as key value pairs\n * note: This is currently imported and used by Gecko-JS\n */\nconst getQueryParams = () => {\n  const { search } = history.location;\n  return splitQueryString(search);\n};\n\n/**\n * getQueryParam\n *\n * For a given key returns the value in the query string\n *\n * @param {string} param\n */\nconst getQueryParam = param => {\n  const { search } = history.location;\n  const queryParams = splitQueryString(search);\n  return queryParams[param];\n};\n\n/**\n * setQueryParam\n *\n * Adds an item to the query string\n *\n * @param {string} param\n * @param {string} value\n */\nconst setQueryParam = (param, value) => {\n  const { pathname, search } = history.location;\n  const queryParams = splitQueryString(search);\n\n  queryParams[param] = value;\n\n  history.replace({\n    pathname,\n    search: joinQueryParams(queryParams),\n  });\n};\n\n/**\n * removeQueryParam\n *\n * Removes an item from the query string\n *\n * @param {string} param\n */\nconst removeQueryParam = param => {\n  const { pathname, search } = history.location;\n  const queryParams = splitQueryString(search);\n\n  delete queryParams[param];\n\n  history.replace({\n    pathname,\n    search: joinQueryParams(queryParams),\n  });\n};\n\nconst router = {\n  navigate,\n  goBack: () => history.goBack(),\n  getHistory: () => history,\n  getQueryParams,\n  getQueryParam,\n  setQueryParam,\n  removeQueryParam,\n};\n\n// TODO stop exporting `navigate` directly, it makes spying difficult\nexport { navigate, router, history };\n","module.exports = (__webpack_require__(28))(32);","module.exports = (__webpack_require__(28))(1109);","// extracted by mini-css-extract-plugin\nmodule.exports = {\"button\":\"button---35uUh\",\"idle\":\"idle---2jADW\",\"message\":\"message---1Kl6N\"};","// extracted by mini-css-extract-plugin\nmodule.exports = {\"fullscreenButton\":\"fullscreenButton---1nN1K\"};","import React, { PureComponent } from 'react';\nimport PropTypes from 'prop-types';\nimport classNames from 'classnames';\nimport FormattedMessage, { formatMessage } from '../../src/lib/i18n';\n\nimport styles from './fullscreen-button.scss';\n\nclass FullscreenButton extends PureComponent {\n  render() {\n    const {\n      isPointerActive,\n      isFullscreen,\n      enableClickAnywhere,\n      onEnterFullscreen,\n      onExitFullscreen,\n    } = this.props;\n\n    let message;\n\n    if (enableClickAnywhere) {\n      message = isFullscreen\n        ? <FormattedMessage id=\"button.fullscreen.exit\" />\n        : <FormattedMessage id=\"button.fullscreen.enter\" />;\n    }\n\n    const icon = isFullscreen\n      ? <i className={'fa fa-compress'} />\n      : <i className={'fa fa-expand'} />;\n\n    return (\n      <button\n        title={formatMessage('dashboard.enterFullscreen')}\n        className={classNames(styles.button, {\n          [styles.idle]: !isPointerActive,\n        })}\n        onClick={isFullscreen ? onExitFullscreen : onEnterFullscreen}\n      >\n        <span>\n          {icon}\n          {message &&\n            <span className={styles.message}>\n              {message}\n            </span>}\n        </span>\n      </button>\n    );\n  }\n}\n\nFullscreenButton.propTypes = {\n  isFullscreen: PropTypes.bool,\n  isPointerActive: PropTypes.bool,\n  enableClickAnywhere: PropTypes.bool,\n  onEnterFullscreen: PropTypes.func,\n  onExitFullscreen: PropTypes.func,\n};\n\nexport default FullscreenButton;\n","import FullscreenButton from './fullscreen-button-component';\nexport default FullscreenButton;\n","import React, { PureComponent } from 'react';\nimport PropTypes from 'prop-types';\nimport FullscreenButtonComponent from './fullscreen-button';\nimport fscreen from 'fscreen';\nimport { bindAll } from 'lodash';\n\nimport style from './outer-frame-control-style.scss';\n\nclass OuterFrameControlComponent extends PureComponent {\n  constructor(props) {\n    super(props);\n    this.state = { isFullscreen: this.isFullscreen(), isPointerActive: false };\n    this.idleTimer = null;\n\n    bindAll(this, [\n      'handleClickAnywhere',\n      'handleFullscreenChange',\n      'handleEnterFullscreen',\n      'handleExitFullscreen',\n      'handleMouseMove',\n      'onMessageReceived',\n    ]);\n  }\n\n  componentDidMount() {\n    const iframe = this.getIframe();\n\n    fscreen.addEventListener('fullscreenchange', this.handleFullscreenChange);\n\n    if (this.props.enableClickAnywhere) {\n      // If enableClickAnywhere is enabled, we're disabling all\n      // pointer events on the iframe, so that we can listen to mousemove\n      // and click events of the parent frame\n      iframe.style.pointerEvents = 'none';\n      document.addEventListener('click', this.handleClickAnywhere, true);\n      document.addEventListener('mousemove', this.handleMouseMove, true);\n    }\n\n    window.addEventListener('message', this.onMessageReceived, false);\n\n    if (!this.state.isFullscreen) {\n      this.idleTimer = setTimeout(\n        () => this.setState({ isPointerActive: false }),\n        2000,\n      );\n    }\n  }\n\n  componentWillUnmount() {\n    const iframe = this.getIframe();\n\n    fscreen.removeEventListener(\n      'fullscreenchange',\n      this.handleFullscreenChange,\n    );\n\n    if (this.props.enableClickAnywhere) {\n      iframe.style.pointerEvents = 'auto';\n      document.removeEventListener('click', this.handleClickAnywhere, true);\n      document.removeEventListener('mousemove', this.handleMouseMove, true);\n    }\n\n    window.removeEventListener('message', this.onMessageReceived, false);\n\n    clearTimeout(this.idleTimer);\n  }\n\n  handleClickAnywhere(e) {\n    // Capture event at the top level (document) and stop propagation\n    // to the button element\n    e.stopPropagation();\n    if (this.isFullscreen()) {\n      fscreen.exitFullscreen();\n    } else {\n      fscreen.requestFullscreen(document.body);\n    }\n  }\n\n  handleEnterFullscreen() {\n    fscreen.requestFullscreen(document.body);\n  }\n\n  handleExitFullscreen() {\n    fscreen.exitFullscreen();\n  }\n\n  handleFullscreenChange() {\n    const isFullscreen = this.isFullscreen();\n    const iframeWindow = this.getIframe().contentWindow;\n\n    this.setState({ isFullscreen });\n    iframeWindow.postMessage(\n      { type: 'handleFullscreenChange', isFullscreen },\n      '*',\n    );\n  }\n\n  handleMouseMove() {\n    clearTimeout(this.idleTimer);\n    this.setState({ isPointerActive: true });\n\n    this.idleTimer = setTimeout(\n      () => this.setState({ isPointerActive: false }),\n      2000,\n    );\n  }\n\n  onMessageReceived(message) {\n    switch (message.data.type) {\n      case 'handleMousemove':\n        this.handleMouseMove();\n        break;\n      case 'reloadPage':\n        window.location.reload();\n        break;\n      default:\n        break;\n    }\n  }\n\n  getIframe() {\n    return document.getElementById('gb-dashboard-iframe');\n  }\n\n  render() {\n    return (\n      <div className={style.fullscreenButton}>\n        <FullscreenButtonComponent\n          {...this.props}\n          isPointerActive={this.state.isPointerActive}\n          isFullscreen={this.state.isFullscreen}\n          onEnterFullscreen={this.handleEnterFullscreen}\n          onExitFullscreen={this.handleExitFullscreen}\n        />\n      </div>\n    );\n  }\n\n  isFullscreen() {\n    if (fscreen.fullscreenElement !== null) {\n      return true;\n    }\n\n    return false;\n  }\n}\n\nOuterFrameControlComponent.propTypes = {\n  enableClickAnywhere: PropTypes.bool,\n};\n\nexport default OuterFrameControlComponent;\n","import \"core-js/stable\";\nimport \"regenerator-runtime/runtime\";\n/*\n * Add Intl support for old browsers. 'intl' handles all the Polyfill\n * logic internally so we just need to import it along with the data\n * for locales we want to support. When all browsers that we want\n * to support have native Intl support, we can delete this.\n */\nimport 'intl';\n\nimport React from 'react';\nimport ReactDOM from 'react-dom';\nimport { ConfiguredI18NProvider } from '../src/lib/i18n';\nimport HistoryProvider from '../src/lib/history-provider';\nimport OuterFrameControlComponent from './outer-frame-control-component';\n\nclass OuterFrameControl {\n  constructor(domHost) {\n    this.domHost = domHost;\n  }\n\n  render(props) {\n    ReactDOM.render(\n      <ConfiguredI18NProvider>\n        <HistoryProvider>\n          <OuterFrameControlComponent {...props} />\n        </HistoryProvider>\n      </ConfiguredI18NProvider>,\n      this.domHost,\n    );\n  }\n\n  remove() {\n    ReactDOM.unmountComponentAtNode(this.domHost);\n  }\n}\n\nexport { OuterFrameControl };\n"],"sourceRoot":""}