{"version":3,"file":"js/9365.chunk.js?v=1742528680091","mappings":"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","sources":["webpack://fed-boilerplate/./node_modules/react-if/dist/react-if.esm.js"],"sourcesContent":["import React, { Fragment, useRef, useState, useMemo, useEffect } from 'react';\n\n/**\n * Renders a React component while also checking whether the children are a function or not\n * @param props Props of the component to render\n */\nvar render = function render(props) {\n  if (typeof props.children === 'function') {\n    return React.createElement(Fragment, null, props.children());\n  }\n  return React.createElement(Fragment, null, props.children || null);\n};\n\n/**\n * If the `<Case />` is the first one to have its condition evaluates to true\n * inside the parent `<Switch />` it will be the only rendered.\n * @param props The props to pass down to the `<Case />` component\n */\nvar Case = function Case(_ref) {\n  var _ref$children = _ref.children,\n    children = _ref$children === void 0 ? null : _ref$children;\n  return render({\n    children: children\n  });\n};\n\n/**\n * If no `<Case />` have its condition evaluates to true inside the parent `<Switch />`,\n * the first `<Default />` will be the only one rendered.\n * @param props The props to pass down to the `<Default />` component\n */\nvar Default = function Default(_ref) {\n  var _ref$children = _ref.children,\n    children = _ref$children === void 0 ? null : _ref$children;\n  return render({\n    children: children\n  });\n};\n\n/**\n * Must only contain a single child, which it renders as-is.\n * Should not be used outside of an `<If />` block.\n * @param props The props to pass down to the `<Else />` component\n */\nvar Else = function Else(props) {\n  return render(props);\n};\n\n/**\n * Must contain only a single child, which it renders as-is.\n * Should not be used outside of an `<If />` block whose condition prop is a promise.\n * @param props The props to pass down to the `<Fallback />` component\n */\nvar Fallback = function Fallback(props) {\n  return render(props);\n};\n\n/**\n * Resolves a condition that is {@link BooleanLike} or returns {@link BooleanLike} from a function\n * @param condition The condition to resolve\n */\nvar getConditionResult = function getConditionResult(condition) {\n  var conditionResult = Boolean(typeof condition === 'function' ? condition() : condition);\n  return conditionResult;\n};\n\nfunction _regeneratorRuntime() {\n  _regeneratorRuntime = function () {\n    return exports;\n  };\n  var exports = {},\n    Op = Object.prototype,\n    hasOwn = Op.hasOwnProperty,\n    defineProperty = Object.defineProperty || function (obj, key, desc) {\n      obj[key] = desc.value;\n    },\n    $Symbol = \"function\" == typeof Symbol ? Symbol : {},\n    iteratorSymbol = $Symbol.iterator || \"@@iterator\",\n    asyncIteratorSymbol = $Symbol.asyncIterator || \"@@asyncIterator\",\n    toStringTagSymbol = $Symbol.toStringTag || \"@@toStringTag\";\n  function define(obj, key, value) {\n    return Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: !0,\n      configurable: !0,\n      writable: !0\n    }), obj[key];\n  }\n  try {\n    define({}, \"\");\n  } catch (err) {\n    define = function (obj, key, value) {\n      return obj[key] = value;\n    };\n  }\n  function wrap(innerFn, outerFn, self, tryLocsList) {\n    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator,\n      generator = Object.create(protoGenerator.prototype),\n      context = new Context(tryLocsList || []);\n    return defineProperty(generator, \"_invoke\", {\n      value: makeInvokeMethod(innerFn, self, context)\n    }), generator;\n  }\n  function tryCatch(fn, obj, arg) {\n    try {\n      return {\n        type: \"normal\",\n        arg: fn.call(obj, arg)\n      };\n    } catch (err) {\n      return {\n        type: \"throw\",\n        arg: err\n      };\n    }\n  }\n  exports.wrap = wrap;\n  var ContinueSentinel = {};\n  function Generator() {}\n  function GeneratorFunction() {}\n  function GeneratorFunctionPrototype() {}\n  var IteratorPrototype = {};\n  define(IteratorPrototype, iteratorSymbol, function () {\n    return this;\n  });\n  var getProto = Object.getPrototypeOf,\n    NativeIteratorPrototype = getProto && getProto(getProto(values([])));\n  NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype);\n  var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);\n  function defineIteratorMethods(prototype) {\n    [\"next\", \"throw\", \"return\"].forEach(function (method) {\n      define(prototype, method, function (arg) {\n        return this._invoke(method, arg);\n      });\n    });\n  }\n  function AsyncIterator(generator, PromiseImpl) {\n    function invoke(method, arg, resolve, reject) {\n      var record = tryCatch(generator[method], generator, arg);\n      if (\"throw\" !== record.type) {\n        var result = record.arg,\n          value = result.value;\n        return value && \"object\" == typeof value && hasOwn.call(value, \"__await\") ? PromiseImpl.resolve(value.__await).then(function (value) {\n          invoke(\"next\", value, resolve, reject);\n        }, function (err) {\n          invoke(\"throw\", err, resolve, reject);\n        }) : PromiseImpl.resolve(value).then(function (unwrapped) {\n          result.value = unwrapped, resolve(result);\n        }, function (error) {\n          return invoke(\"throw\", error, resolve, reject);\n        });\n      }\n      reject(record.arg);\n    }\n    var previousPromise;\n    defineProperty(this, \"_invoke\", {\n      value: function (method, arg) {\n        function callInvokeWithMethodAndArg() {\n          return new PromiseImpl(function (resolve, reject) {\n            invoke(method, arg, resolve, reject);\n          });\n        }\n        return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();\n      }\n    });\n  }\n  function makeInvokeMethod(innerFn, self, context) {\n    var state = \"suspendedStart\";\n    return function (method, arg) {\n      if (\"executing\" === state) throw new Error(\"Generator is already running\");\n      if (\"completed\" === state) {\n        if (\"throw\" === method) throw arg;\n        return doneResult();\n      }\n      for (context.method = method, context.arg = arg;;) {\n        var delegate = context.delegate;\n        if (delegate) {\n          var delegateResult = maybeInvokeDelegate(delegate, context);\n          if (delegateResult) {\n            if (delegateResult === ContinueSentinel) continue;\n            return delegateResult;\n          }\n        }\n        if (\"next\" === context.method) context.sent = context._sent = context.arg;else if (\"throw\" === context.method) {\n          if (\"suspendedStart\" === state) throw state = \"completed\", context.arg;\n          context.dispatchException(context.arg);\n        } else \"return\" === context.method && context.abrupt(\"return\", context.arg);\n        state = \"executing\";\n        var record = tryCatch(innerFn, self, context);\n        if (\"normal\" === record.type) {\n          if (state = context.done ? \"completed\" : \"suspendedYield\", record.arg === ContinueSentinel) continue;\n          return {\n            value: record.arg,\n            done: context.done\n          };\n        }\n        \"throw\" === record.type && (state = \"completed\", context.method = \"throw\", context.arg = record.arg);\n      }\n    };\n  }\n  function maybeInvokeDelegate(delegate, context) {\n    var methodName = context.method,\n      method = delegate.iterator[methodName];\n    if (undefined === method) return context.delegate = null, \"throw\" === methodName && delegate.iterator.return && (context.method = \"return\", context.arg = undefined, maybeInvokeDelegate(delegate, context), \"throw\" === context.method) || \"return\" !== methodName && (context.method = \"throw\", context.arg = new TypeError(\"The iterator does not provide a '\" + methodName + \"' method\")), ContinueSentinel;\n    var record = tryCatch(method, delegate.iterator, context.arg);\n    if (\"throw\" === record.type) return context.method = \"throw\", context.arg = record.arg, context.delegate = null, ContinueSentinel;\n    var info = record.arg;\n    return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, \"return\" !== context.method && (context.method = \"next\", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = \"throw\", context.arg = new TypeError(\"iterator result is not an object\"), context.delegate = null, ContinueSentinel);\n  }\n  function pushTryEntry(locs) {\n    var entry = {\n      tryLoc: locs[0]\n    };\n    1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry);\n  }\n  function resetTryEntry(entry) {\n    var record = entry.completion || {};\n    record.type = \"normal\", delete record.arg, entry.completion = record;\n  }\n  function Context(tryLocsList) {\n    this.tryEntries = [{\n      tryLoc: \"root\"\n    }], tryLocsList.forEach(pushTryEntry, this), this.reset(!0);\n  }\n  function values(iterable) {\n    if (iterable) {\n      var iteratorMethod = iterable[iteratorSymbol];\n      if (iteratorMethod) return iteratorMethod.call(iterable);\n      if (\"function\" == typeof iterable.next) return iterable;\n      if (!isNaN(iterable.length)) {\n        var i = -1,\n          next = function next() {\n            for (; ++i < iterable.length;) if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next;\n            return next.value = undefined, next.done = !0, next;\n          };\n        return next.next = next;\n      }\n    }\n    return {\n      next: doneResult\n    };\n  }\n  function doneResult() {\n    return {\n      value: undefined,\n      done: !0\n    };\n  }\n  return GeneratorFunction.prototype = GeneratorFunctionPrototype, defineProperty(Gp, \"constructor\", {\n    value: GeneratorFunctionPrototype,\n    configurable: !0\n  }), defineProperty(GeneratorFunctionPrototype, \"constructor\", {\n    value: GeneratorFunction,\n    configurable: !0\n  }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, \"GeneratorFunction\"), exports.isGeneratorFunction = function (genFun) {\n    var ctor = \"function\" == typeof genFun && genFun.constructor;\n    return !!ctor && (ctor === GeneratorFunction || \"GeneratorFunction\" === (ctor.displayName || ctor.name));\n  }, exports.mark = function (genFun) {\n    return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, \"GeneratorFunction\")), genFun.prototype = Object.create(Gp), genFun;\n  }, exports.awrap = function (arg) {\n    return {\n      __await: arg\n    };\n  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () {\n    return this;\n  }), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) {\n    void 0 === PromiseImpl && (PromiseImpl = Promise);\n    var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);\n    return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) {\n      return result.done ? result.value : iter.next();\n    });\n  }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, \"Generator\"), define(Gp, iteratorSymbol, function () {\n    return this;\n  }), define(Gp, \"toString\", function () {\n    return \"[object Generator]\";\n  }), exports.keys = function (val) {\n    var object = Object(val),\n      keys = [];\n    for (var key in object) keys.push(key);\n    return keys.reverse(), function next() {\n      for (; keys.length;) {\n        var key = keys.pop();\n        if (key in object) return next.value = key, next.done = !1, next;\n      }\n      return next.done = !0, next;\n    };\n  }, exports.values = values, Context.prototype = {\n    constructor: Context,\n    reset: function (skipTempReset) {\n      if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = \"next\", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) \"t\" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined);\n    },\n    stop: function () {\n      this.done = !0;\n      var rootRecord = this.tryEntries[0].completion;\n      if (\"throw\" === rootRecord.type) throw rootRecord.arg;\n      return this.rval;\n    },\n    dispatchException: function (exception) {\n      if (this.done) throw exception;\n      var context = this;\n      function handle(loc, caught) {\n        return record.type = \"throw\", record.arg = exception, context.next = loc, caught && (context.method = \"next\", context.arg = undefined), !!caught;\n      }\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i],\n          record = entry.completion;\n        if (\"root\" === entry.tryLoc) return handle(\"end\");\n        if (entry.tryLoc <= this.prev) {\n          var hasCatch = hasOwn.call(entry, \"catchLoc\"),\n            hasFinally = hasOwn.call(entry, \"finallyLoc\");\n          if (hasCatch && hasFinally) {\n            if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);\n            if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);\n          } else if (hasCatch) {\n            if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);\n          } else {\n            if (!hasFinally) throw new Error(\"try statement without catch or finally\");\n            if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);\n          }\n        }\n      }\n    },\n    abrupt: function (type, arg) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc <= this.prev && hasOwn.call(entry, \"finallyLoc\") && this.prev < entry.finallyLoc) {\n          var finallyEntry = entry;\n          break;\n        }\n      }\n      finallyEntry && (\"break\" === type || \"continue\" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null);\n      var record = finallyEntry ? finallyEntry.completion : {};\n      return record.type = type, record.arg = arg, finallyEntry ? (this.method = \"next\", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record);\n    },\n    complete: function (record, afterLoc) {\n      if (\"throw\" === record.type) throw record.arg;\n      return \"break\" === record.type || \"continue\" === record.type ? this.next = record.arg : \"return\" === record.type ? (this.rval = this.arg = record.arg, this.method = \"return\", this.next = \"end\") : \"normal\" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel;\n    },\n    finish: function (finallyLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel;\n      }\n    },\n    catch: function (tryLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc === tryLoc) {\n          var record = entry.completion;\n          if (\"throw\" === record.type) {\n            var thrown = record.arg;\n            resetTryEntry(entry);\n          }\n          return thrown;\n        }\n      }\n      throw new Error(\"illegal catch attempt\");\n    },\n    delegateYield: function (iterable, resultName, nextLoc) {\n      return this.delegate = {\n        iterator: values(iterable),\n        resultName: resultName,\n        nextLoc: nextLoc\n      }, \"next\" === this.method && (this.arg = undefined), ContinueSentinel;\n    }\n  }, exports;\n}\nfunction asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {\n  try {\n    var info = gen[key](arg);\n    var value = info.value;\n  } catch (error) {\n    reject(error);\n    return;\n  }\n  if (info.done) {\n    resolve(value);\n  } else {\n    Promise.resolve(value).then(_next, _throw);\n  }\n}\nfunction _asyncToGenerator(fn) {\n  return function () {\n    var self = this,\n      args = arguments;\n    return new Promise(function (resolve, reject) {\n      var gen = fn.apply(self, args);\n      function _next(value) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"next\", value);\n      }\n      function _throw(err) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"throw\", err);\n      }\n      _next(undefined);\n    });\n  };\n}\nfunction _extends() {\n  _extends = Object.assign ? Object.assign.bind() : function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n    return target;\n  };\n  return _extends.apply(this, arguments);\n}\n\n/**\n * The MIT License (MIT)\n *\n * Copyright © `2020` `The Sapphire Community and its contributors`\n *\n * Source: https://github.com/sapphiredev/utilities/blob/main/packages/utilities/src/lib/isThenable.ts\n * Full license: https://github.com/sapphiredev/utilities/blob/main/LICENSE.md\n */\n/**\n * Verify if the input is a function.\n * @param input The function to verify\n */\nfunction isFunction(input) {\n  return typeof input === 'function';\n}\nfunction hasThen(input) {\n  return Reflect.has(input, 'then') && isFunction(input.then);\n}\nfunction hasCatch(input) {\n  return Reflect.has(input, 'catch') && isFunction(input[\"catch\"]);\n}\n/**\n * Verify if an object is a promise.\n * @param input The promise to verify\n */\nfunction isThenable(input) {\n  if (typeof input !== 'object' || input === null) return false;\n  return input instanceof Promise || input !== Promise.prototype && hasThen(input) && hasCatch(input);\n}\n\n/**\n * Compare two arrays without checking for possible nested properties\n * @param a Array to compare with b\n * @param b Array to compare with a\n * @returns True if arrays are identical, false if they are different\n */\nvar shallowArraysEqual = function shallowArraysEqual(a, b) {\n  if (!Array.isArray(a) || !Array.isArray(b)) throw new Error('shallowArraysEqual only accepts arrays as parameters');\n  if (a.length !== b.length) return false;\n  for (var i = 0; i < a.length; ++i) {\n    if (a[i] !== b[i]) return false;\n  }\n  return true;\n};\n/**\n * Create a CancellablePromise from a native Promise\n * @param promise The promise object to wrap\n * @returns Return value is an object of type CancellablePromise, with 2 properties:\n * - promise: a promise that can be left pending\n * - cancel: the function to use for cancelling the returned promise\n */\nvar createCancellablePromise = function createCancellablePromise(promise) {\n  if (!isThenable(promise)) {\n    throw new Error('Argument of createCancellablePromise should be a Promise');\n  }\n  var isCancelled = {\n    value: false\n  };\n  var wrappedPromise = new Promise( /*#__PURE__*/function () {\n    var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(res, rej) {\n      var d;\n      return _regeneratorRuntime().wrap(function _callee$(_context) {\n        while (1) switch (_context.prev = _context.next) {\n          case 0:\n            _context.prev = 0;\n            _context.next = 3;\n            return promise;\n          case 3:\n            d = _context.sent;\n            return _context.abrupt(\"return\", !isCancelled.value && res(d));\n          case 7:\n            _context.prev = 7;\n            _context.t0 = _context[\"catch\"](0);\n            !isCancelled.value && rej(_context.t0);\n          case 10:\n          case \"end\":\n            return _context.stop();\n        }\n      }, _callee, null, [[0, 7]]);\n    }));\n    return function (_x, _x2) {\n      return _ref.apply(this, arguments);\n    };\n  }());\n  // Forward potential additional properties\n  Object.keys(promise).forEach(function (key) {\n    wrappedPromise[key] = promise[key];\n  });\n  return {\n    promise: wrappedPromise,\n    cancel: function cancel() {\n      isCancelled.value = true;\n    }\n  };\n};\n\n/**\n * Calls a function only once during component lifecycle;\n * When dependency array is provided, will call the function again if at least one of the dependencies changed\n * @param callback The function to execute only once\n * @param dependencies A list of dependencies whose value, if changed since last call,\n * will trigger the execution of the callback\n */\nvar useSingleton = function useSingleton(callback, dependencies) {\n  if (dependencies === void 0) {\n    dependencies = [];\n  }\n  var hasRan = useRef(false);\n  var lastDependencies = useRef([]);\n  // Parameters type check\n  if (typeof callback !== 'function') {\n    throw new Error(\"Incorrect callback parameter for useSingleton hook; expected a function, but got: '\" + typeof callback + \"'.\");\n  }\n  if (!Array.isArray(dependencies)) {\n    throw new Error(\"Incorrect dependencies parameter for useSingleton; expected an array, but got: '\" + typeof dependencies + \"'.\");\n  }\n  var hasDependencies = Array.isArray(dependencies) && dependencies.length > 0;\n  if (hasDependencies) {\n    // Has dependencies\n    var hasAnyDependencyChanged = !shallowArraysEqual(lastDependencies.current, dependencies);\n    if (hasAnyDependencyChanged) {\n      // Any dep has changed => overwrite last dependencies and execute callback\n      lastDependencies.current = dependencies;\n    } else if (hasRan.current) {\n      // No dep has changed => same behaviour as if no dependencies\n      return;\n    }\n  } else if (hasRan.current) {\n    // No dependencies\n    return;\n  }\n  callback();\n  hasRan.current = true;\n};\n\n/**\n * Must contain only a single child, which it renders as-is.\n * Should not be used outside of an `<If />` block.\n * @param props The props to pass down to the `<Then />` component\n */\nvar Then = function Then(props) {\n  return render(props);\n};\n\n/**\n * Is included in the `<If />` component, rendered when the condition prop of `<If />` is a Promise;\n * Renders the Fallback component, if contains any, until provided promise is fulfilled;\n * Renders `<Then />` when promise is fulfilled, `<Else />` when rejected\n */\nfunction IfAsync(_ref) {\n  var promise = _ref.promise,\n    _ref$keepAlive = _ref.keepAlive,\n    keepAlive = _ref$keepAlive === void 0 ? false : _ref$keepAlive,\n    children = _ref.children;\n  var _useState = useState(null),\n    isResolved = _useState[0],\n    setIsResolved = _useState[1];\n  var _useState2 = useState(null),\n    returnValue = _useState2[0],\n    setReturnValue = _useState2[1];\n  // Make promise cancellable\n  var cancellablePromise = useMemo(function () {\n    return createCancellablePromise(promise);\n  }, [promise]);\n  var history = useRef([]); // Keep history of promises\n  // Handle unmount\n  useEffect(function () {\n    return function () {\n      if (!keepAlive) {\n        cancellablePromise.cancel();\n      }\n    };\n  }, [cancellablePromise, cancellablePromise.promise, keepAlive]);\n  // Await promise\n  useSingleton( /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {\n    var data;\n    return _regeneratorRuntime().wrap(function _callee$(_context) {\n      while (1) switch (_context.prev = _context.next) {\n        case 0:\n          setIsResolved(null);\n          setReturnValue(null);\n          _context.prev = 2;\n          _context.next = 5;\n          return cancellablePromise.promise;\n        case 5:\n          data = _context.sent;\n          setReturnValue(data);\n          setIsResolved(true);\n          history.current.push(cancellablePromise);\n          _context.next = 16;\n          break;\n        case 11:\n          _context.prev = 11;\n          _context.t0 = _context[\"catch\"](2);\n          setReturnValue(_context.t0);\n          setIsResolved(false);\n          history.current.push(cancellablePromise);\n        case 16:\n        case \"end\":\n          return _context.stop();\n      }\n    }, _callee, null, [[2, 11]]);\n  })), [cancellablePromise.promise]);\n  if (!children || !isThenable(promise)) {\n    return null;\n  }\n  if (isResolved === null) {\n    // Promise is pending\n    var hasFallback = React.Children.toArray(children).find(function (c) {\n      return c.type === Fallback;\n    });\n    return React.createElement(Fragment, null, hasFallback || null);\n  }\n  if (!isResolved) {\n    // Promise is fulfilled and rejected\n    var hasElse = React.Children.toArray(children).find(function (c) {\n      return c.type === Else;\n    });\n    if (!hasElse) return React.createElement(Fragment, null, null);\n    // Inject caught error\n    var elseElement = hasElse;\n    if (typeof hasElse.props.children === 'function') {\n      elseElement = _extends({}, hasElse, {\n        props: _extends({}, hasElse.props, {\n          children: function children() {\n            return hasElse.props.children(returnValue, history.current, cancellablePromise.promise);\n          }\n        })\n      });\n    }\n    return React.createElement(Fragment, null, elseElement);\n  }\n  // Promise is fulfilled and resolved\n  var hasThen = React.Children.toArray(children).find(function (c) {\n    return c.type === Then;\n  });\n  if (!hasThen) return React.createElement(Fragment, null, null);\n  // Inject promise return value\n  var thenElement = hasThen;\n  if (typeof hasThen.props.children === 'function') {\n    thenElement = _extends({}, hasThen, {\n      props: _extends({}, hasThen.props, {\n        children: function children() {\n          return hasThen.props.children(returnValue, history.current, cancellablePromise.promise);\n        }\n      })\n    });\n  }\n  return React.createElement(Fragment, null, thenElement);\n}\n\n/**\n * Handles errors by throwing them to the console.\n * `__DEV__` is replaced by dts-cli using {@link https://www.npmjs.com/package/babel-plugin-dev-expression babel-plugin-dev-expressions}\n * which will ensure this entire throw is not present in production\n * @param condition The condition to check\n * @param message The message to throw if `condition` resolves to `true`\n */\nfunction tinyWarning(condition, message) {\n  if (process.env.NODE_ENV !== \"production\") {\n    if (condition) {\n      // check console for IE9 support which provides console\n      // only with open devtools\n      if (typeof console !== 'undefined') {\n        console.warn(message);\n      }\n      // Throwing an error and catching it immediately to improve debugging\n      // Users can utilize 'pause on caught exceptions' to get into this throw\n      try {\n        throw new Error(message);\n      } catch (x) {\n        // noop\n      }\n    }\n  }\n}\n\n/**\n * If condition evaluates to true, renders the `<Then />` block will be rendered,\n * otherwise renders the `<Else />` block. Either block may be omitted.\n *\n * This component can contain any number of `<Then />` or `<Else />` blocks,\n * but only the first block of the right type (either Then or Else, depending on the condition) will be rendered.\n * @param __namedParameters The props to pass down to the `<IF />` component, see {@link ComponentWithConditionProps}\n */\nvar If = function If(_ref) {\n  var condition = _ref.condition,\n    _ref$keepAlive = _ref.keepAlive,\n    keepAlive = _ref$keepAlive === void 0 ? false : _ref$keepAlive,\n    children = _ref.children;\n  if (!children) {\n    return null;\n  }\n  tinyWarning(!Array.isArray(children) && !(children.type === Else || children.type === Then) || !React.Children.toArray(children).every(function (child) {\n    return child.type === Else || child.type === Then || child.type === Fallback;\n  }), 'The <If> component should contain <Then /> <Else /> or <Fallback /> components as its children');\n  if (isThenable(condition)) {\n    return React.createElement(IfAsync, {\n      promise: condition,\n      keepAlive: keepAlive\n    }, children);\n  }\n  var conditionResult = getConditionResult(condition);\n  return React.createElement(Fragment, null, React.Children.toArray(children).find(function (c) {\n    return c.type !== Else !== !conditionResult;\n  }) || null);\n};\n\n/**\n * It will render the first matching `<Case />`, or the first encountered `<Default />` (or `null`).\n *\n * This component can contain any number of `<Case />` and one `<Default />` blocks\n * @param __namedParameters Children to pass into the `<Switch />` component\n */\nvar Switch = function Switch(_ref) {\n  var _ref2, _matchingCase;\n  var children = _ref.children;\n  // -- Inspired by react-router --\n  // We use React.Children.forEach instead of React.Children.toArray().find()\n  // here because toArray adds keys to all child elements and we do not want\n  // to trigger an unmount/remount for two children <Case>s or <Default>s\n  var matchingCase = undefined;\n  var defaultCase = undefined;\n  // If the children are a function then resolve it first\n  if (isFunction(children)) {\n    children = children();\n  }\n  React.Children.forEach(children, function (child) {\n    // not a valid react child, don't add it\n    /* istanbul ignore next - This is only a safe fail for people writing bad code */\n    if (!React.isValidElement(child)) {\n      return;\n    }\n    if (!matchingCase && child.type === Case) {\n      var condition = child.props.condition;\n      var conditionResult = getConditionResult(condition);\n      if (conditionResult) {\n        matchingCase = child;\n      } // else not matching condition, don't add it\n    } else if (!defaultCase && child.type === Default) {\n      defaultCase = child;\n    } // else unknown type, don't add it\n  });\n\n  return (_ref2 = (_matchingCase = matchingCase) != null ? _matchingCase : defaultCase) != null ? _ref2 : null;\n};\n\n/** A shorthand for\n *\n * ```jsx\n * <If condition={...}>\n *     <Else>\n *         { ... }\n *     </Else>\n * </If>\n * ```\n *\n * The same rules apply to the child elements as with using the `<Else />` block.\n *\n * @param __namedParameters The props to pass down to the `<IF />` component, see {@link ComponentWithConditionProps}\n */\nvar Unless = function Unless(_ref) {\n  var condition = _ref.condition,\n    _ref$children = _ref.children,\n    children = _ref$children === void 0 ? null : _ref$children;\n  var conditionResult = Boolean(getConditionResult(condition));\n  return !conditionResult && children ? render({\n    children: children\n  }) : null;\n};\n\n/** A shorthand for\n *\n * ```jsx\n * <If condition={...}>\n *     <Then>\n *         { ... }\n *     </Then>\n * </If>\n * ```\n *\n * The same rules apply to the child elements as with using the `<Then /`> block.\n *\n * @param __namedParameters The props to pass down to the `<IF />` component, see {@link ComponentWithConditionProps}\n */\nvar When = function When(_ref) {\n  var condition = _ref.condition,\n    _ref$children = _ref.children,\n    children = _ref$children === void 0 ? null : _ref$children;\n  var conditionResult = Boolean(getConditionResult(condition));\n  return conditionResult && children ? render({\n    children: children\n  }) : null;\n};\n\nexport { Case, Default, Else, Fallback, If, Switch, Then, Unless, When };\n//# sourceMappingURL=react-if.esm.js.map\n"],"names":["render","props","children","Fragment","Case","_ref","_ref$children","Default","Else","Fallback","getConditionResult","condition","Boolean","_regeneratorRuntime","exports","Op","Object","prototype","hasOwn","hasOwnProperty","defineProperty","obj","key","desc","value","$Symbol","Symbol","iteratorSymbol","iterator","asyncIteratorSymbol","asyncIterator","toStringTagSymbol","toStringTag","define","enumerable","configurable","writable","err","wrap","innerFn","outerFn","self","tryLocsList","protoGenerator","Generator","generator","create","context","Context","makeInvokeMethod","tryCatch","fn","arg","type","call","ContinueSentinel","GeneratorFunction","GeneratorFunctionPrototype","IteratorPrototype","this","getProto","getPrototypeOf","NativeIteratorPrototype","values","Gp","defineIteratorMethods","forEach","method","_invoke","AsyncIterator","PromiseImpl","invoke","resolve","reject","record","result","__await","then","unwrapped","error","previousPromise","callInvokeWithMethodAndArg","state","Error","undefined","done","delegate","delegateResult","maybeInvokeDelegate","sent","_sent","dispatchException","abrupt","methodName","return","TypeError","info","resultName","next","nextLoc","pushTryEntry","locs","entry","tryLoc","catchLoc","finallyLoc","afterLoc","tryEntries","push","resetTryEntry","completion","reset","iterable","iteratorMethod","isNaN","length","i","doneResult","displayName","isGeneratorFunction","genFun","ctor","constructor","name","mark","setPrototypeOf","__proto__","awrap","async","Promise","iter","keys","val","object","reverse","pop","skipTempReset","prev","charAt","slice","stop","rootRecord","rval","exception","handle","loc","caught","hasCatch","hasFinally","finallyEntry","complete","finish","catch","thrown","delegateYield","asyncGeneratorStep","gen","_next","_throw","_asyncToGenerator","args","arguments","apply","_extends","assign","bind","target","source","isFunction","input","isThenable","Reflect","has","hasThen","Then","IfAsync","promise","_ref$keepAlive","keepAlive","_useState","useState","isResolved","setIsResolved","_useState2","returnValue","setReturnValue","cancellablePromise","useMemo","isCancelled","wrappedPromise","_callee","res","rej","d","_context","t0","_x","_x2","cancel","createCancellablePromise","history","useRef","useEffect","callback","dependencies","hasRan","lastDependencies","Array","isArray","a","b","shallowArraysEqual","current","useSingleton","data","hasFallback","toArray","find","c","hasElse","elseElement","thenElement","If","every","child","conditionResult","Switch","_ref2","_matchingCase","matchingCase","defaultCase","Unless","When"],"sourceRoot":""}