{"version":3,"sources":["../node_modules/resolve-pathname/esm/resolve-pathname.js","../node_modules/value-equal/esm/value-equal.js","../node_modules/history/esm/history.js","utils/automation-helpers.ts","utils/string-helpers.ts","../node_modules/mobx-react-lite/es/utils.js","utils/array-helper.ts","app-react/components/base-components/orbit-component/orbit-component.ts","../node_modules/mobx-react-lite/es/assertEnvironment.js","../node_modules/mobx-react-lite/es/observerBatching.js","../node_modules/mobx-react-lite/es/staticRendering.js","../node_modules/mobx-react-lite/es/printDebugValue.js","../node_modules/mobx-react-lite/es/reactionCleanupTracking.js","../node_modules/mobx-react-lite/es/useQueuedForceUpdate.js","../node_modules/mobx-react-lite/es/useObserver.js","../node_modules/mobx-react-lite/es/observer.js","../node_modules/mobx-react-lite/es/ObserverComponent.js","../node_modules/mobx-react-lite/es/useAsObservableSource.js","../node_modules/mobx-react-lite/es/index.js","app-react/components/tap-handler/tap-handler.component.tsx","../node_modules/uuid/v4.js","common/utils/time-functions.ts","app-react/services/http/interfaces.ts","app-react/services/http/http.service.ts","app-react/orbit-context.ts","app-react/services/dom/dom.service.ts","utils/Lazy.ts","app-react/services/routing/routing-utils.ts","../node_modules/hoist-non-react-statics/dist/hoist-non-react-statics.cjs.js","../node_modules/tiny-invariant/dist/tiny-invariant.esm.js","app-react/services/routing/route/fallback-route.ts","app-react/services/routing/route/route-base.ts","../node_modules/uuid/lib/rng-browser.js","../node_modules/uuid/lib/bytesToUuid.js","app-react/services/splash/splash.service.ts","app-react/components/raw-components/image/image.tsx","../node_modules/@babel/runtime/helpers/typeof.js","../node_modules/@babel/runtime/helpers/interopRequireDefault.js","../node_modules/mini-create-react-context/dist/esm/index.js","../node_modules/@babel/runtime/helpers/inheritsLoose.js","../node_modules/gud/index.js","../node_modules/path-to-regexp/index.js","../node_modules/isarray/index.js","app-react/components/base-components/orbit-component-with-state/orbit-component-with-state.ts","../node_modules/@babel/runtime/helpers/interopRequireWildcard.js"],"names":["isAbsolute","pathname","charAt","spliceOne","list","index","i","k","n","length","pop","resolvePathname","to","from","undefined","hasTrailingSlash","toParts","split","fromParts","isToAbs","isFromAbs","mustEndAbs","concat","last","up","part","unshift","result","join","substr","valueOf","obj","Object","prototype","call","valueEqual","a","b","Array","isArray","every","item","aValue","bValue","keys","assign","key","createPath","location","search","hash","path","createLocation","state","currentLocation","hashIndex","indexOf","searchIndex","parsePath","_extends","decodeURI","e","URIError","locationsAreEqual","createTransitionManager","prompt","listeners","setPrompt","nextPrompt","confirmTransitionTo","action","getUserConfirmation","callback","appendListener","fn","isActive","listener","apply","arguments","push","filter","notifyListeners","_len","args","_key","forEach","window","document","createElement","clamp","lowerBound","upperBound","Math","min","max","createMemoryHistory","props","_props","_props$initialEntries","initialEntries","_props$initialIndex","initialIndex","_props$keyLength","keyLength","transitionManager","setState","nextState","history","entries","createKey","random","toString","map","entry","createHref","go","nextIndex","ok","nextEntries","slice","splice","replace","goBack","goForward","canGo","block","listen","NamedIntervalType","isInsideAutomation","Check","isNullOrUndefined","mockApplicationStartupConfigs","configs","getCypressToOrbitHooks","onAppStartupConfigs","Error","matchAllWords","text","words","match","removeSpaces","str","removeSpecialCharacters","extractWordsRegularExpressions","word","trim","RegExp","__read","o","m","Symbol","iterator","r","ar","next","done","value","error","useForceUpdate","setTick","useState","useCallback","tick","isPlainObject","proto","getPrototypeOf","getSymbol","name","for","mockGlobal","getGlobal","global","self","splitArrayToChunks","originalArray","chunkSize","arraysEqual","arr1","arr2","shuffle","array","t","floor","OrbitComponent","OrbitComponentWithState","spy","observerBatchingConfiguredSymbol","defaultNoopBatch","globalIsUsingStaticRendering","isUsingStaticRendering","printDebugValue","v","getDependencyTree","reactionCleanupHandle","CLEANUP_LEAKED_REACTIONS_AFTER_MILLIS","uncommittedReactionRefs","Set","ensureCleanupTimerRunning","setTimeout","cleanUncommittedReactions","now","Date","ref","tracking","current","cleanAt","reaction","dispose","delete","size","insideRender","forceUpdateQueue","EMPTY_OBJECT","observerComponentNameFor","baseComponentName","useObserver","options","queuedForceUpdate","forceUpdate","useQueuedForceUpdate","reactionTrackingRef","React","useRef","newReaction_1","Reaction","trackingData_1","mounted","createTrackingData","add","useDebugValue","useEffect","reactionRef","Infinity","queue_1","useLayoutEffect","x","useQueuedForceUpdateBlock","rendering","exception","track","__assign","s","p","hasOwnProperty","this","observer","baseComponent","memoComponent","base","target","realOptions","forwardRef","displayName","wrappedComponent","memo","hoistBlackList","defineProperty","getOwnPropertyDescriptor","$$typeof","render","compare","type","ObserverComponent","_a","children","component","ObserverPropsCheck","componentName","propFullName","extraKey","hasProp","hasExtraProp","propTypes","reactionScheduler","batch","configure","TapHandlerLogic","_element","_timeoutRef","_onClickHandler","classList","ORBIT_TAP","remove","addEventListener","clearTimeout","removeEventListener","TapHandler","_tapHandlerLogic","enabled","elementRef","rng","require","bytesToUuid","module","exports","buf","offset","rnds","ii","namedTimer","handler","interval","intervalType","javascriptFunction","timeSpan","isNumber","TimeSpan","fromMilliseconds","convertToTimeSpan","response","onTimeIntervalCreation","ignoreJavaScriptImplementation","timerId","totalMilliseconds","namedSetInterval","setInterval","namedSetTimeout","HttpError","status","statusText","statusCode","message","HttpService","url","_fetchResponse","fetchedResponse","_parseResponse","URLSearchParams","Headers","method","fetch","contentTypeHeader","headers","get","charset","exec","blob","_decodeBlob","JSON","parse","source","encoding","Promise","resolve","reader","FileReader","onloadend","readAsText","OrbitContext","createContext","OrbitContextProvider","Provider","Consumer","DomService","_eventListenerRegistration","EventListenerRegistration","body","selector","querySelector","head","documentElement","title","className","getElementsByClassName","tagName","getElementsByTagName","id","getElementById","Lazy","_valueFactory","_value","_initializing","isUndefined","_initValue","tryMatchPath","pathToMatch","routes","routeDefinition","j","paths","pattern","matchPath","exact","strict","routeParams","params","reactIs","REACT_STATICS","childContextTypes","contextType","contextTypes","defaultProps","getDefaultProps","getDerivedStateFromError","getDerivedStateFromProps","mixins","KNOWN_STATICS","caller","callee","arity","MEMO_STATICS","TYPE_STATICS","getStatics","isMemo","ForwardRef","getOwnPropertyNames","getOwnPropertySymbols","objectPrototype","hoistNonReactStatics","targetComponent","sourceComponent","blacklist","inheritedComponent","targetStatics","sourceStatics","descriptor","prefix","invariant","condition","FallbackRoute","_routeDefinition","RouteBase","_routeParams","_isOrbitRoute","data","getRandomValues","crypto","bind","msCrypto","rnds8","Uint8Array","byteToHex","bth","SplashService","splashTime","_splashRemovedSubscribers","startTime","parseFloat","performance","toFixed","isNull","splashPageElement","computeSplashTimeInSeconds","console","IMAGE_TYPE","IMAGE_STATUS","EMPTY_IMAGE","Image","_onLoad","LAZY","LOADING","SETTLED","SRC","onLoad","onSettled","_onError","FALLBACK","src","EMPTY_IMAGE_BASE64","fallbackSrc","onError","_intersectionObserver","_intersectionObserverCallback","intersectionRatio","isIntersecting","_destroyIntersectionObserver","onLoadStart","_captureImageElementRef","element","_createTapLogicHandler","_createIntersectionObserver","_getInitialSrcState","lazy","_destroyTapLogicHandler","prevProps","enableTap","IntersectionObserver","root","services","mainScreen","mainScreenElement","rootMargin","threshold","observe","disconnect","alt","width","height","onClick","_typeof","constructor","__esModule","MAX_SIGNED_31_BIT_INT","createEventEmitter","handlers","on","off","h","set","newValue","changedBits","defaultValue","calculateChangedBits","_Provider$childContex","_Consumer$contextType","contextProp","gud","_Component","_this","emitter","_inheritsLoose","_proto","getChildContext","_ref","componentWillReceiveProps","nextProps","oldValue","y","Component","PropTypes","object","isRequired","_Component2","_this2","getValue","onUpdate","observedBits","_proto2","componentDidMount","context","componentWillUnmount","subClass","superClass","create","__proto__","isarray","pathToRegexp","compile","tokensToFunction","tokensToRegExp","PATH_REGEXP","res","tokens","defaultDelimiter","delimiter","escaped","capture","group","modifier","asterisk","partial","repeat","optional","escapeGroup","escapeString","encodeURIComponentPretty","encodeURI","c","charCodeAt","toUpperCase","matches","flags","opts","encode","pretty","encodeURIComponent","token","segment","TypeError","stringify","test","attachKeys","re","sensitive","end","route","endsWithDelimiter","groups","regexpToRegexp","parts","arrayToRegexp","stringToRegexp","arr","_reactions","_disposeReactions","expression","effect","disposer","mobxReaction","_getRequireWildcardCache","WeakMap","cache","has","newObj","hasPropertyDescriptor","desc"],"mappings":"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","file":"static/js/launcher~orbit-main.c8503dc7.chunk.js","sourcesContent":["function isAbsolute(pathname) {\n  return pathname.charAt(0) === '/';\n}\n\n// About 1.5x faster than the two-arg version of Array#splice()\nfunction spliceOne(list, index) {\n  for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1) {\n    list[i] = list[k];\n  }\n\n  list.pop();\n}\n\n// This implementation is based heavily on node's url.parse\nfunction resolvePathname(to, from) {\n  if (from === undefined) from = '';\n\n  var toParts = (to && to.split('/')) || [];\n  var fromParts = (from && from.split('/')) || [];\n\n  var isToAbs = to && isAbsolute(to);\n  var isFromAbs = from && isAbsolute(from);\n  var mustEndAbs = isToAbs || isFromAbs;\n\n  if (to && isAbsolute(to)) {\n    // to is absolute\n    fromParts = toParts;\n  } else if (toParts.length) {\n    // to is relative, drop the filename\n    fromParts.pop();\n    fromParts = fromParts.concat(toParts);\n  }\n\n  if (!fromParts.length) return '/';\n\n  var hasTrailingSlash;\n  if (fromParts.length) {\n    var last = fromParts[fromParts.length - 1];\n    hasTrailingSlash = last === '.' || last === '..' || last === '';\n  } else {\n    hasTrailingSlash = false;\n  }\n\n  var up = 0;\n  for (var i = fromParts.length; i >= 0; i--) {\n    var part = fromParts[i];\n\n    if (part === '.') {\n      spliceOne(fromParts, i);\n    } else if (part === '..') {\n      spliceOne(fromParts, i);\n      up++;\n    } else if (up) {\n      spliceOne(fromParts, i);\n      up--;\n    }\n  }\n\n  if (!mustEndAbs) for (; up--; up) fromParts.unshift('..');\n\n  if (\n    mustEndAbs &&\n    fromParts[0] !== '' &&\n    (!fromParts[0] || !isAbsolute(fromParts[0]))\n  )\n    fromParts.unshift('');\n\n  var result = fromParts.join('/');\n\n  if (hasTrailingSlash && result.substr(-1) !== '/') result += '/';\n\n  return result;\n}\n\nexport default resolvePathname;\n","function valueOf(obj) {\n  return obj.valueOf ? obj.valueOf() : Object.prototype.valueOf.call(obj);\n}\n\nfunction valueEqual(a, b) {\n  // Test for strict equality first.\n  if (a === b) return true;\n\n  // Otherwise, if either of them == null they are not equal.\n  if (a == null || b == null) return false;\n\n  if (Array.isArray(a)) {\n    return (\n      Array.isArray(b) &&\n      a.length === b.length &&\n      a.every(function(item, index) {\n        return valueEqual(item, b[index]);\n      })\n    );\n  }\n\n  if (typeof a === 'object' || typeof b === 'object') {\n    var aValue = valueOf(a);\n    var bValue = valueOf(b);\n\n    if (aValue !== a || bValue !== b) return valueEqual(aValue, bValue);\n\n    return Object.keys(Object.assign({}, a, b)).every(function(key) {\n      return valueEqual(a[key], b[key]);\n    });\n  }\n\n  return false;\n}\n\nexport default valueEqual;\n","import _extends from '@babel/runtime/helpers/esm/extends';\nimport resolvePathname from 'resolve-pathname';\nimport valueEqual from 'value-equal';\nimport warning from 'tiny-warning';\nimport invariant from 'tiny-invariant';\n\nfunction addLeadingSlash(path) {\n  return path.charAt(0) === '/' ? path : '/' + path;\n}\nfunction stripLeadingSlash(path) {\n  return path.charAt(0) === '/' ? path.substr(1) : path;\n}\nfunction hasBasename(path, prefix) {\n  return path.toLowerCase().indexOf(prefix.toLowerCase()) === 0 && '/?#'.indexOf(path.charAt(prefix.length)) !== -1;\n}\nfunction stripBasename(path, prefix) {\n  return hasBasename(path, prefix) ? path.substr(prefix.length) : path;\n}\nfunction stripTrailingSlash(path) {\n  return path.charAt(path.length - 1) === '/' ? path.slice(0, -1) : path;\n}\nfunction parsePath(path) {\n  var pathname = path || '/';\n  var search = '';\n  var hash = '';\n  var hashIndex = pathname.indexOf('#');\n\n  if (hashIndex !== -1) {\n    hash = pathname.substr(hashIndex);\n    pathname = pathname.substr(0, hashIndex);\n  }\n\n  var searchIndex = pathname.indexOf('?');\n\n  if (searchIndex !== -1) {\n    search = pathname.substr(searchIndex);\n    pathname = pathname.substr(0, searchIndex);\n  }\n\n  return {\n    pathname: pathname,\n    search: search === '?' ? '' : search,\n    hash: hash === '#' ? '' : hash\n  };\n}\nfunction createPath(location) {\n  var pathname = location.pathname,\n      search = location.search,\n      hash = location.hash;\n  var path = pathname || '/';\n  if (search && search !== '?') path += search.charAt(0) === '?' ? search : \"?\" + search;\n  if (hash && hash !== '#') path += hash.charAt(0) === '#' ? hash : \"#\" + hash;\n  return path;\n}\n\nfunction createLocation(path, state, key, currentLocation) {\n  var location;\n\n  if (typeof path === 'string') {\n    // Two-arg form: push(path, state)\n    location = parsePath(path);\n    location.state = state;\n  } else {\n    // One-arg form: push(location)\n    location = _extends({}, path);\n    if (location.pathname === undefined) location.pathname = '';\n\n    if (location.search) {\n      if (location.search.charAt(0) !== '?') location.search = '?' + location.search;\n    } else {\n      location.search = '';\n    }\n\n    if (location.hash) {\n      if (location.hash.charAt(0) !== '#') location.hash = '#' + location.hash;\n    } else {\n      location.hash = '';\n    }\n\n    if (state !== undefined && location.state === undefined) location.state = state;\n  }\n\n  try {\n    location.pathname = decodeURI(location.pathname);\n  } catch (e) {\n    if (e instanceof URIError) {\n      throw new URIError('Pathname \"' + location.pathname + '\" could not be decoded. ' + 'This is likely caused by an invalid percent-encoding.');\n    } else {\n      throw e;\n    }\n  }\n\n  if (key) location.key = key;\n\n  if (currentLocation) {\n    // Resolve incomplete/relative pathname relative to current location.\n    if (!location.pathname) {\n      location.pathname = currentLocation.pathname;\n    } else if (location.pathname.charAt(0) !== '/') {\n      location.pathname = resolvePathname(location.pathname, currentLocation.pathname);\n    }\n  } else {\n    // When there is no prior location and pathname is empty, set it to /\n    if (!location.pathname) {\n      location.pathname = '/';\n    }\n  }\n\n  return location;\n}\nfunction locationsAreEqual(a, b) {\n  return a.pathname === b.pathname && a.search === b.search && a.hash === b.hash && a.key === b.key && valueEqual(a.state, b.state);\n}\n\nfunction createTransitionManager() {\n  var prompt = null;\n\n  function setPrompt(nextPrompt) {\n    process.env.NODE_ENV !== \"production\" ? warning(prompt == null, 'A history supports only one prompt at a time') : void 0;\n    prompt = nextPrompt;\n    return function () {\n      if (prompt === nextPrompt) prompt = null;\n    };\n  }\n\n  function confirmTransitionTo(location, action, getUserConfirmation, callback) {\n    // TODO: If another transition starts while we're still confirming\n    // the previous one, we may end up in a weird state. Figure out the\n    // best way to handle this.\n    if (prompt != null) {\n      var result = typeof prompt === 'function' ? prompt(location, action) : prompt;\n\n      if (typeof result === 'string') {\n        if (typeof getUserConfirmation === 'function') {\n          getUserConfirmation(result, callback);\n        } else {\n          process.env.NODE_ENV !== \"production\" ? warning(false, 'A history needs a getUserConfirmation function in order to use a prompt message') : void 0;\n          callback(true);\n        }\n      } else {\n        // Return false from a transition hook to cancel the transition.\n        callback(result !== false);\n      }\n    } else {\n      callback(true);\n    }\n  }\n\n  var listeners = [];\n\n  function appendListener(fn) {\n    var isActive = true;\n\n    function listener() {\n      if (isActive) fn.apply(void 0, arguments);\n    }\n\n    listeners.push(listener);\n    return function () {\n      isActive = false;\n      listeners = listeners.filter(function (item) {\n        return item !== listener;\n      });\n    };\n  }\n\n  function notifyListeners() {\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    listeners.forEach(function (listener) {\n      return listener.apply(void 0, args);\n    });\n  }\n\n  return {\n    setPrompt: setPrompt,\n    confirmTransitionTo: confirmTransitionTo,\n    appendListener: appendListener,\n    notifyListeners: notifyListeners\n  };\n}\n\nvar canUseDOM = !!(typeof window !== 'undefined' && window.document && window.document.createElement);\nfunction getConfirmation(message, callback) {\n  callback(window.confirm(message)); // eslint-disable-line no-alert\n}\n/**\n * Returns true if the HTML5 history API is supported. Taken from Modernizr.\n *\n * https://github.com/Modernizr/Modernizr/blob/master/LICENSE\n * https://github.com/Modernizr/Modernizr/blob/master/feature-detects/history.js\n * changed to avoid false negatives for Windows Phones: https://github.com/reactjs/react-router/issues/586\n */\n\nfunction supportsHistory() {\n  var ua = window.navigator.userAgent;\n  if ((ua.indexOf('Android 2.') !== -1 || ua.indexOf('Android 4.0') !== -1) && ua.indexOf('Mobile Safari') !== -1 && ua.indexOf('Chrome') === -1 && ua.indexOf('Windows Phone') === -1) return false;\n  return window.history && 'pushState' in window.history;\n}\n/**\n * Returns true if browser fires popstate on hash change.\n * IE10 and IE11 do not.\n */\n\nfunction supportsPopStateOnHashChange() {\n  return window.navigator.userAgent.indexOf('Trident') === -1;\n}\n/**\n * Returns false if using go(n) with hash history causes a full page reload.\n */\n\nfunction supportsGoWithoutReloadUsingHash() {\n  return window.navigator.userAgent.indexOf('Firefox') === -1;\n}\n/**\n * Returns true if a given popstate event is an extraneous WebKit event.\n * Accounts for the fact that Chrome on iOS fires real popstate events\n * containing undefined state when pressing the back button.\n */\n\nfunction isExtraneousPopstateEvent(event) {\n  return event.state === undefined && navigator.userAgent.indexOf('CriOS') === -1;\n}\n\nvar PopStateEvent = 'popstate';\nvar HashChangeEvent = 'hashchange';\n\nfunction getHistoryState() {\n  try {\n    return window.history.state || {};\n  } catch (e) {\n    // IE 11 sometimes throws when accessing window.history.state\n    // See https://github.com/ReactTraining/history/pull/289\n    return {};\n  }\n}\n/**\n * Creates a history object that uses the HTML5 history API including\n * pushState, replaceState, and the popstate event.\n */\n\n\nfunction createBrowserHistory(props) {\n  if (props === void 0) {\n    props = {};\n  }\n\n  !canUseDOM ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'Browser history needs a DOM') : invariant(false) : void 0;\n  var globalHistory = window.history;\n  var canUseHistory = supportsHistory();\n  var needsHashChangeListener = !supportsPopStateOnHashChange();\n  var _props = props,\n      _props$forceRefresh = _props.forceRefresh,\n      forceRefresh = _props$forceRefresh === void 0 ? false : _props$forceRefresh,\n      _props$getUserConfirm = _props.getUserConfirmation,\n      getUserConfirmation = _props$getUserConfirm === void 0 ? getConfirmation : _props$getUserConfirm,\n      _props$keyLength = _props.keyLength,\n      keyLength = _props$keyLength === void 0 ? 6 : _props$keyLength;\n  var basename = props.basename ? stripTrailingSlash(addLeadingSlash(props.basename)) : '';\n\n  function getDOMLocation(historyState) {\n    var _ref = historyState || {},\n        key = _ref.key,\n        state = _ref.state;\n\n    var _window$location = window.location,\n        pathname = _window$location.pathname,\n        search = _window$location.search,\n        hash = _window$location.hash;\n    var path = pathname + search + hash;\n    process.env.NODE_ENV !== \"production\" ? warning(!basename || hasBasename(path, basename), 'You are attempting to use a basename on a page whose URL path does not begin ' + 'with the basename. Expected path \"' + path + '\" to begin with \"' + basename + '\".') : void 0;\n    if (basename) path = stripBasename(path, basename);\n    return createLocation(path, state, key);\n  }\n\n  function createKey() {\n    return Math.random().toString(36).substr(2, keyLength);\n  }\n\n  var transitionManager = createTransitionManager();\n\n  function setState(nextState) {\n    _extends(history, nextState);\n\n    history.length = globalHistory.length;\n    transitionManager.notifyListeners(history.location, history.action);\n  }\n\n  function handlePopState(event) {\n    // Ignore extraneous popstate events in WebKit.\n    if (isExtraneousPopstateEvent(event)) return;\n    handlePop(getDOMLocation(event.state));\n  }\n\n  function handleHashChange() {\n    handlePop(getDOMLocation(getHistoryState()));\n  }\n\n  var forceNextPop = false;\n\n  function handlePop(location) {\n    if (forceNextPop) {\n      forceNextPop = false;\n      setState();\n    } else {\n      var action = 'POP';\n      transitionManager.confirmTransitionTo(location, action, getUserConfirmation, function (ok) {\n        if (ok) {\n          setState({\n            action: action,\n            location: location\n          });\n        } else {\n          revertPop(location);\n        }\n      });\n    }\n  }\n\n  function revertPop(fromLocation) {\n    var toLocation = history.location; // TODO: We could probably make this more reliable by\n    // keeping a list of keys we've seen in sessionStorage.\n    // Instead, we just default to 0 for keys we don't know.\n\n    var toIndex = allKeys.indexOf(toLocation.key);\n    if (toIndex === -1) toIndex = 0;\n    var fromIndex = allKeys.indexOf(fromLocation.key);\n    if (fromIndex === -1) fromIndex = 0;\n    var delta = toIndex - fromIndex;\n\n    if (delta) {\n      forceNextPop = true;\n      go(delta);\n    }\n  }\n\n  var initialLocation = getDOMLocation(getHistoryState());\n  var allKeys = [initialLocation.key]; // Public interface\n\n  function createHref(location) {\n    return basename + createPath(location);\n  }\n\n  function push(path, state) {\n    process.env.NODE_ENV !== \"production\" ? warning(!(typeof path === 'object' && path.state !== undefined && state !== undefined), 'You should avoid providing a 2nd state argument to push when the 1st ' + 'argument is a location-like object that already has state; it is ignored') : void 0;\n    var action = 'PUSH';\n    var location = createLocation(path, state, createKey(), history.location);\n    transitionManager.confirmTransitionTo(location, action, getUserConfirmation, function (ok) {\n      if (!ok) return;\n      var href = createHref(location);\n      var key = location.key,\n          state = location.state;\n\n      if (canUseHistory) {\n        globalHistory.pushState({\n          key: key,\n          state: state\n        }, null, href);\n\n        if (forceRefresh) {\n          window.location.href = href;\n        } else {\n          var prevIndex = allKeys.indexOf(history.location.key);\n          var nextKeys = allKeys.slice(0, prevIndex + 1);\n          nextKeys.push(location.key);\n          allKeys = nextKeys;\n          setState({\n            action: action,\n            location: location\n          });\n        }\n      } else {\n        process.env.NODE_ENV !== \"production\" ? warning(state === undefined, 'Browser history cannot push state in browsers that do not support HTML5 history') : void 0;\n        window.location.href = href;\n      }\n    });\n  }\n\n  function replace(path, state) {\n    process.env.NODE_ENV !== \"production\" ? warning(!(typeof path === 'object' && path.state !== undefined && state !== undefined), 'You should avoid providing a 2nd state argument to replace when the 1st ' + 'argument is a location-like object that already has state; it is ignored') : void 0;\n    var action = 'REPLACE';\n    var location = createLocation(path, state, createKey(), history.location);\n    transitionManager.confirmTransitionTo(location, action, getUserConfirmation, function (ok) {\n      if (!ok) return;\n      var href = createHref(location);\n      var key = location.key,\n          state = location.state;\n\n      if (canUseHistory) {\n        globalHistory.replaceState({\n          key: key,\n          state: state\n        }, null, href);\n\n        if (forceRefresh) {\n          window.location.replace(href);\n        } else {\n          var prevIndex = allKeys.indexOf(history.location.key);\n          if (prevIndex !== -1) allKeys[prevIndex] = location.key;\n          setState({\n            action: action,\n            location: location\n          });\n        }\n      } else {\n        process.env.NODE_ENV !== \"production\" ? warning(state === undefined, 'Browser history cannot replace state in browsers that do not support HTML5 history') : void 0;\n        window.location.replace(href);\n      }\n    });\n  }\n\n  function go(n) {\n    globalHistory.go(n);\n  }\n\n  function goBack() {\n    go(-1);\n  }\n\n  function goForward() {\n    go(1);\n  }\n\n  var listenerCount = 0;\n\n  function checkDOMListeners(delta) {\n    listenerCount += delta;\n\n    if (listenerCount === 1 && delta === 1) {\n      window.addEventListener(PopStateEvent, handlePopState);\n      if (needsHashChangeListener) window.addEventListener(HashChangeEvent, handleHashChange);\n    } else if (listenerCount === 0) {\n      window.removeEventListener(PopStateEvent, handlePopState);\n      if (needsHashChangeListener) window.removeEventListener(HashChangeEvent, handleHashChange);\n    }\n  }\n\n  var isBlocked = false;\n\n  function block(prompt) {\n    if (prompt === void 0) {\n      prompt = false;\n    }\n\n    var unblock = transitionManager.setPrompt(prompt);\n\n    if (!isBlocked) {\n      checkDOMListeners(1);\n      isBlocked = true;\n    }\n\n    return function () {\n      if (isBlocked) {\n        isBlocked = false;\n        checkDOMListeners(-1);\n      }\n\n      return unblock();\n    };\n  }\n\n  function listen(listener) {\n    var unlisten = transitionManager.appendListener(listener);\n    checkDOMListeners(1);\n    return function () {\n      checkDOMListeners(-1);\n      unlisten();\n    };\n  }\n\n  var history = {\n    length: globalHistory.length,\n    action: 'POP',\n    location: initialLocation,\n    createHref: createHref,\n    push: push,\n    replace: replace,\n    go: go,\n    goBack: goBack,\n    goForward: goForward,\n    block: block,\n    listen: listen\n  };\n  return history;\n}\n\nvar HashChangeEvent$1 = 'hashchange';\nvar HashPathCoders = {\n  hashbang: {\n    encodePath: function encodePath(path) {\n      return path.charAt(0) === '!' ? path : '!/' + stripLeadingSlash(path);\n    },\n    decodePath: function decodePath(path) {\n      return path.charAt(0) === '!' ? path.substr(1) : path;\n    }\n  },\n  noslash: {\n    encodePath: stripLeadingSlash,\n    decodePath: addLeadingSlash\n  },\n  slash: {\n    encodePath: addLeadingSlash,\n    decodePath: addLeadingSlash\n  }\n};\n\nfunction stripHash(url) {\n  var hashIndex = url.indexOf('#');\n  return hashIndex === -1 ? url : url.slice(0, hashIndex);\n}\n\nfunction getHashPath() {\n  // We can't use window.location.hash here because it's not\n  // consistent across browsers - Firefox will pre-decode it!\n  var href = window.location.href;\n  var hashIndex = href.indexOf('#');\n  return hashIndex === -1 ? '' : href.substring(hashIndex + 1);\n}\n\nfunction pushHashPath(path) {\n  window.location.hash = path;\n}\n\nfunction replaceHashPath(path) {\n  window.location.replace(stripHash(window.location.href) + '#' + path);\n}\n\nfunction createHashHistory(props) {\n  if (props === void 0) {\n    props = {};\n  }\n\n  !canUseDOM ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'Hash history needs a DOM') : invariant(false) : void 0;\n  var globalHistory = window.history;\n  var canGoWithoutReload = supportsGoWithoutReloadUsingHash();\n  var _props = props,\n      _props$getUserConfirm = _props.getUserConfirmation,\n      getUserConfirmation = _props$getUserConfirm === void 0 ? getConfirmation : _props$getUserConfirm,\n      _props$hashType = _props.hashType,\n      hashType = _props$hashType === void 0 ? 'slash' : _props$hashType;\n  var basename = props.basename ? stripTrailingSlash(addLeadingSlash(props.basename)) : '';\n  var _HashPathCoders$hashT = HashPathCoders[hashType],\n      encodePath = _HashPathCoders$hashT.encodePath,\n      decodePath = _HashPathCoders$hashT.decodePath;\n\n  function getDOMLocation() {\n    var path = decodePath(getHashPath());\n    process.env.NODE_ENV !== \"production\" ? warning(!basename || hasBasename(path, basename), 'You are attempting to use a basename on a page whose URL path does not begin ' + 'with the basename. Expected path \"' + path + '\" to begin with \"' + basename + '\".') : void 0;\n    if (basename) path = stripBasename(path, basename);\n    return createLocation(path);\n  }\n\n  var transitionManager = createTransitionManager();\n\n  function setState(nextState) {\n    _extends(history, nextState);\n\n    history.length = globalHistory.length;\n    transitionManager.notifyListeners(history.location, history.action);\n  }\n\n  var forceNextPop = false;\n  var ignorePath = null;\n\n  function locationsAreEqual$$1(a, b) {\n    return a.pathname === b.pathname && a.search === b.search && a.hash === b.hash;\n  }\n\n  function handleHashChange() {\n    var path = getHashPath();\n    var encodedPath = encodePath(path);\n\n    if (path !== encodedPath) {\n      // Ensure we always have a properly-encoded hash.\n      replaceHashPath(encodedPath);\n    } else {\n      var location = getDOMLocation();\n      var prevLocation = history.location;\n      if (!forceNextPop && locationsAreEqual$$1(prevLocation, location)) return; // A hashchange doesn't always == location change.\n\n      if (ignorePath === createPath(location)) return; // Ignore this change; we already setState in push/replace.\n\n      ignorePath = null;\n      handlePop(location);\n    }\n  }\n\n  function handlePop(location) {\n    if (forceNextPop) {\n      forceNextPop = false;\n      setState();\n    } else {\n      var action = 'POP';\n      transitionManager.confirmTransitionTo(location, action, getUserConfirmation, function (ok) {\n        if (ok) {\n          setState({\n            action: action,\n            location: location\n          });\n        } else {\n          revertPop(location);\n        }\n      });\n    }\n  }\n\n  function revertPop(fromLocation) {\n    var toLocation = history.location; // TODO: We could probably make this more reliable by\n    // keeping a list of paths we've seen in sessionStorage.\n    // Instead, we just default to 0 for paths we don't know.\n\n    var toIndex = allPaths.lastIndexOf(createPath(toLocation));\n    if (toIndex === -1) toIndex = 0;\n    var fromIndex = allPaths.lastIndexOf(createPath(fromLocation));\n    if (fromIndex === -1) fromIndex = 0;\n    var delta = toIndex - fromIndex;\n\n    if (delta) {\n      forceNextPop = true;\n      go(delta);\n    }\n  } // Ensure the hash is encoded properly before doing anything else.\n\n\n  var path = getHashPath();\n  var encodedPath = encodePath(path);\n  if (path !== encodedPath) replaceHashPath(encodedPath);\n  var initialLocation = getDOMLocation();\n  var allPaths = [createPath(initialLocation)]; // Public interface\n\n  function createHref(location) {\n    var baseTag = document.querySelector('base');\n    var href = '';\n\n    if (baseTag && baseTag.getAttribute('href')) {\n      href = stripHash(window.location.href);\n    }\n\n    return href + '#' + encodePath(basename + createPath(location));\n  }\n\n  function push(path, state) {\n    process.env.NODE_ENV !== \"production\" ? warning(state === undefined, 'Hash history cannot push state; it is ignored') : void 0;\n    var action = 'PUSH';\n    var location = createLocation(path, undefined, undefined, history.location);\n    transitionManager.confirmTransitionTo(location, action, getUserConfirmation, function (ok) {\n      if (!ok) return;\n      var path = createPath(location);\n      var encodedPath = encodePath(basename + path);\n      var hashChanged = getHashPath() !== encodedPath;\n\n      if (hashChanged) {\n        // We cannot tell if a hashchange was caused by a PUSH, so we'd\n        // rather setState here and ignore the hashchange. The caveat here\n        // is that other hash histories in the page will consider it a POP.\n        ignorePath = path;\n        pushHashPath(encodedPath);\n        var prevIndex = allPaths.lastIndexOf(createPath(history.location));\n        var nextPaths = allPaths.slice(0, prevIndex + 1);\n        nextPaths.push(path);\n        allPaths = nextPaths;\n        setState({\n          action: action,\n          location: location\n        });\n      } else {\n        process.env.NODE_ENV !== \"production\" ? warning(false, 'Hash history cannot PUSH the same path; a new entry will not be added to the history stack') : void 0;\n        setState();\n      }\n    });\n  }\n\n  function replace(path, state) {\n    process.env.NODE_ENV !== \"production\" ? warning(state === undefined, 'Hash history cannot replace state; it is ignored') : void 0;\n    var action = 'REPLACE';\n    var location = createLocation(path, undefined, undefined, history.location);\n    transitionManager.confirmTransitionTo(location, action, getUserConfirmation, function (ok) {\n      if (!ok) return;\n      var path = createPath(location);\n      var encodedPath = encodePath(basename + path);\n      var hashChanged = getHashPath() !== encodedPath;\n\n      if (hashChanged) {\n        // We cannot tell if a hashchange was caused by a REPLACE, so we'd\n        // rather setState here and ignore the hashchange. The caveat here\n        // is that other hash histories in the page will consider it a POP.\n        ignorePath = path;\n        replaceHashPath(encodedPath);\n      }\n\n      var prevIndex = allPaths.indexOf(createPath(history.location));\n      if (prevIndex !== -1) allPaths[prevIndex] = path;\n      setState({\n        action: action,\n        location: location\n      });\n    });\n  }\n\n  function go(n) {\n    process.env.NODE_ENV !== \"production\" ? warning(canGoWithoutReload, 'Hash history go(n) causes a full page reload in this browser') : void 0;\n    globalHistory.go(n);\n  }\n\n  function goBack() {\n    go(-1);\n  }\n\n  function goForward() {\n    go(1);\n  }\n\n  var listenerCount = 0;\n\n  function checkDOMListeners(delta) {\n    listenerCount += delta;\n\n    if (listenerCount === 1 && delta === 1) {\n      window.addEventListener(HashChangeEvent$1, handleHashChange);\n    } else if (listenerCount === 0) {\n      window.removeEventListener(HashChangeEvent$1, handleHashChange);\n    }\n  }\n\n  var isBlocked = false;\n\n  function block(prompt) {\n    if (prompt === void 0) {\n      prompt = false;\n    }\n\n    var unblock = transitionManager.setPrompt(prompt);\n\n    if (!isBlocked) {\n      checkDOMListeners(1);\n      isBlocked = true;\n    }\n\n    return function () {\n      if (isBlocked) {\n        isBlocked = false;\n        checkDOMListeners(-1);\n      }\n\n      return unblock();\n    };\n  }\n\n  function listen(listener) {\n    var unlisten = transitionManager.appendListener(listener);\n    checkDOMListeners(1);\n    return function () {\n      checkDOMListeners(-1);\n      unlisten();\n    };\n  }\n\n  var history = {\n    length: globalHistory.length,\n    action: 'POP',\n    location: initialLocation,\n    createHref: createHref,\n    push: push,\n    replace: replace,\n    go: go,\n    goBack: goBack,\n    goForward: goForward,\n    block: block,\n    listen: listen\n  };\n  return history;\n}\n\nfunction clamp(n, lowerBound, upperBound) {\n  return Math.min(Math.max(n, lowerBound), upperBound);\n}\n/**\n * Creates a history object that stores locations in memory.\n */\n\n\nfunction createMemoryHistory(props) {\n  if (props === void 0) {\n    props = {};\n  }\n\n  var _props = props,\n      getUserConfirmation = _props.getUserConfirmation,\n      _props$initialEntries = _props.initialEntries,\n      initialEntries = _props$initialEntries === void 0 ? ['/'] : _props$initialEntries,\n      _props$initialIndex = _props.initialIndex,\n      initialIndex = _props$initialIndex === void 0 ? 0 : _props$initialIndex,\n      _props$keyLength = _props.keyLength,\n      keyLength = _props$keyLength === void 0 ? 6 : _props$keyLength;\n  var transitionManager = createTransitionManager();\n\n  function setState(nextState) {\n    _extends(history, nextState);\n\n    history.length = history.entries.length;\n    transitionManager.notifyListeners(history.location, history.action);\n  }\n\n  function createKey() {\n    return Math.random().toString(36).substr(2, keyLength);\n  }\n\n  var index = clamp(initialIndex, 0, initialEntries.length - 1);\n  var entries = initialEntries.map(function (entry) {\n    return typeof entry === 'string' ? createLocation(entry, undefined, createKey()) : createLocation(entry, undefined, entry.key || createKey());\n  }); // Public interface\n\n  var createHref = createPath;\n\n  function push(path, state) {\n    process.env.NODE_ENV !== \"production\" ? warning(!(typeof path === 'object' && path.state !== undefined && state !== undefined), 'You should avoid providing a 2nd state argument to push when the 1st ' + 'argument is a location-like object that already has state; it is ignored') : void 0;\n    var action = 'PUSH';\n    var location = createLocation(path, state, createKey(), history.location);\n    transitionManager.confirmTransitionTo(location, action, getUserConfirmation, function (ok) {\n      if (!ok) return;\n      var prevIndex = history.index;\n      var nextIndex = prevIndex + 1;\n      var nextEntries = history.entries.slice(0);\n\n      if (nextEntries.length > nextIndex) {\n        nextEntries.splice(nextIndex, nextEntries.length - nextIndex, location);\n      } else {\n        nextEntries.push(location);\n      }\n\n      setState({\n        action: action,\n        location: location,\n        index: nextIndex,\n        entries: nextEntries\n      });\n    });\n  }\n\n  function replace(path, state) {\n    process.env.NODE_ENV !== \"production\" ? warning(!(typeof path === 'object' && path.state !== undefined && state !== undefined), 'You should avoid providing a 2nd state argument to replace when the 1st ' + 'argument is a location-like object that already has state; it is ignored') : void 0;\n    var action = 'REPLACE';\n    var location = createLocation(path, state, createKey(), history.location);\n    transitionManager.confirmTransitionTo(location, action, getUserConfirmation, function (ok) {\n      if (!ok) return;\n      history.entries[history.index] = location;\n      setState({\n        action: action,\n        location: location\n      });\n    });\n  }\n\n  function go(n) {\n    var nextIndex = clamp(history.index + n, 0, history.entries.length - 1);\n    var action = 'POP';\n    var location = history.entries[nextIndex];\n    transitionManager.confirmTransitionTo(location, action, getUserConfirmation, function (ok) {\n      if (ok) {\n        setState({\n          action: action,\n          location: location,\n          index: nextIndex\n        });\n      } else {\n        // Mimic the behavior of DOM histories by\n        // causing a render after a cancelled POP.\n        setState();\n      }\n    });\n  }\n\n  function goBack() {\n    go(-1);\n  }\n\n  function goForward() {\n    go(1);\n  }\n\n  function canGo(n) {\n    var nextIndex = history.index + n;\n    return nextIndex >= 0 && nextIndex < history.entries.length;\n  }\n\n  function block(prompt) {\n    if (prompt === void 0) {\n      prompt = false;\n    }\n\n    return transitionManager.setPrompt(prompt);\n  }\n\n  function listen(listener) {\n    return transitionManager.appendListener(listener);\n  }\n\n  var history = {\n    length: entries.length,\n    action: 'POP',\n    location: entries[index],\n    index: index,\n    entries: entries,\n    createHref: createHref,\n    push: push,\n    replace: replace,\n    go: go,\n    goBack: goBack,\n    goForward: goForward,\n    canGo: canGo,\n    block: block,\n    listen: listen\n  };\n  return history;\n}\n\nexport { createBrowserHistory, createHashHistory, createMemoryHistory, createLocation, locationsAreEqual, parsePath, createPath };\n","import {Check, TimeSpan} from '@sparkware/app-utils';\nimport {ApplicationStartupConfigurations} from '../app-react/app-bootstrap/config-interfaces/application-startup.configurations';\nimport {TimeIntervalName} from '../common/utils/time-interval-names';\n\nexport const CYPRESS_TO_ORBIT_HOOKS_OBJECT_NAME = 'CypressToOrbitHooks';\nexport const CYPRESS_GLOBAL_OBJECT_NAME = 'Cypress';\n\nexport function isInsideAutomation(): boolean {\n    return !Check.isNullOrUndefined(window[CYPRESS_GLOBAL_OBJECT_NAME])\n        && !Check.isNullOrUndefined(window[CYPRESS_GLOBAL_OBJECT_NAME][CYPRESS_TO_ORBIT_HOOKS_OBJECT_NAME])\n}\n\n\nexport function mockApplicationStartupConfigs(configs: ApplicationStartupConfigurations): ApplicationStartupConfigurations {\n    if(isInsideAutomation()) {\n        getCypressToOrbitHooks().onAppStartupConfigs(configs);\n    }\n    return configs;\n}\n\nexport function getCypressToOrbitHooks(): ICypressToOrbitHooks {\n    if(!isInsideAutomation()) {\n        throw new Error('You can only call getCypressToOrbitHooks inside automation');\n    }\n    return window[CYPRESS_GLOBAL_OBJECT_NAME][CYPRESS_TO_ORBIT_HOOKS_OBJECT_NAME] as ICypressToOrbitHooks;\n}\n\nexport interface OnTimeIntervalCreationResult {\n    ignoreJavaScriptImplementation: boolean;\n    timerId?: number;\n}\n\nexport enum NamedIntervalType {\n    setInterval,\n    setTimeout\n}\n\nexport interface ICypressToOrbitHooks {\n    onAppStartupConfigs(configs: ApplicationStartupConfigurations);\n    onTimeIntervalCreation(name: TimeIntervalName, callback: () => void, interval: TimeSpan, intervalType: NamedIntervalType): OnTimeIntervalCreationResult;\n}\n\n","export function matchAllWords(text: string, words: RegExp[]): boolean {\n    for(let index = 0; index < words.length; index++) {\n        if(!text.match(words[index])) {\n            return false;\n        }\n    }\n    return true;\n}\n\nexport function removeSpaces(str) {\n    return str.replace(/\\s/g, '');\n}\n\nexport function removeSpecialCharacters(str: string): string {\n    return str.replace(/[^a-zA-Z ]/g, \"\");\n}\n\n/**\n * Given a string extracts all the words from it and converts them in case insensitive regular expressions\n * @param {string} text\n * @return {RegExp[]}\n */\nexport function extractWordsRegularExpressions(text: string): RegExp[] {\n    if(!text) {\n        return [];\n    }\n\n    return text.split(' ')\n        .map(word => word.trim())\n        .filter(word => word)\n        .map(word => new RegExp(word, 'gi'));\n}","var __read = (this && this.__read) || function (o, n) {\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n    if (!m) return o;\n    var i = m.call(o), r, ar = [], e;\n    try {\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\n    }\n    catch (error) { e = { error: error }; }\n    finally {\n        try {\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\n        }\n        finally { if (e) throw e.error; }\n    }\n    return ar;\n};\nimport { useCallback, useEffect, useState } from \"react\";\nvar EMPTY_ARRAY = [];\nexport function useUnmount(fn) {\n    useEffect(function () { return fn; }, EMPTY_ARRAY);\n}\nexport function useForceUpdate() {\n    var _a = __read(useState(0), 2), setTick = _a[1];\n    var update = useCallback(function () {\n        setTick(function (tick) { return tick + 1; });\n    }, []);\n    return update;\n}\nexport function isPlainObject(value) {\n    if (!value || typeof value !== \"object\") {\n        return false;\n    }\n    var proto = Object.getPrototypeOf(value);\n    return !proto || proto === Object.prototype;\n}\nexport function getSymbol(name) {\n    if (typeof Symbol === \"function\") {\n        return Symbol.for(name);\n    }\n    return \"__$mobx-react \" + name + \"__\";\n}\nvar mockGlobal = {};\nexport function getGlobal() {\n    if (typeof window !== \"undefined\") {\n        return window;\n    }\n    if (typeof global !== \"undefined\") {\n        return global;\n    }\n    if (typeof self !== \"undefined\") {\n        return self;\n    }\n    return mockGlobal;\n}\n","\nexport function splitArrayToChunks<T>(originalArray: T[], chunkSize: number): Array<T[]> {\n\n  if(!originalArray || originalArray.length === 0) {\n    return [];\n  }\n\n  let result: Array<T[]> = [];\n  for(let i = 0; i * chunkSize < originalArray.length; i++) {\n    result.push(originalArray.slice(i * chunkSize, i * chunkSize + chunkSize));\n  }\n\n  return result;\n}\n\nexport function arraysEqual<T>(arr1: T[], arr2: T[]) {\n  if (arr1 === arr2) return true;\n  if (arr1 == null || arr2 == null) return false;\n  if (arr1.length !== arr2.length) return false;\n\n  for (let i = 0; i < arr1.length; ++i) {\n    if (arr1[i] !== arr2[i]) return false;\n  }\n  return true;\n}\n\n/**\n * Shuffle an array using the Fisher-Yates unbiased algorithm\n * Read more about the algorithm here: https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle\n * The implementation is taken from here: https://bost.ocks.org/mike/shuffle/\n * and updated a bit for typescript\n */\nexport function shuffle(array: unknown[]) {\n  let m = array.length, t: unknown;\n\n  // While there remain elements to shuffle…\n  while (m) {\n\n    // Pick a remaining element…\n    let i = Math.floor(Math.random() * m--);\n\n    // And swap it with the current element.\n    t = array[m];\n    array[m] = array[i];\n    array[i] = t;\n  }\n\n  return array;\n}\n","import {OrbitComponentWithState} from '../orbit-component-with-state/orbit-component-with-state';\n\nexport class OrbitComponent<TProps = {}> extends OrbitComponentWithState<TProps, {}> {\n}\n\n\n","import { spy } from \"mobx\";\nimport { useState } from \"react\";\nif (!useState) {\n    throw new Error(\"mobx-react-lite requires React with Hooks support\");\n}\nif (!spy) {\n    throw new Error(\"mobx-react-lite requires mobx at least version 4 to be available\");\n}\n","import { configure } from \"mobx\";\nimport { getGlobal, getSymbol } from \"./utils\";\nvar observerBatchingConfiguredSymbol = getSymbol(\"observerBatching\");\nexport function defaultNoopBatch(callback) {\n    callback();\n}\nexport function observerBatching(reactionScheduler) {\n    if (!reactionScheduler) {\n        reactionScheduler = defaultNoopBatch;\n        if (\"production\" !== process.env.NODE_ENV) {\n            console.warn(\"[MobX] Failed to get unstable_batched updates from react-dom / react-native\");\n        }\n    }\n    configure({ reactionScheduler: reactionScheduler });\n    getGlobal()[observerBatchingConfiguredSymbol] = true;\n}\nexport var isObserverBatched = function () { return !!getGlobal()[observerBatchingConfiguredSymbol]; };\n","var globalIsUsingStaticRendering = false;\nexport function useStaticRendering(enable) {\n    globalIsUsingStaticRendering = enable;\n}\nexport function isUsingStaticRendering() {\n    return globalIsUsingStaticRendering;\n}\n","import { getDependencyTree } from \"mobx\";\nexport function printDebugValue(v) {\n    return getDependencyTree(v);\n}\n","export function createTrackingData(reaction) {\n    var trackingData = {\n        cleanAt: Date.now() + CLEANUP_LEAKED_REACTIONS_AFTER_MILLIS,\n        reaction: reaction\n    };\n    return trackingData;\n}\n/**\n * The minimum time before we'll clean up a Reaction created in a render\n * for a component that hasn't managed to run its effects. This needs to\n * be big enough to ensure that a component won't turn up and have its\n * effects run without being re-rendered.\n */\nexport var CLEANUP_LEAKED_REACTIONS_AFTER_MILLIS = 10000;\n/**\n * The frequency with which we'll check for leaked reactions.\n */\nexport var CLEANUP_TIMER_LOOP_MILLIS = 10000;\n/**\n * Reactions created by components that have yet to be fully mounted.\n */\nvar uncommittedReactionRefs = new Set();\n/**\n * Latest 'uncommitted reactions' cleanup timer handle.\n */\nvar reactionCleanupHandle;\nfunction ensureCleanupTimerRunning() {\n    if (reactionCleanupHandle === undefined) {\n        reactionCleanupHandle = setTimeout(cleanUncommittedReactions, CLEANUP_TIMER_LOOP_MILLIS);\n    }\n}\nexport function scheduleCleanupOfReactionIfLeaked(ref) {\n    uncommittedReactionRefs.add(ref);\n    ensureCleanupTimerRunning();\n}\nexport function recordReactionAsCommitted(reactionRef) {\n    uncommittedReactionRefs.delete(reactionRef);\n}\n/**\n * Run by the cleanup timer to dispose any outstanding reactions\n */\nfunction cleanUncommittedReactions() {\n    reactionCleanupHandle = undefined;\n    // Loop through all the candidate leaked reactions; those older\n    // than CLEANUP_LEAKED_REACTIONS_AFTER_MILLIS get tidied.\n    var now = Date.now();\n    uncommittedReactionRefs.forEach(function (ref) {\n        var tracking = ref.current;\n        if (tracking) {\n            if (now >= tracking.cleanAt) {\n                // It's time to tidy up this leaked reaction.\n                tracking.reaction.dispose();\n                ref.current = null;\n                uncommittedReactionRefs.delete(ref);\n            }\n        }\n    });\n    if (uncommittedReactionRefs.size > 0) {\n        // We've just finished a round of cleanups but there are still\n        // some leak candidates outstanding.\n        ensureCleanupTimerRunning();\n    }\n}\n/* istanbul ignore next */\n/**\n * Only to be used by test functions; do not export outside of mobx-react-lite\n */\nexport function forceCleanupTimerToRunNowForTests() {\n    // This allows us to control the execution of the cleanup timer\n    // to force it to run at awkward times in unit tests.\n    if (reactionCleanupHandle) {\n        clearTimeout(reactionCleanupHandle);\n        cleanUncommittedReactions();\n    }\n}\n/* istanbul ignore next */\nexport function resetCleanupScheduleForTests() {\n    if (reactionCleanupHandle) {\n        clearTimeout(reactionCleanupHandle);\n        reactionCleanupHandle = undefined;\n    }\n    uncommittedReactionRefs.clear();\n}\n","import React from \"react\";\nvar insideRender = false;\nvar forceUpdateQueue = [];\nexport function useQueuedForceUpdate(forceUpdate) {\n    return function () {\n        if (insideRender) {\n            forceUpdateQueue.push(forceUpdate);\n        }\n        else {\n            forceUpdate();\n        }\n    };\n}\nexport function useQueuedForceUpdateBlock(callback) {\n    // start intercepting force-update calls\n    insideRender = true;\n    forceUpdateQueue = [];\n    try {\n        var result = callback();\n        // stop intercepting force-update\n        insideRender = false;\n        // store queue or nothing if it was empty to execute useLayoutEffect only when necessary\n        var queue_1 = forceUpdateQueue.length > 0 ? forceUpdateQueue : undefined;\n        // run force-update queue in useLayoutEffect\n        React.useLayoutEffect(function () {\n            if (queue_1) {\n                queue_1.forEach(function (x) { return x(); });\n            }\n        }, [queue_1]);\n        return result;\n    }\n    finally {\n        insideRender = false;\n    }\n}\n","import { Reaction } from \"mobx\";\nimport React from \"react\";\nimport { printDebugValue } from \"./printDebugValue\";\nimport { createTrackingData, recordReactionAsCommitted, scheduleCleanupOfReactionIfLeaked } from \"./reactionCleanupTracking\";\nimport { isUsingStaticRendering } from \"./staticRendering\";\nimport { useForceUpdate } from \"./utils\";\nimport { useQueuedForceUpdate, useQueuedForceUpdateBlock } from \"./useQueuedForceUpdate\";\nvar EMPTY_OBJECT = {};\nfunction observerComponentNameFor(baseComponentName) {\n    return \"observer\" + baseComponentName;\n}\nexport function useObserver(fn, baseComponentName, options) {\n    if (baseComponentName === void 0) { baseComponentName = \"observed\"; }\n    if (options === void 0) { options = EMPTY_OBJECT; }\n    if (isUsingStaticRendering()) {\n        return fn();\n    }\n    var wantedForceUpdateHook = options.useForceUpdate || useForceUpdate;\n    var forceUpdate = wantedForceUpdateHook();\n    var queuedForceUpdate = useQueuedForceUpdate(forceUpdate);\n    // StrictMode/ConcurrentMode/Suspense may mean that our component is\n    // rendered and abandoned multiple times, so we need to track leaked\n    // Reactions.\n    var reactionTrackingRef = React.useRef(null);\n    if (!reactionTrackingRef.current) {\n        // First render for this component (or first time since a previous\n        // reaction from an abandoned render was disposed).\n        var newReaction_1 = new Reaction(observerComponentNameFor(baseComponentName), function () {\n            // Observable has changed, meaning we want to re-render\n            // BUT if we're a component that hasn't yet got to the useEffect()\n            // stage, we might be a component that _started_ to render, but\n            // got dropped, and we don't want to make state changes then.\n            // (It triggers warnings in StrictMode, for a start.)\n            if (trackingData_1.mounted) {\n                // We have reached useEffect(), so we're mounted, and can trigger an update\n                queuedForceUpdate();\n            }\n            else {\n                // We haven't yet reached useEffect(), so we'll need to trigger a re-render\n                // when (and if) useEffect() arrives.  The easiest way to do that is just to\n                // drop our current reaction and allow useEffect() to recreate it.\n                newReaction_1.dispose();\n                reactionTrackingRef.current = null;\n            }\n        });\n        var trackingData_1 = createTrackingData(newReaction_1);\n        reactionTrackingRef.current = trackingData_1;\n        scheduleCleanupOfReactionIfLeaked(reactionTrackingRef);\n    }\n    var reaction = reactionTrackingRef.current.reaction;\n    React.useDebugValue(reaction, printDebugValue);\n    React.useEffect(function () {\n        // Called on first mount only\n        recordReactionAsCommitted(reactionTrackingRef);\n        if (reactionTrackingRef.current) {\n            // Great. We've already got our reaction from our render;\n            // all we need to do is to record that it's now mounted,\n            // to allow future observable changes to trigger re-renders\n            reactionTrackingRef.current.mounted = true;\n        }\n        else {\n            // The reaction we set up in our render has been disposed.\n            // This is either due to bad timings of renderings, e.g. our\n            // component was paused for a _very_ long time, and our\n            // reaction got cleaned up, or we got a observable change\n            // between render and useEffect\n            // Re-create the reaction\n            reactionTrackingRef.current = {\n                reaction: new Reaction(observerComponentNameFor(baseComponentName), function () {\n                    // We've definitely already been mounted at this point\n                    queuedForceUpdate();\n                }),\n                cleanAt: Infinity\n            };\n            queuedForceUpdate();\n        }\n        return function () {\n            reactionTrackingRef.current.reaction.dispose();\n            reactionTrackingRef.current = null;\n        };\n    }, []);\n    // delay all force-update calls after rendering of this component\n    return useQueuedForceUpdateBlock(function () {\n        // render the original component, but have the\n        // reaction track the observables, so that rendering\n        // can be invalidated (see above) once a dependency changes\n        var rendering;\n        var exception;\n        reaction.track(function () {\n            try {\n                rendering = fn();\n            }\n            catch (e) {\n                exception = e;\n            }\n        });\n        if (exception) {\n            throw exception; // re-throw any exceptions caught during rendering\n        }\n        return rendering;\n    });\n}\n","var __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nimport { forwardRef, memo } from \"react\";\nimport { isUsingStaticRendering } from \"./staticRendering\";\nimport { useObserver } from \"./useObserver\";\n// n.b. base case is not used for actual typings or exported in the typing files\nexport function observer(baseComponent, options) {\n    // The working of observer is explained step by step in this talk: https://www.youtube.com/watch?v=cPF4iBedoF0&feature=youtu.be&t=1307\n    if (isUsingStaticRendering()) {\n        return baseComponent;\n    }\n    var realOptions = __assign({ forwardRef: false }, options);\n    var baseComponentName = baseComponent.displayName || baseComponent.name;\n    var wrappedComponent = function (props, ref) {\n        return useObserver(function () { return baseComponent(props, ref); }, baseComponentName);\n    };\n    wrappedComponent.displayName = baseComponentName;\n    // memo; we are not interested in deep updates\n    // in props; we assume that if deep objects are changed,\n    // this is in observables, which would have been tracked anyway\n    var memoComponent;\n    if (realOptions.forwardRef) {\n        // we have to use forwardRef here because:\n        // 1. it cannot go before memo, only after it\n        // 2. forwardRef converts the function into an actual component, so we can't let the baseComponent do it\n        //    since it wouldn't be a callable function anymore\n        memoComponent = memo(forwardRef(wrappedComponent));\n    }\n    else {\n        memoComponent = memo(wrappedComponent);\n    }\n    copyStaticProperties(baseComponent, memoComponent);\n    memoComponent.displayName = baseComponentName;\n    return memoComponent;\n}\n// based on https://github.com/mridgway/hoist-non-react-statics/blob/master/src/index.js\nvar hoistBlackList = {\n    $$typeof: true,\n    render: true,\n    compare: true,\n    type: true\n};\nfunction copyStaticProperties(base, target) {\n    Object.keys(base).forEach(function (key) {\n        if (!hoistBlackList[key]) {\n            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(base, key));\n        }\n    });\n}\n","import { useObserver } from \"./useObserver\";\nfunction ObserverComponent(_a) {\n    var children = _a.children, render = _a.render;\n    var component = children || render;\n    if (typeof component !== \"function\") {\n        return null;\n    }\n    return useObserver(component);\n}\nObserverComponent.propTypes = {\n    children: ObserverPropsCheck,\n    render: ObserverPropsCheck\n};\nObserverComponent.displayName = \"Observer\";\nexport { ObserverComponent as Observer };\nfunction ObserverPropsCheck(props, key, componentName, location, propFullName) {\n    var extraKey = key === \"children\" ? \"render\" : \"children\";\n    var hasProp = typeof props[key] === \"function\";\n    var hasExtraProp = typeof props[extraKey] === \"function\";\n    if (hasProp && hasExtraProp) {\n        return new Error(\"MobX Observer: Do not use children and render in the same time in`\" + componentName);\n    }\n    if (hasProp || hasExtraProp) {\n        return null;\n    }\n    return new Error(\"Invalid prop `\" +\n        propFullName +\n        \"` of type `\" +\n        typeof props[key] +\n        \"` supplied to\" +\n        \" `\" +\n        componentName +\n        \"`, expected `function`.\");\n}\n","var __read = (this && this.__read) || function (o, n) {\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n    if (!m) return o;\n    var i = m.call(o), r, ar = [], e;\n    try {\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\n    }\n    catch (error) { e = { error: error }; }\n    finally {\n        try {\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\n        }\n        finally { if (e) throw e.error; }\n    }\n    return ar;\n};\nimport { observable, runInAction } from \"mobx\";\nimport React from \"react\";\nimport { isPlainObject } from \"./utils\";\nexport function useAsObservableSourceInternal(current, usedByLocalStore) {\n    var culprit = usedByLocalStore ? \"useLocalStore\" : \"useAsObservableSource\";\n    if (\"production\" !== process.env.NODE_ENV && usedByLocalStore) {\n        var _a = __read(React.useState(current), 1), initialSource = _a[0];\n        if ((initialSource !== undefined && current === undefined) ||\n            (initialSource === undefined && current !== undefined)) {\n            throw new Error(\"make sure you never pass `undefined` to \" + culprit);\n        }\n    }\n    if (usedByLocalStore && current === undefined) {\n        return undefined;\n    }\n    if (\"production\" !== process.env.NODE_ENV && !isPlainObject(current)) {\n        throw new Error(culprit + \" expects a plain object as \" + (usedByLocalStore ? \"second\" : \"first\") + \" argument\");\n    }\n    var _b = __read(React.useState(function () { return observable(current, {}, { deep: false }); }), 1), res = _b[0];\n    if (\"production\" !== process.env.NODE_ENV &&\n        Object.keys(res).length !== Object.keys(current).length) {\n        throw new Error(\"the shape of objects passed to \" + culprit + \" should be stable\");\n    }\n    runInAction(function () {\n        Object.assign(res, current);\n    });\n    return res;\n}\nexport function useAsObservableSource(current) {\n    return useAsObservableSourceInternal(current, false);\n}\n","import \"./assertEnvironment\";\nimport { unstable_batchedUpdates as batch } from \"./utils/reactBatchedUpdates\";\nimport { observerBatching } from \"./observerBatching\";\nobserverBatching(batch);\nexport { isUsingStaticRendering, useStaticRendering } from \"./staticRendering\";\nexport { observer } from \"./observer\";\nexport { useObserver } from \"./useObserver\";\nexport { Observer } from \"./ObserverComponent\";\nexport { useForceUpdate } from \"./utils\";\nexport { useAsObservableSource } from \"./useAsObservableSource\";\nexport { useLocalStore } from \"./useLocalStore\";\nexport { useQueuedForceUpdate, useQueuedForceUpdateBlock } from \"./useQueuedForceUpdate\";\nexport { isObserverBatched, observerBatching } from \"./observerBatching\";\n","import React from 'react';\nimport {OrbitComponent} from '../base-components/orbit-component/orbit-component';\nimport {ORBIT_TAP} from '../../themes/css-global-classes';\n\n\ninterface TapHandlerProps {\n  enabled: boolean;\n  elementRef: any;\n}\n\nexport class TapHandlerLogic {\n    constructor(private _element: HTMLElement) {\n        this._element.addEventListener('click', this._onClickHandler);\n    }\n\n    private _timeoutRef = null;\n\n    private _onClickHandler = () => {\n        if (this._timeoutRef) {\n            return;\n        }\n\n        this._element.classList.add(ORBIT_TAP);\n        this._timeoutRef = setTimeout(() => {\n            this._element.classList.remove(ORBIT_TAP);\n            this._timeoutRef = null;\n        }, 150);\n\n    };\n\n    dispose() {\n        if(this._timeoutRef) {\n            clearTimeout(this._timeoutRef);\n        }\n\n        this._element.removeEventListener('click', this._onClickHandler);\n    }\n\n}\n\n\nexport class TapHandler extends OrbitComponent<TapHandlerProps> {\n\n\n  render() {\n    return (\n        <>\n          {this.props.children}\n        </>\n    )\n  }\n\n\n  private _tapHandlerLogic: TapHandlerLogic | null = null;\n\n  componentDidMount() {\n    super.componentDidMount();\n    if(this.props.enabled) {\n      this._tapHandlerLogic = new TapHandlerLogic(this.props.elementRef.current);\n    }\n\n  }\n\n  componentWillUnmount() {\n    super.componentWillUnmount();\n    if(this._tapHandlerLogic) {\n        this._tapHandlerLogic.dispose();\n    }\n  }\n\n\n}\n","var rng = require('./lib/rng');\nvar bytesToUuid = require('./lib/bytesToUuid');\n\nfunction v4(options, buf, offset) {\n  var i = buf && offset || 0;\n\n  if (typeof(options) == 'string') {\n    buf = options === 'binary' ? new Array(16) : null;\n    options = null;\n  }\n  options = options || {};\n\n  var rnds = options.random || (options.rng || rng)();\n\n  // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`\n  rnds[6] = (rnds[6] & 0x0f) | 0x40;\n  rnds[8] = (rnds[8] & 0x3f) | 0x80;\n\n  // Copy bytes to buffer, if provided\n  if (buf) {\n    for (var ii = 0; ii < 16; ++ii) {\n      buf[i + ii] = rnds[ii];\n    }\n  }\n\n  return buf || bytesToUuid(rnds);\n}\n\nmodule.exports = v4;\n","import {getCypressToOrbitHooks, NamedIntervalType, isInsideAutomation} from '../../utils/automation-helpers';\nimport {TimeIntervalName} from './time-interval-names';\nimport {Check, TimeSpan} from '@sparkware/app-utils';\n\nfunction convertToTimeSpan(interval: number | TimeSpan): TimeSpan {\n    if(Check.isNumber(interval)) {\n        return TimeSpan.fromMilliseconds(interval);\n    } else {\n        return interval;\n    }\n}\n\nfunction namedTimer(name: TimeIntervalName | null | undefined,\n                       handler: () => void,\n                       interval: TimeSpan | number,\n                       intervalType: NamedIntervalType,\n                       javascriptFunction: (handler: () => void, timeout: number) => number): number {\n\n    if(Check.isNullOrUndefined(handler)) {\n        throw new Error('namedInterval: handler argument cannot be null or undefined');\n    }\n\n    if(Check.isNullOrUndefined(interval)) {\n        throw new Error('namedInterval: interval argument cannot be null or undefined');\n    }\n\n    let timeSpan = convertToTimeSpan(interval);\n\n    if(name && isInsideAutomation()) {\n        const response = getCypressToOrbitHooks().onTimeIntervalCreation(name, handler, timeSpan, intervalType);\n        if(response.ignoreJavaScriptImplementation) {\n            // we are here because current running test decided to fake this timer\n            return response.timerId;\n        }\n    }\n\n\n\n    return javascriptFunction(handler, timeSpan.totalMilliseconds);\n}\n\n\n\nexport function namedSetInterval(name: TimeIntervalName, handler: () => void, interval: TimeSpan | number): number {\n    return namedTimer(name, handler, interval, NamedIntervalType.setInterval, setInterval);\n}\n\nexport function namedSetTimeout(name: TimeIntervalName, handler: () => void, interval: TimeSpan | number): number {\n    return namedTimer(name, handler, interval, NamedIntervalType.setTimeout, setTimeout);\n}","export class HttpError {\n  public readonly statusCode: number;\n  public readonly message: string;\n\n  constructor({status, statusText}: Response) {\n    this.statusCode = status;\n    this.message = status + ' - ' + statusText;\n  }\n}\n","import {\n  IHttpService\n} from './http.service.interface';\nimport {HttpError} from \"./interfaces\";\n\n\nexport class HttpService implements IHttpService {\n  async get(url: string, options?: RequestInit): Promise<any> {\n    const fetchedResponse = await this._fetchResponse(url,'GET', options);\n    return this._parseResponse(fetchedResponse);\n  }\n\n  async post(url: string, options?: RequestInit): Promise<any> {\n    const fetchedResponse = await this._fetchResponse(url, 'POST', options);\n    return this._parseResponse(fetchedResponse);\n  }\n\n  createUrlSearchParams(): URLSearchParams {\n    return new URLSearchParams();\n  }\n\n  createHeaders(): Headers {\n    return new Headers();\n  }\n\n  async _fetchResponse(url: string, method: string, options?: RequestInit):Promise<Response> {\n    options = {...options, method: method};\n    const response = await fetch(url, options);\n\n    return response;\n  }\n\n  async _parseResponse(response: Response):Promise<any> {\n    if(!response.ok) {\n      throw new HttpError(response);\n    }\n\n    const contentTypeHeader = response.headers.get('Content-Type') || '';\n    let charset = 'utf-8';\n    if(contentTypeHeader.indexOf('charset=') > -1) {\n      [,charset] = /charset=([^ ]+)/.exec(contentTypeHeader);\n    }\n\n    const blob = await response.blob();\n    const text = await this._decodeBlob(blob, charset);\n\n    if(contentTypeHeader.indexOf('application/json') >= 0) {\n      return JSON.parse(text);\n    } else {\n      return text;\n    }\n  }\n\n  private _decodeBlob(source: Blob, encoding: string = 'utf-16'): Promise<string> {\n    return new Promise(resolve => {\n      const reader = new FileReader();\n      reader.onloadend = () => {\n        resolve(reader.result as string);\n      };\n      reader.readAsText(source, encoding);\n    })\n  }\n}\n","import React from 'react';\nimport {IServiceFactory} from './services/service-factory.interface';\n\n\n\nexport interface IOrbitContext {\n  services: IServiceFactory\n}\n\nexport const OrbitContext = React.createContext<IOrbitContext>(null!);\n\nexport const OrbitContextProvider = OrbitContext.Provider;\nexport const OrbitContextConsumer = OrbitContext.Consumer;\n","import {IDomService} from './dom.service.interface';\nimport {EventListenerRegistration} from '../../../utils/event-listener-registration';\n\n\nexport class DomService implements IDomService {\n  constructor() {\n    this._eventListenerRegistration = new EventListenerRegistration(document);\n  }\n\n  disableScrolling(): void {\n    this.body.classList.add('no-scrolling');\n  }\n\n  enableScrolling(): void {\n    this.body.classList.remove('no-scrolling');\n  }\n\n  querySelector(selector: string): Element | null {\n    return document.querySelector(selector);\n  }\n\n  get body(): HTMLElement {\n    return document.body;\n  }\n\n  get head(): HTMLElement {\n    return document.head;\n  }\n\n  get html(): HTMLElement {\n      return document.documentElement;\n  }\n\n  setDocumentTitle(title: string): void {\n    if(title) {\n      document.title = title;\n    }\n  }\n\n  get locationPathName(): string {\n    return document.location.pathname;\n  }\n\n  private readonly _eventListenerRegistration;\n  get subscribeTo(): EventListenerRegistration {\n    return this._eventListenerRegistration;\n  }\n\n  getElementsByClassName(className: string): HTMLCollectionOf<Element> {\n    return document.getElementsByClassName(className);\n  }\n\n  getElementsByTagName(tagName: string): HTMLCollectionOf<Element> {\n    return document.getElementsByTagName(tagName);\n  }\n\n  getElementById(id: string): HTMLElement | null {\n    return document.getElementById(id);\n  }\n\n  createElement(tagName: string): HTMLElement {\n    return document.createElement(tagName);\n  }\n}\n","import {Check} from '@sparkware/app-utils';\n\nexport class Lazy<T>{\n  constructor(private _valueFactory: () => T) {\n  }\n\n  private _value = undefined;\n  private _initializing = false;\n  private _initValue() {\n    if(this._initializing) {\n      throw new Error('Lazy circular dependency detected: ' + this._valueFactory)\n    }\n    if(Check.isUndefined(this._value)) {\n      this._initializing = true;\n      try {\n        this._value = this._valueFactory();\n      }\n      finally {\n        this._initializing = false;\n      }\n\n    }\n  }\n\n  get value(): T {\n    this._initValue();\n\n    return this._value;\n  }\n\n  forceInit() {\n    this._initValue();\n  }\n}\n","import { matchPath } from 'react-router';\nimport {RouteDefinition, RouteParams} from '../routing-configuration/route-definition/route-definition';\n\n\nexport interface RouteMatchResult {\n    routeDefinition: RouteDefinition;\n    routeParams: RouteParams;\n}\nexport function tryMatchPath(pathToMatch: string, routes: RouteDefinition[]): RouteMatchResult {\n    for(let i = 0; i < routes.length; i++) {\n        let routeDefinition = routes[i];\n\n        for(let j = 0; j < routeDefinition.paths.length; j++) {\n            let pattern = routeDefinition.paths[j];\n            let match = matchPath(pathToMatch, {\n                path: pattern,\n                exact: routeDefinition.exact,\n                strict: false\n            });\n\n            if(match) {\n                return {\n                    routeDefinition: routeDefinition,\n                    routeParams: match.params\n                };\n            }\n        }\n    }\n\n    return null;\n}","'use strict';\n\nvar reactIs = require('react-is');\n\n/**\n * Copyright 2015, Yahoo! Inc.\n * Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.\n */\nvar REACT_STATICS = {\n  childContextTypes: true,\n  contextType: true,\n  contextTypes: true,\n  defaultProps: true,\n  displayName: true,\n  getDefaultProps: true,\n  getDerivedStateFromError: true,\n  getDerivedStateFromProps: true,\n  mixins: true,\n  propTypes: true,\n  type: true\n};\nvar KNOWN_STATICS = {\n  name: true,\n  length: true,\n  prototype: true,\n  caller: true,\n  callee: true,\n  arguments: true,\n  arity: true\n};\nvar FORWARD_REF_STATICS = {\n  '$$typeof': true,\n  render: true,\n  defaultProps: true,\n  displayName: true,\n  propTypes: true\n};\nvar MEMO_STATICS = {\n  '$$typeof': true,\n  compare: true,\n  defaultProps: true,\n  displayName: true,\n  propTypes: true,\n  type: true\n};\nvar TYPE_STATICS = {};\nTYPE_STATICS[reactIs.ForwardRef] = FORWARD_REF_STATICS;\n\nfunction getStatics(component) {\n  if (reactIs.isMemo(component)) {\n    return MEMO_STATICS;\n  }\n\n  return TYPE_STATICS[component['$$typeof']] || REACT_STATICS;\n}\n\nvar defineProperty = Object.defineProperty;\nvar getOwnPropertyNames = Object.getOwnPropertyNames;\nvar getOwnPropertySymbols = Object.getOwnPropertySymbols;\nvar getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\nvar getPrototypeOf = Object.getPrototypeOf;\nvar objectPrototype = Object.prototype;\nfunction hoistNonReactStatics(targetComponent, sourceComponent, blacklist) {\n  if (typeof sourceComponent !== 'string') {\n    // don't hoist over string (html) components\n    if (objectPrototype) {\n      var inheritedComponent = getPrototypeOf(sourceComponent);\n\n      if (inheritedComponent && inheritedComponent !== objectPrototype) {\n        hoistNonReactStatics(targetComponent, inheritedComponent, blacklist);\n      }\n    }\n\n    var keys = getOwnPropertyNames(sourceComponent);\n\n    if (getOwnPropertySymbols) {\n      keys = keys.concat(getOwnPropertySymbols(sourceComponent));\n    }\n\n    var targetStatics = getStatics(targetComponent);\n    var sourceStatics = getStatics(sourceComponent);\n\n    for (var i = 0; i < keys.length; ++i) {\n      var key = keys[i];\n\n      if (!KNOWN_STATICS[key] && !(blacklist && blacklist[key]) && !(sourceStatics && sourceStatics[key]) && !(targetStatics && targetStatics[key])) {\n        var descriptor = getOwnPropertyDescriptor(sourceComponent, key);\n\n        try {\n          // Avoid failures from read-only properties\n          defineProperty(targetComponent, key, descriptor);\n        } catch (e) {}\n      }\n    }\n  }\n\n  return targetComponent;\n}\n\nmodule.exports = hoistNonReactStatics;\n","var isProduction = process.env.NODE_ENV === 'production';\nvar prefix = 'Invariant failed';\nfunction invariant(condition, message) {\n  if (condition) {\n    return;\n  }\n\n  if (isProduction) {\n    throw new Error(prefix);\n  } else {\n    throw new Error(prefix + \": \" + (message || ''));\n  }\n}\n\nexport default invariant;\n","import {RouteDefinition, RouteParams, RouteRender} from '../../routing-configuration/route-definition/route-definition';\nimport {IRoute} from \"./route.interface\";\nimport React from \"react\";\n\nexport class FallbackRoute implements IRoute{\n  private readonly _routeDefinition: RouteDefinition;\n\n  constructor(render: RouteRender) {\n    this._routeDefinition = {\n      paths: [],\n      render: render\n    }\n  }\n\n  render(): React.ReactNode {\n    return this._routeDefinition.render(this.routeParams);\n  }\n\n  get routeParams(): RouteParams {\n    return {};\n  }\n\n  get isOrbitRoute(): boolean {\n    return false;\n  }\n\n  get data(): any {\n    return {};\n  }\n\n  get routeDefinition(): RouteDefinition {\n    return this._routeDefinition;\n  }\n\n  protected  _isMiniOrbitRoute(): boolean {\n    return false;\n  }\n}\n","import {IRoute} from './route.interface';\nimport {RouteData, RouteDefinition, RouteParams} from '../../routing-configuration/route-definition/route-definition';\nimport React from 'react';\n\nexport abstract class RouteBase implements IRoute {\n  constructor(private _routeDefinition: RouteDefinition, private _routeParams: RouteParams) {}\n\n  render(): React.ReactNode {\n    return this._routeDefinition?.render(this._routeParams);\n  }\n\n  get routeParams(): RouteParams {\n    return this._routeParams;\n  }\n\n  get isOrbitRoute(): boolean {\n    return this._isOrbitRoute();\n  }\n\n  get data(): RouteData {\n    return this._routeDefinition.data;\n  }\n\n  get routeDefinition(): RouteDefinition {\n    return this._routeDefinition;\n  }\n\n\n  protected abstract _isOrbitRoute(): boolean;\n\n}\n","// Unique ID creation requires a high quality random # generator.  In the\n// browser this is a little complicated due to unknown quality of Math.random()\n// and inconsistent support for the `crypto` API.  We do the best we can via\n// feature-detection\n\n// getRandomValues needs to be invoked in a context where \"this\" is a Crypto\n// implementation. Also, find the complete implementation of crypto on IE11.\nvar getRandomValues = (typeof(crypto) != 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto)) ||\n                      (typeof(msCrypto) != 'undefined' && typeof window.msCrypto.getRandomValues == 'function' && msCrypto.getRandomValues.bind(msCrypto));\n\nif (getRandomValues) {\n  // WHATWG crypto RNG - http://wiki.whatwg.org/wiki/Crypto\n  var rnds8 = new Uint8Array(16); // eslint-disable-line no-undef\n\n  module.exports = function whatwgRNG() {\n    getRandomValues(rnds8);\n    return rnds8;\n  };\n} else {\n  // Math.random()-based (RNG)\n  //\n  // If all else fails, use Math.random().  It's fast, but is of unspecified\n  // quality.\n  var rnds = new Array(16);\n\n  module.exports = function mathRNG() {\n    for (var i = 0, r; i < 16; i++) {\n      if ((i & 0x03) === 0) r = Math.random() * 0x100000000;\n      rnds[i] = r >>> ((i & 0x03) << 3) & 0xff;\n    }\n\n    return rnds;\n  };\n}\n","/**\n * Convert array of 16 byte values to UUID string format of the form:\n * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX\n */\nvar byteToHex = [];\nfor (var i = 0; i < 256; ++i) {\n  byteToHex[i] = (i + 0x100).toString(16).substr(1);\n}\n\nfunction bytesToUuid(buf, offset) {\n  var i = offset || 0;\n  var bth = byteToHex;\n  // join used to fix memory issue caused by concatenation: https://bugs.chromium.org/p/v8/issues/detail?id=3175#c4\n  return ([bth[buf[i++]], bth[buf[i++]], \n\tbth[buf[i++]], bth[buf[i++]], '-',\n\tbth[buf[i++]], bth[buf[i++]], '-',\n\tbth[buf[i++]], bth[buf[i++]], '-',\n\tbth[buf[i++]], bth[buf[i++]], '-',\n\tbth[buf[i++]], bth[buf[i++]],\n\tbth[buf[i++]], bth[buf[i++]],\n\tbth[buf[i++]], bth[buf[i++]]]).join('');\n}\n\nmodule.exports = bytesToUuid;\n","import {ISplashService} from './splash-service.interface';\nimport {Check} from '@sparkware/app-utils';\n\nexport class SplashService implements ISplashService {\n  constructor() {\n    //document.body.style.position = 'fixed';\n    document.body.classList.add('disable-animations');\n  }\n\n  computeSplashTimeInSeconds(startTime: number): number {\n    return parseFloat(((performance.now() - startTime) / 1000).toFixed(2));\n  }\n\n  splashTime: number = null;\n\n  removeSplash(): void   {\n    if(!Check.isNull(this.splashTime)) {\n      console.error('removeSplash called second time!');\n      return;\n    }\n    //document.body.style.removeProperty('position');\n    document.body.classList.remove('disable-animations');\n    let splashPageElement = document.getElementById('splash-page');\n    if(splashPageElement) {\n      splashPageElement.remove();\n    }\n    this.splashTime = this.computeSplashTimeInSeconds(window['splashStart']);\n\n    this._splashRemovedSubscribers.forEach(callback => callback());\n\n  }\n\n  private _splashRemovedSubscribers: Array<() => void> = [];\n  onSplashRemoved(callback: () => void) {\n    this._splashRemovedSubscribers.push(callback);\n  }\n\n}\n","import React from 'react';\nimport {TapHandlerLogic} from '../../tap-handler/tap-handler.component';\nimport {OrbitComponentWithState} from \"../../base-components/orbit-component-with-state/orbit-component-with-state\";\n\nenum IMAGE_TYPE {\n    EMPTY_IMAGE_BASE64,\n    FALLBACK,\n    SRC\n};\nenum IMAGE_STATUS {\n    LAZY,\n    LOADING,\n    SETTLED\n}\n\ninterface ImageSettleStatus {\n    value: \"load\" | \"error\",\n    type: IMAGE_TYPE,\n}\n\n/**\n * We could have defined this interface as \"ImageProps extends React.ImgHTMLAttributes<HTMLImageElement>\"\n * and define inside only what's extra (like \"lazy\" or \"fallbackSrc\") and props that alter the original def (like \"width: number\" instead of default \"width: string | number\")\n * But in case of someone styling the \"Image\" component with: styled(Image)<{squareIcon: boolean}>. The extra prop will bleed into the DOM and React will throw:\n * -- \"Warning: React does not recognize the `squareIcon` prop on a DOM element. If you intentionally want it to appear in the DOM as a custom attribute, spell it as lowercase `squareicon` instead. If you accidentally passed it from a parent component, remove it from the DOM element.\"\n * Also, ocasionally I am getting this warning\n * -- \"Warning: React does not recognize the `forwardedRef` prop on a DOM element. If you intentionally want it to appear in the DOM as a custom attribute, spell it as lowercase `forwardedref` instead. If you accidentally passed it from a parent component, remove it from the DOM element.\"\n *\n * So I am whitelisting props we actually use, and I am filtering based on that\n */\nexport interface ImageProps {\n    // props common with React.ImgHTMLAttributes<HTMLImageElement>\n    src: string;\n    alt?: string;\n    className?: string;\n    title?: string;\n    onClick?(event: React.MouseEvent<HTMLImageElement, MouseEvent>): void;\n    onLoad?(e: React.SyntheticEvent<HTMLImageElement, Event>): void;\n    onError?(e: React.SyntheticEvent<HTMLImageElement, Event>): void;\n\n    // props derived from React.ImgHTMLAttributes<HTMLImageElement> with slight changes\n    width?: number; // instead of string | number\n    height?: number; // instead of string | number\n\n    // custom props\n    fallbackSrc?: string;\n    enableTap?: boolean;\n    lazy?: boolean;\n    onLoadStart?(): void;\n    onSettled?(settleStatus: ImageSettleStatus): void;\n}\n\ninterface ImageState {\n    src: string;\n    type: IMAGE_TYPE;\n    status: IMAGE_STATUS;\n}\n\nconst EMPTY_IMAGE = 'data:image/gif;base64,R0lGODlhAQABAAD/ACwAAAAAAQABAAACADs=';\n\nexport class Image extends OrbitComponentWithState<ImageProps, ImageState> {\n\n    constructor(props: ImageProps) {\n        super(props);\n        this.state = this._getInitialSrcState();\n    }\n\n    private _getInitialSrcState() {\n        /**\n         * If this is a lazy load image we initialize the state.src with the fallback image from props\n         * but in case this is not provided we just set an empty image gif.\n         * This will prevent the borders to be visible around the image while scrolled into the view.\n         */\n        if (this.props.lazy) {\n            return {\n                src: this.props.fallbackSrc || EMPTY_IMAGE,\n                type: this.props.fallbackSrc ? IMAGE_TYPE.FALLBACK : IMAGE_TYPE.EMPTY_IMAGE_BASE64,\n                status: IMAGE_STATUS.LAZY\n            };\n        }\n        if (this.props.onLoadStart) {\n            this.props.onLoadStart();\n        }\n        return {\n            src: this.props.src,\n            type: IMAGE_TYPE.SRC,\n            status: IMAGE_STATUS.LOADING\n        };\n    }\n\n    private _onLoad = (e: React.SyntheticEvent<HTMLImageElement, Event>) => {\n        if (this.state.status === IMAGE_STATUS.LAZY) {\n            return;\n        }\n        if (this.state.status === IMAGE_STATUS.LOADING) {\n            this.setState({\n                status: IMAGE_STATUS.SETTLED\n            });\n            if (this.state.type === IMAGE_TYPE.SRC && this.props.onLoad) {\n                this.props.onLoad(e);\n            }\n            if (this.props.onSettled) {\n                this.props.onSettled({\n                    value: \"load\",\n                    type: this.state.type\n                });\n            }\n        }\n    }\n    private _onError = (e: React.SyntheticEvent<HTMLImageElement, Event>) => {\n        if (this.state.status === IMAGE_STATUS.LAZY && this.state.type === IMAGE_TYPE.FALLBACK) {\n            this.setState({\n                src: EMPTY_IMAGE,\n                type: IMAGE_TYPE.EMPTY_IMAGE_BASE64,\n            });\n        }\n        if (this.state.status === IMAGE_STATUS.LOADING) {\n            if (this.state.type === IMAGE_TYPE.SRC) {\n                this.setState({\n                    src: this.props.fallbackSrc || EMPTY_IMAGE,\n                    type: this.props.fallbackSrc ? IMAGE_TYPE.FALLBACK : IMAGE_TYPE.EMPTY_IMAGE_BASE64\n                });\n                if (this.props.onError) {\n                    this.props.onError(e);\n                }\n            } else if (this.state.type === IMAGE_TYPE.FALLBACK) {\n                this.setState({\n                    src: EMPTY_IMAGE,\n                    type: IMAGE_TYPE.EMPTY_IMAGE_BASE64,\n                });\n            } else if (this.state.type === IMAGE_TYPE.EMPTY_IMAGE_BASE64) {\n                this.setState({\n                    status: IMAGE_STATUS.SETTLED\n                });\n                if (this.props.onSettled) {\n                    this.props.onSettled({\n                        value: \"error\",\n                        type: this.state.type\n                    });\n                }\n            }\n        }\n    }\n\n    componentWillUnmount() {\n        super.componentWillUnmount();\n        this._destroyIntersectionObserver();\n        this._destroyTapLogicHandler();\n    }\n\n    componentDidUpdate(prevProps: ImageProps) {\n        if (this.props.fallbackSrc !== prevProps.fallbackSrc && this.state.type === IMAGE_TYPE.FALLBACK) {\n            this.setState({\n                src: this.props.fallbackSrc\n            });\n        }\n        if (this.props.src !== prevProps.src) {\n            if (this.state.status === IMAGE_STATUS.SETTLED) {\n                this.setState({\n                    src: this.props.src,\n                    type: IMAGE_TYPE.SRC\n                });\n            }\n        }\n    }\n\n    private _tapHandlerLogic: TapHandlerLogic | null = null;\n    private _createTapLogicHandler(element: HTMLElement) {\n        if (this.props.enableTap) {\n            this._destroyTapLogicHandler();\n            this._tapHandlerLogic = new TapHandlerLogic(element);\n        }\n    }\n\n    private _destroyTapLogicHandler() {\n        if (this._tapHandlerLogic) {\n            this._tapHandlerLogic.dispose();\n            this._tapHandlerLogic = null;\n        }\n    }\n\n    private _intersectionObserver: IntersectionObserver | null;\n\n    private _createIntersectionObserver(element: HTMLImageElement) {\n        if (!this.props.lazy) {\n            return;\n        }\n\n        // just in case this is called twice for this component we want to discard the existing intersection observer and create a new one\n        this._destroyIntersectionObserver();\n\n        this._intersectionObserver = new IntersectionObserver(this._intersectionObserverCallback, {\n            // if we don't attach to the correct scroll container (the one that has the scroll bars) then the rootMargin doesn't work correctly\n            root: this.services.mainScreen.mainScreenElement,\n            rootMargin: '15px',\n            threshold: 0.1\n        });\n\n        this._intersectionObserver.observe(element);\n    }\n\n    private _destroyIntersectionObserver() {\n        if (this._intersectionObserver) {\n            this._intersectionObserver.disconnect();\n            this._intersectionObserver = null;\n        }\n    }\n\n    private _intersectionObserverCallback = (entries: IntersectionObserverEntry[], observer: IntersectionObserver) => {\n        if (entries[0].intersectionRatio > 0 || entries[0].isIntersecting) {\n            this._destroyIntersectionObserver();\n\n            this.setState({\n                src: this.props.src,\n                type: IMAGE_TYPE.SRC,\n                status: IMAGE_STATUS.LOADING\n            });\n\n            if (this.props.onLoadStart) {\n                this.props.onLoadStart();\n            }\n        }\n    };\n\n    private _captureImageElementRef = (element: HTMLImageElement) => {\n        if (element) {\n            this._createTapLogicHandler(element);\n            this._createIntersectionObserver(element);\n        }\n    };\n\n    render() {\n        let {\n            // standard img props that need to be altered\n            alt,\n            // pass-through props\n            className, title, width, height,\n        } = this.props;\n\n        return <img\n            className={className}\n            title={title}\n            width={width}\n            height={height}\n            /*alt is set here to avoid a react warning which says that all images must have an alt property*/\n            alt={alt || ''}\n            src={this.state.src}\n            ref={this._captureImageElementRef}\n            onLoad={this._onLoad}\n            onError={this._onError}\n            onClick={this.props.onClick}\n        />;\n    }\n\n}\n","function _typeof(obj) {\n  if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n    module.exports = _typeof = function _typeof(obj) {\n      return typeof obj;\n    };\n  } else {\n    module.exports = _typeof = function _typeof(obj) {\n      return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n    };\n  }\n\n  return _typeof(obj);\n}\n\nmodule.exports = _typeof;","function _interopRequireDefault(obj) {\n  return obj && obj.__esModule ? obj : {\n    \"default\": obj\n  };\n}\n\nmodule.exports = _interopRequireDefault;","import React, { Component } from 'react';\nimport _inheritsLoose from '@babel/runtime/helpers/inheritsLoose';\nimport PropTypes from 'prop-types';\nimport gud from 'gud';\nimport warning from 'tiny-warning';\n\nvar MAX_SIGNED_31_BIT_INT = 1073741823;\n\nfunction objectIs(x, y) {\n  if (x === y) {\n    return x !== 0 || 1 / x === 1 / y;\n  } else {\n    return x !== x && y !== y;\n  }\n}\n\nfunction createEventEmitter(value) {\n  var handlers = [];\n  return {\n    on: function on(handler) {\n      handlers.push(handler);\n    },\n    off: function off(handler) {\n      handlers = handlers.filter(function (h) {\n        return h !== handler;\n      });\n    },\n    get: function get() {\n      return value;\n    },\n    set: function set(newValue, changedBits) {\n      value = newValue;\n      handlers.forEach(function (handler) {\n        return handler(value, changedBits);\n      });\n    }\n  };\n}\n\nfunction onlyChild(children) {\n  return Array.isArray(children) ? children[0] : children;\n}\n\nfunction createReactContext(defaultValue, calculateChangedBits) {\n  var _Provider$childContex, _Consumer$contextType;\n\n  var contextProp = '__create-react-context-' + gud() + '__';\n\n  var Provider =\n  /*#__PURE__*/\n  function (_Component) {\n    _inheritsLoose(Provider, _Component);\n\n    function Provider() {\n      var _this;\n\n      _this = _Component.apply(this, arguments) || this;\n      _this.emitter = createEventEmitter(_this.props.value);\n      return _this;\n    }\n\n    var _proto = Provider.prototype;\n\n    _proto.getChildContext = function getChildContext() {\n      var _ref;\n\n      return _ref = {}, _ref[contextProp] = this.emitter, _ref;\n    };\n\n    _proto.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {\n      if (this.props.value !== nextProps.value) {\n        var oldValue = this.props.value;\n        var newValue = nextProps.value;\n        var changedBits;\n\n        if (objectIs(oldValue, newValue)) {\n          changedBits = 0;\n        } else {\n          changedBits = typeof calculateChangedBits === 'function' ? calculateChangedBits(oldValue, newValue) : MAX_SIGNED_31_BIT_INT;\n\n          if (process.env.NODE_ENV !== 'production') {\n            warning((changedBits & MAX_SIGNED_31_BIT_INT) === changedBits, 'calculateChangedBits: Expected the return value to be a ' + '31-bit integer. Instead received: ' + changedBits);\n          }\n\n          changedBits |= 0;\n\n          if (changedBits !== 0) {\n            this.emitter.set(nextProps.value, changedBits);\n          }\n        }\n      }\n    };\n\n    _proto.render = function render() {\n      return this.props.children;\n    };\n\n    return Provider;\n  }(Component);\n\n  Provider.childContextTypes = (_Provider$childContex = {}, _Provider$childContex[contextProp] = PropTypes.object.isRequired, _Provider$childContex);\n\n  var Consumer =\n  /*#__PURE__*/\n  function (_Component2) {\n    _inheritsLoose(Consumer, _Component2);\n\n    function Consumer() {\n      var _this2;\n\n      _this2 = _Component2.apply(this, arguments) || this;\n      _this2.state = {\n        value: _this2.getValue()\n      };\n\n      _this2.onUpdate = function (newValue, changedBits) {\n        var observedBits = _this2.observedBits | 0;\n\n        if ((observedBits & changedBits) !== 0) {\n          _this2.setState({\n            value: _this2.getValue()\n          });\n        }\n      };\n\n      return _this2;\n    }\n\n    var _proto2 = Consumer.prototype;\n\n    _proto2.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {\n      var observedBits = nextProps.observedBits;\n      this.observedBits = observedBits === undefined || observedBits === null ? MAX_SIGNED_31_BIT_INT : observedBits;\n    };\n\n    _proto2.componentDidMount = function componentDidMount() {\n      if (this.context[contextProp]) {\n        this.context[contextProp].on(this.onUpdate);\n      }\n\n      var observedBits = this.props.observedBits;\n      this.observedBits = observedBits === undefined || observedBits === null ? MAX_SIGNED_31_BIT_INT : observedBits;\n    };\n\n    _proto2.componentWillUnmount = function componentWillUnmount() {\n      if (this.context[contextProp]) {\n        this.context[contextProp].off(this.onUpdate);\n      }\n    };\n\n    _proto2.getValue = function getValue() {\n      if (this.context[contextProp]) {\n        return this.context[contextProp].get();\n      } else {\n        return defaultValue;\n      }\n    };\n\n    _proto2.render = function render() {\n      return onlyChild(this.props.children)(this.state.value);\n    };\n\n    return Consumer;\n  }(Component);\n\n  Consumer.contextTypes = (_Consumer$contextType = {}, _Consumer$contextType[contextProp] = PropTypes.object, _Consumer$contextType);\n  return {\n    Provider: Provider,\n    Consumer: Consumer\n  };\n}\n\nvar index = React.createContext || createReactContext;\n\nexport default index;\n","function _inheritsLoose(subClass, superClass) {\n  subClass.prototype = Object.create(superClass.prototype);\n  subClass.prototype.constructor = subClass;\n  subClass.__proto__ = superClass;\n}\n\nmodule.exports = _inheritsLoose;","// @flow\n'use strict';\n\nvar key = '__global_unique_id__';\n\nmodule.exports = function() {\n  return global[key] = (global[key] || 0) + 1;\n};\n","var isarray = require('isarray')\n\n/**\n * Expose `pathToRegexp`.\n */\nmodule.exports = pathToRegexp\nmodule.exports.parse = parse\nmodule.exports.compile = compile\nmodule.exports.tokensToFunction = tokensToFunction\nmodule.exports.tokensToRegExp = tokensToRegExp\n\n/**\n * The main path matching regexp utility.\n *\n * @type {RegExp}\n */\nvar PATH_REGEXP = new RegExp([\n  // Match escaped characters that would otherwise appear in future matches.\n  // This allows the user to escape special characters that won't transform.\n  '(\\\\\\\\.)',\n  // Match Express-style parameters and un-named parameters with a prefix\n  // and optional suffixes. Matches appear as:\n  //\n  // \"/:test(\\\\d+)?\" => [\"/\", \"test\", \"\\d+\", undefined, \"?\", undefined]\n  // \"/route(\\\\d+)\"  => [undefined, undefined, undefined, \"\\d+\", undefined, undefined]\n  // \"/*\"            => [\"/\", undefined, undefined, undefined, undefined, \"*\"]\n  '([\\\\/.])?(?:(?:\\\\:(\\\\w+)(?:\\\\(((?:\\\\\\\\.|[^\\\\\\\\()])+)\\\\))?|\\\\(((?:\\\\\\\\.|[^\\\\\\\\()])+)\\\\))([+*?])?|(\\\\*))'\n].join('|'), 'g')\n\n/**\n * Parse a string for the raw tokens.\n *\n * @param  {string}  str\n * @param  {Object=} options\n * @return {!Array}\n */\nfunction parse (str, options) {\n  var tokens = []\n  var key = 0\n  var index = 0\n  var path = ''\n  var defaultDelimiter = options && options.delimiter || '/'\n  var res\n\n  while ((res = PATH_REGEXP.exec(str)) != null) {\n    var m = res[0]\n    var escaped = res[1]\n    var offset = res.index\n    path += str.slice(index, offset)\n    index = offset + m.length\n\n    // Ignore already escaped sequences.\n    if (escaped) {\n      path += escaped[1]\n      continue\n    }\n\n    var next = str[index]\n    var prefix = res[2]\n    var name = res[3]\n    var capture = res[4]\n    var group = res[5]\n    var modifier = res[6]\n    var asterisk = res[7]\n\n    // Push the current path onto the tokens.\n    if (path) {\n      tokens.push(path)\n      path = ''\n    }\n\n    var partial = prefix != null && next != null && next !== prefix\n    var repeat = modifier === '+' || modifier === '*'\n    var optional = modifier === '?' || modifier === '*'\n    var delimiter = res[2] || defaultDelimiter\n    var pattern = capture || group\n\n    tokens.push({\n      name: name || key++,\n      prefix: prefix || '',\n      delimiter: delimiter,\n      optional: optional,\n      repeat: repeat,\n      partial: partial,\n      asterisk: !!asterisk,\n      pattern: pattern ? escapeGroup(pattern) : (asterisk ? '.*' : '[^' + escapeString(delimiter) + ']+?')\n    })\n  }\n\n  // Match any characters still remaining.\n  if (index < str.length) {\n    path += str.substr(index)\n  }\n\n  // If the path exists, push it onto the end.\n  if (path) {\n    tokens.push(path)\n  }\n\n  return tokens\n}\n\n/**\n * Compile a string to a template function for the path.\n *\n * @param  {string}             str\n * @param  {Object=}            options\n * @return {!function(Object=, Object=)}\n */\nfunction compile (str, options) {\n  return tokensToFunction(parse(str, options), options)\n}\n\n/**\n * Prettier encoding of URI path segments.\n *\n * @param  {string}\n * @return {string}\n */\nfunction encodeURIComponentPretty (str) {\n  return encodeURI(str).replace(/[\\/?#]/g, function (c) {\n    return '%' + c.charCodeAt(0).toString(16).toUpperCase()\n  })\n}\n\n/**\n * Encode the asterisk parameter. Similar to `pretty`, but allows slashes.\n *\n * @param  {string}\n * @return {string}\n */\nfunction encodeAsterisk (str) {\n  return encodeURI(str).replace(/[?#]/g, function (c) {\n    return '%' + c.charCodeAt(0).toString(16).toUpperCase()\n  })\n}\n\n/**\n * Expose a method for transforming tokens into the path function.\n */\nfunction tokensToFunction (tokens, options) {\n  // Compile all the tokens into regexps.\n  var matches = new Array(tokens.length)\n\n  // Compile all the patterns before compilation.\n  for (var i = 0; i < tokens.length; i++) {\n    if (typeof tokens[i] === 'object') {\n      matches[i] = new RegExp('^(?:' + tokens[i].pattern + ')$', flags(options))\n    }\n  }\n\n  return function (obj, opts) {\n    var path = ''\n    var data = obj || {}\n    var options = opts || {}\n    var encode = options.pretty ? encodeURIComponentPretty : encodeURIComponent\n\n    for (var i = 0; i < tokens.length; i++) {\n      var token = tokens[i]\n\n      if (typeof token === 'string') {\n        path += token\n\n        continue\n      }\n\n      var value = data[token.name]\n      var segment\n\n      if (value == null) {\n        if (token.optional) {\n          // Prepend partial segment prefixes.\n          if (token.partial) {\n            path += token.prefix\n          }\n\n          continue\n        } else {\n          throw new TypeError('Expected \"' + token.name + '\" to be defined')\n        }\n      }\n\n      if (isarray(value)) {\n        if (!token.repeat) {\n          throw new TypeError('Expected \"' + token.name + '\" to not repeat, but received `' + JSON.stringify(value) + '`')\n        }\n\n        if (value.length === 0) {\n          if (token.optional) {\n            continue\n          } else {\n            throw new TypeError('Expected \"' + token.name + '\" to not be empty')\n          }\n        }\n\n        for (var j = 0; j < value.length; j++) {\n          segment = encode(value[j])\n\n          if (!matches[i].test(segment)) {\n            throw new TypeError('Expected all \"' + token.name + '\" to match \"' + token.pattern + '\", but received `' + JSON.stringify(segment) + '`')\n          }\n\n          path += (j === 0 ? token.prefix : token.delimiter) + segment\n        }\n\n        continue\n      }\n\n      segment = token.asterisk ? encodeAsterisk(value) : encode(value)\n\n      if (!matches[i].test(segment)) {\n        throw new TypeError('Expected \"' + token.name + '\" to match \"' + token.pattern + '\", but received \"' + segment + '\"')\n      }\n\n      path += token.prefix + segment\n    }\n\n    return path\n  }\n}\n\n/**\n * Escape a regular expression string.\n *\n * @param  {string} str\n * @return {string}\n */\nfunction escapeString (str) {\n  return str.replace(/([.+*?=^!:${}()[\\]|\\/\\\\])/g, '\\\\$1')\n}\n\n/**\n * Escape the capturing group by escaping special characters and meaning.\n *\n * @param  {string} group\n * @return {string}\n */\nfunction escapeGroup (group) {\n  return group.replace(/([=!:$\\/()])/g, '\\\\$1')\n}\n\n/**\n * Attach the keys as a property of the regexp.\n *\n * @param  {!RegExp} re\n * @param  {Array}   keys\n * @return {!RegExp}\n */\nfunction attachKeys (re, keys) {\n  re.keys = keys\n  return re\n}\n\n/**\n * Get the flags for a regexp from the options.\n *\n * @param  {Object} options\n * @return {string}\n */\nfunction flags (options) {\n  return options && options.sensitive ? '' : 'i'\n}\n\n/**\n * Pull out keys from a regexp.\n *\n * @param  {!RegExp} path\n * @param  {!Array}  keys\n * @return {!RegExp}\n */\nfunction regexpToRegexp (path, keys) {\n  // Use a negative lookahead to match only capturing groups.\n  var groups = path.source.match(/\\((?!\\?)/g)\n\n  if (groups) {\n    for (var i = 0; i < groups.length; i++) {\n      keys.push({\n        name: i,\n        prefix: null,\n        delimiter: null,\n        optional: false,\n        repeat: false,\n        partial: false,\n        asterisk: false,\n        pattern: null\n      })\n    }\n  }\n\n  return attachKeys(path, keys)\n}\n\n/**\n * Transform an array into a regexp.\n *\n * @param  {!Array}  path\n * @param  {Array}   keys\n * @param  {!Object} options\n * @return {!RegExp}\n */\nfunction arrayToRegexp (path, keys, options) {\n  var parts = []\n\n  for (var i = 0; i < path.length; i++) {\n    parts.push(pathToRegexp(path[i], keys, options).source)\n  }\n\n  var regexp = new RegExp('(?:' + parts.join('|') + ')', flags(options))\n\n  return attachKeys(regexp, keys)\n}\n\n/**\n * Create a path regexp from string input.\n *\n * @param  {string}  path\n * @param  {!Array}  keys\n * @param  {!Object} options\n * @return {!RegExp}\n */\nfunction stringToRegexp (path, keys, options) {\n  return tokensToRegExp(parse(path, options), keys, options)\n}\n\n/**\n * Expose a function for taking tokens and returning a RegExp.\n *\n * @param  {!Array}          tokens\n * @param  {(Array|Object)=} keys\n * @param  {Object=}         options\n * @return {!RegExp}\n */\nfunction tokensToRegExp (tokens, keys, options) {\n  if (!isarray(keys)) {\n    options = /** @type {!Object} */ (keys || options)\n    keys = []\n  }\n\n  options = options || {}\n\n  var strict = options.strict\n  var end = options.end !== false\n  var route = ''\n\n  // Iterate over the tokens and create our regexp string.\n  for (var i = 0; i < tokens.length; i++) {\n    var token = tokens[i]\n\n    if (typeof token === 'string') {\n      route += escapeString(token)\n    } else {\n      var prefix = escapeString(token.prefix)\n      var capture = '(?:' + token.pattern + ')'\n\n      keys.push(token)\n\n      if (token.repeat) {\n        capture += '(?:' + prefix + capture + ')*'\n      }\n\n      if (token.optional) {\n        if (!token.partial) {\n          capture = '(?:' + prefix + '(' + capture + '))?'\n        } else {\n          capture = prefix + '(' + capture + ')?'\n        }\n      } else {\n        capture = prefix + '(' + capture + ')'\n      }\n\n      route += capture\n    }\n  }\n\n  var delimiter = escapeString(options.delimiter || '/')\n  var endsWithDelimiter = route.slice(-delimiter.length) === delimiter\n\n  // In non-strict mode we allow a slash at the end of match. If the path to\n  // match already ends with a slash, we remove it for consistency. The slash\n  // is valid at the end of a path match, not in the middle. This is important\n  // in non-ending mode, where \"/test/\" shouldn't match \"/test//route\".\n  if (!strict) {\n    route = (endsWithDelimiter ? route.slice(0, -delimiter.length) : route) + '(?:' + delimiter + '(?=$))?'\n  }\n\n  if (end) {\n    route += '$'\n  } else {\n    // In non-ending mode, we need the capturing groups to match as much as\n    // possible by using a positive lookahead to the end or next path segment.\n    route += strict && endsWithDelimiter ? '' : '(?=' + delimiter + '|$)'\n  }\n\n  return attachKeys(new RegExp('^' + route, flags(options)), keys)\n}\n\n/**\n * Normalize the given path string, returning a regular expression.\n *\n * An empty array can be passed in for the keys, which will hold the\n * placeholder key descriptions. For example, using `/user/:id`, `keys` will\n * contain `[{ name: 'id', delimiter: '/', optional: false, repeat: false }]`.\n *\n * @param  {(string|RegExp|Array)} path\n * @param  {(Array|Object)=}       keys\n * @param  {Object=}               options\n * @return {!RegExp}\n */\nfunction pathToRegexp (path, keys, options) {\n  if (!isarray(keys)) {\n    options = /** @type {!Object} */ (keys || options)\n    keys = []\n  }\n\n  options = options || {}\n\n  if (path instanceof RegExp) {\n    return regexpToRegexp(path, /** @type {!Array} */ (keys))\n  }\n\n  if (isarray(path)) {\n    return arrayToRegexp(/** @type {!Array} */ (path), /** @type {!Array} */ (keys), options)\n  }\n\n  return stringToRegexp(/** @type {string} */ (path), /** @type {!Array} */ (keys), options)\n}\n","module.exports = Array.isArray || function (arr) {\n  return Object.prototype.toString.call(arr) == '[object Array]';\n};\n","import React from 'react';\nimport {IServiceFactory} from '../../../services/service-factory.interface';\nimport {OrbitContext} from '../../../orbit-context';\nimport {reaction as mobxReaction, IReactionDisposer, IReactionOptions, IReactionPublic} from 'mobx';\n\nexport class OrbitComponentWithState<TProps, TState> extends React.Component<TProps, TState> {\n\n    private _reactions: IReactionDisposer[] = [];\n\n    protected get services(): IServiceFactory {\n        /** This code is for unit tests, enzyme is not compatible wit the current react context api so we pass the context through a prop */\n        if ((this.props as any)['context']) {\n            return (this.props as any)['context'].services;\n        }\n\n        return this.context.services;\n    }\n\n    //React life time hooks stubs for future use\n    componentDidMount() {}\n\n    componentWillUnmount() {\n        this._disposeReactions();\n    }\n\n\n    protected reaction<T>(expression: (r: IReactionPublic) => T, effect: (arg: T, r: IReactionPublic) => void, opts?: IReactionOptions): IReactionDisposer {\n        let disposer = mobxReaction(expression, effect, opts);\n        this._reactions.push(disposer);\n        return disposer;\n    }\n\n    private _disposeReactions() {\n        this._reactions.forEach(disposer => disposer());\n    }\n}\n\nOrbitComponentWithState.contextType = OrbitContext;\n","var _typeof = require(\"../helpers/typeof\");\n\nfunction _getRequireWildcardCache() {\n  if (typeof WeakMap !== \"function\") return null;\n  var cache = new WeakMap();\n\n  _getRequireWildcardCache = function _getRequireWildcardCache() {\n    return cache;\n  };\n\n  return cache;\n}\n\nfunction _interopRequireWildcard(obj) {\n  if (obj && obj.__esModule) {\n    return obj;\n  }\n\n  if (obj === null || _typeof(obj) !== \"object\" && typeof obj !== \"function\") {\n    return {\n      \"default\": obj\n    };\n  }\n\n  var cache = _getRequireWildcardCache();\n\n  if (cache && cache.has(obj)) {\n    return cache.get(obj);\n  }\n\n  var newObj = {};\n  var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;\n\n  for (var key in obj) {\n    if (Object.prototype.hasOwnProperty.call(obj, key)) {\n      var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;\n\n      if (desc && (desc.get || desc.set)) {\n        Object.defineProperty(newObj, key, desc);\n      } else {\n        newObj[key] = obj[key];\n      }\n    }\n  }\n\n  newObj[\"default\"] = obj;\n\n  if (cache) {\n    cache.set(obj, newObj);\n  }\n\n  return newObj;\n}\n\nmodule.exports = _interopRequireWildcard;"],"sourceRoot":""}